I recently received an email asking me, “ Do you know of any good books about developing software or thinking in abstraction? I have books, but how did you train your mind?”
I'm not sure I even have a clue. I think that some of the things I've read and worked on were influential, but it isn't clear to me whether anyone else would agree. I've met people that have read the same books and their thought processes are completely alien to me. I know people that are very good at what they do, and reach solid, well-engineered solutions, but I cannot talk with them because they seem to have an insane basic approach to understanding. I've also been on the other end of this where I cannot seem to get the other person to understand a very simple idea on which everything hinges. But since this is a blog, I hardly need to be informed to express an opinion.
College was a huge influence on my thinking. I was fortunate enough to learn from some of the luminaries not only in Computer Science, but also in Math (Gian-Carlo Rota, Alar Toomre), Material Science (August Witt), Physics (I forget), Film (Richard Leacock), etc. What I noticed was that these really smart people spent an awful lot of their time and energy thinking about and talking about the basics and fundamentals. Over and over again they would stress going back to first principles. They invariably would lecture about “creating a model” to help in understanding. In the introductory courses, we'd focus on the commonly used models, but the professors would usually show us alternative models that had interesting properties. In the advanced courses, we would often use several different models. Sometimes the models were apparently contradictory, but were nonetheless useful.
6.001, Structure and Interpretation of Computer Programs, was heavily oriented towards controlling complexity with abstraction. To a large extent, it wasn't a programming course, but a survey course that explored a huge number of abstractions that have been found useful. The fact that it used Scheme as an expository language is irrelevant. The real point of the course was to look at the many different techniques of abstraction and to illustrate the commonalities and differences between them. However, the difficulty of the course tended to obscure this for many students. When you're trying to learn the syntax and semantics of a language, you can easily get bogged down in the minutiae and miss the big picture. For example, the “Triangle Language” problem set made heavy use of higher-order procedures.
The pedagogic goal was twofold: to become comfortable manipulating procedures as first-class objects, but also to be able to create an abstract model of picture composition through triangle-oriented primitives. At the abstract level, we had triangular `pictures' that could be decomposed by cutting larger triangles into sections, or composed by pasting smaller triangles together with scaling and rotation.
The Triangle Language is not a very complex language. It is not very general or useful. It is simply an example of a trivial domain-specific language. It is possible for a student to do the entire problem set, learn a huge amount about higher-order procedures, ace the quiz, and completely miss the point about solving a problem through creating a domain-specific toolkit. Many did. It was ok because every problem set contained some more examples of this. Eventually it will sink in.
6.004 also spent a lot of time talking about different abstractions, but it proceeded differently. We started with the linear model of a transistor, then developed the digital abstraction, from there we had switches. With a couple of more electronic elements, we could implement combinational logic. The combinational logic could be used to implement flip-flops and finite state machines. The state machines, combined with some memory, could implement simple push-down automata and stack machines. A stack machine is a good target for a higher level language, so we could write a compiler. The really interesting part of this course was the lab work where we'd wire these things up. Each week we'd augment the circuits built the previous week and we had built a small computer by the time we got to the end of the course. What was good about this was that you could see all the levels of abstraction at once. The little black transistors over on that side of the board were implementing a gate in a state machine that drove the clock for the microcode unit. You could look at the transistor as switching bits, computing part of a trivial function, or throttling electrons, whichever abstraction was the most relevant at the time.
I guess that the old maxim “practice makes perfect” is true. I trained my mind — They trained my mind by constantly teaching about various abstractions.
As for books, I obviously recommend Structure and Interpretation of Computer Programs, but there aren't many books that just talk about abstractions. It is well worth learning alternative abstractions to things you already know. Hamiltonian and Lagrangian physics has a different view than Newtonian physics, for example. (Unfortunately, it is hard to just get a simple introduction to Lagrangian and Hamiltonian physics.) It unfortunate that many useful alternative abstractions are very poorly taught. Try to find alternative abstractions that make sense to you. Try recasting familiar ideas in different abstractions (this can be fun and bizarre if the abstraction is from an unrelated subject). Rewrite a program based on a completely different abstract model. Try to simplify a complex program to the minimal abstraction possible. Just keep on practicing!
Tuesday, February 14, 2012
| INTERNATIONAL LISP CONFERENCE 2012 |
| http://www.international-lisp-conference.org |
| Campus Plaza Kyoto, Kyoto, Japan - October 21-24, 2012 |
| Sponsored by: The Association of Lisp Users |
The Association of Lisp Users is pleased to announce the 2012
International Lisp Conference will be held in Kyoto, Japan at
Campus Plaza Kyoto from October 21st to 24th, 2012.
This year's program consists of tutorials at beginners' and
advanced levels, prominent invited speakers from the Lisp
communities, an excellent technical session, tours of
Jidai-Matsuri: festival enjoyed by people of all ages,
participating in its historical reenactment parade dressed in
authentic costumes representing various periods, and characters
in Japanese feudal history.
General conference announcements are made on a very occasional
basis to the low-volume mailing list
Original submissions in all areas related to the conference themes
are invited for the following categories:
Papers: Technical papers of up to 15 pages that describe original
Demonstrations: Abstracts of up to 2 pages for demonstrations of
tools, libraries and applications.
Workshops: Abstracts of up to 2 pages for groups of people who
intend to work on a focussed topic for half a day.
Tutorials: Abstracts of up to 2 pages for indepth presentations
about topics of special interest for 90 - 180 minutes.
Panel discussions: Abstracts of up to 2 pages for discussions about
current themes. Panel discussion proposals must mention panel
member who are willing to partake in a discussion.
Lightning talks: Abstracts of up to one page for talks to last
for no more than 5 minutes.
Please send contributions before the submission deadline, including
abstracts of 4 pages for technical papers and abstracts of 2 pages
for all other categories.
Deadline for abstract submissions: July 15, 2012
Notification of acceptance or rejection: July 31, 2012
Deadline for final paper submissions: August 31, 2012
Papers to be presented should be submitted electronically at
and need to use the ACM format
Lisp is one of the greatest ideas from computer science and a
major influence for almost all programming languages and for all
sufficiently complex software applications.
The International Lisp Conference is a forum for the discussion of
Lisp and, in particular, the design, implementation and
application of any of the Lisp dialects. We encourage everyone
interested in Lisp to participate.
We invite high quality submissions in all areas involving Lisp
dialects and any other languages in the Lisp family, including,
but not limited to, ACL2, AutoLisp, Clojure, Common Lisp,
ECMAScript, Dylan, Emacs Lisp, ISLISP, Racket, Scheme, SKILL, etc.
Topics may include any and all combinations of Lisp and:
* Language design and implementation
* Language integration, inter-operation and deployment
* Applications (especially commercial)
* Reflection, meta-object protocols, meta-programming
* Domain-specific languages
* Programming paradigms and environments
* Parallel and distributed computing
* Theorem proving
* Scientific computing
* Data mining
* Semantic web
General Chair: KURODA Hisao (Mathematical Systems Inc. / ALU)
Members: Daniel Herring (ALU)
Jon L White (ALU)
Rusty Johnson (ALU)
Program Chair: Hiroshi Okuno (Kyoto Univ.)
Members: Keith Corbett (Clozure Associates)
Alex Fukunaga (University of Tokyo)
Antonio Leitao (INESC-ID)
Joe Marshall (MIT)
Scott Mckay (ITA software)
Nancy Reed (University of Hawaii)
Kent Pitman (nhplace.com)
Duane Rettig (Franz Inc.)
Didier Verna (EPITA)
Takuo Watanabe (Tokyo Institute of Technology)
Edi Weitz (weitz.de)
Taiichi Yuasa (Kyoto University)
Local chair: Tetsuya Ogata (Kyoto Univ.)
Members: CHIBA Masaomi
* General Questions: ilc12-organizing-committee at alu.org
* Program Committee: ilc2012 at easychair.org
For more information, see http://www.international-lisp-conference.org
Posted by Joe Marshall at 9:28 AM