
Simple Made Easy (2011) - nailer
https://www.infoq.com/presentations/Simple-Made-Easy
======
corysama
Simple Made Easy is a great introduction to the Rich Hickey Fanclub [1] ;)

Other recommendations for early viewing are "Hammock Driven Development", "The
Value of Values" and "The Design of Datomic".

[1] [https://github.com/tallesl/Rich-Hickey-
fanclub](https://github.com/tallesl/Rich-Hickey-fanclub)

~~~
amelius
Hickey may be a brilliant software architect, but I'm wondering how high he
ranks as a business leader. How is his company Datomic doing? Also in the
light of the new database service Cloud Spanner just launched by Google.

~~~
mh8h
Datomic is very different from the typical database in terms of the operations
it supports. I don't think Google Spanner, or the other similar products, are
direct competitors.

I don't know much about how they are doing financially though.

------
mmphosis
[https://github.com/matthiasn/talk-
transcripts/blob/master/Hi...](https://github.com/matthiasn/talk-
transcripts/blob/master/Hickey_Rich/SimpleMadeEasy.md)

------
romaniv
This is a classic. Definitely worth watching for everyone working within IT.

------
nailer
One thing I've found super helpful on my current project (which happens to be
node) is using OSS concepts and npm as a unit of modularity.

Eg, everything is just a grab bag of functions in an npm module (sometimes
with a closure holding some state - I either reject or don't understand FP
people when they claim FP doesn't have state).

Each module has tests, dependencies, a README, and if it is reusable by other
projects, is even OSSd and published. Writing software as if it's going to be
published makes me be more modular. Being modular makes things easier to
reason about and therefore has stopped by codebase from becoming complex to
work with.

~~~
chowells
FP people have never claimed they don't have state. That's a straw man used to
argue against something no one is saying.

The claim is that there is no hidden state - everything is made explicit.

~~~
nailer
I have no argument against FP, not am I making one here. But plenty of FP
advocates claim FP "avoids state". It's not a straw man, it's just experience
from asking people to explain FP.

------
swah
At some point it felt like Clojure was the future, the new thing, so amazingly
better - was that just a feeling of novelty? Or something went wrong with its
use case?

Of course, these days its about Rust, Swift and LLVM, but it doesn't have
those lispy properties we love...

~~~
rlander
I felt like that, like Clojure was the future, around 2009/2010\. But then
Java libraries and their impossible stack traces got in the way.

I've been waiting for a native Clojure implementation (or on top of Python or
the Erlang VM) ever since.

~~~
pjmlp
There are few abandoned attempts.

Writing from scratch those Java libraries, including a good quality AOT
compiler and GC is not something to do as hobby on the weekends.

~~~
branchly2
Don't need all those Java libraries if you've got good FFI with C libraries.

Don't need AOT compilation; if you want performance, just stick with regular
Clojure on the JVM.

I'd love to just see a small general-purpose interpreted Clojure (quick start
up, small memory footprint, easy access to C libs), even if it lacked
concurrency features.

~~~
pjmlp
For that I fail to see the point of why not use a Scheme or Common Lisp
compiler instead.

~~~
branchly2
Thank you. Though I really like having Clojure's:

* literal syntax for maps, vectors, sets, and regexes

* keywords

* clear separation of functional constructs (`for`, `map`, etc.) vs side-effecting ones (`do`, `doall`, `when`).

* large standard library of built-in functions, with overall fairly nice naming of things.

I've looked at Scheme, but it appears to be missing those things. I think some
of them may be provided by srfi's, but upon a quick reading I couldn't make
much sense of how to include and use them.

~~~
nickik
Racket is probably something you should look at. Im not sure it has all these
things, but it is also a modern updated Lisp language based on Scheme.

------
rcarmo
Needs a (2011) in the title. Still a very good session, though.

~~~
nailer
Done.

