Article originally posted on InfoQ. Visit InfoQ

Transcript

Miller: It was a cold, dark night in New York City. Rich Hickey pondered in his study, frustrated with complexity, mutated state, never-ending inherited boilerplate. He suspected there could be a better way, without sacrificing power, performance, or changing of state. He admired functional programming philosophies, but was interested to see if they could be applied more practically. Because Lisps were uncommon academically, they were born in the dungeon of MIT. Schemeing on recursion and list processing, but humans are chaotic, and our data, it reflects that. Sequential data, linked lists, good to teach theoretically, but for production, not a reality. Associative structures, hashmaps, like an array, are more authentic. Rich thought, maybe this was the way.

Speaking of humans living chaotically, this time back in 2007 in Washington, D.C., I was a young, creative rebel, frustrated with authority. The only class for me was the one I skipped, or the CSS for my MySpace pics. I didn’t believe that STEM was for me. I thought math was difficult, and the answers eluded me. When it came time to choose a path academically, I chose the school of hard knocks into grateful dead university. Years of meetups and talks and blogs and YouTubes and slides, Clojure had proved itself, scaled up in size. The community swelled, excited with hope. Simple made easy was finally in scope.

Meanwhile, back in central PA, a dreadheaded vagabond was not doing ok. It turns out my plan of selling grilled cheese on lot wasn’t actually as compelling or lucrative or legal as I thought. Jobs weren’t careers, and the hours sure sucked. My brain was so bored, but then in walked some luck. “You’re looking for something lucrative and fun? Have you tried programming?” My experience level was none. “This fire new book just dropped. It’s for people like you. It’s called, ‘Clojure for the Brave and True.'” I started to listen. What’s a todo? What do you mean just join the Slack, read some books, eval, apply, and get cool? Fast forward 2019.

November days in PA were getting colder and shorter. I found fun hacking away, putting data in order. I was poking around in the Clojurian Slack, when it was Alex Miller who answered me back. “No more opportunity grant stipends for the conj, I’m afraid, but I’m happy to gift you a ticket. No need to pay. I hope you enjoy our humble programming group. Please remember to apply for a grant for my conference, StrangeLoop”. I had no idea the effects this would have. Maybe Alex did. He is Clojure’s cool dad. I met folks. I took notes, for loop, friends forever. I learned things. I earned wings talking about compile errors. I got a job. I flew away, finally free from my cage.

Background

My name is Jordan, also known as lambduhhh. In addition to the zillion projects I have going on, lately I’ve just been writing music. When I sat down to write the hook intro for this, it came out like that. I just decided to run with it. I think it went well, somewhere between The Night Before Christmas and Dr. Seuss, I think.

Understanding Curiosity

How many of you feel confident that you know the core philosophies of Clojure? Anybody confident enough to explain to a junior dev, to a child, of the two? Let’s explore how curiosity can turn that hesitation into confidence. Whether you’re new to Clojure or you’re an experienced Clojurian, this talk is about how curiosity drives growth, both for individuals and entire ecosystems. It’s about how asking the right questions and seeking feedback and embracing uncertainty can transform overconfidence into wisdom, and complexity into simplicity. This is something we do in Clojure land, we love to be pedantic and define words. It’s just our thing. Let’s start with understanding curiosity.

The Latin root of curiosity is curiosus, meaning careful, diligent, or eager to know. It suggests intentional attention and care, and a focused effort to understand. I actually really love this definition. I love Brené Brown. She’s just awesome. She expands on this in her book, “Atlas of the Heart”. She defines curiosity as recognizing a gap in our knowledge about something that interests us and then becoming emotionally and cognitively invested in closing that gap through exploration and learning. It starts with interest, and it can go from mild curiosity to passionate investigation rabbit holes. It’s about vulnerability and courage and the willingness to engage with uncertainty and risk and go somewhere you don’t know. Together, these definitions show us that curiosity isn’t just passive wonder. It’s an active commitment to seeking understanding and growth. Curiosity is what bridges the gap between what we know, what we don’t know, and what we don’t realize that we don’t know. I’m going to explore that journey with you.

Outline

First, we’re going to talk about Rich Hickey and the evolution of the Clojure ecosystem. Then I’m going to talk about my personal story of learning, failure, growth, all the good stuff. Then I’m going to do a showcase of the mature Clojure ecosystem. That’s going to be the actionable part. That’s really going to drive home how maturity can drive curiosity, and vice versa.

Rich Hickey and the Evolution of the Clojure Ecosystem

Rich Hickey was working as a software developer, navigating the same issues many of you have faced. Immutable state causing frustrating, hard-to-reproduce bugs. Concurrency becoming essential, but it was still difficult and error-prone. Nobody knew how to reason about it. Then, endless boilerplate code in languages like Java with inheritance hierarchies. OO really promised this reusability, but in reality, you didn’t get to reuse anything. You had to redefine everything. It was adding complexity instead of reducing it. Developers were immediately drawn to the potential, like immutability, concurrency, Lisp for the JVM. Some of you all were all here. The early adopters were passionate. For a while, it felt like Clojure could solve everything. As the excitement grew, so did the tension. Developers had very strong opinions about what they wanted Clojure to become.

In 2009, Rich responded with a now famous essay, “Open Source is Not About You”. In it, he reminded everybody of the purpose of open source. It’s about the software, it’s not about individual expectations. It’s about a way to share ideas and solutions, but it’s not a guarantee that every request will be implemented. This essay was pretty polarizing. It did set the tone for how Clojure would evolve. Like, not through satisfying every demand or trying to become popular, but staying focused on the core philosophy of simplicity and practicality. Rich’s response shows us another kind of curiosity.

A curiosity to ask, what makes open source sustainable in the long run? His essay helped clarify that Clojure wasn’t chasing clout or trying to gain popularity. It was about solving real problems and being used in a very real way. This moment really marked a critical turning point. It helped align the community around Clojure’s core philosophy and its principles: simplicity, immutability, power, focus. It reflected something that we see that’s bigger, a pattern we see with pretty much almost every piece of new technology, the rise of the hype. The cycle starts with this Peak of Inflated Expectations, where the hype runs high, everyone thinks the new technology is going to solve all these problems.

Then, reality sets in, the Trove of Disillusionment, where challenges emerge, things get more real, and excitement fades. A lot of technologies don’t move on past this stage. If you have a technology with staying power, like you have curiosity, perseverance, it can lead to refinement, where tools, libraries, communities come together and start supporting and getting closer to the promise that technology made in the beginning. At the end goes the Plateau of Productivity, where the technology becomes a trusted tool in the domain. Clojure’s journey aligns almost perfectly with this curve.

As the initial excitement faded, developers started to question Clojure. Is it too niche? Lisp, isn’t that academic? What is with the parentheses? Can it scale? Many developers found functional programming unfamiliar, and the Lisp syntax, like the prefix notation, was just too much. Clojure’s growth slowed. That’s when we entered the Trove of Disillusionment. Some of these critiques showed up on Hacker News. I think some of those threads were called like, is Clojure dead? They said things like, Clojure isn’t the most beginner-friendly language, which is true. However, Rich remained steadfast. In 2011, he delivered his influential talk, Simple Made Easy, where he emphasized the distinction between simplicity and ease, and the importance of managing complexity through immutable data structures and pure functions, keeping it functional.

This talk was huge in reshaping perceptions and encouraging developers to see Clojure not as a complex tool, but as a means to achieve simplicity. This really laid the groundwork for the Slope of Enlightenment. During this period, Rich also teamed up with the core team and Stu Halloway to develop Datomic, an immutable, time-aware database that’s the ideological extension of Clojure. Clojure is open source. If Clojure had a product baby and it was a database, that’s Datomic. It was released in 2012. It’s all the same thing: simplicity, immutability, power, focus, and thinking about data as a first-class citizen.

Today, Clojure is a mature, trusted language powering mission-critical systems across industries like finance, healthcare, and e-commerce. In 2020, Nubank acquired Cognitect, which is the consultancy and the core team behind Clojure and Datomic. That solidified its place in enterprise development. It’s not just an academic experiment. This is solving real-world problems at scale. The ecosystem has grown to include beginner-friendly tools like Babashka for scripting. We just talked about Datomic, which is a little bit more advanced. Clojure’s journey through the Gartner Hype Cycle reflects how curiosity and persistence can transform hype into sustained innovation.

Personal Story of Learning, Failure, and Growth

What’s the point of this talk? Just as curiosity shaped Clojure’s journey, it shaped mine too. When I started programming, I wasn’t thinking about immutability, simplicity, or best practices. I knew nothing. I was thinking about survival. I was thinking about finding something that could bring stability to my life, and growth. Just like Clojure, my path also wasn’t a straight line. It was messy. It’s been humbling. It’s been full of lessons that I didn’t even realize that I needed at the time. How many of you have ever thought, I got this, be cake, only to discover later that maybe you didn’t got this? Glad we’re in the same, got to humble it down. When I first started programming, I wasn’t even sure I was programming. Like I said, I was just making my MySpace pics look pretty. I didn’t think that STEM was for me. I thought programming was something that genius people did, and math seemed really out of reach.

Part of that probably had to do with the fact that I didn’t have the discipline to do the homework. My only exposure was passively in class. Looking back, hindsight is 20-20 on that one. Because of all that, I went into another direction. For years, I didn’t touch code. I didn’t own a computer. I just thought I wasn’t smart enough to belong in tech. Fast-forward to my mid-20s, when I realized that I needed a career that was stable and challenging. I was working as a bartender, and it was one of my customers at the bar could come in with his laptop. At first, I hesitated because, wasn’t I already too far behind? Haven’t all you all been doing this since forever? Don’t you have the programmer gene? People believed in me, and that was really important in my journey. As I’ve learned since then, curiosity is one of my top values, just personal development. I dove right in.

So unconsciously incompetent, I specifically remember a joke I told online on Facebook. I was excited to be learning programming, and somebody had been doing something in JavaScript, and I commented something that very clearly showed that I did not know the difference between Java and JavaScript. I was like, yes, I’m down with the Java 2, but, yes, no. What I did is I learned how to learn better. Turns out, it was active learning. As it turns out, MIT puts out all the good stuff basically for free. I started with something called Scheme school, and SICP, the purple book right there, “Structure and Interpretation of Computer Programs”, is a classic title from MIT. There are these lectures that go along with it that are really good, especially to watch now. What’s cool is that was a time in programming where women did programming. About half the class was women, so it was cool to see that. That also goes in ups and downs.

As I said, most importantly, I had lots of people that believed that I could be a programmer too. I was handed a book, written by somebody that believed that Clojure is for everyone. I coded along with content produced by people that I’m now really proud to call friends. I started to produce more like edutainment content as I got farther along in my career because teaching is a good way to learn. That’s when I realized how much I didn’t know. This phase was humbling and exciting. Aided by my REPL, I was exploring and building and taking too long to do everything. Every day was a new flow. Every new concept was like climbing a mountain. I just kept going, just curious little cat over here. It was really impactful to find a community where I felt like I belonged. I felt the Clojure community really just embraced me. I felt like I belonged. It’s really cool.

This was not on accident. This is ripped from a paper called, “The History of Clojure”. Just as much as Rich had intentionally designed Clojure for the professional programmer, he had also intentionally established and required a tone of supportiveness, positivity, and respect that had been seized upon, maintained, and enforced by the community itself as one of the core values, and points of pride. The Clojure community is friendly, and we’re helpful and we tolerate nothing less. We’re aggressive about it. Eventually, I got my first job as a programmer. Winter 2019, I interviewed all day on a Thursday, accepted an offer on Friday. Then packed all my things into a minivan, drove five hours, and on Tuesday, I signed a lease in Charlottesville, Virginia. I was like, “I made it. I’m a real person now. I’m a real programmer”. That confidence went on for a little bit. I started experimenting using advanced techniques before I fully understood the basics. I realized that I still don’t really understand the basics. I was a bug hunter in the ClojureScript code base.

Despite painting a picture of an overly eager, newly minted programmer, my performance reviews were good and I was really complimented on my ability to leverage communication as a means to solve the real problem. Although I was told that I needed to be more pragmatic, I was not sure what that meant because I did not yet have the experience that causes you to be more pragmatic. I ended up getting fired from my first job as a result of that hubris. Ask me my feelings about Clojure transducers sometimes. Then I got another ClojureScript job. It was a startup that failed.

Then, I was yearning for learning and I pursued opportunities to level up. I started working at Vouch with the maintainer of the ClojureScript compiler because I was doing ClojureScript. That’s with David. Over the course of three years, I rode on this dichotomy. On one hand, my edutainment content was getting super popular and I seemed to be on this rainbow rocket to Clojure fame. Thinking I had it all figured out, then only to have reality check me really hard when I kept getting fired. These failures were devastating and they taught me something really important though. Overconfidence can only take you so far. If you’re not curious, if you’re not actually actively asking questions and seeking feedback and looking for improvement, you’re not growing.

This was in Charlottesville. I was so excited, overconfident. Everything’s fine. Then this was, I don’t want to say rock bottom, but this last tech job apocalypse, it got me. It was my first time of really getting got by the loss of jobs. After losing my second job, I knew that something had to change, and I couldn’t rely on overconfidence anymore. I needed a new approach. Around this time, Rich did his talk, Design in Practice. This is at the Clojure Conj in 2023. He mentioned this book, “The Socratic Method: A Practitioner’s Handbook”. That book has been a turning point for me, and started just thinking about my own thinking. It breaks down the Socratic dialogues to the different techniques that are used. Those dialogues are meant to show a way of thinking, a way of questioning yourself. I got really into asking better questions and finding inconsistencies and being a hypocrite, and leaning into my cognitive dissonance and exploring it, and just shamelessly seeking feedback. I love being wrong, it’s so great.

Fun fact, a lot of this thinking is actually done in Google Sheets. Building on Rich’s talk from last year, Alex actually did a talk at the Conj, and that was titled, Design in Practice in Practice. I recommend both those talks. It’s a really good way to structure your thinking. I’ve run every tool possible. I’ve done Miro. I’ve done Lucid. I’ve done all of the things. Google Sheets though? The cycle of curiosity, experimenting, failing, learning, repeating, also known as screwing around, finding out, recording it.

Four months ago, I joined the Datomic Developer Success Team at Nubank. I work on the Clojure ecosystem and developing it as part of Nubank. I still don’t have all the answers. I love not knowing answers, remember? I’ve learned that curiosity is the key to growth. By staying curious, I’ve not only improved as a developer, but I’ve also connected with a community that values real learning and real thinking. Like my story, just like Clojure, isn’t about being perfect, it’s about growing and learning and solving real problems. That’s my journey. It wasn’t a straight line and it wasn’t without failure. Every step of the way, curiosity kept me moving forward. Progress isn’t linear.

The Journey in Context

Now let’s zoom out and put the story in context, my story. Who’s heard of the Dunning-Kruger effect? Psychologist David Dunning and Justin Kruger identified a cognitive bias where people with low competence in a skill overestimate their ability. There’s often a burst of overconfidence. It’s been named, the Peak of Mount Stupid. As we gain more experience, reality sets in and confidence drops, this is known as the Valley of Despair. I think that the Socratic word for it is aporia. If we keep going, curiosity and perseverance can help us climb up the Slope of Enlightenment until we reach a place of more balanced, humble competence. Looking back, my journey as a programmer mirrors this exactly.

At first, I didn’t know how much I didn’t know. I didn’t know so much, I just signed up to be a programmer overnight. I’m like, “That looks cool. Ok, sure”. Maybe in that case, it worked in my favor. In the next couple years of software development aided by my REPL, I bikeshed up Mount Ignorance. After losing my second job, I arrived at the Peak of Mount Stupid. Losing my second job in three years, while I was under contract to buy my house, was my Valley of Despair, a humbling but necessary step towards growth. Considering my personal values more deeply and embracing curiosity, it’s helping me climb out of this, but it’s a daily battle.

Here’s where it gets interesting. My journey isn’t just personal. It mirrors the journey of Clojure itself as seen through the Gartner Hype Cycle. The Peak of Inflated Expectations maps to the Peak of Mount Stupid, where excitement and overconfidence reign. The Trough of Disillusionment matches the Valley of Despair, where reality sets in and challenges become clear. The Slope of Enlightenment is named the same in both frameworks, a period of growth and refinement driven by curiosity. Clojure’s story and my story follow the same arc because they’re both about the process of learning and growth.

Actually, both of these frameworks have been criticized for being just recording the normal process of life and putting too much stock in the data. What’s the takeaway here? If both the Dunning-Kruger effect and the Gartner Hype Cycle are inevitable, how do we move forward? Anybody have any guess? Is it curiosity, the word I’ve said 20 times? Maybe. The answer is curiosity. Curiosity keeps us asking questions and seeking feedback and staying open to growth. It’s what helped me climb out of the Valley of Despair and it’s what helped Clojure move from hype to maturity. Curiosity bridges that gap between that overconfidence and true wisdom and skill. It’s the antidote to both individual and community versions of the same struggle.

Clojure’s Mature Ecosystem

So far, we’ve explored two journeys. One, Clojure’s evolution through the Gartner Hype Cycle and my personal growth story through the Dunning-Kruger effect. We’ve seen how curiosity played a critical role in both, transforming hype and overconfidence into sustained growth and basic competence. What’s this look like in practice? How has curiosity shaped the tools and libraries that make Clojure not just language, but a vibrant, mature ecosystem? In this final section, I want to highlight some of the more exciting developments that maybe you’ve missed out on because our community is insular. We don’t really hang out on all of the places that normally you would find developers, for example, Stack Overflow. We have our own Clojurian Slack. We used to congregate on Twitter, but now that’s dead, so that’s cool. Whether you’re new to Clojure or you’re an experienced Clojurian, I want to show you these tools in a way that matches up with your experience.

I talked about this a little bit, but this is called the four stages of competence model. If you really oversimplified it, it’s novice, intermediate, and expert. I actually crowdsourced a lot of these answers. We’re going to start at novice, and for each level, I’m going to do the passive introduction. I’m going to think of these as like books, talks, things that you can passively take in. Then, the second part I’m going to share tools, libraries, frameworks, that bleeding edge stuff we were just talking about. If you’re a complete novice, and you don’t know where to start with Clojure, I do recommend, “Clojure for the Brave and True”. Although, skip the first couple chapters, because they talk about Leiningen, which is an outdated build tool that we’ve replaced with tools.deps. It tries to get you started on Emacs. Do not. Another book, “Programming Clojure”, is a pragmatic programmer’s book by Alex.

The fourth edition is going to come out, because there have been sneak peek, there have been some updates to Java that actually used to be like a code golf thing, like the opening section was like, this is it in Java. Then it was like, this is it in Clojure, and like a tiny little, but Java improved, actually, inspired by Clojure. Java improved, because Brian Goetz hangs out with the Clojure crew. They’re redoing, the fourth edition should be out. There are so many significant Rich Hickey talks. You just got to start, but Simple Made Easy is really notable. Also, Hammock Driven Development, you have to see just so you can get all the hammock jokes. It’s like a cultural touchpoint. Really, that’s just about stopping and thinking, not coding, thinking.

The other thing you can check out is my podcast, it’s called, Lost in Lambduhhs, and that is independently produced, so your expectations need to go down here, way down. Actually, I initially started it as an excuse to teach myself production skills, and people like it, so I do continue to do it. It’s just inconsistent, so I’ll just give you that. A lot of the tools that we’re talking about, I’ve interviewed a lot of those authors. The whole point of Lost in Lambduhhs is to meet the person behind the GitHub, because I figure if we humanize the people that make our tools, we can be more empathetic to them. We get into some really awesome conversations. I don’t know why Buddhism has been a theme of this season, but completely unrelated, every single person is like, Buddhism has come up. That’s cool.

Here we have the tools, because we like active, active learning. If you go to clojure.camp. At this point, we’re a learning community, I think would be the best way to describe it. With one of my co-founders a couple weeks ago at the Conj, we actually did a whole talk about Clojure Camp that does the story from beginning to end, and what we’ve learned. One of the rabbit holes that I have jumped down is pedagogy and learning and teaching. We’ve really been using Clojure Camp as a learning experience experiment, trying to figure out how to teach new skills at scale. It’s not cohort-based, it’s just a Discord with some buddies that meet sometimes and talk about some code, do some mob programming. A few years ago, we got the Clojure CLI and deps.edn, that has been a game changer. You can just go and go, clj, and just get a REPL. Look at that, so easy, “Hey friends, hello world”, we love that. We have finally got good IDE support.

Saying that, I do Emacs, because when I learned Clojure, that was the path, that’s what you did. You learned Emacs. You had paredit, you could balance your parentheses and everything was fine, but it was hard. We don’t have that be hard anymore. Calva for VS Code is amazing. It even has a Clojure tutorial built in it. It’s just a plugin. If you want to put it on expert mode, you can even go on VS Code, there’s even plugins for Emacs key bindings. You can still use your paredit, which is useful. Then use the tool that you’re actually familiar with. There’s also Cursive for IntelliJ. I use that. I love JetBrains.

One of our open-source contributors, actually the one that urged me to start my podcast in the beginning, is Michiel Borkent, also known as borkdude. This man is legendary in our culture. He has made clj-kondo, which is linting support, and Babashka, which is native, fast-starting Clojure interpreter for scripting. In the Clojure survey, we added a question about, what are you using? Is it Babashka? It was like up to 90% of Clojure developers are using Babashka, which is nuts.

Now we’re going to go over to intermediate level. Intermediate level, at this stage, you’ve started experimenting, and you’ve realized, this Clojure stuff is cool, but you know there’s more to learn. You can actually build some real useful applications, and you can explore some advanced capabilities. You don’t have to think about how to balance every single thing. Hopefully, at this point, you’ve started to actually use the REPL. If you’ve started to do that, good on you, because a lot of people never get that far, and so they never reap the benefit of a fast feedback loop, which is really disappointing. Actually, I think this just got put into print. Clojure Brain Teasers is 25 puzzles to help identify flaws in your existing mental model, and then correct it. I have been working on this book for the last two years with Alex Miller.

At first, my imposter syndrome was so high. I get an email from one of my heroes, you want to co-author a book? Yes, I would. It took a very long time. One of the things that he valued was my curiosity and my ability to ask questions. We realized how beneficial it is to have somebody that is closer to the level of competence the actual audience of the book would be reading, because Alex is so unconsciously competent, he’s so fluent that he can’t even understand what’s so hard about concurrency.

These are more intermediate resources. Other intermediate resources. We have, “Clojure Applied”. That is also a pragmatic programmer book. That is authored by Alex and Stu. “Grokking Simplicity”, was released a few years ago. That is Eric Normand, who has been hugely influential helping me in my learning journey. Purelyfunctional.tv is his website. He does weekly newsletters. “Grokking Simplicity” really emphasizes functional programming principles and why they matter. It goes into like deep dive into, but it’s still approachable at the same time. It’s hard to do that, and he did it very well. Debugging with a Scientific Method, by Stu. That’s another really great talk about how to use the REPL.

Lastly, the Cognicast podcast, which is now, I think, called The Hammock by Nubank. What’s cool, little fun fact trivia, is in 2021, I was interviewed. I was doing enough memes. I was making enough waves. They were like, who is this girl? They interviewed me. The person that interviewed me is Robert Randolph, who is now my manager. That was like just a very slow roll. I think they just kept an eye waiting for my competence or wisdom or something to get better. I’m really grateful for the team that I work on now and my manager, because I’ve never experienced having a good manager before. I get to now. It’s just so amazing.

Here are more tools. Portal is a data visualization inspector that goes into your REPL and helps you with the workflow. I actually have a podcast episode where I talk to the author and creator of that, Chris, djblue. Add-lib helps you dynamically add libraries to your REPL during development. Also, to the ClojureScript ecosystem, we got shadow-cljs. It’s the build tool that we needed because it simplifies working with ClojureScript and npm. As I explained earlier, actually, the majority of my professional experience has been with ClojureScript. Watching specifically how shadow helped that ecosystem and make it more accessible to people, that was really cool to be there for that. We have a whole data science sect because Clojure is so good for data science. The only problem is that all the data science libraries are in Python. Bummer? Not really. We have libpython-clj, which helps bridge that. You can use all your favorite Python libraries for your data science, but then actually think about the reasoning in Clojure. That’s cool.

The Scicloj group, as it’s called, they are in the Clojure in Slack, but they actually hang out mostly on Zulip because they mirror the Slack to the Zulip, and then it keeps the history forever, because data science people. Makes sense, they want the data. There are really cool things. It’s almost like an ecosystem inside an ecosystem, the Scicloj data science story. When I did that poll asking, they mentioned Tablecloth, saying it simplifies data manipulation and visualization for analysts and scientists. I’m not a data scientist. I wish I could elaborate on this more.

If you are, you should go into the Slack and start being curious. FlowStorm debugger, I have tried that. That’s cool. It’s a debugging tool that you can use with your REPL for this interactive, fast-tracking program flow. You have to experience it. I feel like I can’t really communicate how awesome the REPL workflow is. It’s like, normally you have to send over your entire program. With a REPL, it’s literally line by line. You have such a tight feedback loop with the data that you’re working on that you can ask it direct questions. It’s awesome because it helps you grow through the exploration. I have a hypothesis that that is why I’ve been able to accelerate as quickly as I have in programming is because of the aid of this feedback loop, of helping me, because there are three things to become an expert, and it’s not 10,000 hours. It all boils down to deliberate practice, which is giving feedback to others, asking for feedback for yourself, and then giving feedback to yourself. The REPL helps you achieve that.

Expert. At this stage, you’ve mastered the fundamentals, and you’re pushing boundaries with what’s possible with Clojure. This is where the curiosity leads into innovation, the innovation story. Here are the tools that represent the cutting edge. 2012, that’s not cutting edge. As I mentioned, I work on the Datomic team. It’s free software, but not free software like that. It’s free to use, not open source. It’s really awesome. It’s used by companies like Netflix.

As we talked about earlier, Nubank went so all in on Datomic, they literally just acquired the consultancy that made it in the language. They feel pretty strongly about it. Because as it turns out, it’s crazy that we mutate state in databases, like when you actually think about it. If you’re asking a question to something, and then you’re changing it, we don’t do that. It’s really good for applications like FinTech and health. When you really don’t want to lose your data, you can’t lose your data, that’s what Datomic is for. XTDB, they are another Clojure-based database that has the time-aware features that I was just talking about.

I think they call it bitemporal capabilities. That just means that you can say, at any point in time, what was the state of this like? That’s because we don’t change the data. There’s also Electric, I think the company is Hyperfiddle, but Electric and Missionary. There’s actually a lot of tools done by Electric. They’re reactive programming frameworks. I am a fan of Dustin Getz, the person behind Hyperfiddle. We went through beginning, intermediate, and expert, and now we have the very tip-top of the chain, Google Sheets, the one true tool for thinking.

Conclusion

Originally, Rich Hickey said, when he embarked on Clojure, he was not, nor did he aspire to be a designer. From now on, he was responsible for Clojure. The success of Clojure changed his life and career in ways that he never thought possible. Clojure Camp gave me the opportunity to be a learning experience designer. That’s one thing I do have in common with Rich, is that Clojure has changed my life in ways that I am so grateful for and I never thought possible. That’s why I’m so passionate about sharing it with everybody.

See more presentations with transcripts