Bruce and I are both at OSCON, in Portland, this week. This offers us a rare opportunity to work together in person, and that’s always fun (and productive).
We presented a half-day tutorial, Introduction to Scala, from Atomic Scala yesterday. We were surprised that we had a repeat tutorial attendee (hi John!) who had previously joined us at the CodeMash tutorial last January. We got up to the Class Exercises in the book, and we hope that attendees will continue independently. If you attended, we would love your feedback.
I’ll be speaking tomorrow, “Sneaking Scala through the Back Door” and Bruce has 2 talks on Thursday, “Rethinking Errors: Lessons from Scala and Go” and “Reinventing Business”. Both of us will be participating in OSCON Office Hours, which give attendees an opportunity to come talk to us. If you’re at OSCON, we would love to talk to you! We even have a few copies of the book with us!
If you aren’t at OSCON, consider attending the Scala Summit in Crested Butte August 19-21.
We wrote Atomic Scala to appeal to beginning programmers as well as experienced programmers who have been frustrated with the sharp learning curve often described when learning Scala. In the atom “How to Use This Book”, we encourage experienced programmers to move through the material more quickly by skipping to the summaries (Summary 1 and Summary 2). Those summaries also help beginners by reinforcing the information that we previously presented in detailed atoms and with additional exercises.
If you previously downloaded the free sample, go ahead and grab another copy. The first 100 pages of the book (free download) has now been updated, and includes the Programmer Fast Track for the first several atoms (Summary 1) that I described above. Summary 2 is not in the first 100 pages, but I think you will have enough information to see if this approach works for you. The print book is now available to order, if you’re interested, but try the download first so that you’ll see if this is a book that appeals to you before you buy it. Also, if you would prefer the Kindle version, we’re working on it, and we are planning for that to become available in 1-2 months.
Let us know what you think!
A few weeks ago, an interesting blog post appeared, written by Graham Lea. He posited that there was a new library available for Java programmers and that the thought that folks should check it out. He went on to describe some compelling features, such as:
- Improved Collections
- Less boilerplate
- Extensive pattern matching
- Automatic property mechanisms
- Integrates with your existing code
- And more (read the article)
And then he exposes that he’s talking about Scala. Brilliant! I love it because he addresses concerns that we often hear in the Java community like, “My programmers don’t know it” and “The code will look different” and “Finding enough programmers that know it”, but compares these challenges to those encountered when adopting a new framework (which folks seem to accept).
It’s worth a read and worth your consideration. We may be preaching to the converted here (you *are* reading the Atomic Scala blog, after all), but maybe you’re trying to figure out how to get Scala accepted as one of your “approved languages” or how to talk about using Scala with other team members. Let us know what you think! And definitely let Graham know too!
Atomic Scala is now “in production,” which means we’re building the index and finalizing the cover and making editing passes and creating other support elements so we can actually go to press in a month or so. We’ll stay with print-on-demand for the time being because we’re still learning things and want the freedom to make improvements. This book is also an attempt to adjust to the way that people actually learn and to make that learning experience better — this makes it more of a continuous experiment. For example, a few weeks ago my coauthor and I gave a one-day tutorial at a conference, and we came away realizing that experienced programmers needed a couple of summary chapters that they could jump to; this way the book can serve both beginning programmers and experienced programmers. So we came back and wrote those, and now the book is better. We expect this experience will be repeated as we gain more information about how people learn from the book.
We’ve been busy getting the Atomic Scala book ready for an early access printing for CodeMash, where we will be presenting a 1-Day seminar on Wednesday, January 10. The book has shipped to the conference location in Sandusky, OH, and we’re looking forward to seeing it!
We expect that there will be some fun face-palm moments where we realize that we have explained something poorly or inadvertently introduced a forward reference. We will use feedback from the attendees and from early viewers of the book to refine the final edition.
Following CodeMash, Josh Suereth will be joining us in Ann Arbor, MI, for the inaugural Ann Arbor Scala Enthusiasts meeting on Wednesday, January 16. If you’re in the area, please join us. The meeting, starting at 6 pm, is free and open to the public. It will be held at SRT Solutions, 206 S. Fifth Ave., Suite 200, Ann Arbor, MI 48104.
Hope to see you either in Sandusky or in Ann Arbor in January, or somewhere else in 2013!
Bruce Eckel traveled to Poland in May 2012 to present an introduction to Scala at Geecon. In this presentation, he describes our “atomic” approach to the book — introducing small pieces and building from that, rather than assuming a knowledge of Java and building on that.
You can watch Bruce’s presentation here.
I’m having some fun today “splitting an atom”, based on some feedback from a reader who downloaded the first 25% of Atomic Scala. He said that he thought that Values and Data Types should be split, so I started down that path this morning …
I’m splitting it into 2 atoms: Values … and Data Types. Following our practice before theory principle, Values must come first since Data Types has no context without storing a value. That’s driving some other fun changes too, notably in the Type Inference atom.
The Type Inference atom appeared later in the book because that’s how we thought of it … as something special that Scala does for us. But why did we think of it as special? Because we’re programmers who didn’t have that in other languages. Ah, but we’re writing this book to appeal to beginners as well as to seasoned developers. Stepping back, we realized that beginners don’t know that they have to declare the types of variables. And why should they? You didn’t have to do that in math class and that all worked out OK.
Beginners are not tied to the restrictions in older programming languages that required you to do so. So why not introduce Values using Type Inference and later show how you can do this in a more verbose way? I wouldn’t have thought of this when we started writing the book, but because our atoms are written to contain single concepts, they are also easy to re-order.
We are really grateful for feedback! Please keep it coming!
Here’s Bruce’s blog on the Atomic Scala book and the upcoming seminar in Boulder: http://www.artima.com/weblogs/viewpost.jsp?thread=345161
And here’s mine: http://www.srtsolutions.com/atomic-scala-book-written
Glad to see we’re pretty much on the same page!
The Atomic Scala book edits are fairly complete, and exercises/solutions are in place. Some people would ship the book now. But Bruce’s experience with Thinking in Java and Thinking in C++ tells us that holding seminars from the book before unleashing it on the public offers a perspective that will make the content fundamentally more understandable and will lead to happier readers.
We like happy readers, so we will be holding two 5-day “Gentle Introduction to Scala” seminars in various locations around the United States. Participants will receive an early access version of the print book and enjoy a highly interactive seminar on Scala, using the book and “atomic concepts” for learning. Watch this blog for announcements on dates and locations.