Learn the secret of effective Clojure programmers
Repl-Driven Development in Clojure
- Tired of long compile times?
- Sick of losing your state when you reload your server?
- Wish you could get into deep flow while you're programming?
Instead, imagine if you:
- Recompiled only what changed—even as small as a single function
- Never restarted your server so the state is never lost
- Got rich, frequent feedback from a live, running system
All of that is possible with Clojure, when you use Repl-Driven Development.
Clojure was built, first and foremost, to be dynamic. It was designed for a very interactive coding style where you are continuously evaluating code at the repl. This syle of programming is called Repl-Driven Development, and it's one of the superpowers of Clojure.
This course teaches the mindset, practices, and tools of Repl-Driven Development.
Repl-Driven Development is not a specific process. It is an idea—that programming should be a process of interacting with and modifying a live system. You don't bundle up your whole application and send it to the computer for processing. Instead, you are in a continuous conversation about your problem domain. The end result, when you do it right, is a deep state of flow and engagement with your software.
Repl-Driven Development is a set of tools and techniques that support this idea. The tools come from your editors and Clojure itself. And the techniques are ways of evaluating code and working with the dynamic runtime. We go over all of that in this course.
Who is this course for?
This course is for anyone who has wanted to write better code and have more fun. Throughout the course, we dive deep into important topics like:
- the evaluation semantics of Clojure—which is designed specifically for Repl-Driven Development (RDD)
- the three keybindings you need for RDD—which are available in the top Clojure IDEs
- guidelines for what to evaluate, when
- how to maintain flow while you're programming
- dealing with common problems you may encounter
- how to run a Clojure repl even in Java projects
- navigating namespaces
- setting up your project for RDD
- using the repl to explore large amounts of data
- $199
B02 Repl-Driven Development in Clojure
- Closed
Contents
What is Repl-Driven Development?
Preview- 8 mins
- 438 MB
The mental switch to Repl-Driven Development - Batch vs interactive programming
- 11 mins
- 903 MB
All about Flow
Preview- 13 mins
- 759 MB
A map of the Repl-Driven Development territory
- 18 mins
- 1010 MB
Example of Repl-Driven Development
- 44 mins
- 1.27 GB
Clojure execution semantics
- 31 mins
- 700 MB
Compiling and executing code from your Clojure editor
- 21 mins
- 485 MB
Starting a Basic REPL Workflow
- 11 mins
- 192 MB
Coding interactively at the Repl
- 29 mins
- 649 MB
Guidelines for Repl-Driven Development
- 20 mins
- 1.11 GB
Ergonomics - Tools to write code
- 13 mins
- 272 MB
Structural editing - Tools to write code
- 13 mins
- 262 MB
Testing code with the Repl
- 13 mins
- 293 MB
Dealing with errors
- 23 mins
- 968 MB
println debugging
- 24 mins
- 629 MB
Scientific debugging
- 16 mins
- 380 MB
Keeping code in sync
- 38 mins
- 738 MB
Controlling namespace reloading with defonce
- 20 mins
- 414 MB
Printing values and controlling printing
- 27 mins
- 558 MB
Playing with values at the repl
- 21 mins
- 427 MB
Navigating namespaces at the repl
- 19 mins
- 455 MB
Interactive documentation
- 14 mins
- 300 MB
Running a Clojure repl in a Java application
- 37 mins
- 823 MB
Editing servers and other long-running processes
- 22 mins
- 472 MB
Some reloading tools some people use
- 23 mins
- 621 MB
Recap and Conclusions
- 14 mins
- 50.9 MB
- $199
B02 Repl-Driven Development in Clojure
- Closed