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!
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 spending the day reordering atoms for Atomic Scala. It’s hard not to have any forward references (where we mention something we haven’t described yet and promise to talk about it later), but we think that this is really important, and we’ve made a commitment to our readers to avoid it.
But reordering cascades. So when I found that we had a reference to Methods in Objects, I decided to move Methods up. But Methods uses Testing, so I have to either rewrite the Methods atom or move Testing up. Aha, but Testing talks about Objects. D’oh!
It would be easy to convince ourselves to allow it “just this once, just this little forward reference”, but it’s slippery slope and we’re not going to do it.
It’s a fun puzzle. So that’s how I’m spending my day today, and I’m pretty happy about that!
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!
We’re happy to announce that the first seminar from Atomic Scala will be in Boulder, Colorado, from October 15-19, 2012. Bruce Eckel and Dianne Marsh will present “atoms” (very small, single concept chapters) from the book. The seminar will be hands-on, with exercises associated with each of the atoms. Each attendee will receive an early access version of the print book as well.
You can find more information and registration information on the Boulder Seminar Page.
Note: we’re managing early bird pricing a bit differently than we have in the past. Instead of having an early bird date, we’ve made a number of tickets (10) available at early bird pricing. Once those tickets sell, all additional tickets will be sold at regular pricing. If we do not sell 10 tickets before our deadline of September 15, we will not hold the seminar and we will refund the early bird ticket price to those who purchased them. This allows us to ensure that our costs are met within the cancellation period for the venue.
We will be announcing a second seminar location soon (likely either Boston or Ann Arbor).
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.