Giters

abom / software-papers

đź“š A curated list of papers for Software Engineers

Geek Repo:Geek Repo

Github PK Tool:Github PK Tool

Papers for Software Engineers workflow

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


Hierarchical list of papers
  1. Von Neumann's First Computer Program. Knuth (1970).
  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).
  4. Engineering a Sort Function. Bentley, McIlroy (1993).
  5. Computer Programming as an Art. Knuth (1974).
  6. A Design Methodology for Reliable Software Systems. Liskov (1972).
  7. Programming with Abstract Data Types. Liskov, Zilles (1974).
  8. Why Functional Programming Matters. Hughes (1990).
  9. An Incremental Approach to Compiler Construction. Ghuloum (2006).
  10. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987).
  11. Communicating sequential processes. Hoare (1976).
  12. The UNIX Time- Sharing System. Ritchie, Thompson (1974).
  13. A Relational Model of Data for Large Shared Data Banks. Codd (1970).
  14. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974).
  15. New Directions in Cryptography. Diffie, Hellman (1976).
  16. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978).
  17. Designing for Usability: Key Principles and What Designers Think. Gould, Lewis (1985).
  18. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998).
  19. CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012).
  20. Dynamo, Amazon’s Highly Available Key-value store. DeCandia et al (2007).
  21. On Designing and Deploying Internet Scale Services. Hamilton (2007).
  22. Thinking Methodically about Performance. Gregg (2012).
  23. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008).
    • Ethereum: A Next-Generation Smart Contract and Decentralized Application Platform. Buterin (2014).

Top-level papers only
  1. Von Neumann's First Computer Program. Knuth (1970).
  2. Computing Machinery and Intelligence. Turing (1950).
  3. A Method for the Construction of Minimum-Redundancy Codes. Huffman (1952).
  4. Engineering a Sort Function. Bentley, McIlroy (1993).
  5. Computer Programming as an Art. Knuth (1974).
  6. A Design Methodology for Reliable Software Systems. Liskov (1972).
  7. Programming with Abstract Data Types. Liskov, Zilles (1974).
  8. Why Functional Programming Matters. Hughes (1990).
  9. An Incremental Approach to Compiler Construction. Ghuloum (2006).
  10. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987).
  11. Communicating sequential processes. Hoare (1976).
  12. The UNIX Time- Sharing System. Ritchie, Thompson (1974).
  13. A Relational Model of Data for Large Shared Data Banks. Codd (1970).
  14. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974).
  15. New Directions in Cryptography. Diffie, Hellman (1976).
  16. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978).
  17. Designing for Usability: Key Principles and What Designers Think. Gould, Lewis (1985).
  18. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998).
  19. CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012).
  20. Dynamo, Amazon’s Highly Available Key-value store. DeCandia et al (2007).
  21. On Designing and Deploying Internet Scale Services. Hamilton (2007).
  22. Thinking Methodically about Performance. Gregg (2012).
  23. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008).

All papers in chronological order
  1. As We May Think. Bush (1945).
  2. Computing Machinery and Intelligence. Turing (1950).
  3. The Education of a Computer. Hopper (1952).
  4. A Method for the Construction of Minimum-Redundancy Codes. Huffman (1952).
  5. On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem. Kruskal (1956).
  6. Man-Computer symbiosis. Licklider (1958).
  7. A Note on Two Problems in Connexion with Graphs. Dijkstra (1959).
  8. Recursive Programming. Dijkstra (1960).
  9. Some Moral and Technical Consequences of Automation. Wiener (1960).
  10. Steps towards Artificial Intelligence. Minsky (1960).
  11. Recursive Functions of Symbolic Expressions and Their Computation by Machine. McCarthy (1960).
  12. Quicksort. Hoare (1962).
  13. An Experimental Time-Sharing System. CorbatĂł, Merwin Daggett, Daley (1962).
  14. MetaII: A Syntax Oriented Compiler Writing Language. Schorrem (1964).
  15. Programming Considered as a Human Activity. Dijkstra (1965).
  16. Solution Of a Problem in Concurrent Program Control. Dijkstra (1965).
  17. Some Thoughts About the Social Implications of Accessible Computing. David, Fano (1965).
  18. ELIZA—a computer program for the study of natural language communication between man and machine. Weizenbaum (1966).
  19. The Next 700 Programming Languages. Landin (1966).
  20. Goto Statement Considered Harmful. Dijkstra (1968).
  21. How do committees invent?. Conway (1968).
  22. The Structure of the "THE"-Multiprogramming System. Dijkstra (1968).
  23. Von Neumann's First Computer Program. Knuth (1970).
  24. Space/Time Trade-offs in Hash Coding with Allowable Errors. Bloom (1970).
  25. Managing the Development of Large Software Systems. Royce (1970).
  26. A Relational Model of Data for Large Shared Data Banks. Codd (1970).
  27. Program development by stepwise refinement. Wirth (1971).
  28. On the Criteria To Be Used in Decomposing Systems into Modules. Parnas (1971).
  29. The Humble Programmer. Dijkstra (1972).
  30. A Design Methodology for Reliable Software Systems. Liskov (1972).
  31. Information Distribution Aspects of Design Methodology. Parnas (1972).
  32. A Statistical Interpretation of Term Specificity in Retrieval. Spärck Jones (1972).
  33. Ordered hash tables. Amble, Knuth (1974).
  34. Computer Programming as an Art. Knuth (1974).
  35. Programming with Abstract Data Types. Liskov, Zilles (1974).
  36. Monitors: An operating system structuring concept. Hoare (1974).
  37. The UNIX Time- Sharing System. Ritchie, Thompson (1974).
  38. A Protocol for Packet Network Intercommunication. Cerf, Kahn (1974).
  39. Self-stabilizing systems in spite of distributed control. Dijkstra (1974).
  40. The Mythical Man Month. Brooks (1975).
  41. Granularity of Locks and Degrees of Consistency in a Shared Data Base. Gray et al (1975).
  42. Big Omicron and big Omega and big Theta. Knuth (1976).
  43. The Semantics of Predicate Logic as a Programming Language. Van Emden, Kowalski (1976).
  44. Communicating sequential processes. Hoare (1976).
  45. System R: Relational Approach to Database Management. Astrahan et al. (1976).
  46. New Directions in Cryptography. Diffie, Hellman (1976).
  47. A Universal Algorithm for Sequential Data Compression. Ziv, Lempel (1977).
  48. The Smalltalk-76 Programming System Design and Implementation. Ingalls (1978).
  49. A Theory of Type Polymorphism in Programming. Milner (1978).
  50. Can Programming Be Liberated from the von Neumann Style?. Backus (1978).
  51. A Micro-Manual for LISP - Not the whole truth. McCarthy (1978).
  52. On the Duality of Operating System Structures. Lauer, Needham (1978).
  53. Ethernet: Distributed packet switching for local computer networks. Metcalfe, Boggs (1978).
  54. A Method for Obtaining Digital Signatures and Public-Key Cryptosystems. Rivest, Shamir, Adleman (1978).
  55. Time, Clocks, and the Ordering of Events in a Distributed System. Lamport (1978).
  56. The paradigms of programming. Floyd (1979).
  57. The Ubiquitous B-Tree. Comer (1979).
  58. Designing Software for Ease of Extension and Contraction. Parnas (1979).
  59. Access Path Selection in a Relational Database Management System. Selinger et al (1979).
  60. How To Share A Secret. Shamir (1979).
  61. A Certified Digital Signature. Merkle (1979).
  62. Crash Recovery in a Distributed Data Storage System. Lampson, Sturigs (1979).
  63. Protocols for Public Key Cryptosystems. Merkle (1980).
  64. The Emperor’s Old Clothes. Hoare (1981).
  65. The Semantic Elegance of Applicative Languages. Turner (1981).
  66. The Transaction Concept: Virtues and Limitations. Gray (1981).
  67. Tutorials for the First-Time Computer User. Al-Awar, Chapanis, Ford (1981).
  68. The Byzantine Generals Problem. Lamport, Shostak, Pease (1982).
  69. The star user interface: an overview. Smith, Irby, Kimball (1982).
  70. Design Principles for Human-Computer Interfaces. Norman (1983).
  71. Design Rules Based on Analyses of Human Error. Norman (1983).
  72. Ironies of automation. Bainbridge (1983).
  73. A Theory of the Learnable. Valiant (1984).
  74. Programming pearls: Algorithm design techniques. Bentley (1984).
  75. Programming pearls: The back of the envelope. Bentley (1984).
  76. Literate Programming. Knuth (1984).
  77. The Modular Structure of Complex Systems. Parnas, Clements, Weiss (1984).
  78. Reflections on Trusting Trust. Thompson (1984).
  79. End-To-End Arguments in System Design. Saltzer, Reed, Clark (1984).
  80. Programming as Theory Building. Naur (1985).
  81. On understanding types, data abstraction, and polymorphism. Cardelli, Wegner (1985).
  82. An algorithm for distributed computation of a Spanning Tree in an Extended LAN. Perlman (1985).
  83. Impossibility of Distributed Consensus With One Faulty Process. Fisher, Lynch, Patterson (1985).
  84. Designing for Usability: Key Principles and What Designers Think. Gould, Lewis (1985).
  85. Making data structures persistent. Driscoll et al (1986).
  86. Programming pearls: little languages. Bentley (1986).
  87. The design of POSTGRES. Stonebraker, Rowe (1986).
  88. No Silver Bullet: Essence and Accidents of Software Engineering. Brooks (1987).
  89. Epidemic Algorithms for Replicated Database Maintenance. Demers et al (1987).
  90. The Design Philosophy of the DARPA Internet Protocols. Clark (1988).
  91. Toward higher-level abstractions for software systems. Shaw (1990).
  92. Why Functional Programming Matters. Hughes (1990).
  93. Implementing Fault-Tolerant Services Using the State Machine Approach: A Tutorial. Schneider (1990).
  94. Heuristic Evaluation of User Interfaces. Nielsen, Molich (1990).
  95. SELF: The Power of Simplicity. Ungar, Smith (1991).
  96. Lisp: Good news, bad news, how to win big. Gabriel (1991).
  97. On Building Systems That Will Fail. CorbatĂł (1991).
  98. The Design and Implementation of a Log-Structured File System. Rosenblum, Ousterhout (1991).
  99. Foundations for the Study of Software Architecture. Perry, Wolf (1992).
  100. The essence of functional programming. Wadler (1992).
  101. World-Wide Web: Information Universe. Berners-Lee et al (1992).
  102. Engineering a Sort Function. Bentley, McIlroy (1993).
  103. The Essence of Compiling with Continuations. Flanagan et al (1993).
  104. Software Aging. Parnas (1994).
  105. How to Build a Highly Available System Using Consensus. Lampson (1996).
  106. The Dangers of Replication. Gray et al (1996).
  107. The Development of Erlang. Joe Armstrong (1997).
  108. Software Transactional Memory. Shavit, Touitou (1997).
  109. Towards Accessible Human-Computer Interaction. Bergman, Johnson (1997).
  110. The Cathedral and the Bazaar. Raymond (1998).
  111. The anatomy of a large-scale hypertextual Web search engine. Brin, Page (1998).
  112. Rules of Thumb in Data Engineering. Gray, Shenay (1999).
  113. The PageRank Citation Ranking: Bringing Order to the Web. Page, Brin, Motwani (1999).
  114. Harvest, Yield, and Scalable Tolerant Systems. Fox, Brewer (1999).
  115. QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs. Claessen, Hughes (2000).
  116. How Complex Systems Fail. Cook (2000).
  117. Paxos made simple. Lamport (2001).
  118. K-Anonymity: A Model For Protecting Privacy. Sweeney (2002).
  119. Recovery Oriented Computing (ROC): Motivation, Definition, Techniques, and Case Studies. Patterson et al (2002).
  120. A Brief History of Just-In-Time. Aycock (2003).
  121. The Google File System. Ghemawat, Gobioff, Leung (2003).
  122. Crash-Only Software. Candea, Fox (2003).
  123. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. Lattner, Adve (2004).
  124. TOR: The second generation onion router. Dingledine et al (2004).
  125. MapReduce: Simplified Data Processing on Large Clusters. Dean, Ghemawat (2004).
  126. A Nanopass Framework for Compiler Education. Sarkar, Waddell, Dybvig (2005).
  127. Church's Thesis and Functional Programming. Turner (2006).
  128. An Incremental Approach to Compiler Construction. Ghuloum (2006).
  129. Out of the Tar Pit. Moseley, Marks (2006).
  130. Why the Internet only just works. Handley (2006).
  131. Bigtable: A Distributed Storage System for Structured Data. Chang et al (2006).
  132. Performance Anti-Patterns. Smaalders (2006).
  133. Dynamo, Amazon’s Highly Available Key-value store. DeCandia et al (2007).
  134. On Designing and Deploying Internet Scale Services. Hamilton (2007).
  135. Bitcoin, A peer-to-peer electronic cash system. Nakomoto (2008).
  136. Building on Quicksand. Helland, Campbell (2009).
  137. ZooKeeper: wait-free coordination for internet scale systems. Hunt et al (2010).
  138. The Hadoop Distributed File System. Shvachko et al (2010).
  139. Thinking Clearly about Performance. Millsap (2010).
  140. Kafka: a Distributed Messaging System for Log Processing. Kreps, Narkhede, Rao (2011).
  141. CAP Twelve Years Later: How the "Rules" Have Changed. Brewer (2012).
  142. Thinking Methodically about Performance. Gregg (2012).
  143. The Network is Reliable. Bailis, Kingsbury (2014).
  144. In Search of an Understandable Consensus Algorithm. Ongaro, Ousterhout (2014).
  145. Ethereum: A Next-Generation Smart Contract and Decentralized Application Platform. Buterin (2014).
  146. Life Beyond Distributed Transactions: An apostate's opinion. Helland (2016).
  147. Bringing the Web up to Speed with WebAssembly. Haas (2017).
  148. Amazon Aurora: Design Considerations for High Throughput Cloud-Native Relational Databases. Verbitski et al (2017).
  149. Nines are Not Enough: Meaningful Metrics for Clouds. Mogul, Wilkes (2019).

Sources

This list was inspired by (and draws from) several books and paper collections:

Meta reads

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

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.
    • Machine Learning is mostly missing because I'm not familiar enough with the area 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.

About

đź“š A curated list of papers for Software Engineers

License:MIT License

Languages

Language:Python 100.0%