Glenn Vanderburg

: Blog

3 of 3 articles
Agility for students, revisited
Tue, 19 Nov 2002 (12:31) #
Since writing about teaching agility to computer science students, I've had a few more ideas, plus excellent suggestions from Patrick Linskey and Michael McCracken.

Patrick's suggestion (which I can't believe I didn't think of myself) is to teach them more about the history of our field. We don't have to make computer science students scholars of computer history, but we should give them some idea of the rich scope of the topic. Introductory computer courses tend to cover Babbage, Turing, and von Neumann, and then skip straight to Bill Gates. And for most CS students, that's the end of it.

Michael's suggestion is this:

... professors often understand the distinction between teaching skills for their own sake and teaching them as applications of more general principles. It's important to convey that to the students as well. Giving an idea of trends and perspective helps breed the kind of healthy skepticism about tools and paradigms that Glenn mentions.
That's absolutely right. All too frequently I meet young programmers who are confused about that -- they think the particular techniques and tools they were taught are the fundamental things.

Here are the other things I've thought of:

  • Computer science students should learn, even as undergraduates, to read technical papers, and how to find them. (I have suggestions for anyone who's looking for seminal papers that are well written and approachable.)
  • Along the same lines as Patrick's suggestion: teach them about the great personalities of the field. Knuth, Hoare, Dijkstra, Englebart, Kay, Moore, Cray, Cocke, Hopper, Dahl, Thompson, Ritchie, Kernighan, McIlroy, Bentley, McCarthy, Minsky, Wirth, Steele, and many, many others are important not just for their technical contributions, but also for the color and vibrance they've brought to our field and its history. Learning about them and their relationships helps bring our past and present to life.
  • Help students to understand that there are communities of developers that they will be joining, and that those communities are where much of the advancement comes from. User groups, mailing lists, wikis, and blogspace are just some examples. Show students how they can be contributors, not just users.
  • Somewhere, years ago, I heard that one of the characteristics of "the professions" (medicine, law, architecture, engineering, etc.) was that professionals were expected to keep their education current. I have some friends who are doctors, and their homes and offices are always full of current medical journals. I often hear people complain that as a field we are not more "professional," and yet few programmers take that responsibility seriously. It's amazing how many programmers with years of experience have never read a book about programming (as opposed to just an API reference or tutorial) since they left school. That ethic of continued self-education should be taught to CS students, if they are to call themselves professionals.
  • Students need to leave school with some knowledge of ideas that are out of the mainstream. ZUIs, magic lenses, pie menus. Plan 9, BeOS. AOP, intentional programming, multiparadigm programming. Mob software. And many, many more.
Agility for students
Fri, 15 Nov 2002 (12:54) #
Last night I gave a talk on Extreme Programming and the principles of agile development to the Fort Worth IEEE/CS. It went very well -- the attendance was good, there was a lot of interest, and there were many good questions at the end. I was filling in for Dave Thomas, who couldn't make it due to a death in the family, so I was very glad it went so well. (I didn't want them to be disappointed with the second-stringer!)

The first question after I concluded was from a TCU Computer Science professor who said, "As an academic, what can I do to prepare my students for environments like this?" My first answer was, "Can we have lunch? Because the answer to your question is long." But then I gave her a short answer: teach your students not just to write code, but to read it, and read code written by other people, and then to add features to it to test whether they've understood it. She seemed happy with that (I gather she's already doing a lot of that, as well). But there is more to it than that. Here are some things I've thought of:

  • Teach the students the principles of emergent behavior, so they'll be comfortable with the ideas of evolutionary design.
  • Teach them about refactoring and the ways in which software is malleable. Teach them how this can be used as a feedback mechanism to incorporate what you learn into the design.
  • Teach them the history of engineering, and encourage discussion about where software development currently sits on the path to maturity that the other engineering disciplines have gone through.
  • Discuss the ways in which software development is similar to other engineering disciplines, and how it differs. Likewise, discuss similarities with art, craft, and science.
  • Teach them skepticism about tools, and explain how the state of the software development art (in terms of platforms, techniques, and paradigms) always runs slightly ahead of tool support, so those who aren't dependent on fancy tools have an advantage.
  • Teach students that we don't really understand software development that well, and the techniques they are learning today aren't necessarily the best way to do things.
  • You won't have time to teach them everything about computer science, but at least give them glimpses of the many things they don't know.

If anybody has any more ideas, please let me know. (Also let me know if you disagree with any of the ones I listed.) She's hip, she gets it, and we certainly need computer science professors who genuinely want to know the answer to the question she asked. I want to give her great answers.

Herding Racehorses, Racing Sheep
Tue, 22 Oct 2002 (20:37) #
My friends Dave Thomas and Andy Hunt -- the Pragmatic Programmers -- are always teaching me new things. This time, it's "The Dreyfus Model of Skills Acquisition." I ran across the slides from Andy's talk at JAOO. Everyone involved in software development should be aware of this.

The funny thing, to me, is where I think it came from. A few months ago, while Dave and I were having lunch one day, he mentioned that he was reading a book about the history of nursing. My first thought was "that's weird," followed immediately by "I bet he'll learn something interesting that applies to programming." And sure enough, there are strong hints in Andy's talk that they learned of the Dreyfus model through historical connections with the nursing profession.

One of the slides makes this point:

Experience comes from practice. (Broad and general, not narrow and specific.)
Dave and Andy certainly cast their nets wide, and they are prime examples of the value of a generalist approach.