Papers for Software Engineers

A curated list of papers that may be of interest to Software Engineering students or professionals. See the sources and selection criteria below.

List of papers by topic

1. Von Neumann's First Computer Program. Knuth (1970). \ _{Computer History; Early Programming}

   • The Education of a Computer. Hopper (1952).
   • Recursive Programming. Dijkstra (1960).
   • Programming Considered as a Human Activity. Dijkstra (1965).
   • Goto Statement Considered Harmful. Dijkstra (1968).
   • Program development by stepwise refinement. Wirth (1971).
   • The Humble Programmer. Dijkstra (1972).
   • Computer Programming as an Art. Knuth (1974).
   • The paradigms of programming. Floyd (1979).
   • Literate Programming. Knuth (1984).

2. Computing Machinery and Intelligence. Turing (1950). \ _{Early Artificial Intelligence}

   • Some Moral and Technical Consequences of Automation. Wiener (1960).
   • Steps towards Artificial Intelligence. Minsky (1960).
   • ELIZA—a computer program for the study of natural language communication between man and machine. Weizenbaum (1966).
   • A Theory of the Learnable. Valiant (1984).

3. A Method for the Construction of Minimum-Redundancy Codes. Huffman (1952). \ _{Information Theory}

   • Prediction and Entropy of Printed English. Shannon (1950).
   • A Universal Algorithm for Sequential Data Compression. Ziv, Lempel (1977).
   • Fifty Years of Shannon Theory. Verdú (1998).

4. Engineering a Sort Function. Bentley, McIlroy (1993). \ _{Data Structures; Algorithms}

   • On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem. Kruskal (1956).
   • A Note on Two Problems in Connexion with Graphs. Dijkstra (1959).
   • Quicksort. Hoare (1962).
   • Space/Time Trade-offs in Hash Coding with Allowable Errors. Bloom (1970).
   • The Ubiquitous B-Tree. Comer (1979).
   • Programming pearls: Algorithm design techniques. Bentley (1984).
   • Programming pearls: The back of the envelope. Bentley (1984).
   • Making data structures persistent. Driscoll et al (1986).

5. A Design Methodology for Reliable Software Systems. Liskov (1972). \ _{Software Design}

   • On the Criteria To Be Used in Decomposing Systems into Modules. Parnas (1972).
   • Information Distribution Aspects of Design Methodology. Parnas (1972).
   • Programming with Abstract Data Types. Liskov, Zilles (1974).
   • Designing Software for Ease of Extension and Contraction. Parnas (1979).
   • Programming as Theory Building. Naur (1985).
   • Towards a Theory of Conceptual Design for Software. Jackson (2015).

6. Programming Paradigms for Dummies: What Every Programmer Should Know. Van Roy (2012). \ _{Programming Paradigms}

   • Recursive Functions of Symbolic Expressions and Their Computation by Machine. McCarthy (1960).
   • The Semantics of Predicate Logic as a Programming Language. Van Emden, Kowalski (1976).
   • The Smalltalk-76 Programming System Design and Implementation. Ingalls (1978).
   • A Theory of Type Polymorphism in Programming. Milner (1978).
   • Can Programming Be Liberated from the von Neumann Style? Backus (1978).
   • The Semantic Elegance of Applicative Languages. Turner (1981).
   • On understanding types, data abstraction, and polymorphism. Cardelli, Wegner (1985).
   • Why Functional Programming Matters. Hughes (1990).
   • SELF: The Power of Simplicity. Ungar, Smith (1991).
   • The essence of functional programming. Wadler (1992).
   • QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs. Claessen, Hughes (2000).
   • Church's Thesis and Functional Programming. Turner (2006).

7. An Incremental Approach to Compiler Construction. Ghuloum (2006). \ _{Language Design; Compilers}

   • The Next 700 Programming Languages. Landin (1966).
   • Programming pearls: little languages. Bentley (1986).
   • The Essence of Compiling with Continuations. Flanagan et al (1993).
   • A Brief History of Just-In-Time. Aycock (2003).
   • LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. Lattner, Adve (2004).
   • A Unified Theory of Garbage Collection. Bacon, Cheng, Rajan (2004).
   • A Nanopass Framework for Compiler Education. Sarkar, Waddell, Dybvig (2005).
   • Bringing the Web up to Speed with WebAssembly. Haas (2017).

8. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987). \ _{Software Engineering; Project Management}

   • How do committees invent? Conway (1968).
   • Managing the Development of Large Software Systems. Royce (1970).
   • The Mythical Man Month. Brooks (1975).
   • On Building Systems That Will Fail. Corbató (1991).
   • Software Aging. Parnas (1994).
   • Laws of Software Evolution Revisited. Lehman (1997).
   • The Cathedral and the Bazaar. Raymond (1998).
   • Out of the Tar Pit. Moseley, Marks (2006).

9. Communicating sequential processes. Hoare (1978). \ _Concurrency

   • Solution Of a Problem in Concurrent Program Control. Dijkstra (1965).
   • Monitors: An operating system structuring concept. Hoare (1974).
   • On the Duality of Operating System Structures. Lauer, Needham (1978).
   • Software Transactional Memory. Shavit, Touitou (1997).

10. The UNIX Time- Sharing System. Ritchie, Thompson (1974). \ _{Operating Systems}

    • An Experimental Time-Sharing System. Corbató, Merwin Daggett, Daley (1962).
    • The Structure of the \"THE\"-Multiprogramming System. Dijkstra (1968).
    • The nucleus of a multiprogramming system. Hansen (1970).
    • Reflections on Trusting Trust. Thompson (1984).
    • The Design and Implementation of a Log-Structured File System. Rosenblum, Ousterhout (1991).

11. A Relational Model of Data for Large Shared Data Banks. Codd (1970). \ _Databases

    • Granularity of Locks and Degrees of Consistency in a Shared Data Base. Gray et al (1975).
    • Access Path Selection in a Relational Database Management System. Selinger et al (1979).
    • The Transaction Concept: Virtues and Limitations. Gray (1981).
    • The design of POSTGRES. Stonebraker, Rowe (1986).
    • Rules of Thumb in Data Engineering. Gray, Shenay (1999).

12. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974). \ _Networking

    • Ethernet: Distributed packet switching for local computer networks. Metcalfe, Boggs (1978).
    • End-To-End Arguments in System Design. Saltzer, Reed, Clark (1984).
    • An algorithm for distributed computation of a Spanning Tree in an Extended LAN. Perlman (1985).
    • The Design Philosophy of the DARPA Internet Protocols. Clark (1988).
    • TOR: The second generation onion router. Dingledine et al (2004).
    • Why the Internet only just works. Handley (2006).
    • The Network is Reliable. Bailis, Kingsbury (2014).

13. New Directions in Cryptography. Diffie, Hellman (1976). \ _Cryptography

    • A Method for Obtaining Digital Signatures and Public-Key Cryptosystems. Rivest, Shamir, Adleman (1978).
    • How To Share A Secret. Shamir (1979).
    • A Digital Signature Based on a Conventional Encryption Function. Merkle (1987).
    • The Salsa20 family of stream ciphers. Bernstein (2007).

14. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978). \ _Dis