Jonathan Deyrson

Programming starts with types, functions, and abstraction. Everything else comes as a result of compositionality.

Magnetic Selection

... I’m predicting a software engineering gold rush where more and more human engineers will have to be hired to clean up the train wrecks left behind by the next few years of vibe programming ... ... the current LLM lemming rush over a cliff ... [0] I used to think that academics were the ones that are inventing the future, but I guess they want to keep things as is.

Wonderful collection of links .. another book on Applied Category Theory I really enjoyed is this one by Fong and Spivak ..

Why use functional effects in your model? Functional effect systems help you build the stories / recipes of your program, which are pure values. Many such values can be composed together to form larger values. In the Scala 3/ZIO example shown `generateTrades` builds a **description** of a program that, when evaluated, may emit zero or more values of type `Trade`, may fail with errors of type `Throwable`, and uses an environment of type `Any`. Effects encourage value based programming, encoding side-effects as computation that can be delayed till the edge. This keeps most of your model pure and you can reason about it.

Once you are into functional programming almost all of the GoF patterns dissolve into natural constructs and idioms of FP - higher order functions, algebraic data types and pattern matching, combinators like map and fold and various algebraic composition techniques. You don’t need the fanfare of documenting them as design patterns.

the best way to get good at something is usually to just practice actually doing the thing in question. a lot of very capable people outsmart themselves with complex plans that involve working a lot on fake prerequisites.

To some extent statically typed functional programming is algebraic programming. There are quite a bit of algebra as the underpinning of many abstractions that we use in FP on a regular basis. Do you think some basic knowledge of abstract algebra helps think about building and architecting functional programs ? Thinking of a conference talk based on this theme ..

@mathiasverraes and "you still need to know what good (code) looks like".

This. Your job is not to write working code, your job is to design a working system.

@mathiasverraes @aardling_eu @ddd_eu @datameshlive @EventCentricEU @ncraftsConf @einarwh AKA: Why didn't your AI-generated PR get approved? "The job isn't just about writing syntactically valid code that works." Sema vibes!

If you're considering to submit a talk to one of @aardling_eu 's conferences (@ddd_eu, @datameshlive , @EventCentricEU , @ncraftsConf ), it's a good idea to watch @einarwh's talk :-) youtube.com/watch?v=XhKcel…

Some good news and a big discount 45% on several titles today: 🟢 Functional Design and Architecture 🟣 Architecture Modernization 🟡 Grokking Functional Programming 🟠 Grokking Simplicity

Optimize first for readability and then for performance. Reasons: 1. The whole codebase needs to be readable. Not the whole of the codebase needs to be equally performant. 2. Once you have a modular and readable codebase, identify the hotspots that need to be optimised for performance. Can sacrifice some readability there as well. 3. It's much easier to optimise a readable code for performance than a performant spaghetti for readability

55 years ago today Apollo 11 took off —and then landed a man on the moon — thanks to software from an MIT team led by 32-year-old Margaret Hamilton. Full video: bit.ly/2XxYlDM (v/@MAKERSwomen) More: bit.ly/4d38NKi @NASA

This looks pretty neat - a TUI for Apache Kafka github.com/sauljabin/kask…

Shower thoughts: Vim commands are a DSL for editing text. That's what puts it in a different power class. Because it occurs to me that to be a Domain Specific Language, you really need to have a Domain Specific *Grammar*. #Vim has editing grammar, and that's what sets it apart.

As someone who likes to program in a statically typed language, having a mental model in terms of typed abstractions seems very natural to me. And you can apply equational reasoning on this model to discover the algebraic properties. In the paper Why calculating is better than scheming (cs.kent.ac.uk/people/staff/d…), Phil Wadler compares the experiences of teaching programming using Schema versus Miranda. And concludes "My experience suggests that languages such as KRC and Miranda are a significantly better vehicle for this task(*) than Lisp" (*) By task he means introduction to programming as an engineering discipline

This paper was core to TigerBeetle’s design in 2020. The idea that more than scalability in the cost-agnostic sense (“do more with more”), we should think of scalability also in terms of optimizing the unit of scale (“do more with less”).

@ericevans0 @ddd_eu "People with DDD skills will be necessary" @ericevans0 @ddd_eu #dddeu

Now "What We Know We Don't Know" by @hillelogram at @ddd_eu #dddeu on empirical software engineering, the science of figuring out what actually works and doesn't work in SE