Papers for Software Engineers

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

1. Von Neumann's First Computer Program. Knuth (1970).
   • The Education of a Computer. Hopper (1952).
   • Recursive Programming. Dijkstra (1960).
   • Goto Statement Considered Harmful. Dijkstra (1968).
   • Program development by stepwise refinement. Wirth (1971).
   • The paradigms of programming. Floyd (1979).
2. Computing Machinery and Intelligence. Turing (1950).
   • 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).
   • 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. The Ubiquitous B-Tree. Comer (1979).
   • 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).
6. Engineering a Sort Function. Bentley, McIlroy (1993).
   • Quicksort. Hoare (1962).
7. Computer Programming as an Art. Knuth (1974).
   • The Humble Programmer. Dijkstra (1972).
   • The Emperor’s Old Clothes. Hoare (1981).
   • Literate Programming. Knuth (1984).
   • Programming as Theory Building. Naur (1985).
8. Programming with Abstract Data Types. Liskov, Zilles (1974).
   • A Design Methodology for Reliable Software Systems. Liskov (1972).
   • 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).
9. Why Functional Programming Matters. Hughes (1990).
   • Recursive Functions of Symbolic Expressions and Their Computation by Machine. McCarthy (1960).
   • Can Programming Be Liberated from the von Neumann Style?. Backus (1978).
   • The Art of the Interpreter. Steele, Sussman (1978).
   • The Semantic Elegance of Applicative Languages. Turner (1981).
   • QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs. Claessen, Hughes (2000).
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).
    • Toward higher-level abstractions for software systems. Shaw (1990).
    • Foundations for the Study of Software Architecture. Perry, Wolf (1992).
    • Software Aging. Parnas (1994).
    • Software Engineering: An Unconsummated Marriage. Parnas (1997).
11. 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).
12. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987).
    • Out of the Tar Pit. Moseley, Marks (2006).
13. 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).
    • Software Transactional Memory. Shavit, Touitou (1997).
14. The UNIX Time- Sharing System. Ritchie, Thompson (1974).
    • An Experimental Time-Sharing System. Corbató, Merwin Daggett, Daley (1962).
    • The Structure of the "THE"-Multiprogramming System. Dijkstra (1968).
    • Reflections on Trusting Trust. Thompson (1984).
    • The Design and Implementation of a Log-Structured File System. Rosenblum, Ousterhout (1991).
15. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974).
    • Ethernet: Distributed packet switching for local computer networks. Metcalfe, Boggs (1978).
    • An algorithm for distributed computation of a Spanning Tree in an Extended LAN. Perlman (1985).
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).
    • A Certified Digital Signature. Merkle (1979).
    • K-Anonymity: A Model For Protecting Privacy. Sweeney (2002).
17. Hints for Computer System Design. Lampson (1983).
    • End-To-End Arguments in System Design. Saltzer, Reed, Clark (1984).
    • A Note on Distributed Computing. Waldo et al (1994).
    • Rules of Thumb in Data Engineering. Gray, Shenay (1999).
    • The Network is Reliable. Bailis, Kingsbury (2014).
18. Thinking Methodically about Performance. Gregg (2012).
    • Performance Anti-Patterns. Smaalders (2006).
    • Thinking Clearly about Performance. Millsap (2010).
19. A Relational Model of Data for Large Shared Data Banks. Codd (1970).
    • Granularity of Locks and Degrees of Consistency in a Shared Data Base. Gray et al (1975).
    • System R: Relational Approach to Database Management. Astrahan et al. (1976).
    • 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).
20. 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).
21. Implementing Fault-Tolerant Services Using the State Machine Approach: A Tutorial. Schneider (1990).
    • How to Build a Highly Available System Using Consensus. Lampson (1996).
    • Paxos made simple. Lamport (2001).
    • In Search of an Understandable Consensus Algorithm. Ongaro, Ousterhout (2014).
22. CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012).
    • Epidemic Algorithms for Replicated Database Maintenance. Demers et al (1987).
    • The Dangers of Replication. Gray et al (1996).
    • Harvest, Yield, and Scalable Tolerant Systems. Fox, Brewer (1999).
    • Building on Quicksand. Helland, Campbell (2009).
    • Life Beyond Distributed Transactions: An apostate's opinion. Helland (2016).
23. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998).
    • World-Wide Web: Information Universe. Berners-Lee et al (1992).
    • The PageRank Citation Ranking: Bringing Order to the Web. Page, Brin, Motwani (1999).
24. 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).
    • Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases. Verbitski et al (2017).
25. 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).
26. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008).
    • Ethereum: A Next-Generation Smart Contract and Decentralized Application Platform. Buterin (2014).

Show full list in chronological order

1. Computing Machinery and Intelligence. Turing (1950)
2. A Method for the Construction of Minimum-Redundancy Codes. Huffman (1952)
3. The Education of a Computer. Hopper (1952)
4. On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem. Kruskal (1956)
5. A Note on Two Problems in Connexion with Graphs. Dijkstra (1959)
6. Recursive Programming. Dijkstra (1960)
7. Some Moral and Technical Consequences of Automation. Wiener (1960)
8. Steps towards Artificial Intelligence. Minsky (1960)
9. Recursive Functions of Symbolic Expressions and Their Computation by Machine. McCarthy (1960)
10. Quicksort. Hoare (1962)
11. An Experimental Time-Sharing System. Corbató, Merwin Daggett, Daley (1962)
12. Solution Of a Problem in Concurrent Program Control. Dijkstra (1965)
13. ELIZA—a computer program for the study of natural language communication between man and machine. Weizenbaum (1966)
14. Goto Statement Considered Harmful. Dijkstra (1968)
15. How do committees invent?. Conway (1968)
16. The Structure of the "THE"-Multiprogramming System. Dijkstra (1968)
17. Von Neumann's First Computer Program. Knuth (1970)
18. A Relational Model of Data for Large Shared Data Banks. Codd (1970)
19. Space/Time Trade-offs in Hash Coding with Allowable Errors. Bloom (1970)
20. Managing the Development of Large Software Systems. Royce (1970)
21. On the Criteria To Be Used in Decomposing Systems into Modules. Parnas (1971)
22. Program development by stepwise refinement. Wirth (1971)
23. Reducibility among Combinatorial Problems. Karp (1972)
24. The Humble Programmer. Dijkstra (1972)
25. A Design Methodology for Reliable Software Systems. Liskov (1972)
26. Information Distribution Aspects of Design Methodology. Parnas (1972)
27. Computer Programming as an Art. Knuth (1974)
28. Programming with Abstract Data Types. Liskov, Zilles (1974)
29. The UNIX Time- Sharing System. Ritchie, Thompson (1974)
30. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974)
31. Ordered hash tables. Amble, Knuth (1974)
32. Monitors: An operating system structuring concept. Hoare (1974)
33. Self-stabilizing systems in spite of distributed control. Dijkstra (1974)
34. The Mythical Man Month. Brooks (1975)
35. Granularity of Locks and Degrees of Consistency in a Shared Data Base. Gray et al (1975)
36. Communicating sequential processes. Hoare (1976)
37. New Directions in Cryptography. Diffie, Hellman (1976)
38. Big Omicron and big Omega and big Theta. Knuth (1976)
39. System R: Relational Approach to Database Management. Astrahan et al. (1976)
40. A Universal Algorithm for Sequential Data Compression. Ziv, Lempel (1977)
41. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978)
42. A Theory of Type Polymorphism in Programming. Milner (1978)
43. Can Programming Be Liberated from the von Neumann Style?. Backus (1978)
44. The Art of the Interpreter. Steele, Sussman (1978)
45. On the Duality of Operating System Structures. Lauer, Needham (1978)
46. Ethernet: Distributed packet switching for local computer networks. Metcalfe, Boggs (1978)
47. A Method for Obtaining Digital Signatures and Public-Key Cryptosystems. Rivest, Shamir, Adleman (1978)
48. The Ubiquitous B-Tree. Comer (1979)
49. The paradigms of programming. Floyd (1979)
50. Designing Software for Ease of Extension and Contraction. Parnas (1979)
51. How To Share A Secret. Shamir (1979)
52. A Certified Digital Signature. Merkle (1979)
53. Access Path Selection in a Relational Database Management System. Selinger et al (1979)
54. The Emperor’s Old Clothes. Hoare (1981)
55. The Semantic Elegance of Applicative Languages. Turner (1981)
56. The Transaction Concept: Virtues and Limitations. Gray (1981)
57. The Byzantine Generals Problem. Lamport, Shostak, Pease (1982)
58. Hints for Computer System Design. Lampson (1983)
59. Ironies of automation. Bainbridge (1983)
60. A Theory of the Learnable. Valiant (1984)
61. Literate Programming. Knuth (1984)
62. The Modular Structure of Complex Systems. Parnas, Clements, Weiss (1984)
63. Reflections on Trusting Trust. Thompson (1984)
64. End-To-End Arguments in System Design. Saltzer, Reed, Clark (1984)
65. Amortized Computational Complexity. Tarjan (1985)
66. Programming as Theory Building. Naur (1985)
67. On understanding types, data abstraction, and polymorphism. Cardelli, Wegner (1985)
68. An algorithm for distributed computation of a Spanning Tree in an Extended LAN. Perlman (1985)
69. Impossibility of Distributed Consensus With One Faulty Process. Fisher, Lynch, Patterson (1985)
70. Making data structures persistent. Driscoll et al (1986)
71. The design of POSTGRES. Stonebraker, Rowe (1986)
72. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987)
73. Epidemic Algorithms for Replicated Database Maintenance. Demers et al (1987)
74. Why Functional Programming Matters. Hughes (1990)
75. Implementing Fault-Tolerant Services Using the State Machine Approach: A Tutorial. Schneider (1990)
76. Toward higher-level abstractions for software systems. Shaw (1990)
77. SELF: The Power of Simplicity. Ungar, Smith (1991)
78. Lisp: Good news, bad news, how to win big. Gabriel (1991)
79. The Design and Implementation of a Log-Structured File System. Rosenblum, Ousterhout (1991)
80. Foundations for the Study of Software Architecture. Perry, Wolf (1992)
81. World-Wide Web: Information Universe. Berners-Lee et al (1992)
82. Engineering a Sort Function. Bentley, McIlroy (1993)
83. Software Aging. Parnas (1994)
84. A Note on Distributed Computing. Waldo et al (1994)
85. How to Build a Highly Available System Using Consensus. Lampson (1996)
86. The Dangers of Replication. Gray et al (1996)
87. Software Engineering: An Unconsummated Marriage. Parnas (1997)
88. Software Transactional Memory. Shavit, Touitou (1997)
89. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998)
90. The Cathedral and the Bazaar. Raymond (1998)
91. Rules of Thumb in Data Engineering. Gray, Shenay (1999)
92. Harvest, Yield, and Scalable Tolerant Systems. Fox, Brewer (1999)
93. The PageRank Citation Ranking: Bringing Order to the Web. Page, Brin, Motwani (1999)
94. QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs. Claessen, Hughes (2000)
95. How Complex Systems Fail. Cook (2000)
96. Paxos made simple. Lamport (2001)
97. K-Anonymity: A Model For Protecting Privacy. Sweeney (2002)
98. Recovery Oriented Computing (ROC): Motivation, Definition, Techniques, and Case Studies. Patterson et al (2002)
99. The Google File System. Ghemawat, Gobioff, Leung (2003)
100. Crash-Only Software. Candea, Fox (2003)
101. MapReduce: Simplified Data Processing on Large Clusters. Dean, Ghemawat (2004)
102. Out of the Tar Pit. Moseley, Marks (2006)
103. Performance Anti-Patterns. Smaalders (2006)
104. Bigtable: A Distributed Storage System for Structured Data. Chang et al (2006)
105. Dynamo, Amazon’s Highly Available Key-value store. DeCandia et al (2007)
106. On Designing and Deploying Internet Scale Services. Hamilton (2007)
107. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008)
108. Building on Quicksand. Helland, Campbell (2009)
109. Thinking Clearly about Performance. Millsap (2010)
110. ZooKeeper: wait-free coordination for internet scale systems. Hunt et al (2010)
111. Kafka: a Distributed Messaging System for Log Processing. Kreps, Narkhede, Rao (2011)
112. Thinking Methodically about Performance. Gregg (2012)
113. CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012)
114. The Network is Reliable. Bailis, Kingsbury (2014)
115. In Search of an Understandable Consensus Algorithm. Ongaro, Ousterhout (2014)
116. Ethereum: A Next-Generation Smart Contract and Decentralized Application Platform. Buterin (2014)
117. Life Beyond Distributed Transactions: An apostate's opinion. Helland (2016)
118. Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases. Verbitski et al (2017)
119. Nines are Not Enough: Meaningful Metrics for Clouds. Mogul, Wilkes (2019)

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 extremely useful resource. For distributed systems, I used Distributed systems for fun and profit and for Relational Data Bases, I used the Red Book.

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

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 alternatives, related or follow-up papers and I wanted to keep track of those as well, I 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.
   • Similarly, I tended to skip more theoretical papers, those focusing on mathematical foundations for Computer Science, electronic aspects of hardware, etc.
   • UI/UX and modern Machine Learning are missing because I'm not familiar enough with those areas to find relevant, non overly specific papers. Suggestions are welcome.

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.