Papers for Software Engineers

A curated list of papers that may be of interest to Software Engineering students or professionals.

1. Computing Machinery and Intelligence. Turing (1950).
   • Some Moral and Technical Consequences of Automation. Wiener (1960).
   • ELIZA—a computer program for the study of natural language communication between man and machine. Weizenbaum (1966).
2. The Education of a Computer. Hopper (1952).
3. A Method for the Construction of Minimum-Redundancy Codes. Huffman (1952).
   • A Universal Algorithm for Sequential Data Compression. Ziv, Lempel (1977).
4. 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).
   • Reducibility among Combinatorial Problems. Karp (1972).
   • Big Omicron and big Omega and big Theta. Knuth (1976).
   • Amortized Computational Complexity. Tarjan (1985).
5. Recursive Functions of Symbolic Expressions and Their Computation by Machine. McCarthy (1960).
   • The Art of the Interpreter. Steele, Sussman (1978).
6. Cramming More Components onto Integrated Circuits. Moore (1965).
   • Validity of the Single Processor Approach to Achieving Large-Scale Computing Capabilities. Amdahl (1967).
   • A Simple Capacity Model of Massively Parallel Transaction Systems. Gunther (1993).
7. Scatter storage techniques. Morris (1968).
   • Space/Time Trade-offs in Hash Coding with Allowable Errors. Bloom (1970).
   • Ordered hash tables. Amble, Knuth (1974).
   • Making data structures persistent. Driscoll et al (1986).
8. Goto Statement Considered Harmful. Dijkstra (1968).
   • Recursive Programming. Dijkstra (1960).
   • The Structure of the "THE"-Multiprogramming System. Dijkstra (1968).
   • Program development by stepwise refinement. Wirth (1971).
   • The Humble Programmer. Dijkstra (1972).
9. A Relational Model of Data for Large Shared Data Banks. Codd (1970).
10. 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).
    • The Modular Structure of Complex Systems. Parnas, Clements, Weiss (1984).
    • Software Aging. Parnas (1994).
    • Software Engineering: An Unconsummated Marriage. Parnas (1997).
11. The UNIX Time- Sharing System. Ritchie, Thompson (1974).
    • An Experimental Time-Sharing System. Corbató, Merwin Daggett, Daley (1962).
    • Reflections on Trusting Trust. Thompson (1984).
12. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974).
    • Ethernet: Distributed packet switching for local computer networks. Metcalfe, Boggs (1978).
13. Programming with Abstract Data Types. Liskov, Zilles (1974).
    • A Design Methodology for Reliable Software Systems. Liskov (1972).
    • The paradigms of programming. Floyd (1979).
    • On understanding types, data abstraction, and polymorphism. Cardelli, Wegner (1985).
    • SELF: The Power of Simplicity. Ungar, Smith (1991).
14. Computer Programming as an Art. Knuth (1974).
    • An Axiomatic Basis for Computer Programming. Hoare (1969).
    • Literate Programming. Knuth (1984).
    • Programming as Theory Building. Naur (1985).
15. The Mythical Man Month. Brooks (1975).
    • How do committees invent?. Conway (1968).
    • Managing the Development of Large Software Systems. Royce (1970).
    • Lisp: Good news, bad news, how to win big. Gabriel (1991).
    • The Cathedral and the Bazaar. Raymond (1998).
16. New Directions in Cryptography. Diffie, Hellman (1976).
    • A Method for Obtaining Digital Signatures and Public-Key Cryptosystems. Rivest, Shamir, Adleman (1978).
    • How To Share A Secret. Shamir (1979).
    • K-Anonymity: A Model For Protecting Privacy. Sweeney (2002).
    • Calibrating Noise to Sensitivity in Private Data Analysis. Dwork et al (2006).
17. Communicating sequential processes. Hoare (1976).
    • 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).
    • The Emperor’s Old Clothes. Hoare (1981).
    • Software Transactional Memory. Shavit, Touitou (1997).
18. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978).
    • Self-stabilizing systems in spite of distributed control. Dijkstra (1974).
    • The Byzantine Generals Problem. Lamport, Shostak, Pease (1982).
    • Impossibility of Distributed Consensus With One Faulty Process. Fisher, Lynch, Patterson (1985).
    • How to Build a Highly Available System Using Consensus. Lampson (1996).
    • The Part-Time Parliament. Lamport (1998).
    • Paxos made simple. Lamport (2001).
    • CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012).
    • In Search of an Understandable Consensus Algorithm. Ongaro, Ousterhout (2014).
    • Consistency, Availability, and Convergence. Mahajan, Alvisi, Dahlin (2014).
19. End-To-End Arguments in System Design. Saltzer, Reed, Clark (1984).
    • A Note on Distributed Computing. Waldo et al (1994).
    • The Network is Reliable. Bailis, Kingsbury (2014).
20. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987).
    • Hints for Computer System Design. Lampson (1983).
    • Out of the Tar Pit. Moseley, Marks (2006).
21. Why Functional Programming Matters. Hughes (1990).
    • Can Programming Be Liberated from the von Neumann Style?. Backus (1978).
    • The Semantic Elegance of Applicative Languages. Turner (1981).
    • Church's Thesis and Functional Programming. Turner (2006).
22. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998).
    • As We May Think. Bush (1945).
    • The PageRank Citation Ranking: Bringing Order to the Web. Page, Brin, Motwani (1999).
23. Dynamo, Amazon’s Highly Available Key-value store. DeCandia et al (2007).
    • The Google File System. Ghemawat, Gobioff, Leung (2003).
    • MapReduce: Simplified Data Processing on Large Clusters. Dean, Ghemawat (2004).
    • Bigtable: A Distributed Storage System for Structured Data. Chang et al (2006).
    • ZooKeeper: wait-free coordination for internet scale systems. Hunt et al (2010).
    • Kafka: a Distributed Messaging System for Log Processing. Kreps, Narkhede, Rao (2011).
24. On Designing and Deploying Internet Scale Services. Hamilton (2007).
    • Ironies of automation. Bainbridge (1983).
    • How Complex Systems Fail. Cook (2000).
    • Recovery Oriented Computing (ROC): Motivation, Definition, Techniques, and Case Studies. Patterson et al (2002).
    • Crash-Only Software. Candea, Fox (2003).
    • Nines are Not Enough: Meaningful Metrics for Clouds. Mogul, Wilkes (2019).
25. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008).
    • Ethereum: A Next-Generation Smart Contract and Decentralized Application Platform. Buterin (2014).
26. Thinking Methodically about Performance. Gregg (2012).

Show full list in chronological order:

This list was inspired by (and draws from) the Papers We Love project and the Ideas That Created the Future book by Harry R. Lewis. I also found the morning paper blog to be an extremly useful resource.

Selection criteria

1. The list should stay short. Let's say no more than 30 papers.
   • The idea is not to include every interesting paper that I come across but rather to keep a representative list that's possible to read from start to finish with a similar level of effort as reading a technical book from cover to cover.
   • I tried to include one paper per each major topic and author. Since in the process I found a lot of noteworthy alternative, related or follow-up papers and I wanted to keep track of those as well, included them as sublist items (some of these sublists are currently longer than they should).
2. The papers shouldn't be too long. For the same reasons as the previous item, I try to avoid papers longer than 20 or 30 pages.
3. They should be self-contained and readable enough to be approachable by the casual technical reader.
4. They should be freely available online.
5. Although historical relevance was taken into account, I omitted seminal papers in the cases where I found them hard to approach, when the main subject of the paper wasn't the thing that made them influential, etc.
   • That being said, where possible I preferred the original paper on each subject over modern updates or summary papers.
6. I tended to prefer topics that I can relate to my professional practice, typically papers originated in the industry or about innovations that later saw wide adoption. Likewise I tended to skip more theoretical papers, those focused on mathematical foundations for Computer Science, on electronic aspects of hardware, etc.

Disclaimer: I'm not a frequent paper reader, so I made this list as a sort of roadmap for myself. I haven't read all of the papers in the list yet; as I do, I may find than some don't meet the described criteria after all and remove them, or decide to add new ones.

And, yes, this repository is a way to procrastinate on the actual reading after I finished making the list.

Meta reads

A few interesting resources about reading papers from Papers We Love and elsewhere:

• Should I read papers?
• How to Read an Academic Article
• How to Read a Paper. Keshav (2007).
• Efficient Reading of Papers in Science and Technology. Hanson (1999).
• On ICSE’s “Most Influential Papers”. Parnas (1995).