-- CSCI 4500 / 6500 Programming Languages: Reading --

Important Technical Papers in Programming Languages

You will need to write a 1 page summary for each (required) paper that you read. The summary must answer the below five questions (briefly).

What is the problem that the authors are trying to solve?
- Why is the problem important?
What is their approach and how is it original and innovative? (original - compare it against contemporary approaches).
How is the approach evaluated?
- What are the simplifying assumptions?
- What are the strength and weaknesses of their solution?
What are the results/impact of paper
- Why is this paper important?
- Did they solve the problem?
- Does it have an impact - is it still relevant? Why is it worth reading.
What constructive criticism can you give to the presenter (e.g., would should have been included/excluded, make sure to address 'concepts' convered in the paper and relate how they were covered by the presenter).

Please don't comment much on the presenters style of speaking, focus on commenting on the 'content' or how well concepts were covered and possibly the organization of the talk?

Some PDF or ps versions of the paper are provided as a courtesy, however you are expected on your own to find these papers on the web or using the library (e.g., at googlee you can use the command filetype:pdf to restrict your search to the filetype of a paper).

Please check access/search for paper well before your presentation date (or writing your summary). Also as a courtey, the presenter should post the link to the paper in his or her presentation.

General Advice

Spencer Rugaber. How to Read a Research Paper.

Michael J. Hanson and Dylan McNamee, Efficient Reading of Papers in Science and Technology.

Simon L Peyton Jones, John Hughes, and John Launchbury, How to give a good research talk.

John Ousterhout, How to give a bad talk.

Programming Language Design & Practical Issues

Hoare, C. A. R., Hints on Programming-Language Design, In Essays in Computing Science , C. A. R. Hoare and C. B. Jones, 1989 (Stanford/Berkeley/GTech reading lists)

Gabriel, Richard, Lisp: Good News, Bad News, and How to Win Big

Wirth, N., On the Design of Programming Languages, In Acta Informatica (Berkely)

Peter Wegner, Programming Languages - The First 25 years, IEEE Trans. Computers 25(12): 1207-1225 (1976)

Peter J. Landin. The next 700 programming languages. Communications of the ACM, 9(3):157-166, March 1966 (The greatest of the great (mentioned by many people))

Syntax, scanning and parsing

"Report on the algorithmic language ALGOL 60" (the language that Hoare said it was an improvement not only on its predecessors but on nearly all of its successors) (introduction of BNF, block structure, local scope recursiveness, types, call by-value, call by name)

Revised Report on the Algorithmic Language ALGOL 60, Naur, Backus, Bauer, Green, Katz, McCarthy, Perlis, Rutishauser, Samelson, Vauquois, Wegstein, van Wijngaarden, and Woodger, CACM 1(17), January 1963.

Ole-Johan Dahl, Kristen Nygaard, SIMULA: an ALGOL-based simulation language, Communications of the ACM archive, Volume 9 , Issue 9 (September 1966), Pages: 671 - 678

One-Pass, Optimal Tree Parsing - With Or Without Trees, Todd A. Proebsting and Benjamin A. Whaley, CC'96 April 1996. (automated code selection, parsing)

Hard-coding bottom-up code generation tables to save time and space, Christopher W. Fraser and Robert R. Henry, Software-Practice and Experience 21, (1):1-12, January 1991 (automated code selection)

Semantics

Floyd: Assigning Meaning to Programs (Symposium in Applied Mathematics 1967) (axiomatic semantics)

Hoare, C. A. R., "An Axiomatic Basis for Computer Programming" Communications of the ACM, 12(10):576-580 and 583, October 1969.

(1400+ (The greatest of the great (mentioned by many people))

Hoare's Proof of a program FIND

K. R. Apt. Ten years of Hoare logic: A survey--Part 1 . ACM Transactions on Programming Languages and Systems Vol. 3, No. 4, pp. 431-483, 1981. (GTech, Berkeley)

T. Reps, Optimal-time incremental semantic analysis for syntax-directed editors. Ninth Annual ACM Symposium on Principles of Programming Languages, pages 169-176, January 1982. (attribute grammars)

Jukka Paakki. Attribute Grammar Paradigms--A High-Level Methodology in Language Implementation. ACM Computing Surveys, 27(2):196-256, June 1995. (introduction only, gtech)

R. D. Tennent. The Denotational Semantics of Programming Languages. Communications of the ACM, 19:437-453, August 1976.

Gordon D. Plotkin. A structural approach to operational semantics. Technical Report DAIMI FN-19, Computer Science Department, Aarhus University, Aarhus, Denmark, September 1981. (pretty great works)

Edsger W. Dijkstra. Guarded Commands, Nondeterminancy and Formal Derivation of Programs. CACM, Vol. 18, No. 8, August 1975 (GTech, Berkelay) (axiomatic) umich

Functional Programming

Philip Wadler, The Essence of Functional Programming (1992), Conference Record of the Nineteenth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (288 citations) (discusses the use monads to structure functional programs - supports a notion of sequencing)

John Hughes, Why Functional Programming Matters, (1984), Computer Journal, 32(2):98 (shows how two key features of functional languages---higher-order functions (which take other functions as arguments) and lazy evaluation (which defers computations until their results are really needed) (204 citations)

John McCarthy. Recursive functions of symbolic expressions and their computation by machine, part I. Communications of the ACM, 3(4):184-195, April 1960. (pretty great works) (original paper on lisp)

John Backus, Can Programming by Liberated from the von Neumann Style? A Functional Style and its Algebra of Programs, Communications of the ACM, 21(8):613-641, August, 1978 (Backus functional programming vision)

P. Hudak, Conception, Evolution, and Application of Functional Programming Languages, ACM Computing Surveys, 21(3):359-411.

Andrew Appel, A Critique of Standard ML, CS Department, Princeton University, TR-364-92, February 1992.

Gordon Plotkin. Call-by-name, call-by-value, and the lambda-calculus. Theoretical Computer Science, 1:125-159, 1975. (The greatest of the great (mentioned by many people)) (formalizes evaluation strategies and simulations using operational semantics and continuations, call by-name can be simulated by call by value and vice versa) .

Type Systems

James H. Morris, Jr. Protection in Programming Languages. Communications of the ACM, 16(1):15-21, January 1973. (Type systems background)

Type Inference

Robin Milner, A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17:348--375, Dec 1978. (GTech, Berkeley) (type reconstruction/type inference) (The greatest of the great (mentioned by many people))

L. Cardelli and P. Wegner. On Understanding Types, Data Abstraction, and Polymorphism., [A5 & nicer font] [compileres.iecc (1)] [compileres.iecc (2)] ACM Computing Surveys Vol. 17, No. 4, 1985, 471-522. (types/type inference, classification of polymorphism using the "fun" language (that is very pleasant to work with) (Georgia Tech, Berkely)

Benjamin C. Pierce and David N. Turner. Local Type Inference. ACM Transactions on Programming Languages and Systems Volume 22 , Issue 1 (2000) (type inference)

L. Damas and R. Milner. Principle type-schemes for functional programs. In Ninth Annual ACM Symposium on Principles of Programming Languages, pages 207-212, January 1982. Type Inference (Pretty great works)

Hoare, C. A. R., Recursive data structures, Interntational Journal of Parallel Programming, Volume 4, Number 2, pages 105-132, 1975, Springer.

Dynamic typing in a statically typed language, Martin Abadi and Luca Cardelli and Benjamin Pierce and Gordon Plotkin, ACM Transactions on Programming Languages and Systems (TOPLAS) Volume 13 , Issue 2 (April 1991) Pages: 237 - 268 Year of Publication: 1991 (181 google)

Andrew Wright and Matthias Felleisen. "A syntactic approach to type soundness" (Berkeley) (Cited by 367) (soundness and comlexity of milner type inference)

Safety for Legacy Code Necula: CCured: Type-Safe Retrofitting of Legacy Code (POPL 2002)

Abstraction and Types

Barbara Liskov and John Guttag. Abstraction and Specification in Program Development. Chapter 4: Data Abstraction. 1986.

B. Liskov, A. Snyder, R. Atkinson and C. Schaffert. Abstraction Mechanisms in CLU. Communications of the ACM, 20(8):564-576, August, 1977. (abstraction techniques, types, reliable software --motivating types) (311)

John Guttag, Abstract data types and the development of data structures, Communications of the ACM, 1977 - portal.acm.org (abstract data types can play a significant role in the development of software that is reliable, efficient, and flexible. This paper presents and ... ) Cited by 171

Logic Programming

Robert Kowalski. Algorithm = Logic + Control. Communications of the ACM, 22(7):424-435, July 1979.

Robert Kowalski. Predicate logic as programming language. In IFIP Congress, pages 569-574, 1974. Reprinted in Computers for Artificial Intelligence Applications, (eds. Wah, B. and Li, G.-J.), IEEE Computer Society Press, Los Angeles, 1986, pp. 68-73. (pretty great works)

Davis, Ruth E., "Logic Programming and Prolog: A Tutorial", IEEE Software Engineering, 2, 5 September 1985, pp. 493-501. (a tutorial)

Ehud Shapiro and David H.D. Warren. The Fifth Generation Project: Personal Perspectives. Communications of the ACM, 36(3):46-48, March 1993.

Jaffar & Maher, Constraint Logic Programming: A Survey

Aspects of Algol and it's family languages

Dijkstra Guarded Commands, Nondeterminancy and Formal Derivation of Programs (Berkelay optional, GTech - PL) (499) (i.e. the if .. fi, do .. od things)

Edsger W. Dijkstra. Go to statement considered harmful. [Tribble's nice annoted notes] [Wikipedia w/ links to other resources] 11(3):147-148, March 1968. Pretty great works (mentioned by multiple people)

Donald E. Knuth. Structured programming with 'go to' statments. Communications of the ACM, 6(4):261-301, 1974. (A great many great works (mentioned at least once))

Object Oriented Programming

David Ungar and Randall B. Smith, Self: The Power of Simplicity SIGPLAN Notices 22(12), December, 1987. (Also published in Lisp and Symbolic Computation 4(3), Kluwer Academic Publishers, June, 1991.) (A great many great works)

J. Palsberg and M. I. Schwartzbach. Object-oriented type inference. In Proceedings of the ACM Conference on Object-Oriented programming: Systems, Languages, and Applications, October 1991.

Bjarne Stroustrup. What is "Object-Oriented Programming"?. Proceedings of the First European Software Festival, 1991 revised version. (stroustrup's definition of OO (?), flawed paper)

Pizza into Java: Translating theory into practice, Martin Odersky and Philip Wadler, Proc. 24th ACM Symposium on Principles of Programming Languages, January 1997. (340)

Luca Cardelli. A semantics of multiple inheritance. In G. Kahn, D. MacQueen, and G. Plotkin, editors, Semantics of Data Types, volume 173 of Lecture Notes in Computer Science, pages 51-67. Springer-Verlag, 1984. Full version in Information and Computation, 76(2/3):138-164, 1988. (pretty great works)

Subroutines and Control Abstractions

Hanson, David R. "Is Block Structure Necessary?", Software Practice and Experience, 11,1981, (pp. 853-866). (argues subroutines are unnecessary)

Edsger W. Dijkstra. Recursive programming. In Saul Rosen, editor, Programming Systems and Languages, chapter 3C, pages 221-227. McGraw-Hill, New York, 1960. Pretty great works (mentioned by multiple people))

Concurrent Programming and Parallel Languagues (thanks to Guy Blelloch)

Arvind and Rishiyur S. Nikhil. A Dataflow Approach to General-purpose Parallel Computing. Computation Structures Group Memo 302, Laboratory for Computer Science, Massachusetts Institute of Technology, July 1989.

MultiLisp. Lisp with futures. A future is a promise to provide the value of a computation if needed; pointers to the future may be freely manipulated. Run-time system decides when futures should create new processes. An introduction to Multilisp [Hal85] and developments in MultiLisp, particularly the difficulties of implementing both futures and explicit continuations ( call/cc) [Hal90].

Hal85 R. H. Halstead. MultiLisp: A Language for Concurrent Symbolic Computation. ACM Transactions on Programming Languages and Systems, 7(4):501-538, October 1985.

Hal90 R. H. Halstead. New Ideas in Parallel Lisp: Language Design, Implementation, and Programming Tools. In G. Goos and J. Hartmanis, editors, Parallel Lisp: Languages and Systems, Proceedings of the U.S./Japan Workshop on Parallel Lisp, volume 441, pages 2-57. Springer-Verlag, 1990.

Jade: A High-Level, Machine-Independent Language for Parallel Programming, M. C. Rinard and D. J. Scales and M. S. Lam, IEEE Computer, June, 1993.

Programming Parallel Algorithms, Guy Blelloch, CACM, May 1996.

Scripting Languages

JK Ousterhout, Scripting: Higher-Level Programming for the 21st Century softpanorma [1] softpanorma [2] Wikipedia sourceforge IEEE Computer, 1998

Misc

Fateman (Berkeley) Software Fault Prevention by Language Choice: Why C is Not my Favorite Language. (software engineering)

P. Cousot and R. Cousot. Abstract Interpretation: A Unified Lattice Model for Static Analysis of Programs by Construction or Approximation of Fixpoints. In Symposium on Principles of Programming Languages, pages 238-252, January, 1977.

Wilson, Uniprocessor garbage collection techniques. In International Workshop on Memory Management in the Springer-Verlag Lecture Notes in Computer Science series., St. Malo, France, September 1992. Also online. (GTech)

"On the Criteria To Be Used in Decomposing Systems into Modules" Parnas

Alpern, Cocchi, Fink, Grove, Efficient Implementation of Java Interfaces: Invokeinterface Considered Harmless. OOPSLA 2001 proceedings, pp. 108-124. (GTech)

Wilson, Johnstone, Neely, Boles. Dynamic Storage Allocation: A Survey and Critical Review. In International Workshop on Memory Management, Kinross, Scotland, UK, 1995. Also online. (GTech)

Wing, J. "A Specifier's Introduction to Formal Methods", Computer 23(9): 8-26, September, 1990. (GTech)

Bracha, Odersky, Stoutamire, Wadler, Making the future safe for the past: Adding Genericity to the Java Programming Language. OOPSLA '98 proceedings, pp. 183-200. (GTech, Berkeley, object oriented, parametric polymorphism) (332)

Berkeley VA lecture notes on attribute grammars etc (berkeley) cs.mun.ca

http://www.cs.williams.edu/~morgan/cs334/#reading

http://www.cs.cmu.edu/~crary/819-f09/