with Stuart Halloway and Stuart Sierra
Learn to program Clojure from two experienced Clojure programmers and authors in this three-day programming course. If you're a Java programmer, if you care about concurrency, or if you enjoy working in low-ceremony languages such as Ruby or Python, Clojure is for you.
Clojure is a general-purpose language with direct support for Java, a modern Lisp dialect, and support in both the language and data structures for functional programming. Learn Clojure and you'll become a better all-around programmer. But this is more than an academic exercise. You'll also be able to write applications that have the beauty and elegance of a good scripting language, the power and reach of the JVM, and a modern, concurrency-safe functional style.
- Expand your programming toolbox by learning functional programming with a general-purpose language.
- Eliminate incidental complexity in your programs using pure functions, multimethods, and macros.
- Write applications that are expressed in a concurrency-safe, functional style and that run on the Java Virtual Machine with efficient access to Java.
You've heard about functional programming. This is your chance to really get into it and learn directly from the experts!
“I liked the top-notch presenters, engaging slides, and interesting labs!”
What Will I Learn?
How to program Clojure like the pros. This isn't a language reference course or bullet-list overview of Clojure. It's a hands-on programming course where you'll learn Clojure by actually writing Clojure code to solve many common problems. Topics include:
- Functional programming: Functional programs use immutable values and pure functions to produce programs that are expressive, easy to read, easy to test, and easy to compose into larger systems. Learn to replace variables, branches and loops with more powerful constructs: values, higher-order functions, and sequence comprehensions.
- Lisp syntax: Clojure code is data: once you know Clojure's data structures you know the syntax. The simplicity and regularity of this approach makes code easier to read, write, generate, and automate. Scared of parentheses? After you learn the joys of paredit you will have nothing to fear.
- The sequence library: In Clojure, it is a virtue to have a small number of nouns (data structures) that can work a large and flexible set of verbs (pure functions). The centerpiece of this approach is the sequence library, a set of functions that work with all of Clojure's aggregate data types. Learn to use compose Clojure's lazy sequences to solve complex problems without having to introduce any new data types.
- Concurrency: A sane approach to concurrency cannot be an afterthought, it has to permeate language design. Once it does, many common concurrency problems are surprisingly simple. Learn to use Clojure's software transactional memory, agent, and atoms to write simple programs that will work correctly with multiple threads and cores.
- Java interop: Adopting Clojure does not mean abandoning the development mainstream. Clojure's Java interop is first-class: it combines easy syntax with proxyless invocation for high performance. Learn to create and call Java objects from Clojure, and to call Clojure code from Java.
- Multimethods: Polymorphism is a specific solution to a general problem: associating functions with the objects they consume. Learn to use multimethods, which are a general solution to the same problem.
- Macros: No language is complete, or perfect. But Lisp dialects like Clojure can extend themselves through macros. If you have ever been burdened with duplicate code, or "blessed" with unnecessary design patterns, you will appreciate the unique ability of macros to extend and improve a language to meet your specific domain needs.
- OO Revisited: Protocols and types allow Clojure programs to deliver on the failed promise of OO: reuse by composition. While at a glance these features appear to be just another variant of interfaces and classes, protocols and types are different beasts altogether, fixing subtle problems that have plagued reuse in mainstream OO languages.
- The Clojure ecosystem: Learn how to integrate Clojure with Swing, web applications, and databases. Also, Clojure is quickly becoming a language of choice for working with the most innovative new Java libraries. See how to use Clojure with libraries such as Cascading+Hadoop, RabbitMQ+swarmiji, and incanter.
- Clojure.Next: Review upcoming enhancements to Clojure with the Clojure/core developers who are leading development for the next release.
Who Teaches the Course?
Stuart Halloway is the CTO of Relevance, an agile software development shop based in Durham, N.C., USA. Stuart has twenty years experience in software development, and over a decade of experience as a teacher and writer. He is a Clojure committer and the author of the book Programming Clojure.
Stuart Sierra is a developer at Relevance, a member of Clojure/core, and the co-author of Practical Clojure (Apress, 2010). He is heavily involved in the development of Clojure and has written numerous open-source libraries. Prior to 2010, he worked at Columbia Law School on AltLaw, a groundbreaking open-source search engine for legal scholarship, making use of Hadoop, Lucene, and semantic web technologies.
Who Should Attend?
Experienced Programmers. This course will be a good fit for you if:
- You have 5+ years experience in a mainstream software development language.
- You have experience with at least one of: (1) Java, (2) some dialect of Lisp, (3) concurrent systems, (4) functional programming.
- You are a self-starter comfortable installing and building open-source software.
What's a Studio?
Comprehensive, Hands-On Learning. The Studio experience doesn't begin and end in the classroom. The moment you register, we'll help you start preparing for the course. In the Studio you'll enjoy a distraction-free, interactive learning environment. When you return to your project, you'll have access to supporting resources to help you succeed. (Why we call them Studios.)
1. Help You Prepare: Before you arrive, you'll:
- Receive prep material to help you get the most out of our time together
- Get detailed laptop set-up instructions
2. In the Studio: In our collaborative learning environment you'll:
- Learn through guided instruction and hands-on programming exercises
- Discover new techniques in live coding sessions
- Get your questions answered by experts and your peers
- Reinforce the concepts you've learned in books, and dig deeper
- Discuss timely topics, tips, and tricks
3. On-Going Support: After you return to your project, you can:
- Get your questions answered on our alumni-only mailing list
- Get discounts on books, screencasts, and future training to continue learning
4. Success: Deliver your app with more confidence!
- Show off your app in our alumni gallery.
- Connect with fellow alumni in our Yearbook.
“Certainly one of the best training experiences I've ever had… The materials are good, the guys are experts and the entire thing was fun—which is hard to say about any training program.”
What Should I Bring?
Your Laptop. It wouldn't be a hands-on course if you didn't walk away having written some code. You'll be most productive on the laptop you use regularly. (On average, 60% of attendees bring Mac OS X, 30% bring Windows, and 10% bring Linux.)
A few weeks before the course, we'll send out detailed instructions for installing everything you'll need. During the course, you'll get hands-on experience working through prepared exercises, and experimenting on your own, too.
Food, Code, and More. Here's what's included with your registration:
- A continental breakfast, a hot lunch, and continuous beverages and snacks each day
- A binder with the printed course material
- All the exercises and example source code to refer back to later
- An invitation to our alumni-only mailing list for help after the Studio
- Proof of completion online as well as a signed certificate
- Internet connectivity during the Studio
- A stylish Pragmatic Studio t-shirt
- Discounts on future training