Kevin P. Taylor

Agile 2010 Presentation: Programmer Self-Education

At the Agile 2010 Conference in Florida, I'm happy to be presenting a 30 minute experience report entitled, Programmer Self-Education: My Year Studying Programming Language Fundamentals on Tuesday at 11:30.

Official Session Description

After attending Michael Feathers's talk at SCNA 2009 titled "Self-Education and the Craftsman," Kevin Taylor made a commitment to himself to read the revered, and despised, MIT textbook, "Structure and Interpretation of Computer Programs" (SICP). Over the next year, he spent hours each week working through challenging programming exercises in Lisp. In this talk, Kevin shares some of the programming fundamentals he discovered, or rediscovered. Kevin also shares his insights on the importance of self-education (knowledge + practice) for software craftsmen and their journey toward mastery.

Additional Insights

This session is about programmer self-education first and the material contained within SICP, second. Unfortunately, after considering how much SICP material I should present, it became painfully obvious that I wouldn't be able to do justice to any topics from the book within 30 minutes.

Since many of us aspire to become masters of our craft, I am using this brief session to discuss:

1. How/why I chose to spend my time with SICP, a seemingly impractical book.
2. Brief highlights of material I discovered/rediscovered in the book.
3. My general approach to self-education, which is applicable to any topic worth aspiring to master.

Frankly, this experience report could be expanded into a whole day or semester of material, so be prepared for a whirlwind, if you attend.

EDIT 1/10/2012: Here is a link to the presentation (this one given a few weeks after the agile conference):

http://vimeo.com/14611112

Command Line Scripts in Scheme

I write a fair number of command line scripts. Usually I use sh, bash, sed, awk, etc. Or, Ruby for heavy lifting. But, having spent the past nine months studying Scheme, why not try scripting in it? Now that I have, I can report that it is simple and leads to concise and elegant little scripts, with nice command line parsing and procedures to get to the system. And, the REPL, makes in convenient to experiment and hack.

Here is a basic script in Scheme. In it, I parse the command line for the passed argument and then echo it back out to the terminal. This should be enough to get you started.

#! /usr/bin/env mzscheme
#lang scheme
; parse arg out of command line
; and assign to arg
; automatically supports -h or --help flag
; supports custom flags also
(define arg
(command-line
#:args
(str) str))
; print out the arg
(printf "~a\n" arg)

"Self-Education and the Craftsman" SCNA Presentation

My favorite conference of the year was, not surprisingly, this summer's Software Craftsmanship North America, which was co-organized by Obtiva.

The presentations were challenging, diverse, and at times, uncomfortable. Because of several of those presentations, I've since had opportunities to question my own closely-held beliefs about our profession and my career as a professional programmer.

The presentation that had the biggest impact on me personally was Michael Feathers' "Self-Education and the Craftsman." (See the whole presentation.) Maybe this is because I am largely a self-educated programmer myself. And, many of the best hackers I've worked with have been self-educated. (That is an interesting phenomenon in our industry, which I'll save for a future post.)

Instead of a list of flavor-of-the-day APIs, frameworks, and languages, Feathers gave us a laundry list of important programming language topics that are widely-unknown or misunderstood among otherwise well-heeled programmers. These are topics that separate the master from the journeyman.

(Of course, it takes more than knowledge to achieve mastery. As George Leonard explains in Mastery, "to achieve mastery, you must practice a new skill patiently, diligently, and consistently."

Language Topics

In Feathers' talk, there was hardly a mention of Ruby on Rails or Spring 2.x or the JVM. Instead, he gave us this list of topics to wrestle with:

• Big-O, Little-O, Theta Notation,
• Covariance and contravariance,
• Types,
• Objects are closures,
• State machines,
• Regular expressions and automata,
• Turing machines,
• Halting problem,
• Worse is better,
• Redundancy is not a strength: How to make logic stronger,
• Security on Sand: "On Trusting Trust"
• Location transparency is a myth,
• Objects are clay.

Book Recommendations

In addition to the above list of topics to review or introduced myself to, as the case may be, Feathers gave us this list of must-read books:

• Structure and Interpretation of Computer Programs, by Abelson and Sussman
• Designing Object Systems, by Cook and Daniels
• Graphs: Theory and Algorithms, by Thulasiraman and Swamy
• Compilers: Principles, Techniques, and Tools, by Aho
• Discrete Mathematics with Combinatorics, by Anderson
• Introduction to the Theory of Computation, by Sipser

SICP Study Groups

Another of the outcomes of the Feathers presentation was the formation of several SICP study groups, based on his recommendation of the book.

Compilers: Principles, Techniques, and Tools study group, anyone?

(equal? (+ vim screen) '(lisp programming environment))

For the past few months, I've been involved in an SICP study group that uses Scheme as the programming language of choice. As most programmers know, Emacs is the de facto standard tool for Lispers. But, Vim + *nix shell is my preferred toolset: at least until I am convinced that another, more specialized tool is warranted. I don't dislike Emacs (that much). Since the SICP material is challenging enough, I decided not to complicate things by fiddling with Emacs.

So, instead, I was able to fiddle with Vim and cobble together a reasonable Lisp programming environment using Vim, screen, and the Scheme interpreter of choice for the SICP book, MIT/GNU Scheme.

To get this to work, I assume you are working on some *nix operating system, such as Mac OS X or Linux.

1. Install MIT/GNU Scheme
2. Install GNU screen
3. Install the Screen (vim + gnu screen) Vim plug-in
4. Add the following configuration lines to your .vimrc file (located in your home directory):

   "For screen.vim send block
   "to SendScreen function
   "(eg Scheme interpreter)
   vmap <C-c><C-c> :ScreenSend<CR>
   nmap <C-c><C-c> vip<C-c><C-c>
   

   These two lines map the CONTROL+c CONTROL+c (double Control-c) key sequence to the Vim command "vip" and then send the result of "vip" to the ScreenSend function (provided by the Screen plug-in). The net effect is that double Control-c will highlight whatever block of code your cursor is in and send that block to whatever process ScreenSend is mapped to. In our case, that will be the Scheme interpreter.
5. Now, we are ready to open a console window, fire up Vim, and write some Scheme code. After opening Vim, execute the ScreenShell command:

   :ScreenShell scheme
   

   This command will launch a screen instance, attach the currently running Vim process to the upper screen window, and then launch a new Scheme process and attach it to the lower screen window. This gives you a nice two window setup with your editor above and your interpreter below. Now you should see something like the following:
6. Let's go ahead and type some Scheme code in the top window, the Vim buffer:

   (+ 1 1)

   With your cursor somewhere on or between the opening and closing parentheses, type the double Control-c key sequence. You should see the code highlighted and then interpreted in the bottom window:
   

Tada! You now have a simple Lisp REPL programming environment.

There are lots of enhancements you'll want to make to this basic set-up if you plan to do any significant Lisp coding. For instance, you'll want to add plug-ins for syntax highlighting and parenthesis matching. But, this is a good start for exploring Lisp in your favorite editor.

Let me know other ways you've set up Vim to work with Lisp.

SICP Study Groups

One of my favorite outcomes from this summer's Software Craftsmanship North America conference, which Obtiva co-organized, is the SICP study groups. SICP refers to the MIT computer science textbook, Structure and Interpretation of Computer Programs, which is one of the most lucid, and challenging, foundational texts on the subject of computer programming languages.

The reason I am so inspired by the SICP study group phenomenon is that it highlights what I love most about programmers, and more specifically, software craftsmen. Even before we used that label, passionate hackers have been forming user groups, book clubs, IRC channels, and mailing lists, to gather, discuss, and challenge each other's ideas. And, through that, refine their own.

SICP itself is a walk through the esoteric Lisp dialect called Scheme. While on that walk, readers learn about abstractions, objects, closures, recursion, meta-programming, logic programming, and interpreters and compilers.

In fact, there are no mentions of any of the exciting new technologies, frameworks, or languages that will help land a gig. Nothing learned in the book will immediately increase the value of a resume or cause said resume to trigger a recruiter's keyword search on Dice.

So, why are dozens of experienced programmers, many of them the alpha-geeks on their teams, spending their time working through this difficult textbook together? They want to understand. The fundamentals. The whys. The history. The art. The craft. They want to understand the field.

The best professional basketball players on a team are also the last to leave the court after practice has ended. They continue to practice their free throw, their lay up, and their jump shot, long after teammates have showered and left the building.

We are practicing our jump shots.