"Simple Made Easy" - Rich Hickey (2011)

I'm sure most folks here have seen the talk, but Rich Hickey's Simple Made Easy # is a superb discussion about this in the context of software. # ▶ this video

You need to watch this ▶ this video We should try not to make technical judgements based in flippant things like how few lines can someone not even familiar with the ecosystem get a hello world working

Also the point of software engineering is to take the real complexity that actually exists and you can't get rid of and work out how to write simple code to deal with it. Good software architecture does not include complexity because there is complexity in the business. It manages the complexity with simple code. The trouble is when people say "complex" you don't really know what they mean, though. They often just mean "difficult". Every programmer who wants to use that word needs to watch this: ▶ this video

loved the take and re-enforcement of a talk I’ve loved forever by Rich Hickey (famous for being integral to the creation of Clojure among other things) called “Simple Made Easy” ▶ this video Anyone know of any books that dive deeper into the subject?

"Simple made easy" [0] by Rich Hickey is a must-watch (even if you never touch Clojure) [0] ▶ this video

As developers, I've come to believe that complexity is the worst sin we commit. Everything we talk about can be traced back to this issue. This is largely due to paying attention to Rich Hickey and learning Clojure. ▶ this video

"Simple made Easy" is a nice add-on, the first half is the philosophical part and a classic. ▶ this video

I think Rich Hickey's talk about simple is great for defining these terms (literally). He describes how the roots of "simplex" mean single braid, which compares to the twisting & coupling with complexity; an apt visual for software development. He also differentiates simple/complex from easy/hard, which is important. ▶ this video

I think LLMs have made a lot of developers forget the lessons in "Simple Made Easy": ▶ this video LLMs seem to be really good at reproducing the classic Ball of Mud, that can't really be refactored or understood. There's a lot of power in creating simple components that interact with other simple components to produce complex functionality. While each component is easy to understand and debug and predict its performance. The trick is to figure out how to decompose your complex problem into these simple components and their interactions. I suppose once LLMs get really good at that skill, will be when we really won't need developers any more.

> They just don’t get it. What comprises a good presentation. I take it one could argue between what's a presentation and a talk but to me one of the very best presentation I've seen is Rich Hickey presenting Clojure. Then there's "Simple made easy" considered by many to be one of the greatest ever: ▶ this video There are many bullet points: but he'll go through each them and only show the next bullet point once he's done with the previous one. He even kids about a made up graph on one of the slide. I think that what makes a good presentation depends a lot on what's being presented.

I know this gets shared all the time, but in case anybody in this thread hasn’t seen the rich hickey talk: ▶ this video

A simple system is built so that not many parts are intertwined and hard to understand how it is built. A easy system might be very complexly built, but presents and easy interface for you to use. If complex it would be hard to understand how it is built and how to modify. Basically simple describes how the system is built, while easy describes how much you need to know to use it. They are orthogonal, so a system can be both complex and easy, both simple and hard. See ▶ this video