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.

<br/> <details open> <summary>List of papers by topic</summary> <br/>

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}

   • 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 (1971).
   • Information Distribution Aspects of Design Methodology. Parnas (1972).
   • Designing Software for Ease of Extension and Contraction. Parnas (1979).
   • Programming as Theory Building. Naur (1985).
   • Software Aging. Parnas (1994).
   • Towards a Theory of Conceptual Design for Software. Jackson (2015).

6. Programming with Abstract Data Types. Liskov, Zilles (1974).
   _{Abstract Data Types; Object-Oriented Programming}

   • The Smalltalk-76 Programming System Design and Implementation. Ingalls (1978).
   • A Theory of Type Polymorphism in Programming. Milner (1978).
   • On understanding types, data abstraction, and polymorphism. Cardelli, Wegner (1985).
   • SELF: The Power of Simplicity. Ungar, Smith (1991).

7. Why Functional Programming Matters. Hughes (1990).
   _{Functional Programming}

   • 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).
   • Can Programming Be Liberated from the von Neumann Style? Backus (1978).
   • The Semantic Elegance of Applicative Languages. Turner (1981).
   • 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).

8. 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).

9. 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).
   • The Cathedral and the Bazaar. Raymond (1998).
   • Out of the Tar Pit. Moseley, Marks (2006).

10. 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).

11. 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).

12. 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).

13. 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).

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

    • A Method for Obtaining Digital Signatures and Public-Key