Resources
Miscellaneous resources
Abadi, Martin, and Luca Cardelli. 1996. A Theory of Objects. New York: Springer. Although not a mathematical concept, object-oriented programming has obtained rigor with this gem.
Abelson, Harold, and Gerald Jay Sussman. 1988. “Lisp: A Language for Stratified Design.” MIT, AI Memo 986.
Abelson, Harold, and Gerald Jay Sussman. 1996. Structure and Interpretation of Computer Programs. Cambridge, MA: MIT Press. There is no better book for learning Scheme and the fine art of programming.
Abiteboul, Serge, Richard Hull, and Victor Vianu. 1995. Foundations of Databases. Boston: Addison-Wesley. Clojure’s clojure.set namespace is actually modeled more on the named conjunctive algebra, for which this book provides a great reference.
Armstrong, Joe. 2007. Programming Erlang. Raleigh, NC: Pragmatic Bookshelf.
Armstrong, Joe. 2007. “A History of Erlang.” Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages.
Bagwell, Phil. 2001. Ideal Hash Trees. Technical report. Clojure’s persistent data structures owe a lot to Phil Bagwell’s paper.
Baker, Henry. 1993. “Equal Rights for Functional Objects or, The More Things Change, The More They Are the Same.” ACM SIGPLAN OOPS Messenger 4, no. 4.
Beck, Kent. 2002. Test Driven Development: By Example. Boston: Addison-Wesley.
Bloch, Joshua. 2008. Effective Java. Upper Saddle River, NJ: Addison-Wesley.
Boncz, Peter, Zukowski Marcin, and Niels Nes. 2005. “MonetDB/X100: Hyper-Pipelining Query Execution.” Proceedings of the CIDR Conference. This paper motivated the implementation of chunked sequences.
Bratko, Ivan. 2000. PROLOG: Programming for Artificial Intelligence. New York: Addison Wesley.
Budd, Timothy. 1995. Multiparadigm Programming in Leda. Reading, MA: Addison-Wesley. This is an expanded discussion of the complexities wrought from a mono-paradigm approach to software development.
Clinger, William. 1998. “Proper Tail Recursion and Space Efficiency.” Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation.
Cormen, Thomas, Charles Leiserson, Ronald Rivest, and Clifford Stein. 2009. Introduction to Algorithms. Cambridge, MA: MIT Press. This is a great reference on algorithmic complexity and Big-O, and as an added bonus, you could use it to stop a charging rhinoceros.
Crockford, Douglas. 2008. JavaScript: The Good Parts. Yahoo Press.
Date, C.J. 2009. SQL and Relational Theory: How to Write Accurate SQL Code. Sebastopol, CA: O’Reilly.
Dijkstra, Edsger Wijbe. 1959. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1. You could change the h function in listing 7.3 to (defn dijkstra-estimate-cost [step-cost-est sz y x] 0) to conform to the ideal presented in this paper.
Flanagan, David. 2006. JavaScript: The Definitive Guide. Sebastopol, CA: O’Reilly.
Forman, Ira, and Nate Forman. 2004. Java Reflection in Action. Greenwich, CT: Manning. Although reflection provides some meta-level manipulation, it’s quite apart from the notion of functions as data.
Friedl, Jeffrey. 1997. Mastering Regular Expressions. Sebastopol, CA: O’Reilly.
Friedman, Daniel, Mitchell Wand, and Christopher T. Haynes. 2001. Essentials of Programming Languages. Cambridge, MA: MIT Press.
Friedman, Daniel, Oleg Kiselyov, and William Byrd. 2006. The Reasoned Schemer. Cambridge, MA: MIT Press. A beautiful book that describes, in detail, a logic engine in less than 100 lines of code.
Gabriel, Richard, and Kent Pitman. 2001. “Technical Issues of Separation in Function Cells and Value Cells.” Originally published in Lisp and Symbolic Computation 1, no. 1 (1988). This is a more thorough examination of the differences between Lisp-1 and Lisp-2.
Gamma, Erich, Richard Helm, Ralph Johnson, and John Vlissides. 1995. Design Patterns: Elements of Reusable Object-Oriented Software. Reading, MA: Addison-Wesley.
Ghosh, Debasish. 2010. DSLs in Action. Greenwich, CT: Manning. There is a much finer level of distinction determining what constitutes whole cloth, including that between internal and external DSLs. In this book, we focus on the classical Lisp model of internal DSLs, but DSLs in Action provides a survey of many DSL-creation techniques.
Glickstein, Bob. 1997. Writing GNU Emacs Extensions. Sebastopol, CA: O’Reilly.
Goetz, Brian. 2006. Java Concurrency in Practice. Upper Saddle River, NJ: Addison-Wesley. Why haven’t you read this yet?
Goldberg, David. 1991. “What Every Computer Scientist Should Know About Floating-Point Arithmetic.” Computing Surveys (March).
Graham, Paul. 1993. On Lisp. Englewood Cliffs, NJ: Prentice Hall. Is there any book or any author more influential to the current generation of dynamic programmers than Graham and On Lisp?
Graham, Paul. 1995. ANSI Common Lisp. Englewood Cliffs, NJ: Prentice Hall.
Gray, Jim, and Andreas Reuter. 1992. Transaction Processing: Concepts and Techniques. San Mateo, CA: Morgan Kaufmann Publishers.
Halloway, Stuart. 2009. “Clojure Is a Better Java Than Java.” Presented at the Greater Atlanta Software Symposium. The origin of the phrase “Java.next” most likely stems from this talk by Halloway.
Hart, Peter, Nils Nilsson, and Bertram Raphael. 1968. “A Formal Basis for the Heuristic Determination of Minimum Cost Paths.” IEEE Transactions on Systems Science and Cybernetics in Systems Science and Cybernetics 4, no. 2.
Hart, Timothy. 1963. MACRO Definitions for LISP. MIT AI Memo AIM-57 (October). Existing copies of this amazing three-page memo are blurred to the point of near incomprehensibility. But if you take the time to digest its contents, you’ll understand how macros are facilitated by a pre-evaluation-evaluation step! That is, the new algorithm for evaluation in Lisp could be: 1) read; 2) eval macros; 3) eval what comes out of the macros.
Heinlein, Robert. 1966. The Moon Is a Harsh Mistress. New York: Putnam. We had considered offering an implementation of Mike as an appendix, but we ran over our page count.
Herlihy, Maurice, and Eliot Moss. 1993. “Transactional Memory: Architectural Support for Lock-Free Data Structures.” Proceedings of the 20th Annual International Symposium on Computer Architecture 21, no. 2 (May). In our opinion, a very lucid description of transactional memory.
Herlihy, Maurice, and Nir Shavit. 2008. The Art of Multiprocessor Programming. Amsterdam; Boston: Elsevier/Morgan Kaufmann.
Hewitt, Carl, Peter Bishop, and Richard Steiger. 1973. “A Universal Modular ACTOR Formalism for Artificial Intelligence.” Proceedings of the Third International Joint Conference on Artificial Intelligence.
Hickey, Rich. 2009. “Are We There Yet?” Presented at the JVM Languages Summit. This wonderful presentation made firm the popular view of Rich as Philosopher Programmer.
Hofstadter, Douglas. 1979. Gödel, Escher, Bach: An Eternal Golden Braid. New York: Basic Books. See the sections “Classes and Instances,” “The Prototype Principle,” and “The Splitting-off of Instances from Classes” for more detail of the topics in section 9.2.
Hoyte, Doug. 2008. Let Over Lambda. Lulu.com. This is an amazing look into the mind-bending power of Common Lisp macros that provided the motivation for the DSLs section of this book. It will blow your mind—in a good way.
Hudak, Paul. 2000. The Haskell School of Expression: Learning Functional Programming Through Multimedia. New York: Cambridge University Press.
Huet, Gerard. 1997. “Functional Pearl: The Zipper.” Journal of Functional Programming 7, no. 5.
Hutton, Graham. 1999. “A Tutorial on the Universality and Expressiveness of fold.” Journal of Functional Programming 9, no. 4.
Iverson, Kenneth. 1962. A Programming Language. New York: Wiley. A beautifully written book that strives to find a universal notation of computation that eventually became the APL programming language.
Kahan, William, and Joseph Darcy. 1998. “How Java’s Floating-Point Hurts Everyone Everywhere.” Presented at the ACM Workshop on Java for High-Performance Network Computing. This paper provides more information on the cyclopean nightmares awaiting you in Java floating point.
Keene, Sonya. 1989. Object-Oriented Programming in Common Lisp: A Programmer’s Guide to CLOS. Boston: Addison-Wesley. The best book on CLOS ever written.
Knuth, Donald. 1997. The Art of Computer Programming: Volume 1 - Fundamental Algorithms. Reading, MA: Addison-Wesley. This book goes into exquisite detail about the primary characteristics of FIFO queues and is highly recommended reading.
Knuth, Donald. 1998. The Art of Computer Programming, Vol. 3: Sorting and Searching. Reading, MA: Addison-Wesley. Running quick-sort on a sorted sequence is an O(n2) operation, which for our implementation in chapter 6 completely defeats its laziness.
Koenig, Dierk, Andrew Glover, Paul King, Guilaume LaForge, and Jon Skeet. 2007. Groovy in Action. Greenwich, CT: Manning.
Kuki, Hirondo, and William James Cody. 1973. “A Statistical Study of the Accuracy of Floating Point Number Systems.” Communications of the ACM 16, no. 4.
Laddad, Ramnivas. 2003. AspectJ in Action: Practical Aspect-Oriented Programming. Greenwich, CT: Manning. We don’t do justice to the notion of aspects—so read this instead.
Levin, Mike. 1963. LISP 1.5 Library, November 1963. Computer History Museum, Herbert Stoyan Collection on LISP Programming (lot X5687.2010). Available on Paul McJones’s Lisp history archive at http://mng.bz/5CAa. This archive is pure gold.
Martin, Robert. 2002. Agile Software Development: Principles, Patterns, and Practices. Upper Saddle River, NJ: Prentice Hall.
McCarthy, John. 1960. “Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I.” Communications of the ACM 3, no. 4. This is the essay that started it all.
McCarthy, John. 1962. LISP 1.5 Programmer’s Manual. Cambridge, MA: MIT Press. Lisp had an array type at least as early as 1962. Sadly, this fact is little known.
McConnell, Steve. 2004. Code Complete: A Practical Handbook of Software Construction. Redmond, WA: Microsoft Press.
Meyer, Bertrand. 1991. Eiffel: The Language. New York: Prentice Hall. The programming language Eiffel relies heavily on contract-based programming methodologies, a cornerstone element of Fogus’s philosophy of Apperception-Driven Development.
Meyer, Bertrand. 2000. Object-Oriented Software Construction. Upper Saddle River, NJ: Prentice Hall.
Michie, Donald. 1968. “Memo Functions and Machine Learning.” Nature 218.
Mooers, Calvin, and Peter Deutsch. 1965. “TRAC, A Text-Handling Language.” ACM, Proceedings of the 1965 20th National Conference.
Moseley, Ben, and Peter Marks. 2006. “Out of the Tar Pit.” Presented at SPA 2006.
Mozgovoy, Maxim. 2009. Algorithms, Languages, Automata, and Compilers: A Practical Approach. Sudbury, MA: Jones and Bartlett Publishers.
Noble, James, and Brian Foote. 2003. “Attack of the Clones.” Proceedings of the 2002 Conference on Pattern Languages of Programs 13. The clone function is inspired by this paper.
Norvig, Peter. 1991. Paradigms of Artificial Intelligence Programming: Case Studies in Common Lisp. San Francisco: Morgan Kaufman Publishers.
Odersky, Martin, Lex Spoon, and Bill Venners. 2008. Programming in Scala: A Comprehensive Step-by-Step Guide. Mountain View, CA: Artima.
Okasaki, Chris. 1996. “The Role of Lazy Evaluation in Amortized Data Structures.” Presented at the International Conference on Functional Programming. This is a much more thorough discussion of incremental versus monolithic computation.
Okasaki, Chris. 1999. Purely Functional Datastructures. Cambridge University Press. Chris Okasaki to the rescue again! Clojure’s persistent queue implementation is based on Okasaki’s batched queue from this seminal work.
Olsen, Russ. 2007. Design Patterns in Ruby. Upper Saddle River, NJ: Addison-Wesley.
Papadimitriou, Christos. 1986. Theory of Database Concurrency Control. New York: Computer Science Press, Inc.
Pierce, Benjamin. 2002. Types and Programming Languages. Cambridge, MA: MIT Press. Fun fact: representing numbers using lambda calculus is known as church encoding. The church-encoded number 9 would be represented as (fn [f] (fn [x] (f (f (f (f (f (f (f (f (f x))))))))))) in Clojure.
Raymond, Eric. 2003. The Art of Unix Programming. Reading, MA: Addison-Wesley Professional.
Rosenberg, Doug, Mark Collins-Cope, and Matt Stephens. 2005. Agile Development with ICONIX Process: People, Process, and Pragmatism. Berkeley, CA: Apress.
Shavit, Nir, and Dan Touitou. 1997. “Software Transactional Memory.” Distributed Computing 10, no. 2 (February). This paper introduced the first software model of transactional memory.
Skeel, Robert. 1992. “Roundoff Error and the Patriot Missile.” SIAM News 25, no. 4.
Steele, Guy L. 1977. “Lambda: the Ultimate GOTO.” ACM, Proceedings of the 1977 Annual Conference.
Steele, Guy L. 1990. Common LISP: The Language. Bedford, MA: Digital Press. This is a very witty book in addition to being packed with information.
Steele, Guy L., and Gerald Sussman. 1978. “The Art of the Interpreter.” MIT, AI Memo 453.
Stewart, Ian. 1995. Concepts of Modern Mathematics. New York: Dover. These Dover math books are often true gems. It would be great to see an adventurous publisher print a similar series revolving around C.S.-relevant topics—monads, category theory, lambda calculus, and so on.
Sussman, Gerald, and Guy L. Steele. 1975. “Scheme: An Interpreter for the Extended Lambda Calculus.” Higher-Order and Symbolic Computation 11, no. 4. This is a discussion of Scheme’s early implementation of lexical closures.
Symbolics Inc. 1986. Reference Guide to Symbolics Common Lisp: Language Concepts. Symbolics Release 7 Document Set.
Thompson, Simon. 1999. Haskell: The Craft of Functional Programming. Reading, MA: Addison-Wesley.
Ullman, Jeffrey. 1988. Principles of Database & Knowledge-Base Systems Vol. 1: Classical Database Systems. Rockville, MD: Computer Science Press.
Ungar, David, and Randal Smith. 1987. “SELF: The Power of Simplicity.” Presented at the Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA), Orlando. The Self programming language is likely the greatest influence on prototypal inheritance.
Van Roy, Peter, and Seif Haridi. 2004. Concepts, Techniques, and Models of Computer Programming. Cambridge, MA: MIT Press.
Wadler, Philip. 1989. “Theorems for Free!” Presented at the Fourth International Conference on Functional Programming and Computer Architecture.
Wampler, Dean, and Alex Payne. 2009. Programming Scala. Sebastopol, CA: O’Reilly.
Whitehead, Alfred North. 1929. Process and Reality: An Essay in Cosmology. Cambridge University Press. For a general overview of Whitehead, see The Wit And Wisdom of Alfred North Whitehead by A.H. Johnson (Boston: Beacon Press, 1947).
Williams, Laurie. 2002. Pair Programming Illuminated. Boston: Addison-Wesley Professional. The limitations of the book format only shadow the idealistic model of pair programming.
Online resources
Braithwaite, Reginald. 2007. “Why Why Functional Programming Matters Matters.” http://mng.bz/2pZP. This column discusses a language-level separation of concerns.
Clementson, Bill. 2008. “Clojure Could Be to Concurrency-Oriented Programming What Java Was to OOP.” http://mng.bz/6S95. A much deeper discussion concerning Erlang actors and Clojure agents.
Dekorte, Steve. Io. http://iolanguage.com.
Fogus, Michael. 2009. Lithp. http://github.com/fogus/lithp.
Fowler, Martin. 2005. “Event Sourcing.” http://mng.bz/5q9A. A very nice article about the motivations, history, and implementation of event sourcing. At least one of the authors of this book has studied this page intently.
Fowler, Martin. 2005. “Fluent Interface.” http://mng.bz/e2r5.
Fowler, Martin. 2007. “Mocks Aren’t Stubs.” http://mng.bz/mq95.
Fowler, Martin. 2011. “Memory Image.” http://mng.bz/6s59. Boils an event-sourcing model down to the basic idea of state as a result of stored events. As always, Fowler presents a lucid explanation.
Graham, Paul. Arc. www.paulgraham.com/arc.html.
Graham, Paul. Arc. 2001. “What Made Lisp Different.” www.paulgraham.com/diff.html. As Graham states, “The whole language always available” appears as a theme throughout this book.
Hickey, Rich. 2012. “The Database as a Value.” Presented at QCon NY. www.infoq.com/presentations/Datomic-Database-Value. This presentation describes the architecture and design motivations behind the Datomic database.
Joswig, Rainer. 2005. “DSLs in Lisp, an Example for an Advanced DSL Development Technique in Lisp.” http://archive.is/KKCLp. Rainer Joswig is a fount of Lisp (especially Common Lisp) wisdom, anecdotes, and technical guidance.
Krukow, Karl. 2009. “Understanding Clojure’s PersistentVector Implementation.” http://mng.bz/0Fjo.
Lindholm, Tim, and Frank Yellin. 1999. Java Language and Virtual Machine Specifications. http://java.sun.com/docs/books/jvms/.
Norvig, Peter. 1998. “Design Patterns in Dynamic Programming.” http://norvig.com/design-patterns/. The section in this book on design patterns was inspired by this presentation.
Norvig, Peter. 2011. “Solving Every Sudoku Puzzle.” http://norvig.com/sudoku.html. Norvig’s Python solver uses search and constraint propagation explicitly rather than using a logic library such as core.logic that provides these features as part of the operational logic. It’s a great article and well worth reading, especially if you wish to learn more about constraints or Sudoku in general. Included in this post are numerous boards with multiple solutions, a few of which send our solver into spasms.
Pike, Rob. 2012. “Concurrency Is Not Parallelism.” http://vimeo.com/49718712. Presented at Heroku’s Waza conference. Contains nice visualizations of concurrent designs and a quick introduction to the Go programming language.
Tarver, Mark. 2008. “Functional Programming in Qi.” http://mng.bz/Jmi0. Some programming languages perform partial application automatically when a function is supplied with fewer than the expected number of arguments. One such language is Qi.
Tarver, Mark. 2009. “The Next Lisp: Back to the Future.” http://mng.bz/qVfz. The notion of Lisp as a programming language genotype is explored.
W3C. 2013. Web Audio API. W3C Working Draft 10 (October). www.w3.org/TR/webaudio/. A nice reference to the Web Audio API that will serve as the basis for an upcoming talk entitled “The Sound of Functional Programming.”
_why. Shoes. http://github.com/shoes/shoes.
Yegge, Steve. 2006. “Execution in the Kingdom of Nouns.” http://mng.bz/E4MB.
Yegge, Steve. 2008. “The Universal Design Pattern.” http://mng.bz/6531. Like many programmers of our generation, we were in many ways inspired and influenced by Steve Yegge’s work—which is why we asked him to write the foreword to the first edition of this book.