Neal Ford

ThoughtWorker / Software Architect / Meme Wrangler

Welcome to the web site of Neal Ford. The purpose of this site is twofold. First, it is an informational site about my professional life, including appearances, articles, presentations, etc. For this type of information, consult the news page (this page) and the About Me pages.

The second purpose for this site is to serve as a forum for the things I enjoy and want to share with the rest of the world. This includes (but is not limited to) reading (Book Club), Triathlon, and Music. This material is highly individualized and all mine!

Please feel free to browse around. I hope you enjoy what you find.

---

Upcoming Conferences

---

QCon San Francisco

San Francisco, CA

November 17-21, 2008

Great Lakes Software Symposium

Chicago, IL

November 21-23, 2008

JAX-Asia 2008

Singapore / Kuala Lumpur / Jakarta

November 25-28, 2008

---

News

---

[July 16] Speaking at Princeton JUG
On Wednesday, July 16th, I speak at the Princeton Java Users Group. I'm doing my Intro to JRuby talk. Should be fun.
Update: The slides are Introduction to JRuby [slides] [samples]

[July 15] Speaking at the Philadelphia JUG
On Tuesday, July 15th, I'll be speaking at the Philadelphia Java Users Group, about a subject dear to my heart: Developer Productivity. I'll be doing a 90 minute talk summarizing some of the parts of the first part of The Productive Programmer, the mechanics portion.
Update: the slides are here.

[July 3] Productive Programmer Arrives!
After 2 years(!) of writing and discussing this book, it is finally here. You can order it from Amazon or directly from the O'Reilly site (especially if you want the bundle that includes the PDF).
Back in 2005, after having fully recovered from writing the Art of Java Web Development in 2003, I decided to look for a fresh book project. I started wondering if the world could use another book on Regular Expressions, other than the seminal work on the subject by O'Reilly. I asked a few people and the universal opinion was a resounding "No!": the current book is so good that it's pointless to try to write another. I was talking about it to David Bock, friend and No Fluff, Just Stuff colleague when I visited NovaJUG, the Java User's Group he facilitates in the DC area. He agreed with everyone else, and we started chatting about what we thought would make a good book. We had both recently observed developers struggling to make an IDE do something that was trivial on the command line, but the developers had spent their entire careers in graphical operating systems and IDE's, and couldn't bash their way out of a paper bag. We decided that it would be cool to write a book about command line tricks and techniques for developers, and that we would write said book. The original idea was to write a gigantic recipe book for programmer productivity. We contacted a publisher (who suggested the title The Productive Programmer), and we started gathering recipes and writing about them.
Then, 2 things happened. David left his job of many years and founded a consultancy, Code Sherpas, and instantly became 300% allocated. At about the same time, his wife Lorna became pregnant with triplets! Clearly, David now has his hands more than full. At about the same time, I realized that a book consisting solely of recipes would be the most boring book every written. But, by that time, I had also noticed some patterns in the productivity stuff in which I was now immersed. In fact, I remember the exact moment I realized that this book should show patterns (or principles) of productivity. I was in India, working on a ThoughtWorks project by day, and writing the book by night. I had some long conversations with some of the folks with which I was working (Hi, Mujir!) about this, and finally settled on the five principles of productivity (which later became 4). Instead of being a book of fish, I now had a fishing manual.
Of course, I've been busy as well, so the work on the book was intermittent at best. Plus the fact that the publisher was really expecting a recipe book, and it was no longer that. So, the publisher and I started going back and forth, wrestling over the format and content to try to mold it into something upon which we could agree. By this time, I had kind of taken over the book because David was so slammed. Eventually, I realized that no amount of massaging was going to create the book the publisher thought they wanted, so the publisher and I decided to part friends. I now had distilled the 5 principles down to 4 (I realized at some point that indirection is really just an aspect of canonicality) and written about them. While I was writing, I was also doing Productive Programmer talks at No Fluff, Just Stuff, honing the material that was perpetually going to be out RSN (Real Soon Now). I now had about 100 pages of refined material. But I also realized that the principles really only covered one aspect of developer productivity, the mechanical side. I also realized that I had been talking about the practical side of productivity in my older talk Clean Up Your Code and its modern sequel 10 Ways to Improve Your Code. That was the last piece. I contacted my now publisher O'Reilly with 1/2 of a productivity book and a clean vision for what the second half should be. So, from December until March this year, I wrote the 2nd half. And, fortunately, David agreed to write the forward of the book, which gave a pleasing resolution to the original vision we both had.
For all those long suffering attendees of my Productive Programmer talks at No Fluff, Just Stuff for the last 2 years: the book is ready.

[May 20th, 2008] Speaking at the Portland Java Users Group
On Tuesday, May 20th, I'll present my "Design Patterns" in Dynamic Languages talk at the Portland Java User's Group, in anticipation of No Fluff, Just Stuff coming to town. In my opinion, The Gang of Four book should have been entitled "Palliatives for Statically Typed Languages", because the recipes it provides are cumbersome solutions to the problems it poses. Using powerful languages makes the solutions in the GoF book look hopelessly complicated. This session shows how to solve the same problems concisely, elegantly, and with far fewer lines of code using the facilities of dynamic languages.
Here are the slides from my talk: "Design Patterns" for Dynamic Languages

[May 19th, 2008] Speaking at the Denver Agile Users Group
I don't get a chance to speak at as many Agile user groups as I'd like, so I'm happy to be presenting my Code Metrics and Analysis for Agile Projects talk in Denver. What do code + methodology have to do with one another? Everything! Agile projects focus on delivering working code, and tools exist to allow you to verify some quality metrics for your code. This session is a survey of tools and metrics that allow you to determine the quality of your code and strategies to "wire it" into your agile project.
Here are the slides from my talk: Code Metrics & Analysis for Agile Projects .

[May 14th, 2008] Speaking at the Dallas Java Users Group
I'm speaking at the Dallas Java Users Group (the MetroPlex Java Users Group) on May 14th, doing my 10 Ways to Improve Your Code talk. Always an active group, should be fun.
Update: Here are the slides I used for the talk: [slides]

[February 13, 2008] Speaking at Twin Cities JUG
I spoke at the Twin Cities JUG on Building DSLs in Static and Dynamic Languages, which is talk I've given in some form or another for several years. But, I've continued to add new content to it (I've updated all the JMock examples to the latest version, which is very nice) and giving it has expanded my understanding of this topic a lot. For me, the more I'm "forced" to talk about something, the more I verbalize it, the better I understand it and all it's nuances. At any rate, I had a good time delivering this talk (despite the fact that the projector refused to show red).
The slides from the talk are here.

[February 6, 2008] Podcast about Groovy and G2
The 2G-Groovy/Grails Experience is just around the corner, and my buddy Scott Davis asked me to chat a bit about the talks I'm doing there ("Design Patterns" in Groovy, Groovyizing You Day Job, and Comparing JRuby and Groovy). That chat is now cast into pod, at this PodCast.

[February 5, 2008] Speaking again at the Gateway JUG
This is my third trip to St. Louis to speak at the Gateway JUG, and I always have fun there. The first time was about SOA (very practical), the second was about Agile project management and Mingle (very agile), and this time it was about Building DSLs in Static and Dynamic Languages (very futuristic). It was a great crowd and I hope I get back to St. Louis again soon.

Slides from my Building DSLs talk

[2008-01-22] Talking Head Video from CodeMash
I got ambushed by someone with a video camera again, but it wasn't too painful. Just after my keynote at CodeMash, someone from Enerjy approached me and asked if he could film me chatting about some of the themes I suggested in my keynote. Well, it isn't hard to get me to talk about software, so he filmed some short segments. He also nabbed some of the other speakers and asked them similar questions, putting them together in themed video shorts. The first one is here: myself and my friend Andy Glover talking about the perpetual argument of art vs. science in programming.

[January 18, 2008] My Blog...in Brazilian Portuguese
Occasionally, I get requests from developers who want to translate my blog entries to other languages. This time, it was my Developer Productivity Mean vs. Median blog entry from back in October. Always happy to spread my scattered ramblings far and wide, you can read it in Portuguese here.

[November 21, 2007] JRuby Podcast with Andrew Glover
My good friend Andy Glover interviewed me for a pod-cast for the Java World site recently, and it has magically appeared. From the blurb on the site:
Neal Ford and Andrew Glover are both well respected Java developers, as well as big fans of Ruby. In this in-depth discussion, Ford talks about why he believes Ruby is the most powerful language you could be paid to program with today, and explains the particular benefits of programming with JRuby. Ford also reveals why he believes Java developers will continue to migrate to languages other than Java, even as many continue to call the Java platform home. This is an essential, engaging discussion for those interested in learning more about JRuby and the trend toward what Ford calls polyglot programming.

Old News

News that isn't news anymore.