Good Computer Science Reading

• NEC Research Index - Computer Science Directory - is an extraordinary resource. An incredible number of academic papers are categorized and indexed (search page). Each document has its own page containing an abstract, links to on-line copies of the paper (usually in PostScript and PDF format), links to papers in the index that cite the given paper, links to related documents, and more.

• "Language Research: Functional Languages and Object-Oriented Programming" by John DiCamillo - a brief overview of functional programming and languages.
• "Object-Oriented Scanning and Parsing" by John DiCamillo - an interesting overview of the design and implementation in C++ of scanners and parsers intended for special purpose languages; e.g., for embedding in tools.
• "Usability and Class Library Design: Guidelines for Simplicity and Power" by Arthur T. Jolin, in Dr. Dobb's Journal, October 1996 - an excellent set of general guidelines for designing class libraries and object frameworks.
• "Building Bug-Free O-O Software: An Introduction to Design by Contract" from ISE, Inc. - sounds like it was written by Bertrand Meyer and, like anything he writes, it was both interesting and worthwhile to read.
• "SWIG: An Easy to Use Tool for Integrating Scripting Languages with C and C++" by David M. Beazley, from the 4th Annual Tcl/Tck Workshop - describes a tool, SWIG, for automatically generating bindings of scripting language commands to user-written C and C++ functions and variables. Of particular interest is the capability of adapting the tool to arbitrary scripting languages; e.g., Tcl, Perl, etc. A generic Language class defines methods for emitting the C++ code that implements the binding of scripting language constructs to C++ constructs: create_function(), link_variable(), declare_const(), etc. To generate bindings for a new scripting language, derive a new class from Language and override the methods to genearte the appropriate C++ "wrappers" for the scripting language.
• C++?? A Critique of C++ by Ian Joyner - hasn't slowed the juggernaut - or should I say, bandwagon.
• "Java and the New Internet Programming Paradigm" adapted from Edward Yourdon's Rise & Resurrection of the American Programmer - a fairly in-depth overview of the capabilities and features of Java, including an interesting look at its potential impact on the software industry.
• Steve McConnell's web site has his "Best Practices" columns from IEEE Software, some articles from Software Development, and excerpts from his Code Complete and Rapid Development books.
• "Eiffel vs. C++: One Language Designer's View" by Bertrand Meyer - a USENET posting from 1989. Back then, multiple inheritance and templates in C++ were just "around the corner" and exception handling was just a gleam in someone's eye. Eiffel, of course, already had all three; see my own "TPOCC and Object-Oriented Programming".
• "Effective STL" by David Harvey - is one among several useful and well-written articles of his on C++ and the Standard Template Library. Also see G. Bowden Wise's well-done "An Overview of the Standard Template Library".
• "Threads: Just Say No" by Michael Spertus - argues against the use of threads. It is one of a number of columns and feature articles available from the on-line magazine, Object Currents; each monthly issue also includes links to on-line articles from its hardcopy sister publications: C++ Report, JOOP, etc. On the subject of threads, also see John Ousterhout's presentation, "Why Threads Are a Bad Idea (For Most Purposes)".
• "Scripting: Higher Level Programming for the 21st Century" by John Ousterhout - appears (to me) to be a subtle attempt to make people realize that Java is not the be-all and end-all of the world. This white paper is vintage Ousterhout: very readable, very interesting, and making very good points.
• "Samba - Unix Talking with PC's" by Andrew Tridgell - is, truthfully, an "entertaining account of the development of the Samba package" and is one of a number of equally entertaining articles available on-line from Linux Journal.
• "libscheme: Scheme as a C Library" by Brent W. Benson, Jr. - describes a well-designed, embeddable Scheme interpreter inspired by the embeddable Tcl interpreter. In the same vein are:
  • Elk, a deluxe, embeddable Scheme interpreter with all the bells and whistles, described in Oliver Laumann's and Carsten Bormann's, "Elk: The Extension Language Kit"
  • MzScheme, another deluxe Scheme interpreter, patterned after libscheme and described in Matthew Flatt's, "Inside MzScheme".
• "Escaping the Event Loop: An Alternative for Multi-Threaded GUIs" by Matthew Fuchs - makes the interesting point that the reactive style of programming with event loops is equivalent to continuation passing style. Fuchs then attempts to show how using continuations as callbacks simplifies the implementation of a multi-threaded program in the context of an event loop, but he loses me at this point.
• "Erlang - A Survey of the Language and Its Industrial Applications" by Joe Armstrong - presents an overview of Erlang, a virtual machine-based, industrial-strength, functional language used to write operational, real-time, telecommunications software. This article made my blood boil - why do we put up with the likes of C++ and Java?
• Revised(4) Report on the Algorithmic Language Scheme edited by William Clinger and Jonathan Rees - is a concise, but very readable specification for the Scheme language, often contrasted with the lengthy and dry specifications of other languages. (This is apparently the official home of R^4RS - the HTML document is correctly formatted and the bibiliography has links to the proper, 2-column PostScript version of the report.)
• "A Distributed Computing Model for Telemetry Data Processing" by Matthew Barry, Kevin Scott, and Steven Weismuller - presents the Information Sharing Protocol (ISP) used to distribute Space Shuttle telemetry and other data to remote computers. In a nutshell, distributed data servers publish data to which clients can subscribe. The paper discussed a number of applications of ISP, but was lacking in implementation details. These can be found, however, in the User's Guide.
• ARIANE 5 Flight 501 Failure - is the report from the Inquiry Board which investigated the failure shortly after launch of the Ariane 5 rocket in June 1996. (Original 18-page ESA report plus 42 slides in PDF format.) Briefly, failure in a software module (reused from Ariane 4) which shouldn't have been active post-launch caused CPUs in both the active and backup Inertial Reference Systems (SRI) to halt. As a result, erroneous attitude data was forwarded to the main computer, which then attempted to correct for the extreme "attitude" of the launch vehicle. The report is very readable and well-worth reading, particularly the final conclusions and recommendations. Also see:
  • "Put It in the Contract: The Lessons of Ariane" by Jean-Marc Jézéquel and Bertrand Meyer - suggests that if the reused software from Ariane 4 had been written following the Design By Contract principle, the potential violation of constraints (which in fact caused the actual failure) would have been detected earlier during the Ariane 5 software design, build or test.
  • "Critique of 'Put It in the Contract: The Lessons of Ariane'" by Ken Garlington - is an informed response to Jézéquel's and Meyer's not-totally-convincing thesis.
  • Usenet comments on "Put it in the contract: The lessons of Ariane", compiled by Jean-Marc Jézéquel.
  • "The Ariane 5 Accident: A Programming Problem?" by Peter B. Ladkin.
• "Experiences Converting a C++ Communication Software Framework to Java" by Prashant Jain and Douglas C. Schmidt, in C++ Report, January 1997 - discusses the conversion of ACE from C++ to Java. Also see Schmidt's other on-line publications.
• "Cygwin32: A Free Win32 Porting Layer for UNIX® Applications" by Geoffrey J. Noer. Also see the Cygwin home page.
• "Back to the Future: The Story of Squeak, A Practical Smalltalk Written in Itself" by Dan Ingalls, Ted Kaehler, John Maloney, Scott Wallace, and Alan Kay, in OOPSLA '96 (or '97?) - describes the design and implementation of a portable Smalltalk software development environment - very interesting and very impressive! Also see the Squeak home page for more documentation and ports to Windows 95 and NT, Macintosh, most UNIX platforms, various PDAs, Acorn's RiscOS, OS/2, DOS, BeOS, and NeXT.
• "Beating the Averages" by Paul Graham - a brief and interesting article about his startup company's successful use of Lisp for web applications. He makes some very good points about programmers' choice of languages, although his trashing of COBOL seems to show a common lack of knowledge of the language. Also see his other articles.
• "UTF-8 and Unicode FAQ for Unix/Linux" by Markus Günther Kuhn - is a comprehensive combination of information and links on Unicode and its UTF-8 encoding in the UNIX environment. Rob Pike and Ken Thompson describe the incorporation of UTF-8 into the Plan 9 operating system in "Hello World or ...". (Does anyone have a current link to a PostScript version of the paper?) Mark Davis emphasizes the distinctions between characters, glyphs, code points, and code units in "Forms of Unicode". Richard Gillam's experience in "Adding internationalization support to the base standard for JavaScript" echoes, in some ways, that of the Plan 9 folks.
• "The Long, Painful History of Time" by Erik Naggum - written in 1999 (i.e., pre-Y2K), this is a fascinating discussion of time, calendars, the representation of time and time intervals on computers, the manipulation of computer time, and a proposed (and implemented) Common Lisp package that avoids many of the time problems faced by application developers. Also see Markus Kuhn's "A Summary of the International Standard Date and Time Notation", Jukka Korpela's "Info on ISO 8601, the date and time representation standard", Peter Meyer's "Calendar Studies", J. R. Stockton's date and time pages, and the ISO 8601 standard itself (1997 version, PDF format).
• Softpanorama: (slightly skeptical) Open Source Software Educational Society - a wealth of articles and links about a variety of computing topics.