24K views · Dec 17, 2012 · 50:01 · 5 HN recommenders · 8 mentions · discussed 2013–2017
Stuart Halloway argues that simplicity is objective, with a definition and etymology useful to programmers, rather than a subjective buzzword. He shows how this view informs Clojure's design and how to make programs simpler.
Why Hacker News points people here: HN commenters recommend it, alongside Rich Hickey's talk, for its precise definition of simple versus easy and its implications for code design.
“He talks about his definition of "simple" (by digging into what the original English definition was) and what that means for code.”HN comment, 2014
“There’s a fair amount of overlap with Rich Hickey’s talk, but both are worth watching”
Earlier Halloway talk overlapping with Hickey's; both worth watching.
Also see Stuart Halloway’s earlier talk, Simplicity Ain’t Easy . There’s a fair amount of overlap with Rich Hickey’s talk, but both are worth watching: this video And also his talk Radical Simplicity : link
“I would recommend "Simplicity Ain't Easy" by Stuart Halloway[1]”
Better explanation of 'simple' via etymology and its misuse.
To get an even better explanation on what the word "simple" means and what it derives from, I would recommend "Simplicity Ain't Easy" by Stuart Halloway[1]. While it is very similar to "Simple made Easy", it focuses a lot more on the etymology of the words "simple" and "complex" and how people misuse the word. [1]: this video
“He talks about his definition of "simple" (by digging into what the original English definition was) and what that means for code.”
Definition of simple from original English meaning and implications for code.
I'll add this to your links: this video He talks about his definition of "simple" (by digging into what the original English definition was) and what that means for code.
“Some of the importent keynotes from some of the early conjs are really importent”
One of the key Clojure conference talks on the Clojure way.
I would suggest to you that Clojure has a very clear "the Clojure Way" I would say, more so then almost any other language. It goes beyond syntax to a pretty deep design level. Its not even all that unique to clojure, you could do 'the clojure way' in other languages, but they usally dont. Some of the importent keynotes from some of the early conjs are really importent, and they really went deep in the community, you can see it in almost every major library. Another commenter has mentioned the notion of 'simple' but thats not really all that clear. I not enougth of a writer to tell you about it, but I can give you the resources: - This classic got Clojure on the map for many people: Are We There Yet? - Rich Hickey www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey - Simple Made Easy - Rich Hickey - link - Simplicity Ain't Easy - Stuart Halloway - this video - Ousterhout's Dichotomy Isn't (Part 2 of the Simplicity/Power/Focus Series) - Stuart Halloway - this video - The Language of the System - Rich Hickey link - Hammock Driven Development - Rich Hickey link In addition to these, there are many talk that are about people trying to run with these ideas. Datomic is a example of taking these ideas to the max, it really standas as a nice example. You can find others in talks by David Nolan for example, but there are tons of applied talks. - The Design of Datomic - Rich Hickey link
“If you haven’t seen them, I recommend the Clojure guys’ talks about the subject of simplicity.”
Uses the etymology of 'simple' for a precise, useful definition.
If you haven’t seen them, I recommend the Clojure guys’ talks about the subject of simplicity. They reached into the etymological history of the word “simple” to pull out its early definition, which is quite precise and IMO tremendously useful in this context, unlike the confused muddle of modern definitions. Rich Hickey, “Simple Made Easy”: link Stu Halloway, “Simplicity Ain’t Easy”: this video
“Stuart Halloway has a great talk on this called "Simplicity Ain't Easy”
Argues FP like Clojure is a better-designed OOP without uncontrolled state mutation.
Stuart Halloway has a great talk on this called "Simplicity Ain't Easy" [0] where he more or less states that a FP language like Clojure is basically a better designed OOP language, because FP is basically contains all its strengths (namespaces, abstractions and the like) and none of its weaknesses (e.g. uncontrolled state mutation) and you are able to select and use specific features you need to solve a specific problem, and not being saddled with every feature (including the ones you do not need to solve the problem at hand) at once. [0] this video
“I would recomend rich or stus talks on simple vs easy.”
Mentioned as a talk on simplicity versus ease.
> OOP is widely-used and easily comprehended because it is a fairly simple way of modeling reality that is compatible with how human beings do it. Have we not learn by now that these systems are not easy to reason about. Are not all the things one first learns (ie Animal -> Dog) bullshit and should be avoided. Why is it in every good OO book that, composition is better then inheritance. Why is every OO book full of examples about how to avoid mutabiltiy and make the system easy to reason about? The idea that OOP systems (as generally) thougth of goes completly out of the window as soon as you have any kind of concurency, even just event handling. > which rejects OOP It does not reject, it takes the usful features like polymorpism and gives them to you. Protocols are better then interfaces, better then duck typing. > In Clojure, if I want to define a symbol there are nine different ways of doing so. There are a lot more then nine. But I would recomend rich or stus talks on simple vs easy. Just saying there is nine of something and thus its complicated is idiotic. Java has only one thing, classes, does that make it simply, or does that just mean that its hoplessly overloaded? Clojure is extreamly simply. State can only live in a var, atom, ref or agent. Every one of these has clear semantics, this includes clear sematnics in a multithreaded world. No other language has such clearly defined state management. > Clojure claims to include these language features as a way to mitigat
“More eloquently explained details in this talk at around the 21 min mark”
Explains polymorphism a la carte without OOP, around 21 minutes.
polymorphism is very good, but not handcuffed to OOP. Clojure protocols, Haskell typeclasses (and many other examples I'm sure) provide the same functionality "a la carte" without the rest of OOP's features coming along for the ride (to paraphrase Rich Hickey and Stuart Halloway). More eloquently explained details in this talk at around the 21 min mark [0]. [0] this video
