| [1] |
Rodin T. A. Aarssen and Tijs van der Storm.
High-fidelity metaprogramming with separator syntax trees. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 27--37, January 2020. [ bib | http ] |
| [2] |
Martín Abadi and Luca Cardelli.
A theory of primitive objects: Second-order systems. Science of Computer Programming, 25(2--3):81--116, December 1995. [ bib | .pdf ] |
| [3] |
Martín Abadi and Luca Cardelli.
A theory of primitive objects: Untyped and first-order systems. Information and Computation, 125(2):78--102, March 1996. [ bib | .pdf ] |
| [4] |
Martín Abadi and Marcelo P. Fiore.
Syntactic considerations on recursive types. In Logic in Computer Science (LICS), pages 242--252, July 1996. [ bib | .ps ] |
| [5] |
Martin Abadi and Leslie Lamport.
The existence of refinement mappings. In Logic in Computer Science (LICS), pages 165--175, July 1988. [ bib | http ] |
| [6] |
Martín Abadi and Gordon D. Plotkin.
A simple differentiable programming language. Proceedings of the ACM on Programming Languages, 4(POPL):38:1--38:28, 2020. [ bib | http ] |
| [7] |
Martín Abadi, Anindya Banerjee, Nevin Heintze, and Jon G. Riecke.
A core calculus of dependency. In Principles of Programming Languages (POPL), pages 147--160, January 1999. [ bib | .ps ] |
| [8] |
Martín Abadi and Bruno Blanchet.
Secrecy types for asymmetric communication. In Foundations of Software Science and Computation Structures (FOSSACS), volume 2030 of Lecture Notes in Computer Science, pages 25--41. Springer, April 2001. [ bib | .html ] |
| [9] |
Martín Abadi, Butler Lampson, and Jean-Jacques Lévy.
Analysis and caching of dependencies. In International Conference on Functional Programming (ICFP), pages 83--91, May 1996. [ bib | .ps ] |
| [10] |
Martín Abadi, Benjamin Pierce, and Gordon Plotkin.
Faithful ideal models for recursive polymorphic types. International Journal of Foundations of Computer Science, 2(1):1--21, March 1991. [ bib | .ps ] |
| [11] |
Javad Abdi, Gilead Posluns, Guozheng Zhang, Boxuan Wang, and Mark C. Jeffrey.
When is parallelism fearless and zero-cost with Rust? In Symposium on Parallelism in Algorithms and Architectures, pages 27--40, June 2024. [ bib | http ] |
| [12] |
Andreas Abel.
Termination checking with types. RAIRO Theoretical Informatics and Applications, 38(4):277--319, 2004. [ bib | .pdf ] |
| [13] |
Andreas Abel.
MiniAgda: Integrating sized and dependent types. In Workshop on Partiality And Recursion in Interactive Theorem Provers (PAR), July 2010. [ bib | .pdf ] |
| [14] |
Andreas Abel, Marcin Benke, Ana Bove, John Hughes, and Ulf Norell.
Verifying Haskell programs using constructive type theory. In Haskell workshop, pages 62--73, September 2005. [ bib | .pdf ] |
| [15] |
Samson Abramsky.
Domain theory in logical form. Annals of Pure and Applied Logic, 51:1--77, 1991. [ bib | .ps.gz ] |
| [16] |
Samson Abramsky, Kohei Honda, and Guy McCusker.
A fully abstract game semantics for general references. In Logic in Computer Science (LICS), pages 334--344, 1998. [ bib | .ps.gz ] |
| [17] |
Umut A. Acar, Vitaly Aksenov, Arthur Charguéraud, and Mike Rainey.
Provably and practically efficient granularity control. In Principles and Practice of Parallel Programming (PPoPP), pages 214--228, February 2019. [ bib | http ] |
| [18] |
Umut A. Acar and Guy E. Blelloch.
Algorithms: Parallel and sequential. Online lecture notes, May 2022. [ bib | http ] |
| [19] |
Umut A. Acar, Arthur Charguéraud, and Mike Rainey.
Scheduling parallel programs by work stealing with private deques. In Principles and Practice of Parallel Programming (PPoPP), pages 219--228, February 2013. [ bib | .pdf ] |
| [20] |
Umut A. Acar, Arthur Charguéraud, and Mike Rainey.
Theory and practice of chunked sequences. In Algorithms (ESA), volume 8737, pages 25--36. Springer, September 2014. [ bib | .pdf ] |
| [21] |
Umut A. Acar, Arthur Charguéraud, Mike Rainey, and Filip Sieczkowski.
Dag-calculus: a calculus for parallel computation. In International Conference on Functional Programming (ICFP), pages 18--32, September 2016. [ bib | http ] |
| [22] |
Peter Achten and Marinus J. Plasmeijer.
The ins and outs of Clean I/O. Journal of Functional Programming, 5(1):81--110, 1995. [ bib | http ] |
| [23] |
Peter Aczel, Jirí Adámek, Stefan Milius, and Jirí Velebil.
Infinite trees and completely iterative theories: a coalgebraic view. Theoretical Computer Science, 300(1-3):1--45, 2003. [ bib | http ] |
| [24] |
Michael D. Adams and Matthew Might.
Restricting grammars with tree automata. Proceedings of the ACM on Programming Languages, 1(OOPSLA):82:1--82:25, 2017. [ bib | http ] |
| [25] |
Reynald Affeldt, Cyril Cohen, and Damien Rouhling.
Formalization techniques for asymptotic reasoning in classical analysis. Journal of Formalized Reasoning, 11(1):43--76, 2018. [ bib | .pdf ] |
| [26] |
Reynald Affeldt, Jacques Garrigue, and Takafumi Saikawa.
A practical formalization of monadic equational reasoning in dependent-type theory. Unpublished, 2023. [ bib | http ] |
| [27] |
Reynald Affeldt, David Nowak, and Yutaka Oiwa.
Formal network packet processing with minimal fuss: invertible syntax descriptions at work. In Programming Languages Meets Program Verification (PLPV), pages 27--36, 2012. [ bib | http ] |
| [28] |
Sten Agerholm.
A HOL basis for reasoning about functional programs. Technical Report RS-94-44, BRICS, December 1994. [ bib | .ps.gz ] |
| [29] |
Sten Agerholm.
LCF examples in HOL. Technical Report RS-94-18, BRICS, June 1994. [ bib | .ps.gz ] |
| [30] |
Alejandro Aguirre, Gilles Barthe, Marco Gaboardi, Deepak Garg, and
Pierre-Yves Strub.
A relational logic for higher-order programs. Journal of Functional Programming, 29:e16, 2019. [ bib | http ] |
| [31] |
Danel Ahman, Cédric Fournet, Catalin Hritcu, Kenji Maillard, Aseem Rastogi,
and Nikhil Swamy.
Recalling a witness: foundations and applications of monotonic state. Proceedings of the ACM on Programming Languages, 2(POPL):65:1--65:30, 2018. [ bib | http ] |
| [32] |
Danel Ahman, Catalin Hritcu, Kenji Maillard, Guido Martínez, Gordon D.
Plotkin, Jonathan Protzenko, Aseem Rastogi, and Nikhil Swamy.
Dijkstra monads for free. In Principles of Programming Languages (POPL), pages 515--529, January 2017. [ bib | http ] |
| [33] |
Amal Ahmed, Andrew W. Appel, Christopher D. Richards, Kedar N. Swadi, Gang Tan,
and Daniel C. Wang.
Semantic foundations for typed assembly languages. ACM Transactions on Programming Languages and Systems, 32(3), 2010. [ bib | .pdf ] |
| [34] |
Amal Ahmed and Matthias Blume.
Typed closure conversion preserves observational equivalence. In International Conference on Functional Programming (ICFP), pages 157--168, September 2008. [ bib | .pdf ] |
| [35] |
Amal Ahmed, Derek Dreyer, and Andreas Rossberg.
State-dependent representation independence. In Principles of Programming Languages (POPL), pages 340--353, January 2009. [ bib | .pdf ] |
| [36] |
Amal Ahmed, Matthew Fluet, and Greg Morrisett.
L3: A linear language with locations. Fundamenta Informaticæ, 77(4):397--449, 2007. [ bib | .pdf ] |
| [37] |
Amal J. Ahmed, Andrew W. Appel, and Roberto Virga.
A stratified semantics of general references embeddable in higher-order logic. In Logic in Computer Science (LICS), pages 75--86, July 2002. [ bib | .pdf ] |
| [38] |
Amal J. Ahmed, Matthew Fluet, and Greg Morrisett.
A step-indexed model of substructural state. In International Conference on Functional Programming (ICFP), pages 78--91, September 2005. [ bib | .pdf ] |
| [39] |
Amal Jamil Ahmed.
Semantics of types for mutable state. PhD thesis, Princeton University, 2004. [ bib | .pdf ] |
| [40] |
Ki Yung Ahn and Andrea Vezzosi.
Executable relational specifications of polymorphic type systems using Prolog. In Functional and Logic Programming, volume 9613 of Lecture Notes in Computer Science, pages 109--125. Springer, March 2016. [ bib | http ] |
| [41] |
Alfred Aho, Ravi Sethi, and Jeffrey Ullman.
Compilateurs: principes, techniques et outils. InterEditions, 1989. [ bib ] |
| [42] |
Alfred V. Aho, John E. Hopcroft, and Jeffrey D. Ullman.
The design and analysis of computer algorithms. Addison-Wesley, 1974. [ bib ] |
| [43] |
Alfred V. Aho, John E. Hopcroft, and Jeffrey D. Ullman.
Data structures and algorithms. Addison-Wesley, 1983. [ bib ] |
| [44] |
Alfred V. Aho, Stephen C. Johnson, and Jeffrey D. Ullman.
Deterministic parsing of ambiguous grammars. Communications of the ACM, 18(8):441--452, 1975. [ bib | http ] |
| [45] |
Alfred V. Aho, Ravi Sethi, and Jeffrey D. Ullman.
Compilers: Principles, techniques, and tools. Addison-Wesley, 1986. [ bib ] |
| [46] |
Alfred V. Aho and Jeffrey D. Ullman.
Optimization of LR(k) parsers. Journal of Computer and System Sciences, 6(6):573--602, 1972. [ bib | http ] |
| [47] |
Alfred V. Aho and Jeffrey D. Ullman.
The theory of parsing, translation, and compiling. Prentice Hall, 1972. [ bib | http ] |
| [48] |
Alfred V. Aho and Jeffrey D. Ullman.
A technique for speeding up LR(k) parsers. SIAM Journal on Computing, 2(2):106--127, 1973. [ bib | http ] |
| [49] |
Alexander Aiken.
Introduction to set constraint-based program analysis. Science of Computer Programming, 35:79--111, 1999. [ bib | .pdf ] |
| [50] |
Alexander Aiken, Manuel Fähndrich, and Raph Levien.
Better static memory management: improving region-based analysis of higher-order languages. ACM SIGPLAN Notices, 30(6):174--185, June 1995. [ bib | .pdf ] |
| [51] |
Alexander Aiken, Manuel Fähndrich, Jeffrey S. Foster, and Zhendong Su.
A toolkit for constructing type- and constraint-based program analyses. Lecture Notes in Computer Science, 1473:76--96, 1998. [ bib | .pdf ] |
| [52] |
Alexander S. Aiken.
The Illyria system, 1994. [ bib | .html ] |
| [53] |
Alexander S. Aiken and Manuel Fähndrich.
Making set-constraint based program analyses scale. Technical Report CSD-96-917, University of California, Berkeley, September 1996. [ bib | .pdf ] |
| [54] |
Alexander S. Aiken and Manuel Fähndrich.
Subtyping polymorphic constrained types. Technical Report CSD-96-898, University of California, Berkeley, March 1996. [ bib ] |
| [55] |
Alexander S. Aiken and Manuel Fähndrich.
Program analysis using mixed term and set constraints. In Static Analysis Symposium (SAS), pages 114--126, September 1997. [ bib | .pdf ] |
| [56] |
Alexander S. Aiken and Edward L. Wimmers.
Solving systems of set constraints. In Logic in Computer Science (LICS), pages 329--340, June 1992. [ bib | .pdf ] |
| [57] |
Alexander S. Aiken and Edward L. Wimmers.
Type inclusion constraints and type inference. In Functional Programming Languages and Computer Architecture (FPCA), pages 31--41. ACM Press, 1993. [ bib | .pdf ] |
| [58] |
Alexander S. Aiken, Edward L. Wimmers, and T. K. Lakshman.
Soft typing with conditional types. In Principles of Programming Languages (POPL), pages 163--173, January 1994. [ bib | .pdf ] |
| [59] |
Alexander S. Aiken, Edward L. Wimmers, and Jens Palsberg.
Optimal representations of polymorphic types with subtyping. Technical Report CSD-96-909, University of California, Berkeley, July 1996. [ bib | .pdf ] |
| [60] |
Elvira Albert, Puri Arenas, Samir Genaim, Germán Puebla, and Damiano
Zanardini.
Cost analysis of java bytecode. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 157--172. Springer, April 2007. [ bib | http ] |
| [61] |
Elvira Albert, Puri Arenas, Samir Genaim, German Puebla, and Damiano Zanardini.
Cost analysis of object-oriented bytecode programs. Theoretical Computer Science, 413(1):142--159, 2012. [ bib | .pdf ] |
| [62] |
Elvira Albert, Samir Genaim, and Miguel Gómez-Zamalloa.
Heap space analysis for Java bytecode. In International Symposium on Memory Management, pages 105--116, October 2007. [ bib | .pdf ] |
| [63] |
Elvira Albert, Samir Genaim, and Miguel Gómez-Zamalloa.
Live heap space analysis for languages with garbage collection. In International Symposium on Memory Management, pages 129--138, June 2009. [ bib | .pdf ] |
| [64] |
Elvira Albert, Samir Genaim, and Miguel Gómez-Zamalloa.
Parametric inference of memory requirements for garbage collected languages. In International Symposium on Memory Management, pages 121--130, June 2010. [ bib | .pdf ] |
| [65] |
Elvira Albert, Samir Genaim, and Miguel Gómez-Zamalloa.
Heap space analysis for garbage collected languages. Science of Computer Programming, 78(9):1427--1448, 2013. [ bib | http ] |
| [66] |
Jonathan Aldrich.
Resource-based programming in Plaid. Fun Ideas and Thoughts, June 2010. [ bib | .pdf ] |
| [67] |
Jonathan Aldrich.
The power of interoperability: why objects are inevitable. In ACM Symposium on New Ideas in Programming and Reflections on Software (Onward!), pages 101--116, October 2013. [ bib | .pdf ] |
| [68] |
Jonathan Aldrich, Ronald Garcia, Mark Hahnenberg, Manuel Mohr, Karl Naden,
Darpan Saini, Sven Stork, Joshua Sunshine, Éric Tanter, and Roger Wolff.
Permission-based programming languages. In International Conference on Software Engineering (ICSE), pages 828--831, May 2011. [ bib | .pdf ] |
| [69] |
Jonathan Aldrich, Joshua Sunshine, Darpan Saini, and Zachary Sparks.
Typestate-oriented programming. In Companion to Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 1015--1022, October 2009. [ bib | .pdf ] |
| [70] |
Guillaume Allais, James Chapman, Conor McBride, and James McKinna.
Type-and-scope safe programs and their proofs. In Certified Programs and Proofs (CPP), pages 195--207, January 2017. [ bib | .pdf ] |
| [71] |
Paulo Sérgio Almeida.
Balloon types: Controlling sharing of state in data types. In European Conference on Object-Oriented Programming (ECOOP), volume 1241 of Lecture Notes in Computer Science, pages 32--59. Springer, June 1997. [ bib | http ] |
| [72] |
Stephen Alstrup, Mikkel Thorup, Inge Li Gørtz, Theis Rauhe, and Uri Zwick.
Union-find with constant time deletions. ACM Transactions on Algorithms, 11(1):6:1--6:28, 2014. [ bib | http ] |
| [73] |
Thorsten Altenkirch, Nils Anders Danielsson, Andres Löh, and Nicolas Oury.
ΠΣ: Dependent types without the sugar. In Functional and Logic Programming, volume 6009 of Lecture Notes in Computer Science, pages 40--55. Springer, April 2010. [ bib | .pdf ] |
| [74] |
Thorsten Altenkirch, Conor McBride, and James McKinna.
Why dependent types matter. Unpublished, April 2005. [ bib | .pdf ] |
| [75] |
Thorsten Altenkirch and Bernhard Reus.
Monadic presentations of lambda terms using generalized inductive types. In Computer Science Logic, volume 1683 of Lecture Notes in Computer Science, pages 453--468. Springer, 1999. [ bib | .pdf ] |
| [76] |
Roberto Amadio and Yann Régis-Gianas.
Certifying and reasoning about cost annotations of functional programs. Higher-Order and Symbolic Computation, January 2013. [ bib | http ] |
| [77] |
Roberto Amadio and Yann Régis-Gianas.
Certifying and reasoning on cost annotations of functional programs. In Foundational and Practical Aspects of Resource Analysis, volume 7177 of Lecture Notes in Computer Science, pages 72--89. Springer, May 2011. [ bib | http ] |
| [78] |
Roberto M. Amadio, Nicholas Ayache, François Bobot, Jaap Boender, Brian
Campbell, Ilias Garnier, Antoine Madet, James McKinna, Dominic P. Mulligan,
Mauro Piccolo, Randy Pollack, Yann Régis-Gianas, Claudio Sacerdoti Coen,
Ian Stark, and Paolo Tranquilli.
Certified complexity (CerCo). In Foundational and Practical Aspects of Resource Analysis, volume 8552 of Lecture Notes in Computer Science, pages 1--18. Springer, August 2014. [ bib | http ] |
| [79] |
Roberto M. Amadio and Luca Cardelli.
Subtyping recursive types. ACM Transactions on Programming Languages and Systems, 15(4):575--631, September 1993. [ bib | .pdf ] |
| [80] |
Guillaume Ambal, Sergueï Lenglet, and Alan Schmitt.
Certified abstract machines for skeletal semantics. In Certified Programs and Proofs (CPP), pages 55--67, January 2022. [ bib | http ] |
| [81] |
Guillaume Ambal, Sergueï Lenglet, Alan Schmitt, and Camille Noûs.
Certified derivation of small-step from big-step skeletal semantics. In Principles and Practice of Declarative Programming (PPDP), pages 11:1--11:48, September 2022. [ bib | http ] |
| [82] |
Pierre America and Jan Rutten.
Solving reflexive domain equations in a category of complete metric spaces. In Mathematical Foundations of Programming Semantics, volume 298 of Lecture Notes in Computer Science, pages 254--288. Springer, 1988. [ bib | http ] |
| [83] |
Afshin Amighi, Christian Haack, Marieke Huisman, and Clément Hurlin.
Permission-based separation logic for multithreaded Java programs. Logical Methods in Computer Science, 11(1):1--66, 2015. [ bib | http ] |
| [84] |
Nada Amin, Samuel Grütter, Martin Odersky, Tiark Rompf, and Sandro
Stucki.
The essence of dependent object types. In A List of Successes That Can Change the World -- Essays Dedicated to Philip Wadler on the Occasion of His 60th Birthday, volume 9600 of Lecture Notes in Computer Science, pages 249--272. Springer, 2016. [ bib | .pdf ] |
| [85] |
Nada Amin and Tiark Rompf.
Type soundness proofs with definitional interpreters. In Principles of Programming Languages (POPL), pages 666--679, January 2017. [ bib | .pdf ] |
| [86] |
Saswat Anand, Edmund K. Burke, Tsong Yueh Chen, John A. Clark, Myra B. Cohen,
Wolfgang Grieskamp, Mark Harman, Mary Jean Harrold, and Phil McMinn.
An orchestrated survey of methodologies for automated software test case generation. Journal of Systems and Software, 86(8):1978--2001, 2013. [ bib | http ] |
| [87] |
Henrik Reif Andersen.
Model checking and Boolean graphs. Theoretical Computer Science, 126(1):3--30, 1994. [ bib | http ] |
| [88] |
Brian Anderson, Lars Bergstrom, David Herman, Josh Matthews, Keegan McAllister,
Manish Goregaokar, Jack Moffitt, and Simon Sapin.
Experience report: Developing the Servo web browser engine using Rust. http://arxiv.org/abs/1505.07383, 2015. [ bib ] |
| [89] |
T. Anderson, J. Eve, and J. J. Horning.
Efficient LR(1) parsers. Acta Informatica, 2:12--39, 1973. [ bib | http ] |
| [90] |
Gregory R. Andrews.
Foundations of multithreaded, parallel, and distributed programming. Addison-Wesley, 2000. [ bib ] |
| [91] |
Gregory R. Andrews and Richard P. Reitman.
An axiomatic approach to information flow in programs. ACM Transactions on Programming Languages and Systems, 2(1):56--76, January 1980. [ bib ] |
| [92] |
Peter B. Andrews.
An introduction to mathematical logic and type theory: to truth through proof. Academic Press, 1986. [ bib ] |
| [93] |
Timos Antonopoulos, Nikos Gorogiannis, Christoph Haase, Max I. Kanovich, and
Joël Ouaknine.
Foundations for decision problems in separation logic with general inductive predicates. In Foundations of Software Science and Computation Structures (FOSSACS), volume 8412 of Lecture Notes in Computer Science, pages 411--425. Springer, April 2014. [ bib | .pdf ] |
| [94] |
Timos Antonopoulos, Eric Koskinen, Ton Chanh Le, Ramana Nagasamudram, David A.
Naumann, and Minh Ngo.
An algebra of alignment for relational verification. Proceedings of the ACM on Programming Languages, 7(POPL):573--603, 2023. [ bib | http ] |
| [95] |
Kalmer Apinis, Helmut Seidl, and Vesal Vojdani.
Enhancing top-down solving with widening and narrowing. In Semantics, Logics, and Calculi -- Essays Dedicated to Hanne Riis Nielson and Flemming Nielson on the Occasion of Their 60th Birthdays, volume 9560 of Lecture Notes in Computer Science, pages 272--288. Springer, 2016. [ bib | .pdf ] |
| [96] |
Maria-Virginia Aponte and Roberto Di Cosmo.
Type isomorphisms for module signatures. In Programming Languages: Implementations, Logics, and Programs (PLILP), volume 1140 of Lecture Notes in Computer Science, pages 334--346. Springer, September 1996. [ bib | http ] |
| [97] |
Andrew Appel.
Modern compiler implementation in ML. Cambridge University Press, 1998. [ bib | http ] |
| [98] |
Andrew W. Appel.
Compiling with continuations. Cambridge University Press, 1992. [ bib | http ] |
| [99] |
Andrew W. Appel.
Verified software toolchain. In European Symposium on Programming (ESOP), volume 6602 of Lecture Notes in Computer Science, pages 1--17. Springer, March 2011. [ bib | .pdf ] |
| [100] |
Andrew W. Appel.
VeriSmall: Verified Smallfoot shape analysis. In Certified Programs and Proofs (CPP), volume 7086 of Lecture Notes in Computer Science, pages 231--246. Springer, December 2011. [ bib | .pdf ] |
| [101] |
Andrew W. Appel and Trevor Jim.
Shrinking lambda expressions in linear time. Journal of Functional Programming, 7(5):515--540, 1997. [ bib | .ps.gz ] |
| [102] |
Andrew W. Appel, Paul-André Melliès, Christopher D. Richards, and
Jérôme Vouillon.
A very modal model of a modern, major, general type system. In Principles of Programming Languages (POPL), pages 109--122, January 2007. [ bib | .pdf ] |
| [103] |
Krzysztof R. Apt.
Ten years of Hoare's logic: A survey---part I. ACM Transactions on Programming Languages and Systems, 3(4):431--483, 1981. [ bib | http ] |
| [104] |
Zena M. Ariola and Jan Willem Klop.
Equational term graph rewriting. Fundamenta Informaticæ, 26(3--4):207--240, 1996. [ bib | .ps.Z ] |
| [105] |
André Arnold and Paul Crubillé.
A linear algorithm to solve fixed-point equations on transition systems. Information Processing Letters, 29(2):57--66, 1988. [ bib | http ] |
| [106] |
André Arnold and Maurice Nivat.
The metric space of infinite trees. Algebraic and topological properties. Fundamenta Informaticæ, 3(4):181--205, 1980. [ bib ] |
| [107] |
Jeroen Arnoldus, Mark G. J. van den Brand, Alexander Serebrenik, and Jacob
Brunekreef.
Code generation with templates, volume 1 of Atlantis Studies in Computing. Atlantis Press, 2012. [ bib | http ] |
| [108] |
Ellen Arvidsson, Elias Castegren, Sylvan Clebsch, Sophia Drossopoulou, James
Noble, Matthew J. Parkinson, and Tobias Wrigstad.
Reference capabilities for flexible memory management. Proceedings of the ACM on Programming Languages, 7(OOPSLA2):1363--1393, 2023. [ bib | http ] |
| [109] |
Kenichi Asai.
On typing delimited continuations: three new solutions to the printf problem. Higher-Order and Symbolic Computation, 22(3):275--291, 2009. [ bib | .pdf ] |
| [110] |
Kenichi Asai and Yukiyoshi Kameyama.
Polymorphic delimited continuations. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 239--254. Springer, November 2007. [ bib | .pdf ] |
| [111] |
Kenichi Asai, Oleg Kiselyov, and Chung-chieh Shan.
Functional ununparsing. Higher-Order and Symbolic Computation, 24(4):311--340, 2011. [ bib | http ] |
| [112] |
David Aspinall, Lennart Beringer, Martin Hofmann, Hans-Wolfgang Loidl, and
Alberto Momigliano.
A program logic for resources. Theoretical Computer Science, 389(3):411--445, 2007. [ bib | http ] |
| [113] |
David Aspinall and Adriana B. Compagnoni.
Heap-bounded assembly language. Journal of Automated Reasoning, 31(3-4):261--302, 2003. [ bib | http ] |
| [114] |
David Aspinall and Martin Hofmann.
Another type system for in-place update. In European Symposium on Programming (ESOP), volume 2305 of Lecture Notes in Computer Science, pages 36--52. Springer, April 2002. [ bib | .pdf ] |
| [115] |
David Aspinall, Martin Hofmann, and Michal Konečný.
A type system with usage aspects. Journal of Functional Programming, 18(2):141--178, 2008. [ bib | http ] |
| [116] |
Robert Atkey.
Parameterised notions of computation. Journal of Functional Programming, 19(3--4):355--376, 2009. [ bib | .pdf ] |
| [117] |
Robert Atkey.
Syntax for free: representing syntax with binding using parametricity. In Typed Lambda Calculi and Applications (TLCA), volume 5608 of Lecture Notes in Computer Science, pages 35--49. Springer, July 2009. [ bib | .pdf ] |
| [118] |
Robert Atkey.
Amortised resource analysis with separation logic. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 85--103. Springer, 2010. [ bib | .pdf ] |
| [119] |
Robert Atkey.
Amortised resource analysis with separation logic. Logical Methods in Computer Science, 7(2:17):1--33, 2011. [ bib | http ] |
| [120] |
Robert Atkey, Sam Lindley, and Jeremy Yallop.
Unembedding domain-specific languages. In Haskell symposium, pages 37--48, September 2009. [ bib | .pdf ] |
| [121] |
Philippe Audebaud and Elena Zucca.
Deriving proof rules from continuation semantics. Formal Aspects of Computing, 11(4):426--447, 1999. [ bib | http ] |
| [122] |
Lennart Augustsson.
Implementing Haskell overloading. In Functional Programming Languages and Computer Architecture (FPCA), pages 65--73, 1993. [ bib | http ] |
| [123] |
Lennart Augustsson and Magnus Carlsson.
An exercise in dependent types: A well-typed interpreter. Workshop on Dependent Types in Programming, 1999. [ bib | http ] |
| [124] |
Jean-Michel Autebert.
Théorie des langages et des automates. Masson, 1994. [ bib ] |
| [125] |
Jean-Michel Autebert, Jean Berstel, and Luc Boasson.
Context-free languages and push-down automata. In Handbook of Formal Languages, volume 1, pages 111--174. Springer, 1997. [ bib | .ps.gz ] |
| [126] |
Jeremy Avigad and Kevin Donnelly.
Formalizing O notation in Isabelle/HOL. In International Joint Conference on Automated Reasoning, volume 3097 of Lecture Notes in Computer Science, pages 357--371. Springer, July 2004. [ bib | .pdf ] |
| [127] |
Nicholas Ayache, Roberto M. Amadio, and Yann Régis-Gianas.
Certifying and reasoning on cost annotations in C programs. In Formal Methods for Industrial Critical Systems, volume 7437 of Lecture Notes in Computer Science, pages 32--46. Springer, August 2012. [ bib | http ] |
| [128] |
John Aycock and Nigel Horspool.
Simple generation of static single-assignment form. In Compiler Construction (CC), volume 1781 of Lecture Notes in Computer Science. Springer, March 2000. [ bib | .ps ] |
| [129] |
Brian Aydemir, Arthur Charguéraud, Benjamin C. Pierce, Randy Pollack, and
Stephanie Weirich.
Engineering formal metatheory. In Principles of Programming Languages (POPL), pages 3--15, January 2008. [ bib | .pdf ] |
| [130] |
Brian Aydemir and Stephanie Weirich.
LNgen: Tool support for locally nameless representations. Technical Report MS-CIS-10-24, University of Pennsylvania Department of Computer and Information Science, June 2010. [ bib | http ] |
| [131] |
Brian E. Aydemir, Aaron Bohannon, Matthew Fairbairn, J. Nathan Foster,
Benjamin C. Pierce, Peter Sewell, Dimitrios Vytiniotis, Geoffrey Washburn,
Stephanie Weirich, and Steve Zdancewic.
Mechanized metatheory for the masses: The PoplMark challenge. In Theorem Proving in Higher Order Logics (TPHOLs), volume 3603 of Lecture Notes in Computer Science, pages 50--65. Springer, August 2005. [ bib | .pdf ] |
| [132] |
Patrick Bahr and Graham Hutton.
Calculating compilers for concurrency. Proceedings of the ACM on Programming Languages, 7(ICFP):740--767, 2023. [ bib | http ] |
| [133] |
Henry G. Baker.
List processing in real time on a serial computer. Communications of the ACM, 21(4):280--294, April 1978. [ bib | http ] |
| [134] |
Henry G. Baker.
Unify and conquer (garbage, updating, aliasing, ...) in functional languages. In ACM Symposium on Lisp and Functional Programming (LFP), pages 218--226, June 1990. [ bib | .ps.gz ] |
| [135] |
Henry G. Baker.
Shallow binding makes functional arrays fast. ACM SIGPLAN Notices, 26(8):145--147, 1991. [ bib | http ] |
| [136] |
Thibaut Balabonski, François Pottier, and Jonathan Protzenko.
Type soundness and race freedom for Mezzo. In Proceedings of the 12th International Symposium on Functional and Logic Programming (FLOPS 2014), volume 8475 of Lecture Notes in Computer Science, pages 253--269. Springer, June 2014. [ bib | .pdf ] |
| [137] |
Thibaut Balabonski, François Pottier, and Jonathan Protzenko.
The design and formalization of Mezzo, a permission-based programming language. ACM Transactions on Programming Languages and Systems, 38(4):14:1--14:94, August 2016. [ bib | .pdf ] |
| [138] |
Vincent Balat, Roberto Di Cosmo, and Marcelo Fiore.
Remarks on isomorphisms in typed lambda calculi with empty and sum type. In Logic in Computer Science (LICS), July 2002. [ bib | .ps.gz ] |
| [139] |
Anindya Banerjee, Nevin Heintze, and Jon G. Riecke.
Region analysis and the polymorphic lambda calculus. In Logic in Computer Science (LICS), pages 88--97, July 1999. [ bib | .pdf ] |
| [140] |
Anindya Banerjee, Nevin Heintze, and Jon G. Riecke.
Design and correctness of program transformations based on control-flow analysis. In International Symposium on Theoretical Aspects of Computer Software (TACS), volume 2215 of Lecture Notes in Computer Science, pages 420--447. Springer, October 2001. [ bib | .ps.gz ] |
| [141] |
Anindya Banerjee and David Naumann.
Secure information flow and pointer confinement in a Java-like language. In IEEE Computer Security Foundations Workshop, pages 253--267, June 2002. [ bib | .ps ] |
| [142] |
Anindya Banerjee and David A. Naumann.
A simple semantics and static analysis for Java security. Technical Report 2001-1, Stevens Institute of Technology, June 2001. [ bib | .ps ] |
| [143] |
Anindya Banerjee and David A. Naumann.
Representation independence, confinement, and access control. In Principles of Programming Languages (POPL), pages 166--177, January 2002. [ bib | .ps ] |
| [144] |
Anindya Banerjee and David A. Naumann.
State based ownership, reentrance, and encapsulation. In European Conference on Object-Oriented Programming (ECOOP), volume 3586 of Lecture Notes in Computer Science, pages 387--411. Springer, July 2005. [ bib | .pdf ] |
| [145] |
Anindya Banerjee, David A. Naumann, and Mohammad Nikouei.
A logical analysis of framing for specifications with pure method calls. ACM Transactions on Programming Languages and Systems, 40(2):6:1--6:90, 2018. [ bib | http ] |
| [146] |
Anindya Banerjee, David A. Naumann, and Stan Rosenberg.
Regional logic for local reasoning about global invariants. In European Conference on Object-Oriented Programming (ECOOP), volume 5142 of Lecture Notes in Computer Science, pages 387--411. Springer, July 2008. [ bib | http ] |
| [147] |
Jean-Pierre Banâtre, Ciarán Bryce, and Daniel Le Métayer.
Compile-time detection of information flow in sequential programs. In European Symposium on Research in Computer Security, volume 875 of Lecture Notes in Computer Science, pages 55--74. Springer, 1994. [ bib | .ps.Z ] |
| [148] |
Yuyan Bao, Guannan Wei, Oliver Bracevac, Yuxuan Jiang, Qiyang He, and Tiark
Rompf.
Reachability types: tracking aliasing and separation in higher-order functional programs. Proceedings of the ACM on Programming Languages, 5(OOPSLA):1--32, 2021. [ bib | http ] |
| [149] |
Andrew Barber.
Dual intuitionistic linear logic. Technical Report ECS-LFCS-96-347, Laboratory for Foundations of Computer Science, School of Informatics at the University of Edinburgh, September 1996. [ bib | http ] |
| [150] |
Henk P. Barendregt.
The lambda calculus, its syntax and semantics. Elsevier, 1984. [ bib | http ] |
| [151] |
Henk P. Barendregt.
Functional programming and lambda calculus. In J. Van Leeuwen, editor, Handbook of Theoretical Computer Science, pages 321--363. Elsevier, 1990. [ bib ] |
| [152] |
Erik Barendsen and Sjaak Smetsers.
Uniqueness type inference. In Programming Languages: Implementations, Logics, and Programs (PLILP), volume 982 of Lecture Notes in Computer Science, pages 189--206. Springer, 1995. [ bib | http ] |
| [153] |
Mike Barnett, Bor-Yuh Evan Chang, Rob DeLine, and Bart Jacobs.
Boogie: A modular reusable verifier for object-oriented programs. In Formal Methods for Components and Objects. Springer, November 2005. [ bib | .pdf ] |
| [154] |
Mike Barnett, Rob DeLine, Manuel Fähndrich, K. Rustan M. Leino, and Wolfram
Schulte.
Verification of object-oriented programs with invariants. Journal of Object Technology, 3(6), 2004. [ bib | http ] |
| [155] |
Mike Barnett, K. Rustan M. Leino, and Wolfram Schulte.
The Spec# programming system: An overview. In Construction and Analysis of Safe, Secure and Interoperable Smart devices (CASSIS), volume 3362 of Lecture Notes in Computer Science, pages 49--69. Springer, 2004. [ bib | .pdf ] |
| [156] |
Mike Barnett, David A. Naumann, Wolfram Schulte, and Qi Sun.
99.44% pure: Useful abstractions in specifications. In Formal Techniques for Java-like Programs, 2004. [ bib | .pdf ] |
| [157] |
Chris Barrett, Riko Jacob, and Madhav Marathe.
Formal language constrained path problems. SIAM Journal on Computing, 30(3):809--837, 2000. [ bib | .ps.gz ] |
| [158] |
Alexandra Barros and Roberto Ierusalimschy.
Eliminating cycles in weak tables. Journal of Universal Computer Science, 14(21):3481--3497, 2008. [ bib | .pdf ] |
| [159] |
Frank Bartels, Friedrich von Henke, Holger Pfeifer, and Harald Rueß.
Mechanizing domain theory. Ulmer Informatik-Berichte 96-10, Universität Ulm, Fakultät für Informatik, 1996. [ bib | .ps.gz ] |
| [160] |
Gilles Barthe, Raphaëlle Crubillé, Ugo Dal Lago, and Francesco Gavazzo.
On the versatility of open logical relations -- continuity, automatic differentiation, and a containment theorem. In European Symposium on Programming (ESOP), volume 12075 of Lecture Notes in Computer Science, pages 56--83. Springer, April 2020. [ bib | http ] |
| [161] |
Gilles Barthe, Julien Forest, David Pichardie, and Vlad Rusu.
Defining and reasoning about recursive functions: A practical tool for the Coq proof assistant. In Functional and Logic Programming, volume 3945 of Lecture Notes in Computer Science, pages 114--129. Springer, April 2006. [ bib | .pdf ] |
| [162] |
Gilles Barthe, John Hatcliff, and Morten Heine Sørensen.
CPS translations and applications: The cube and beyond. Higher-Order and Symbolic Computation, 12(2):125--170, 1999. [ bib | http ] |
| [163] |
Aditi Barthwal and Michael Norrish.
Verified, executable parsing. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 160--174. Springer, 2009. [ bib | .pdf ] |
| [164] |
Massimo Bartoletti, Pierpaolo Degano, and GianLuigi Ferrari.
Static analysis for stack inspection. In International Workshop on Concurrency and Coordination, volume 54 of Electronic Notes in Theoretical Computer Science. Elsevier, 2001. [ bib ] |
| [165] |
Mark Batty, Scott Owens, Susmit Sarkar, Peter Sewell, and Tjark Weber.
Mathematizing C++ concurrency. In Principles of Programming Languages (POPL), pages 55--66, January 2011. [ bib | .pdf ] |
| [166] |
Andrej Bauer, Martin Hofmann, and Aleksandr Karbyshev.
On monadic parametricity of second-order functionals. In Foundations of Software Science and Computation Structures (FOSSACS), volume 7794 of Lecture Notes in Computer Science, pages 225--240. Springer, March 2013. [ bib | .pdf ] |
| [167] |
Andrej Bauer and Matija Pretnar.
An effect system for algebraic effects and handlers. Logical Methods in Computer Science, 10(4), 2014. [ bib | .pdf ] |
| [168] |
Andrej Bauer and Matija Pretnar.
Programming with algebraic effects and handlers. Journal of Logical and Algebraic Methods in Programming, 84(1):108--123, 2015. [ bib | .pdf ] |
| [169] |
Andrej Bauer and Matija Pretnar.
Eff. http://www.eff-lang.org/, 2020. [ bib ] |
| [170] |
Atilim Gunes Baydin, Barak A. Pearlmutter, Alexey Andreyevich Radul, and
Jeffrey Mark Siskind.
Automatic differentiation in machine learning: a survey. Journal of Machine Learning Research, 18(153):1--43, 2018. [ bib | .html ] |
| [171] |
Mike Beaven and Ryan Stansifer.
Explaining type errors in polymorphic languages. ACM Letters on Programming Languages and Systems, 2(4):17--30, March 1993. [ bib | .ps.gz ] |
| [172] |
Brett A. Becker, Paul Denny, Raymond Pettit, Durell Bouchard, Dennis J.
Bouvier, Brian Harrington, Amir Kamil, Amey Karkare, Chris McDonald,
Peter-Michael Osera, Janice L. Pearce, and James Prather.
Compiler error messages considered unhelpful: The landscape of text-based programming error message research. In Proceedings of the Working Group Reports on Innovation and Technology in Computer Science Education, pages 177--210, July 2019. [ bib | .pdf ] |
| [173] |
Brett A. Becker, Paul Denny, James Prather, Raymond Pettit, Robert Nix, and
Catherine Mooney.
Towards assessing the readability of programming error messages. In Australasian Computing Education Conference, pages 181--188, February 2021. [ bib | http ] |
| [174] |
Bernhard Beckert, Reiner Hähnle, and Peter H. Schmitt, editors.
Verification of object-oriented software. the KeY approach, volume 4334 of Lecture Notes in Computer Science. Springer, 2007. [ bib | http ] |
| [175] |
C. J. Bell, Robert Dockins, Aquinas Hobor, Andrew W. Appel, and David Walker.
Comparing semantic and syntactic methods in mechanized proof frameworks. In International Workshop on Proof-Carrying Code (PCC), June 2008. [ bib | .pdf ] |
| [176] |
D. E. Bell and Leonard J. LaPadula.
Secure computer systems: Unified exposition and Multics interpretation. Technical Report MTR-2997, The MITRE Corp., July 1975. [ bib | .pdf ] |
| [177] |
Jeffrey M. Bell, Françoise Bellegarde, and James Hook.
Type-driven defunctionalization. In International Conference on Functional Programming (ICFP), August 1997. [ bib | http ] |
| [178] |
Françoise Bellegarde and James Hook.
Substitution: A formal methods case study using monads and transformations. Science of Computer Programming, 23(2-3):287--311, 1994. [ bib | http ] |
| [179] |
John Bender and Jens Palsberg.
A formalization of Java's concurrent access modes. Proceedings of the ACM on Programming Languages, 3(OOPSLA):142:1--142:28, 2019. [ bib | .pdf ] |
| [180] |
Michael A. Bender, Jeremy T. Fineman, Seth Gilbert, and Robert E. Tarjan.
A new approach to incremental cycle detection and related problems. ACM Transactions on Algorithms, 12(2):14:1--14:22, 2016. [ bib | http ] |
| [181] |
Jesper Bengtson, Jonas Braband Jensen, and Lars Birkedal.
Charge! A framework for higher-order separation logic in Coq. In Interactive Theorem Proving (ITP), pages 315--331, August 2012. [ bib | .pdf ] |
| [182] |
Nick Benton.
Simple relational correctness proofs for static analyses and program transformations. In Principles of Programming Languages (POPL), pages 14--25, January 2004. [ bib | http ] |
| [183] |
Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn.
A decidable fragment of separation logic. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 3328 of Lecture Notes in Computer Science, pages 97--109. Springer, December 2004. [ bib | .pdf ] |
| [184] |
Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn.
Smallfoot: Modular automatic assertion checking with separation logic. In Formal Methods for Components and Objects, volume 4111 of Lecture Notes in Computer Science, pages 115--137. Springer, November 2005. [ bib | .pdf ] |
| [185] |
Josh Berdine, Cristiano Calcagno, and Peter W. O'Hearn.
Symbolic execution with separation logic. In Asian Symposium on Programming Languages and Systems (APLAS), volume 3780 of Lecture Notes in Computer Science, pages 52--68. Springer, 2005. [ bib | .pdf ] |
| [186] |
Josh Berdine and Peter W. O'Hearn.
Strong update, disposal, and encapsulation in bunched typing. In Mathematical Foundations of Programming Semantics, volume 158 of Electronic Notes in Theoretical Computer Science, pages 81--98. Elsevier, May 2006. [ bib | .pdf ] |
| [187] |
Josh Berdine, Peter W. O'Hearn, Uday S. Reddy, and Hayo Thielecke.
Linear continuation-passing. Higher-Order and Symbolic Computation, 15(2--3):181--208, 2002. [ bib | .pdf ] |
| [188] |
Martin Berger.
Program logics for sequential higher-order control. In Fundamentals of Software Engineering, volume 5961 of Lecture Notes in Computer Science, pages 194--211. Springer, April 2009. [ bib | .pdf ] |
| [189] |
Martin Berger, Kohei Honda, and Nobuko Yoshida.
A logical analysis of aliasing in imperative higher-order functions. In International Conference on Functional Programming (ICFP), pages 280--293, September 2005. [ bib | http ] |
| [190] |
Jean-Philippe Bernardy, Patrik Jansson, and Koen Claessen.
Testing polymorphic properties. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 125--144. Springer, March 2010. [ bib | .pdf ] |
| [191] |
K. Bernstein and E. W. Stark.
Debugging type errors. Unpublished, November 1995. [ bib | .ps.gz ] |
| [192] |
Bernard Berthomieu and Camille le Moniès de Sagazan.
A calculus of tagged types, with applications to process languages. In Workshop on Types for Program Analysis, pages 1--15, May 1995. [ bib | .ps.gz ] |
| [193] |
Yves Bertot and Pierre Castéran.
Interactive theorem proving and program development -- Coq'Art: The calculus of inductive constructions. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2004. [ bib | .pdf ] |
| [194] |
Frédéric Besson, David Cachera, Thomas P. Jensen, and David Pichardie.
Certified static analysis by abstract interpretation. In Foundations of Security Analysis and Design, volume 5705 of Lecture Notes in Computer Science, pages 223--257. Springer, 2009. [ bib | .pdf ] |
| [195] |
Frédéric Besson, Sandrine Blazy, and Pierre Wilke.
CompCertS: a memory-aware verified C compiler using a pointer as integer semantics. Journal of Automated Reasoning, 63(2):369--392, 2019. [ bib | http ] |
| [196] |
Frédéric Besson, Thomas de Grenier de Latour, and Thomas Jensen.
Secure calling contexts for stack inspection. In Principles and Practice of Declarative Programming (PPDP), pages 76--87, October 2002. [ bib | .pdf ] |
| [197] |
Frédéric Besson, Thomas P. Jensen, Daniel Le Métayer, and Tommy Thorn.
Model checking security properties of control flow graphs. Journal of Computer Security, 9(3):217--250, 2001. [ bib | .pdf ] |
| [198] |
Achyutram Bhamidipaty and Todd A. Proebsting.
Very fast YACC-compatible parsers (for very little effort). Software: Practice and Experience, 28(2):181--190, February 1998. [ bib | .pdf ] |
| [199] |
Karthik Bhargavan, Cédric Fournet, and Andy Gordon.
Modular verification of security protocol code by typing. In Principles of Programming Languages (POPL), pages 445--456, January 2010. [ bib | .pdf ] |
| [200] |
Karthik Bhargavan, Cédric Fournet, Andy Gordon, Sergio Maffeis, and Jesper
Bengtson.
The F7 typechecker, 2011. http://research.microsoft.com/en-us/projects/f7/. [ bib | http ] |
| [201] |
Karthikeyan Bhargavan, Cédric Fournet, Markulf Kohlweiss, Alfredo Pironti, and
Pierre-Yves Strub.
Implementing TLS with verified cryptographic security. In IEEE Symposium on Security and Privacy (S&P), pages 445--459, May 2013. [ bib | .pdf ] |
| [202] |
Girish Bhat and Rance Cleaveland.
Efficient local model-checking for fragments of the modal μ-calculus. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 1055 of Lecture Notes in Computer Science, pages 107--126. Springer, March 1996. [ bib | .ps.gz ] |
| [203] |
Armin Biere, Alessandro Cimatti, Edmund Clarke, and Yunshan Zhu.
Symbolic model checking without BDDs. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 1579 of Lecture Notes in Computer Science, pages 193--207. Springer, March 1999. [ bib | .pdf ] |
| [204] |
Kevin Bierhoff and Jonathan Aldrich.
Modular typestate checking of aliased objects. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 301--320, October 2007. [ bib | .pdf ] |
| [205] |
Kevin Bierhoff, Nels E. Beckman, and Jonathan Aldrich.
Practical API protocol checking with access permissions. In European Conference on Object-Oriented Programming (ECOOP), volume 5653 of Lecture Notes in Computer Science, pages 195--219. Springer, July 2009. [ bib | .pdf ] |
| [206] |
Kevin Bierhoff, Nels E. Beckman, and Jonathan Aldrich.
Checking concurrent typestate with access permissions in Plural: A retrospective. In Peri L. Tarr and Alexander L. Wolf, editors, Engineering of Software, pages 35--48. Springer, 2011. [ bib | .pdf ] |
| [207] |
Bodil Biering, Lars Birkedal, and Noah Torp-Smith.
BI hyperdoctrines and higher-order separation logic. In European Symposium on Programming (ESOP), volume 3444 of Lecture Notes in Computer Science, pages 233--247. Springer, April 2005. [ bib | .pdf ] |
| [208] |
Dariusz Biernacki, Sergueï Lenglet, and Piotr Polesiuk.
A complete normal-form bisimilarity for algebraic effects and handlers. In Formal Structures for Computation and Deduction (FSCD), volume 167 of Leibniz International Proceedings in Informatics, pages 7:1--7:22, 2020. [ bib | http ] |
| [209] |
Dariusz Biernacki, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski.
Handle with care: relational interpretation of algebraic effects and handlers. Proceedings of the ACM on Programming Languages, 2(POPL):8:1--8:30, 2018. [ bib | http ] |
| [210] |
Dariusz Biernacki, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski.
Abstracting algebraic effects. Proceedings of the ACM on Programming Languages, 3(POPL):6:1--6:28, 2019. [ bib | .pdf ] |
| [211] |
Dariusz Biernacki, Maciej Piróg, Piotr Polesiuk, and Filip Sieczkowski.
Binders by day, labels by night: effect instances via lexically scoped handlers. Proceedings of the ACM on Programming Languages, 4(POPL):48:1--48:29, 2020. [ bib | http ] |
| [212] |
Richard Bird and Lambert Meertens.
Nested datatypes. In Mathematics of Program Construction (MPC), volume 1422 of Lecture Notes in Computer Science, pages 52--67. Springer, 1998. [ bib | .pdf ] |
| [213] |
Richard Bird and Ross Paterson.
de Bruijn notation as a nested datatype. Journal of Functional Programming, 9(1):77--91, January 1999. [ bib | http ] |
| [214] |
Richard S. Bird and John Hughes.
The alpha-beta algorithm: An exercise in program transformation. Information Processing Letters, 24(1):53--57, 1987. [ bib | http ] |
| [215] |
Lars Birkedal and Aleš Bizjak.
Lecture notes on Iris: Higher-order concurrent separation logic. Lectures notes, September 2020. [ bib | .pdf ] |
| [216] |
Lars Birkedal, Thomas Dinsdale-Young, Armaël Guéneau, Guilhem Jaber,
Kasper Svendsen, and Nikos Tzevelekos.
Theorems for free from separation logic specifications. Proceedings of the ACM on Programming Languages, 5(ICFP):1--29, 2021. [ bib | http ] |
| [217] |
Lars Birkedal, Bernhard Reus, Jan Schwinghammer, Kristian Støvring, Jacob
Thamsborg, and Hongseok Yang.
Step-indexed Kripke models over recursive worlds. In Principles of Programming Languages (POPL), pages 119--132, January 2011. [ bib | .pdf ] |
| [218] |
Lars Birkedal, Nick Rothwell, Mads Tofte, and David N. Turner.
The ML kit (version 1). Technical Report DIKU 93/14, Department of Computer Science, University of Copenhagen, 1993. [ bib | http ] |
| [219] |
Lars Birkedal, Jan Schwinghammer, and Kristian Støvring.
A metric model of lambda calculus with guarded recursion. Presented at FICS 2010, July 2010. [ bib | .pdf ] |
| [220] |
Lars Birkedal, Kristian Støvring, and Jacob Thamsborg.
The category-theoretic solution of recursive metric-space quations. Technical Report ITU-2009-119, IT University of Copenhagen, 2009. [ bib | .pdf ] |
| [221] |
Lars Birkedal, Kristian Støvring, and Jacob Thamsborg.
Realizability semantics of parametric polymorphism, general references, and recursive types. In Foundations of Software Science and Computation Structures (FOSSACS), volume 5504 of Lecture Notes in Computer Science, pages 456--470. Springer, March 2009. [ bib | .pdf ] |
| [222] |
Lars Birkedal, Kristian Støvring, and Jacob Thamsborg.
Realisability semantics of parametric polymorphism, general references, and recursive types. Mathematical Structures in Computer Science, 20(4):655--703, 2010. [ bib | .pdf ] |
| [223] |
Lars Birkedal and Mads Tofte.
A constraint-based region inference algorithm. Theoretical Computer Science, 258:299--392, 2001. [ bib | .ps.gz ] |
| [224] |
Lars Birkedal, Noah Torp-Smith, and Hongseok Yang.
Semantics of separation-logic typing and higher-order frame rules for Algol-like languages. Logical Methods in Computer Science, 2(5), November 2006. [ bib | http ] |
| [225] |
Andrew D. Birrell.
An introduction to programming with C# threads. Manuscript, 2003. [ bib | .pdf ] |
| [226] |
Sandip K. Biswas.
Dynamic slicing in higher-order programming languages. PhD thesis, University of Pennsylvania, August 1997. [ bib ] |
| [227] |
Régis Blanc, Viktor Kuncak, Etienne Kneuss, and Philippe Suter.
An overview of the Leon verification system: verification by translation to recursive functions. In Workshop on Scala, pages 1:1--1:10, July 2013. [ bib | .pdf ] |
| [228] |
Frédéric Blanqui and Adam Koprowski.
CoLoR: a coq library on well-founded rewrite relations and its application to the automated verification of termination certificates. Mathematical Structures in Computer Science, 21(4):827--859, August 2011. [ bib | .pdf ] |
| [229] |
Sandrine Blazy and Xavier Leroy.
Mechanized semantics for the Clight subset of the C language. Journal of Automated Reasoning, 43(3):263--288, 2009. [ bib | .pdf ] |
| [230] |
Guy E. Blelloch, Daniel Anderson, and Laxman Dhulipala.
ParlayLib -- a toolkit for parallel algorithms on shared-memory multicore machines. In Symposium on Parallelism in Algorithms and Architectures, pages 507--509, July 2020. [ bib | http ] |
| [231] |
Guy E. Blelloch and John Greiner.
Parallelism in sequential functional languages. In Functional Programming Languages and Computer Architecture (FPCA), pages 226--237, 1995. [ bib | .pdf ] |
| [232] |
Guy E. Blelloch and John Greiner.
A provable time and space efficient implementation of NESL. In International Conference on Functional Programming (ICFP), pages 213--225, May 1996. [ bib | .pdf ] |
| [233] |
François Bobot, Jean-Christophe Filliâtre, Claude Marché, and
Andrei Paskevich.
Let's verify this with Why3. Software Tools for Technology Transfer, 17(6):709--727, 2015. [ bib | http ] |
| [234] |
Robert L. Bocchino Jr.
Alias control for deterministic parallelism. In Dave Clarke, James Noble, and Tobias Wrigstad, editors, Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 156--195. Springer, 2013. [ bib | http ] |
| [235] |
Robert L. Bocchino Jr. and Vikram S. Adve.
Types, regions, and effects for safe programming with object-oriented parallel frameworks. In European Conference on Object-Oriented Programming (ECOOP), volume 6813 of Lecture Notes in Computer Science, pages 306--332. Springer, July 2011. [ bib | .pdf ] |
| [236] |
Robert L. Bocchino Jr., Vikram S. Adve, Sarita V. Adve, and Marc Snir.
Parallel programming must be deterministic by default. In USENIX Conference on Hot Topics in Parallelism (HotPar), pages 1--6, 2009. [ bib | .pdf ] |
| [237] |
Robert L. Bocchino Jr., Vikram S. Adve, Danny Dig, Sarita V. Adve, Stephen
Heumann, Rakesh Komuravelli, Jeffrey Overbey, Patrick Simmons, Hyojin Sung,
and Mohsen Vakilian.
A type and effect system for deterministic parallel Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 97--116, October 2009. [ bib | .pdf ] |
| [238] |
Robert L. Bocchino Jr., Stephen Heumann, Nima Honarmand, Sarita V. Adve,
Vikram S. Adve, Adam Welc, and Tatiana Shpeisman.
Safe nondeterminism in a deterministic-by-default parallel language. In Principles of Programming Languages (POPL), pages 535--548, January 2011. [ bib | .pdf ] |
| [239] |
Chiara Bodei, Pierpaolo Degano, Flemming Nielson, and Hanne Riis Nielson.
Static analysis of processes for no read-up and no write-down. In Foundations of Software Science and Computation Structures (FOSSACS), volume 1578 of Lecture Notes in Computer Science, pages 120--134. Springer, March 1999. [ bib | .ps ] |
| [240] |
Martin Bodin, Arthur Charguéraud, Daniele Filaretti, Philippa Gardner, Sergio
Maffeis, Daiva Naudziuniene, Alan Schmitt, and Gareth Smith.
A trusted mechanised JavaScript specification. In Principles of Programming Languages (POPL), pages 87--100, January 2014. [ bib | .pdf ] |
| [241] |
Martin Bodin, Philippa Gardner, Thomas P. Jensen, and Alan Schmitt.
Skeletal semantics and their interpretations. Proceedings of the ACM on Programming Languages, 3(POPL):44:1--44:31, 2019. [ bib | http ] |
| [242] |
Hans-J. Boehm and Sarita V. Adve.
You don't know jack about shared variables or memory models. Communications of the ACM, 55(2):48--54, February 2012. [ bib | http ] |
| [243] |
Sylvie Boldo, François Clément, Jean-Christophe Filliâtre, Micaela
Mayero, Guillaume Melquiond, and Pierre Weis.
Wave equation numerical resolution: a comprehensive mechanized proof of a C program. Journal of Automated Reasoning, 50(4):423--456, April 2013. [ bib | http ] |
| [244] |
Sylvie Boldo, Catherine Lelay, and Guillaume Melquiond.
Coquelicot: A user-friendly library of real analysis for Coq. Mathematics in Computer Science, 9(1):41--62, March 2015. [ bib | http ] |
| [245] |
Juan Pedro Bolívar Puente.
Persistence for the masses: RRB-vectors in a systems language. Proceedings of the ACM on Programming Languages, 1(ICFP):16:1--16:28, 2017. [ bib | .pdf ] |
| [246] |
Daniel Bonniot.
Type-checking multi-methods in ML (a modular approach). In Foundations of Object-Oriented Languages (FOOL), January 2002. [ bib | .ps ] |
| [247] |
Urban Boquist.
Code optimisation techniques for lazy functional languages. PhD thesis, Chalmers University of Technology, April 1999. [ bib | .pdf ] |
| [248] |
Michele Boreale and Davide Sangiorgi.
A fully abstract semantics for causality in the π-calculus. Acta Informatica, 35(5):353--400, May 1998. [ bib | .pdf ] |
| [249] |
Johannes Borgström, Juan Chen, , and Nikhil Swamy.
Verified stateful programs with substructural state and Hoare types. In Programming Languages Meets Program Verification (PLPV), January 2011. [ bib | .pdf ] |
| [250] |
Richard Bornat.
Proving pointer programs in Hoare logic. In Mathematics of Program Construction (MPC), volume 1837 of Lecture Notes in Computer Science, pages 102--126. Springer, 2000. [ bib | .pdf ] |
| [251] |
Richard Bornat, Cristiano Calcagno, Peter O'Hearn, and Matthew Parkinson.
Permission accounting in separation logic. In Principles of Programming Languages (POPL), pages 259--270, January 2005. [ bib | .pdf ] |
| [252] |
Richard Bornat, Cristiano Calcagno, and Hongseok Yang.
Variables as resource in separation logic. In Mathematical Foundations of Programming Semantics, volume 155 of Electronic Notes in Theoretical Computer Science, pages 247--276. Elsevier, May 2005. [ bib | http ] |
| [253] |
Aleksander Boruch-Gruszecki, Martin Odersky, Edward Lee, Ondrej Lhoták, and
Jonathan Immanuel Brachthäuser.
Capturing types. ACM Transactions on Programming Languages and Systems, 45(4):21:1--21:52, 2023. [ bib | http ] |
| [254] |
Ahmed Bouajjani, Javier Esparza, and Oded Maler.
Reachability analysis of pushdown automata: Application to model-checking. In International Conference on Concurrency Theory (CONCUR), volume 1243 of Lecture Notes in Computer Science, pages 135--150. Springer, July 1997. [ bib | .pdf ] |
| [255] |
Gérard Boudol.
Typing termination in a higher-order concurrent imperative language. Information and Computation, 2009. To appear. [ bib | .pdf ] |
| [256] |
Gérard Boudol and Ilaria Castellani.
Non-interference for concurrent programs and thread systems. To appear, September 2001. [ bib | .ps.gz ] |
| [257] |
Sylvain Boulmé.
Intuitionistic refinement calculus. In Typed Lambda Calculi and Applications (TLCA), volume 4583 of Lecture Notes in Computer Science, pages 54--69. Springer, June 2007. [ bib | .pdf ] |
| [258] |
Richard J. Boulton.
Syn: a single language for specifiying abstract syntax trees, lexical analysis, parsing and pretty-printing. Technical Report UCAM-CL-TR-390, University of Cambridge Computer Laboratory, March 1996. [ bib | .html ] |
| [259] |
Frédéric Bour, Basile Clément, and Gabriel Scherer.
Tail modulo cons. In Journées Françaises des Langages Applicatifs (JFLA), April 2021. [ bib | http ] |
| [260] |
Frédéric Bour and François Pottier.
Faster reachability analysis for LR(1) parsers. In Software Language Engineering, pages 113--125, October 2021. [ bib | .pdf ] |
| [261] |
Frédéric Bour, Thomas Refis, and Gabriel Scherer.
Merlin: a language server for OCaml (experience report). Proceedings of the ACM on Programming Languages, 2(ICFP):103:1--103:15, 2018. [ bib | http ] |
| [262] |
François Bourdoncle and Stephan Merz.
On the integration of functional programming, class-based object-oriented programming, and multi-methods. Research Report 26, Centre de Mathématiques Appliquées, Ecole des Mines de Paris, March 1996. [ bib | .html ] |
| [263] |
François Bourdoncle and Stephan Merz.
Type checking higher-order polymorphic multi-methods. In Principles of Programming Languages (POPL), pages 302--315, January 1997. [ bib | .html ] |
| [264] |
Eric Bouwers, Martin Bravenboer, and Eelco Visser.
Grammar engineering support for precedence rule recovery and compatibility checking. Electronic Notes in Theoretical Computer Science, 203(2):85--101, 2008. [ bib | http ] |
| [265] |
Chandrasekhar Boyapati, Robert Lee, and Martin Rinard.
Ownership types for safe programming: preventing data races and deadlocks. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 211--230, November 2002. [ bib | http ] |
| [266] |
Chandrasekhar Boyapati, Barbara Liskov, and Liuba Shrira.
Ownership types for object encapsulation. In Principles of Programming Languages (POPL), pages 213--223, January 2003. [ bib | .pdf ] |
| [267] |
John Boyland.
Alias burying: Unique variables without destructive reads. Science of Computer Programming, 31(6):533--553, May 2001. [ bib | http ] |
| [268] |
John Boyland.
Checking interference with fractional permissions. In Static Analysis Symposium (SAS), volume 2694 of Lecture Notes in Computer Science, pages 55--72. Springer, June 2003. [ bib | http ] |
| [269] |
John Boyland, James Noble, and William Retert.
Capabilities for sharing: A generalisation of uniqueness and read-only. In European Conference on Object-Oriented Programming (ECOOP), volume 2072 of Lecture Notes in Computer Science, pages 2--27. Springer, June 2001. [ bib | http ] |
| [270] |
John Tang Boyland.
Semantics of fractional permissions with nesting. ACM Transactions on Programming Languages and Systems, 32(6):22:1--22:33, 2010. [ bib | http ] |
| [271] |
John Tang Boyland and William Retert.
Connecting effects and uniqueness with adoption. In Principles of Programming Languages (POPL), pages 283--295, January 2005. [ bib | http ] |
| [272] |
Víctor A. Braberman, Federico Javier Fernández, Diego
Garbervetsky, and Sergio Yovine.
Parametric prediction of heap memory requirements. In International Symposium on Memory Management, pages 141--150, June 2008. [ bib | http ] |
| [273] |
Víctor A. Braberman, Diego Garbervetsky, and Sergio Yovine.
A static analysis for synthesizing parametric specifications of dynamic memory consumption. Journal of Object Technology, 5(5):31--58, 2006. [ bib | .pdf ] |
| [274] |
Gilad Bracha and William Cook.
Mixin-based inheritance. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 303--311, 1990. [ bib | .ps ] |
| [275] |
Gilad Bracha and Gary Lindstrom.
Modularity meets inheritance. Technical Report UUCS-91-017, University of Utah, October 1991. [ bib | .ps ] |
| [276] |
Jonathan Immanuel Brachthäuser and Philipp Schuster.
Effekt: extensible algebraic effects in Scala. In Symposium on Scala, pages 67--72, October 2017. [ bib | .pdf ] |
| [277] |
Jonathan Immanuel Brachthäuser, Philipp Schuster, and Klaus Ostermann.
Effects as capabilities: effect handlers and lightweight effect polymorphism. Proceedings of the ACM on Programming Languages, 4(OOPSLA):126:1--126:30, 2020. [ bib | http ] |
| [278] |
Jonathan Immanuel Brachthäuser, Philipp Schuster, and Klaus Ostermann.
Effekt: Capability-passing style for type- and effect-safe, extensible effect handlers in Scala. Journal of Functional Programming, 30:e8, 2020. [ bib | .pdf ] |
| [279] |
Aaron R. Bradley and Zohar Manna.
The calculus of computation. Springer, 2007. [ bib | http ] |
| [280] |
Edwin Brady.
Idris, a general purpose dependently typed programming language: design and implementation. Journal of Functional Programming, 23(5):552–--593, 2013. [ bib | .pdf ] |
| [281] |
Edwin C. Brady.
Programming and reasoning with algebraic effects and dependent types. In International Conference on Functional Programming (ICFP), pages 133--144, September 2013. [ bib | .pdf ] |
| [282] |
Edwin C. Brady.
Resource-dependent algebraic effects. In Trends in Functional Programming (TFP), volume 8843 of Lecture Notes in Computer Science, pages 18--33. Springer, May 2014. [ bib | .pdf ] |
| [283] |
Thomas Braibant and Damien Pous.
Tactics for reasoning modulo AC in Coq. In Certified Programs and Proofs (CPP), volume 7086 of Lecture Notes in Computer Science, pages 167--182. Springer, 2011. [ bib | http ] |
| [284] |
Thomas Braibant, Jonathan Protzenko, and Gabriel Scherer.
Articheck: well-typed generic fuzzing for module interfaces. In ACM Workshop on ML, August 2014. [ bib | .pdf ] |
| [285] |
Marc M. Brandis and Hanspeter Mössenböck.
Single-pass generation of static single-assignment form for structured languages. ACM Transactions on Programming Languages and Systems, 16(6):1684--1698, 1994. [ bib | .ps.gz ] |
| [286] |
Katharina Brandl, Sebastian Erdweg, Sven Keidel, and Nils Hansen.
Modular abstract definitional interpreters for WebAssembly. In European Conference on Object-Oriented Programming (ECOOP), volume 263 of Leibniz International Proceedings in Informatics, pages 5:1--5:28. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, July 2023. [ bib | http ] |
| [287] |
Michael Brandt and Fritz Henglein.
Coinductive axiomatization of recursive type equality and subtyping. Fundamenta Informaticæ, 33:309--338, 1998. [ bib | .ps.gz ] |
| [288] |
Gilles Brassard and Paul Bratley.
Fundamentals of algorithmics. Prentice Hall, 1996. [ bib ] |
| [289] |
Val Breazu-Tannen, Thierry Coquand, Carl A. Gunter, and Andre Scedrov.
Inheritance as implicit coercion. Information and Computation, 93(1):172--221, July 1991. [ bib | .pdf ] |
| [290] |
Joachim Breitner, Antal Spector-Zabusky, Yao Li, Christine Rizkallah, John
Wiegley, and Stephanie Weirich.
Ready, set, verify! applying hs-to-coq to real-world Haskell code (experience report). Proceedings of the ACM on Programming Languages, 2(ICFP):89:1--89:16, 2018. [ bib | http ] |
| [291] |
Stephen Brookes.
A semantics for concurrent separation logic. Theoretical Computer Science, 375(1--3):227--270, 2007. [ bib | http ] |
| [292] |
Stephen Brookes and Peter W. O'Hearn.
Concurrent separation logic. SIGLOG News, 3(3):47--65, 2016. [ bib | .pdf ] |
| [293] |
Stephen D. Brookes.
A semantics for concurrent separation logic. In International Conference on Concurrency Theory (CONCUR), volume 3170 of Lecture Notes in Computer Science, pages 16--34. Springer, August 2004. [ bib | http ] |
| [294] |
James Brotherston, Dino Distefano, and Rasmus Lerchedahl Petersen.
Automated cyclic entailment proofs in separation logic. In International Conference on Automated Deduction (CADE), volume 6803 of Lecture Notes in Computer Science, pages 131--146. Springer, July 2011. [ bib | .pdf ] |
| [295] |
Kim Bruce, Luca Cardelli, Giuseppe Castagna, The Hopkins Object Group, Gary T.
Leavens, and Benjamin Pierce.
On binary methods. Technical Report 95-08a, Department of Computer Science, Iowa State University, December 1995. [ bib | .ps.Z ] |
| [296] |
Kim Bruce, Roberto Di Cosmo, and Giuseppe Longo.
Provable isomorphisms of types. Mathematical Structures in Computer Science, 2(2):231--247, 1992. [ bib | .dvi ] |
| [297] |
Kim B. Bruce, Luca Cardelli, and Benjamin C. Pierce.
Comparing object encodings. Information and Computation, 155(1/2):108--133, November 1999. [ bib | .ps ] |
| [298] |
Aloïs Brunel, Damiano Mazza, and Michele Pagani.
Backpropagation in the simply typed lambda-calculus with linear negation. Proceedings of the ACM on Programming Languages, 4(POPL):64:1--64:27, 2020. [ bib | http ] |
| [299] |
Julian Brunner and Peter Lammich.
Formal verification of an executable LTL model checker with partial order reduction. Journal of Automated Reasoning, 60(1):3--21, 2018. [ bib | .pdf ] |
| [300] |
Peter Buchlovsky and Hayo Thielecke.
A type-theoretic reconstruction of the visitor pattern. Electronic Notes in Theoretical Computer Science, 155:309--329, 2006. [ bib | .pdf ] |
| [301] |
Michele Bugliesi, Stefano Calzavara, Fabienne Eigner, and Matteo Maffei.
Affine refinement types for secure distributed programming. To appear, 2015. [ bib | .pdf ] |
| [302] |
Michele Bugliesi and Silvia Crafa.
Object calculi for dynamic messages. In Foundations of Object-Oriented Languages (FOOL), 1999. [ bib ] |
| [303] |
Michele Bugliesi and Santiago M. Pericás-Geertsen.
Type inference for variant object types. Information and Computation, 177(1):2--27, August 2002. [ bib | .ps.gz ] |
| [304] |
Peter A. Buhr and W. Y. Russell Mok.
Advanced exception handling mechanisms. IEEE Transactions on Software Engineering, 26(9):820--836, 2000. [ bib | .pdf ] |
| [305] |
Alexandre Buisse, Lars Birkedal, and Kristian Støvring.
A step-indexed Kripke model of separation logic for storable locks. Electronic Notes in Theoretical Computer Science, 276:121--143, September 2011. [ bib | .pdf ] |
| [306] |
Lukas Bulwahn, Alexander Krauss, Florian Haftmann, Levent Erkök, and John
Matthews.
Imperative functional programming with Isabelle/HOL. In Theorem Proving in Higher Order Logics (TPHOLs), volume 5170 of Lecture Notes in Computer Science, pages 134--149. Springer, August 2008. [ bib | .pdf ] |
| [307] |
Peter Buneman and Atsushi Ohori.
Polymorphism and type inference in database programming. ACM Transactions on Database Systems, 21(1):30--76, 1996. [ bib | .pdf ] |
| [308] |
Lilian Burdy, Yoonsik Cheon, David Cok, Michael Ernst, Joe Kiniry, Gary T.
Leavens, K. Rustan M. Leino, and Erik Poll.
An overview of JML tools and applications. Software Tools for Technology Transfer, 7(3):212--232, June 2005. [ bib | .pdf ] |
| [309] |
Jacob Burnim, Sudeep Juvekar, and Koushik Sen.
WISE: Automated test generation for worst-case complexity. In International Conference on Software Engineering (ICSE), pages 463--473, May 2009. [ bib | http ] |
| [310] |
R. M. Burstall, D. B. MacQueen, and D. T. Sannella.
HOPE: An experimental applicative language. In ACM Symposium on Lisp and Functional Programming (LFP), pages 136--143, 1980. [ bib | http ] |
| [311] |
David Cachera, Thomas P. Jensen, David Pichardie, and Gerardo Schneider.
Certified memory usage analysis. In Formal Methods (FM), volume 3582 of Lecture Notes in Computer Science, pages 91--106. Springer, July 2005. [ bib | .pdf ] |
| [312] |
David Cachera and David Pichardie.
A certified denotational abstract interpreter. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 9--24. Springer, July 2010. [ bib | http ] |
| [313] |
Jiazhen Cai and Robert Paige.
Program derivation by fixed point computation. Science of Computer Programming, 11(3):197--261, 1989. [ bib | .ps ] |
| [314] |
Luís Caires and João Costa Seco.
The type discipline of behavioral separation. In Principles of Programming Languages (POPL), pages 275--286, January 2013. [ bib | http ] |
| [315] |
Cristiano Calcagno and Dino Distefano.
Infer: An automatic program verifier for memory safety of C programs. In NASA Formal Methods (NFM), volume 6617 of Lecture Notes in Computer Science, pages 459--465. Springer, April 2011. [ bib | .pdf ] |
| [316] |
Cristiano Calcagno, Dino Distefano, Jérémy Dubreil, Dominik Gabi, Pieter
Hooimeijer, Martino Luca, Peter W. O'Hearn, Irene Papakonstantinou, Jim
Purbrick, and Dulma Rodriguez.
Moving fast with software verification. In NASA Formal Methods (NFM), volume 9058 of Lecture Notes in Computer Science, pages 3--11. Springer, April 2015. [ bib | http ] |
| [317] |
Cristiano Calcagno, Dino Distefano, and Peter O'Hearn.
Open-sourcing Facebook Infer: Identify bugs before you ship. https://code.facebook.com/posts/1648953042007882/open-sourcing-facebook-infer-identify-bugs-before-you-ship/, June 2015. [ bib ] |
| [318] |
Cristiano Calcagno, Dino Distefano, Peter W. O'Hearn, and Hongseok Yang.
Compositional shape analysis by means of bi-abduction. In Principles of Programming Languages (POPL), pages 289--300, January 2009. [ bib | .pdf ] |
| [319] |
Cristiano Calcagno, Dino Distefano, Peter W. O'Hearn, and Hongseok Yang.
Compositional shape analysis by means of bi-abduction. Journal of the ACM, 58(6), 2011. [ bib | .pdf ] |
| [320] |
Cristiano Calcagno, Dino Distefano, and Viktor Vafeiadis.
Bi-abductive resource invariant synthesis. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 259--274. Springer, December 2009. [ bib | .pdf ] |
| [321] |
Cristiano Calcagno, Simon Helsen, and Peter Thiemann.
Syntactic type soundness results for the region calculus. Information and Computation, 173(2):199--221, 2002. [ bib | .pdf ] |
| [322] |
Cristiano Calcagno, Eugenio Moggi, and Tim Sheard.
Closed types for a safe imperative MetaML. Journal of Functional Programming, 13(3):545--571, May 2003. [ bib | http ] |
| [323] |
Cristiano Calcagno, Eugenio Moggi, and Walid Taha.
ML-like inference for classifiers. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 79--93. Springer, 2004. [ bib | .pdf ] |
| [324] |
Cristiano Calcagno, Peter W. O'Hearn, and Hongseok Yang.
Local action and abstract separation logic. In Logic in Computer Science (LICS), pages 366--378, July 2007. [ bib | .pdf ] |
| [325] |
Cristiano Calcagno, Hongseok Yang, and Peter W. O'Hearn.
Computability and complexity results for a spatial assertion language for data structures. In Asian Symposium on Programming Languages and Systems (APLAS), pages 289--300, December 2001. [ bib | .ps ] |
| [326] |
Brian Campbell.
Amortised memory analysis using the depth of data structures. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 190--204. Springer, March 2009. [ bib | .pdf ] |
| [327] |
Quentin Carbonneaux, Jan Hoffmann, Tahina Ramananandro, and Zhong Shao.
End-to-end verification of stack-space bounds for C programs. In Programming Language Design and Implementation (PLDI), pages 270--281, June 2014. [ bib | .pdf ] |
| [328] |
Quentin Carbonneaux, Jan Hoffmann, Thomas Reps, and Zhong Shao.
Automated resource analysis with Coq proof objects. In Computer Aided Verification (CAV), volume 10427 of Lecture Notes in Computer Science, pages 64--85. Springer, July 2017. [ bib | .pdf ] |
| [329] |
Quentin Carbonneaux, Jan Hoffmann, and Zhong Shao.
Compositional certified resource bounds. In Programming Language Design and Implementation (PLDI), pages 467--478, June 2015. [ bib | .pdf ] |
| [330] |
Luca Cardelli.
Basic polymorphic typechecking. Science of Computer Programming, 8(2):147--172, 1987. [ bib | http ] |
| [331] |
Luca Cardelli.
A semantics of multiple inheritance. Information and Computation, 76(2/3):138--164, February 1988. [ bib | .pdf ] |
| [332] |
Luca Cardelli.
Typeful programming. In Formal Description of Programming Concepts, IFIP State of the Art Reports Series. Springer, February 1989. [ bib | .pdf ] |
| [333] |
Luca Cardelli.
The Quest language and system, 1991. [ bib | .pdf ] |
| [334] |
Luca Cardelli.
Type systems. In Allen B. Tucker, editor, The Computer Science and Engineering Handbook, pages 2208--2236. CRC Press, 1997. [ bib | .pdf ] |
| [335] |
Luca Cardelli and Giuseppe Longo.
A semantic basis for Quest. Journal of Functional Programming, 1(4):417--458, October 1991. [ bib | .pdf ] |
| [336] |
Luca Cardelli, Florian Matthes, and Martín Abadi.
Extensible syntax with lexical scoping. Research Report 121, Digital Equipment Corporation, Systems Research Center, February 1994. [ bib | .ps.gz ] |
| [337] |
Luca Cardelli and John Mitchell.
Operations on records. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
| [338] |
Luca Cardelli and Peter Wegner.
On understanding types, data abstraction, and polymorphism. ACM Computing Surveys, 17(4):471--522, December 1985. [ bib | .pdf ] |
| [339] |
Felice Cardone.
A coinductive completeness proof for the equivalence of recursive types. Theoretical Computer Science, 275(1--2):575--587, 2002. [ bib | http ] |
| [340] |
Felice Cardone and Mario Coppo.
Type inference with recursive types: syntax and semantics. Information and Computation, 92(1):48--80, 1991. [ bib | http ] |
| [341] |
Jacques Carette.
Gaussian elimination: a case study in efficient genericity with MetaOCaml. Science of Computer Programming, 62(1):3--24, September 2005. [ bib | .pdf ] |
| [342] |
Jacques Carette, Oleg Kiselyov, and Chung chieh Shan.
Finally tagless, partially evaluated. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 222--238. Springer, November 2007. [ bib | http ] |
| [343] |
Jacques Carette, Oleg Kiselyov, and Chung-chieh Shan.
Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages. Journal of Functional Programming, 19(5):509--543, 2009. [ bib | .pdf ] |
| [344] |
Sébastien Carlier, Jeff Polakow, J. B. Wells, and A. J. Kfoury.
System E: Expansion variables for flexible typing with linear and non-linear types and intersection types. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, 2004. [ bib | .pdf ] |
| [345] |
Sébastien Carlier and J. B. Wells.
Type inference with expansion variables and intersection types in System E and an exact correspondence with β-reduction. Technical Report HW-MACS-TR-0012, Heriot-Watt University, January 2004. [ bib | .pdf ] |
| [346] |
Robert Cartwright.
Notes on object-oriented program design, January 2000. [ bib | http ] |
| [347] |
Giuseppe Castagna.
F<=& : integrating parametric and “ad hoc” second order polymorphism. In International Workshop on Database Programming Languages, Workshops in Computing. Springer, September 1993. [ bib ] |
| [348] |
Giuseppe Castagna.
Covariance and contravariance: Conflict without a cause. ACM Transactions on Programming Languages and Systems, 17(3):431--447, May 1995. [ bib | .ps.Z ] |
| [349] |
Giuseppe Castagna and Alain Frisch.
A gentle introduction to semantic subtyping. In Principles and Practice of Declarative Programming (PPDP), pages 198--199, July 2005. [ bib | .pdf ] |
| [350] |
Elias Castegren and Tobias Wrigstad.
Reference capabilities for concurrency control. In European Conference on Object-Oriented Programming (ECOOP), volume 56 of Leibniz International Proceedings in Informatics, pages 5:1--5:26. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, July 2016. [ bib | http ] |
| [351] |
Henry Cejtin, Matthew Fluet, Suresh Jagannathan, and Stephen Weeks.
The MLton compiler, 2007. [ bib | http ] |
| [352] |
Henry Cejtin, Suresh Jagannathan, and Stephen Weeks.
Flow-directed closure conversion for typed languages. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 56--71. Springer, March 2000. [ bib | http ] |
| [353] |
Tej Chajed, Joseph Tassarotti, M. Frans Kaashoek, and Nickolai Zeldovich.
Verifying concurrent, crash-safe systems with Perennial. In Symposium on Operating Systems Principles (SOSP), pages 243--258, October 2019. [ bib | http ] |
| [354] |
Tej Chajed, Joseph Tassarotti, M. Frans Kaashoek, and Nickolai Zeldovich.
Verifying concurrent Go code in Coq with Goose. In Workshop on Coq for Programming Languages, January 2020. [ bib | .pdf ] |
| [355] |
Tej Chajed, Joseph Tassarotti, Mark Theng, Ralf Jung, M. Frans Kaashoek, and
Nickolai Zeldovich.
GoJournal: a verified, concurrent, crash-safe journaling system. In Symposium on Operating Systems Design and Implementation, pages 423--439, July 2021. [ bib | http ] |
| [356] |
Manuel M. T. Chakravarty, Gabriele Keller, Simon L. Peyton Jones, and Simon
Marlow.
Associated types with class. In Principles of Programming Languages (POPL), pages 1--13, January 2005. [ bib | .pdf ] |
| [357] |
Craig Chambers and Gary T. Leavens.
BeCecil, a core object-oriented language with block structure and multimethods: Semantics and typing. Technical Report UW-CSE-96-12-02, University of Washington, December 1996. [ bib | .ps.gz ] |
| [358] |
Bor-Yuh Evan Chang and Xavier Rival.
Relational inductive shape analysis. In Principles of Programming Languages (POPL), pages 247--260, January 2008. [ bib | .pdf ] |
| [359] |
Nicolas Chappe, Paul He, Ludovic Henrio, Yannick Zakowski, and Steve Zdancewic.
Choice trees: Representing nondeterministic, recursive, and impure programs in Coq. Proceedings of the ACM on Programming Languages, 7(POPL):1770--1800, 2023. [ bib | http ] |
| [360] |
Arthur Charguéraud.
Program verification through characteristic formulae. In International Conference on Functional Programming (ICFP), pages 321--332, September 2010. [ bib | .pdf ] |
| [361] |
Arthur Charguéraud.
Characteristic formulae for the verification of imperative programs. In International Conference on Functional Programming (ICFP), pages 418--430, September 2011. [ bib | .pdf ] |
| [362] |
Arthur Charguéraud.
The locally nameless representation. Journal of Automated Reasoning, 49(3):363--408, 2012. [ bib | .pdf ] |
| [363] |
Arthur Charguéraud and Mike Rainey.
Efficient representations for large dynamic sequences in ML. ACM Workshop on ML, September 2017. [ bib | http ] |
| [364] |
Arthur Charguéraud.
Characteristic formulae for mechanized program verification. PhD thesis, Université Paris 7, December 2010. [ bib | .pdf ] |
| [365] |
Arthur Charguéraud.
The optimal fixed point combinator. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 195--210. Springer, July 2010. [ bib | .pdf ] |
| [366] |
Arthur Charguéraud.
Pretty-big-step semantics. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 41--60. Springer, March 2013. [ bib | .pdf ] |
| [367] |
Arthur Charguéraud.
Higher-order representation predicates in separation logic. In Certified Programs and Proofs (CPP), pages 3--14, January 2016. [ bib | http ] |
| [368] |
Arthur Charguéraud.
Separation logic for sequential programs (functional pearl). Proceedings of the ACM on Programming Languages, 4(ICFP):116:1--116:34, 2020. [ bib | http ] |
| [369] |
Arthur Charguéraud.
Separation logic foundations. In Benjamin C. Pierce, editor, Software Foundations, volume 6. 2021. [ bib | http ] |
| [370] |
Arthur Charguéraud.
The CFML tool and library. http://www.chargueraud.org/softs/cfml/, 2024. [ bib ] |
| [371] |
Arthur Charguéraud, Adam Chlipala, Andres Erbsen, and Samuel Gruetter.
Omnisemantics: Smooth handling of nondeterminism. ACM Transactions on Programming Languages and Systems, 45(1):5:1--5:43, 2023. [ bib | http ] |
| [372] |
Arthur Charguéraud, Jean-Christophe Filliâtre, Cláudio
Lourenço, and Mário Pereira.
GOSPEL - providing OCaml with a formal specification language. In Formal Methods (FM), volume 11800 of Lecture Notes in Computer Science, pages 484--501. Springer, October 2019. [ bib | http ] |
| [373] |
Arthur Charguéraud and François Pottier.
Functional translation of a calculus of capabilities. In International Conference on Functional Programming (ICFP), pages 213--224, September 2008. [ bib | .pdf ] |
| [374] |
Arthur Charguéraud and François Pottier.
Machine-checked verification of the correctness and amortized complexity of an efficient union-find implementation. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 137--153. Springer, August 2015. [ bib | .pdf ] |
| [375] |
Arthur Charguéraud and François Pottier.
Temporary read-only permissions for separation logic. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 260--286. Springer, April 2017. [ bib | .pdf ] |
| [376] |
Arthur Charguéraud and François Pottier.
Verifying the correctness and amortized complexity of a union-find implementation in separation logic with time credits. Journal of Automated Reasoning, September 2017. [ bib | .pdf ] |
| [377] |
Arthur Charguéraud and François Pottier.
Verifying the correctness and amortized complexity of a union-find implementation in separation logic with time credits. Journal of Automated Reasoning, 62(3):331--365, March 2019. [ bib | .pdf ] |
| [378] |
Arthur Charguéraud, Alan Schmitt, and Thomas Wood.
JSExplain: A double debugger for JavaScript. In Companion Proceedings of The Web Conference, pages 691--699, April 2018. [ bib | http ] |
| [379] |
Philippe Charles, Christian Grothoff, Vijay Saraswat, Christopher Donawa, Allan
Kielstra, Kemal Ebcioglu, Christoph von Praun, and Vivek Sarkar.
X10: an object-oriented approach to non-uniform cluster computing. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), page 519–538, 2005. [ bib | http ] |
| [380] |
David Chase and Yossi Lev.
Dynamic circular work-stealing deque. In Symposium on Parallelism in Algorithms and Architectures, pages 21--28, July 2005. [ bib | .pdf ] |
| [381] |
Chih-Ping Chen and Paul Hudak.
Rolling your own mutable ADT---a connection between linear types and monads. In Principles of Programming Languages (POPL), pages 54--66, January 1997. [ bib | .ps ] |
| [382] |
Chiyan Chen, Rui Shi, and Hongwei Xi.
A typeful approach to object-oriented programming with multiple inheritance. In Practical Aspects of Declarative Languages (PADL), volume 3057 of Lecture Notes in Computer Science. Springer, June 2004. [ bib | http ] |
| [383] |
Chiyan Chen and Hongwei Xi.
Implementing typeful program transformations. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 20--28, June 2003. [ bib | http ] |
| [384] |
Chiyan Chen and Hongwei Xi.
Meta-programming through typeful code representation. In International Conference on Functional Programming (ICFP), pages 275--286, August 2003. [ bib ] |
| [385] |
Chiyan Chen and Hongwei Xi.
Combining programming with theorem proving. In International Conference on Functional Programming (ICFP), pages 66--77, September 2005. [ bib | .pdf ] |
| [386] |
Chiyan Chen and Hongwei Xi.
Meta-programming through typeful code representation. Journal of Functional Programming, 15(5):797--835, 2005. [ bib | http ] |
| [387] |
Haogang Chen, Daniel Ziegler, Tej Chajed, Adam Chlipala, M. Frans Kaashoek, and
Nickolai Zeldovich.
Using Crash Hoare logic for certifying the FSCQ file system. In Symposium on Operating Systems Principles (SOSP), pages 18--37, October 2015. [ bib | .pdf ] |
| [388] |
Juan Chen and David Tarditi.
A simple typed intermediate language for object-oriented languages. In Principles of Programming Languages (POPL), pages 38--49, January 2005. [ bib | .pdf ] |
| [389] |
Ran Chen, Cyril Cohen, Jean-Jacques Lévy, Stephan Merz, and Laurent Théry.
Formal proofs of Tarjan's algorithm in Why3, Coq, and Isabelle. Manuscript, October 2018. [ bib | .pdf ] |
| [390] |
Ran Chen and Jean-Jacques Lévy.
A semi-automatic proof of strong connectivity. In Verified Software: Theories, Tools and Experiments, volume 10712 of Lecture Notes in Computer Science, pages 49--65. Springer, July 2017. [ bib | .pdf ] |
| [391] |
Chris J. Cheney.
A nonrecursive list compacting algorithm. Communications of the ACM, 13(11):677--678, 1970. [ bib | http ] |
| [392] |
James Cheney.
Scrap your nameplate. In International Conference on Functional Programming (ICFP), pages 180--191, September 2005. [ bib | .pdf ] |
| [393] |
James Cheney and Ralf Hinze.
A lightweight implementation of generics and dynamics. In Haskell workshop, 2002. [ bib | .pdf ] |
| [394] |
James Cheney and Ralf Hinze.
First-class phantom types. Technical Report 1901, Cornell University, 2003. [ bib | http ] |
| [395] |
James Cheney and Christian Urban.
αProlog: A logic programming language with names, binding and α-equivalence. In International Conference on Logic Programming (ICLP), volume 3132 of Lecture Notes in Computer Science, pages 269--283. Springer, September 2004. [ bib | .pdf ] |
| [396] |
Perry Cheng and Guy E. Blelloch.
A parallel, real-time garbage collector. In Programming Language Design and Implementation (PLDI), pages 125--136, June 2001. [ bib | .pdf ] |
| [397] |
Wei-Ngan Chin and Siau-Cheng Khoo.
Calculating sized types. Higher-Order and Symbolic Computation, 14(2--3):261--300, September 2001. [ bib | http ] |
| [398] |
Wei-Ngan Chin, Huu Hai Nguyen, Corneliu Popeea, and Shengchao Qin.
Analysing memory resource bounds for low-level programs. In International Symposium on Memory Management, pages 151--160, June 2008. [ bib | .pdf ] |
| [399] |
Wei-Ngan Chin, Huu Hai Nguyen, Shengchao Qin, and Martin C. Rinard.
Memory usage verification for OO programs. In Static Analysis Symposium (SAS), volume 3672 of Lecture Notes in Computer Science, pages 70--86. Springer, September 2005. [ bib | http ] |
| [400] |
Jawahar Chirimar, Carl A. Gunter, and Jon G. Riecke.
Reference counting as a computational interpretation of linear logic. Journal of Functional Programming, 6(2):195--244, 1996. [ bib | .pdf ] |
| [401] |
Olaf Chitil.
Compositional explanation of types and algorithmic debugging of type errors. In International Conference on Functional Programming (ICFP), pages 193--204, September 2001. [ bib | .ps.gz ] |
| [402] |
Adam Chlipala.
A certified type-preserving compiler from lambda calculus to assembly language. In Programming Language Design and Implementation (PLDI), pages 54--65, June 2007. [ bib | .pdf ] |
| [403] |
Adam Chlipala.
Parametric higher-order abstract syntax for mechanized semantics. In International Conference on Functional Programming (ICFP), pages 143--156, September 2008. [ bib | .pdf ] |
| [404] |
Adam Chlipala.
Mostly-automated verification of low-level programs in computational separation logic. In Programming Language Design and Implementation (PLDI), pages 234--245, June 2011. [ bib | .pdf ] |
| [405] |
Adam Chlipala.
The Bedrock structured programming system: combining generative metaprogramming and Hoare logic in an extensible program verifier. In International Conference on Functional Programming (ICFP), pages 391--402, September 2013. [ bib | .pdf ] |
| [406] |
Adam Chlipala.
Certified programming and dependent types. MIT Press, November 2013. [ bib | http ] |
| [407] |
Adam Chlipala.
From network interface to multithreaded web applications: A case study in modular program verification. In Principles of Programming Languages (POPL), pages 609--622, January 2015. [ bib | .pdf ] |
| [408] |
Adam Chlipala, Gregory Malecha, Greg Morrisett, Avraham Shinnar, and Ryan
Wisnesky.
Effective interactive proofs for higher-order imperative programs. In International Conference on Functional Programming (ICFP), pages 79--90, September 2009. [ bib | .pdf ] |
| [409] |
Minki Cho, Youngju Song, Dongjae Lee, Lennard Gäher, and Derek Dreyer.
Stuttering for free. Proceedings of the ACM on Programming Languages, 7(OOPSLA2):1677--1704, 2023. [ bib | http ] |
| [410] |
Nathan Chong, Byron Cook, Jonathan Eidelman, Konstantinos Kallas, Kareem
Khazem, Felipe R. Monteiro, Daniel Schwartz-Narbonne, Serdar Tasiran,
Michael Tautschnig, and Mark R. Tuttle.
Code-level model checking in the software development workflow at Amazon Web Services. Software: Practice and Experience, 51(4):772--797, 2021. [ bib | http ] |
| [411] |
Venkatesh Choppella.
Unification source-tracking with application to diagnosis of type inference. PhD thesis, Indiana University, August 2002. [ bib | http ] |
| [412] |
Jacek Chrzaszcz.
Polymorphic subtyping without distributivity. In International Symposium on Mathematical Foundations of Computer Science, volume 1450 of Lecture Notes in Computer Science, pages 346--355. Springer, August 1998. [ bib | .ps.gz ] |
| [413] |
Koen Claessen.
A poor man's concurrency monad. Journal of Functional Programming, 9(3):313--323, 1999. [ bib | http ] |
| [414] |
Koen Claessen and John Hughes.
Testing monadic code with QuickCheck. ACM SIGPLAN Notices, 37(12):47--59, 2002. [ bib | .ps ] |
| [415] |
Dave Clarke and Sophia Drossopoulou.
Ownership, encapsulation and the disjointness of type and effect. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 292--310, November 2002. [ bib | .ps ] |
| [416] |
Dave Clarke, Sophia Drossopoulou, and James Noble.
Aliasing, confinement, and ownership in object-oriented programming. In Object-Oriented Technology. ECOOP 2003 Workshop Reader, volume 3013 of Lecture Notes in Computer Science, pages 197--207. Springer, 2004. [ bib | http ] |
| [417] |
Dave Clarke, James Noble, and Tobias Wrigstad, editors.
Aliasing in object-oriented programming. types, analysis and verification, volume 7850 of Lecture Notes in Computer Science. Springer, 2013. [ bib | http ] |
| [418] |
Dave Clarke, Johan Östlund, Ilya Sergey, and Tobias Wrigstad.
Ownership types: A survey. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 15--58. Springer, 2013. [ bib | http ] |
| [419] |
Dave Clarke and Tobias Wrigstad.
External uniqueness is unique enough. In European Conference on Object-Oriented Programming (ECOOP), volume 2743 of Lecture Notes in Computer Science, pages 176--200. Springer, July 2003. [ bib | .pdf ] |
| [420] |
David G. Clarke, James Noble, and John Potter.
Simple ownership types for object containment. In European Conference on Object-Oriented Programming (ECOOP), volume 2072 of Lecture Notes in Computer Science, pages 53--76. Springer, June 2001. [ bib | .pdf ] |
| [421] |
David G. Clarke, John M. Potter, and James Noble.
Ownership types for flexible alias protection. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 48--64, October 1998. [ bib | http ] |
| [422] |
Edmund Clarke.
Programming language constructs for which it is impossible to obtain good Hoare axiom systems. Journal of the ACM, 26(1):129--147, January 1979. [ bib | http ] |
| [423] |
Rance Cleaveland and Bernhard Steffen.
A linear-time model-checking algorithm for the alternation-free modal mu-calculus. In Computer Aided Verification (CAV), volume 575 of Lecture Notes in Computer Science, pages 48--58. Springer, 1991. [ bib | http ] |
| [424] |
Dominique Clément, Joëlle Despeyroux, Thierry Despeyroux, and Gilles
Kahn.
A simple applicative language: Mini-ML. In ACM Symposium on Lisp and Functional Programming (LFP), pages 13--27, 1986. [ bib ] |
| [425] |
John Clements and Matthias Felleisen.
A tail-recursive semantics for stack inspections. In European Symposium on Programming (ESOP), volume 2618 of Lecture Notes in Computer Science, pages 22--37. Springer, April 2003. [ bib | .ps.gz ] |
| [426] |
Martin Clochard, Jean-Christophe Filliâtre, and Andrei Paskevich.
How to avoid proving the absence of integer overflows. In Verified Software: Theories, Tools and Experiments, volume 9593 of Lecture Notes in Computer Science, pages 94--109. Springer, July 2015. [ bib | http ] |
| [427] |
Martin Clochard, Claude Marché, and Andrei Paskevich.
Verified programs with binders. In Programming Languages Meets Program Verification (PLPV), pages 29--40, January 2014. [ bib | http ] |
| [428] |
Michael J. Coblenz, Joshua Sunshine, Jonathan Aldrich, Brad A. Myers, Sam
Weber, and Forrest Shull.
Exploring language support for immutability. In International Conference on Software Engineering (ICSE), pages 736--747, May 2016. [ bib | .pdf ] |
| [429] |
Nicoletta Cocco and S. Dulli.
A mechanism for exception handling and its verification rules. Computer Languages, 7(2):89--102, 1982. [ bib | http ] |
| [430] |
J. Robin B. Cockett, Geoff S. H. Cruttwell, Jonathan Gallagher,
Jean-Simon Pacaud Lemay, Benjamin MacAdam, Gordon D. Plotkin, and Dorette
Pronk.
Reverse derivative categories. In Computer Science Logic, volume 152 of Leibniz International Proceedings in Informatics, pages 18:1--18:16. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, January 2020. [ bib | http ] |
| [431] |
Albert Cohen, Sébastien Donadio, Maria-Jesus Garzaran, Christoph Herrmann,
Oleg Kiselyov, and David Padua.
In search of a program generator to implement generic transformations for high-performance computing. Science of Computer Programming, 62(1):25--46, September 2006. [ bib | .ps.gz ] |
| [432] |
Ernie Cohen, Markus Dahlweid, Mark A. Hillebrand, Dirk Leinenbach, Michal
Moskal, Thomas Santen, Wolfram Schulte, and Stephan Tobies.
VCC: A practical system for verifying concurrent C. In Theorem Proving in Higher Order Logics (TPHOLs), volume 5674 of Lecture Notes in Computer Science, pages 23--42. Springer, 2009. [ bib | http ] |
| [433] |
Dario Colazzo and Giorgio Ghelli.
Subtyping recursive types in Kernel Fun. In Logic in Computer Science (LICS), pages 137--146, July 1999. [ bib ] |
| [434] |
George E. Collins.
A method for overlapping and erasure of lists. Communications of the ACM, 3(12):655--657, 1960. [ bib | http ] |
| [435] |
Gregory D. Collins and Zhong Shao.
Intensional analysis of higher-kinded recursive types. Technical Report YALEU/DCS/TR-1240, Yale University, 2002. [ bib | .pdf ] |
| [436] |
Alain Colmerauer.
Equations and inequations on finite and infinite trees. In International Conference on Fifth Generation Computer Systems (FGCS), pages 85--99, November 1984. [ bib ] |
| [437] |
Hubert Comon.
Constraints in term algebras (short survey). In International Conference on Algebraic Methodology and Software Technology (AMAST), Workshops in Computing. Springer, 1993. [ bib | .ps ] |
| [438] |
Hubert Comon and Pierre Lescanne.
Equational problems and disunification. Journal of Symbolic Computation, 7:371--425, 1989. [ bib | .pdf ] |
| [439] |
Sylvain Conchon and Evelyne Contejean.
The Alt-Ergo automatic theorem prover, 2013. http://alt-ergo.lri.fr/. [ bib | http ] |
| [440] |
Sylvain Conchon and Fabrice Le Fessant.
Jocaml: Mobile agents for Objective-Caml. In International Symposium on Agent Systems and Applications and International Symposium on Mobile Agents (ASA/MA), pages 22--29, October 1999. [ bib | .ps.gz ] |
| [441] |
Sylvain Conchon and Jean-Christophe Filliâtre.
A persistent union-find data structure. In ACM Workshop on ML, pages 37--46, October 2007. [ bib | http ] |
| [442] |
Sylvain Conchon and Jean-Christophe Filliâtre.
Union-Find persistant. In Journées Françaises des Langages Applicatifs (JFLA), 2007. [ bib | .ps.gz ] |
| [443] |
Sylvain Conchon and Jean-Christophe Filliâtre.
Semi-persistent data structures. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 322--336. Springer, April 2008. [ bib | .pdf ] |
| [444] |
Sylvain Conchon, Johannes Kanig, and Stéphane Lescuyer.
Sat-Micro: petit mais costaud! In Journées Françaises des Langages Applicatifs (JFLA), January 2008. [ bib | .ps ] |
| [445] |
Sylvain Conchon and François Pottier.
JOIN(X): Constraint-based type inference for the join-calculus. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 221--236. Springer, April 2001. [ bib | .ps.gz ] |
| [446] |
Jeffrey Considine.
Efficient hash-consing of recursive types. Technical Report 2000-006, Boston University, January 2000. [ bib | .pdf ] |
| [447] |
Lukas Convent, Sam Lindley, Conor McBride, and Craig McLaughlin.
Doo bee doo bee doo. Journal of Functional Programming, 30, March 2020. [ bib | .pdf ] |
| [448] |
Byron Cook, Christoph Haase, Joël Ouaknine, Matthew J. Parkinson, and
James Worrell.
Tractable reasoning in a fragment of separation logic. In International Conference on Concurrency Theory (CONCUR), volume 6901 of Lecture Notes in Computer Science, pages 235--249. Springer, September 2011. [ bib | .pdf ] |
| [449] |
Stephen A. Cook.
The complexity of theorem-proving procedures. In Symposium on the Theory of Computing, pages 151--158, May 1971. [ bib | http ] |
| [450] |
William R. Cook.
On understanding data abstraction, revisited. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 557--572, October 2009. [ bib | .pdf ] |
| [451] |
Ezra Cooper, Sam Lindley, Philip Wadler, and Jeremy Yallop.
Links: Web programming without tiers. In Formal Methods for Components and Objects, volume 4709 of Lecture Notes in Computer Science, pages 266--296. Springer, November 2006. [ bib | .pdf ] |
| [452] |
Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy.
Iterative data-flow analysis, revisited. Technical Report TR04-432, Rice University, March 2004. [ bib | .pdf ] |
| [453] |
Mario Coppo and Mariangiola Dezani-Ciancaglini.
An extension of the basic functionality theory for the λ-calculus. Notre Dame J. Formal Logic, 21(4):685--693, 1980. [ bib ] |
| [454] |
Thierry Coquand.
An analysis of Girard's paradox. In Logic in Computer Science (LICS), pages 227--236, June 1986. [ bib | .pdf ] |
| [455] |
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein.
Introduction to algorithms (third edition). MIT Press, 2009. [ bib | http ] |
| [456] |
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein.
Algorithmique (troisième Édition). Sciences Sup. Dunod, 2010. Traduction française. [ bib | http ] |
| [457] |
Bruno Courcelle.
Fundamental properties of infinite trees. Theoretical Computer Science, 25(2):95--169, March 1983. [ bib ] |
| [458] |
Patrick Cousot.
Methods and logics for proving programs. In Formal Models and Semantics, volume B of Handbook of Theoretical Computer Science, chapter 15, pages 841--993. Elsevier, 1990. [ bib | .pdf.gz ] |
| [459] |
Patrick Cousot and Radhia Cousot.
Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints. In Principles of Programming Languages (POPL), pages 238--252, January 1977. [ bib | .pdf ] |
| [460] |
Patrick Cousot and Radhia Cousot.
Constructive versions of Tarski's fixed point theorems. Pacific Journal of Mathematics, 81(1):43--57, 1979. [ bib | .pdf ] |
| [461] |
Patrick Cousot and Radhia Cousot.
Formal language, grammar and set-constraint-based program analysis by abstract interpretation. In Functional Programming Languages and Computer Architecture (FPCA), pages 170--181. ACM Press, 1995. [ bib ] |
| [462] |
Patrick Cousot and Radhia Cousot.
A gentle introduction to formal verification of computer systems by abstract interpretation. In J. Esparza, O. Grumberg, and M. Broy, editors, Logics and Languages for Reliability and Security, NATO Science Series III: Computer and Systems Sciences, pages 1--29. IOS Press, 2010. [ bib | http ] |
| [463] |
Patrick Cousot, Radhia Cousot, Jérôme Feret, Antoine Miné, and Xavier Rival.
The Astrée static analyzer, 2011. http://www.astree.ens.fr/. [ bib | http ] |
| [464] |
Duncan Coutts, Roman Leshchinskiy, and Don Stewart.
Stream fusion: from lists to streams to nothing at all. In International Conference on Functional Programming (ICFP), pages 315--326, October 2007. [ bib | http ] |
| [465] |
Erik Crank and Matthias Felleisen.
Parameter-passing and the lambda calculus. In Principles of Programming Languages (POPL), pages 233--244, January 1991. [ bib | .ps.gz ] |
| [466] |
Karl Crary.
Type-theoretic methodology for practical programming languages. PhD thesis, Cornell University, August 1998. [ bib | .ps.gz ] |
| [467] |
Karl Crary.
Simple, efficient object encoding using intersection types. Technical Report CMU-CS-99-100, Carnegie Mellon University, 1999. [ bib | .ps.gz ] |
| [468] |
Karl Crary.
A simple proof of call-by-value standardization. Technical Report CMU-CS-09-137, Carnegie Mellon University, 2009. [ bib | .pdf ] |
| [469] |
Karl Crary, David Walker, and Greg Morrisett.
Typed memory management in a calculus of capabilities. In Principles of Programming Languages (POPL), pages 262--275, January 1999. [ bib | .pdf ] |
| [470] |
Karl Crary and Stephanie Weirich.
Flexible type analysis. In International Conference on Functional Programming (ICFP), pages 233--248, 1999. [ bib | .ps.gz ] |
| [471] |
Karl Crary and Stephanie Weirich.
Resource bound certification. In Principles of Programming Languages (POPL), pages 184--198, January 2000. [ bib | .pdf ] |
| [472] |
Karl Crary, Stephanie Weirich, and Greg Morrisett.
Intensional polymorphism in type-erasure semantics. In International Conference on Functional Programming (ICFP), pages 301--313, September 1998. [ bib | .ps ] |
| [473] |
Karl Crary, Stephanie Weirich, and Greg Morrisett.
Intensional polymorphism in type erasure semantics. Journal of Functional Programming, 12(6):567--600, November 2002. [ bib | .ps ] |
| [474] |
Juan Manuel Crespo and César Kunz.
A machine-checked framework for relational separation logic. In Software Engineering and Formal Methods, volume 7041 of Lecture Notes in Computer Science, pages 122--137. Springer, November 2011. [ bib | .pdf ] |
| [475] |
Julien Cretin.
Erasable coercions: a unified approach to type systems. PhD thesis, Université Paris Diderot, January 2014. [ bib | http ] |
| [476] |
Julien Cretin and Didier Rémy.
On the power of coercion abstraction. In Principles of Programming Languages (POPL), pages 361--372, January 2012. [ bib | .pdf ] |
| [477] |
Tristan Crolard and Emmanuel Polonowski.
Deriving a Floyd-Hoare logic for non-local jumps from a formulæ-as-types notion of control. Journal of Logical and Algebraic Methods in Programming, 81(3):181--208, 2012. [ bib | .pdf ] |
| [478] |
Haskell B. Curry and Robert M. Feys.
Combinatory logic, volume 1. North-Holland Publishing Company, Amsterdam, 1958. [ bib ] |
| [479] |
Pavel Curtis.
Constrained quantification in polymorphic type analysis. PhD thesis, Cornell University, February 1990. [ bib | .ps.gz ] |
| [480] |
Lukasz Czajka.
Practical proof search for Coq by type inhabitation. In International Joint Conference on Automated Reasoning, volume 12167 of Lecture Notes in Computer Science, pages 28--57. Springer, July 2020. [ bib | .pdf ] |
| [481] |
Pedro da Rocha Pinto, Thomas Dinsdale-Young, and Philippa Gardner.
TaDA: A logic for time and data abstraction. In Richard E. Jones, editor, European Conference on Object-Oriented Programming (ECOOP), volume 8586 of Lecture Notes in Computer Science, pages 207--231. Springer, July 2014. [ bib | .pdf ] |
| [482] |
Luis Damas.
Type assignment in programming languages. PhD thesis, University of Edinburgh, 1984. [ bib | http ] |
| [483] |
Luis Damas and Robin Milner.
Principal type-schemes for functional programs. In Principles of Programming Languages (POPL), pages 207--212, 1982. [ bib | http ] |
| [484] |
Werner Damm and Bernhard Josko.
A sound and relatively* complete axiomatization of Clarke's language L4. In Logic of Programs, volume 164 of Lecture Notes in Computer Science, pages 161--175. Springer, 1983. [ bib | http ] |
| [485] |
Hoang-Hai Dang, Jacques-Henri Jourdan, Jan-Oliver Kaiser, and Derek Dreyer.
RustBelt meets relaxed memory. Proceedings of the ACM on Programming Languages, 4(POPL):34:1--34:29, 2020. [ bib | http ] |
| [486] |
Hoang-Hai Dang, Jaehwang Jung, Jaemin Choi, Duc-Than Nguyen, William Mansky,
Jeehoon Kang, and Derek Dreyer.
Compass: strong and compositional library specifications in relaxed memory separation logic. In Programming Language Design and Implementation (PLDI), pages 792--808, June 2022. [ bib | http ] |
| [487] |
Nils Anders Danielsson.
A formalisation of the correctness result from “Lightweight semiformal time complexity analysis for purely functional data structures”. Technical Report 07-16, Chalmers University, January 2007. [ bib | .pdf ] |
| [488] |
Nils Anders Danielsson.
Lightweight semiformal time complexity analysis for purely functional data structures. In Principles of Programming Languages (POPL), January 2008. [ bib | .pdf ] |
| [489] |
Nils Anders Danielsson.
Beating the productivity checker using embedded languages. In Partiality and Recursion in Interactive Theorem Provers (PAR@ITP), volume 5 of EPiC Series, pages 34--54. EasyChair, July 2010. [ bib | http ] |
| [490] |
Nils Anders Danielsson.
Correct-by-construction pretty-printing. In Workshop on dependently-typed programming, pages 1--12, September 2013. [ bib | .pdf ] |
| [491] |
Nils Anders Danielsson and Thorsten Altenkirch.
Subtyping, declaratively. In Mathematics of Program Construction (MPC), volume 6120 of Lecture Notes in Computer Science, pages 100--118. Springer, June 2010. [ bib | .pdf ] |
| [492] |
Nils Anders Danielsson, John Hughes, Patrik Jansson, and Jeremy Gibbons.
Fast and loose reasoning is morally correct. In Principles of Programming Languages (POPL), pages 206--217, January 2006. [ bib | .pdf ] |
| [493] |
Norman Danner, Jennifer Paykin, and James S. Royer.
A static cost analysis for a higher-order language. In Programming Languages Meets Program Verification (PLPV), pages 25--34, January 2013. [ bib | .pdf ] |
| [494] |
Olivier Danvy.
Functional unparsing. Technical Report RS-98-12, BRICS, May 1998. [ bib | http ] |
| [495] |
Olivier Danvy.
Functional unparsing. Journal of Functional Programming, 8(6):621--625, November 1998. [ bib | http ] |
| [496] |
Olivier Danvy and Andrzej Filinski.
Abstracting control. In ACM Symposium on Lisp and Functional Programming (LFP), pages 151--160, 1990. [ bib | http ] |
| [497] |
Olivier Danvy and Andrzej Filinski.
Representing control: A study of the CPS transformation. Mathematical Structures in Computer Science, 2(4):361--391, 1992. [ bib | http ] |
| [498] |
Olivier Danvy and Mayer Goldberg.
There and back again. Fundamenta Informaticæ, 66(4):397--413, 2005. [ bib | .pdf ] |
| [499] |
Olivier Danvy, Chantal Keller, and Matthias Puech.
Typeful Normalization by Evaluation. In Types for Proofs and Programs, volume 39 of Leibniz International Proceedings in Informatics, pages 72--88. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2015. [ bib | http ] |
| [500] |
Olivier Danvy and Lasse R. Nielsen.
Defunctionalization at work. Technical Report RS-01-23, BRICS, June 2001. [ bib | http ] |
| [501] |
Olivier Danvy and Lasse R. Nielsen.
Defunctionalization at work. In Principles and Practice of Declarative Programming (PPDP), pages 162--174, September 2001. [ bib | http ] |
| [502] |
Olivier Danvy and Lasse R. Nielsen.
A first-order one-pass CPS transformation. Theoretical Computer Science, 308(1--3):239--257, 2003. [ bib | http ] |
| [503] |
Olivier Danvy and Lasse R. Nielsen.
CPS transformation of beta-redexes. Technical Report RS-04-39, BRICS, December 2004. [ bib | .pdf ] |
| [504] |
Thi Bich Hanh Dao.
Résolution de contraintes du premier ordre dans la théorie des arbres finis ou infinis. PhD thesis, Université de la Méditerranée, December 2000. [ bib | .ps.gz ] |
| [505] |
Thibault Dardinier and Peter Müller.
Hyper Hoare logic: (dis-)Proving program hyperproperties. Proceedings of the ACM on Programming Languages, 8(PLDI):1485--1509, 2024. [ bib | http ] |
| [506] |
Zaynah Dargaye and Xavier Leroy.
Mechanized verification of CPS transformations. In Logic for Programming Artificial Intelligence and Reasoning (LPAR), volume 4790 of Lecture Notes in Artificial Intelligence, pages 211--225. Springer, 2007. [ bib | .pdf ] |
| [507] |
Ankush Das and Shaz Qadeer.
Exact and linear-time gas-cost analysis. In Static Analysis Symposium (SAS), volume 12389 of Lecture Notes in Computer Science, pages 333--356. Springer, November 2020. [ bib | .pdf ] |
| [508] |
Rowan Davies.
Practical refinement-type checking. Technical Report CMU-CS-05-110, School of Computer Science, Carnegie Mellon University, May 2005. [ bib | .pdf ] |
| [509] |
Rowan Davies and Frank Pfenning.
Intersection types and computational effects. In International Conference on Functional Programming (ICFP), pages 198--208, September 2000. [ bib | .pdf ] |
| [510] |
Martin Davis, George Logemann, and Donald Loveland.
A machine program for theorem-proving. Communications of the ACM, 5(7):394--397, 1962. [ bib | http ] |
| [511] |
Martin Davis and Hilary Putnam.
A computing procedure for quantification theory. Journal of the ACM, 7(3):201--215, 1960. [ bib | http ] |
| [512] |
Martin de Boer, Stijn de Gouw, Jonas Klamroth, Christian Jung, Mattias Ulbrich,
and Alexander Weigl.
Formal specification and verification of JDK's identity hash map implementation. In Integrated Formal Methods, volume 13274 of Lecture Notes in Computer Science, pages 45--62. Springer, June 2022. [ bib | http ] |
| [513] |
Nicolaas G. de Bruijn.
Lambda-calculus notation with nameless dummies: a tool for automatic formula manipulation with application to the Church-Rosser theorem. Indag. Math., 34(5):381--392, 1972. [ bib ] |
| [514] |
Maartje de Jonge and Eelco Visser.
An algorithm for layout preservation in refactoring transformations. In Software Language Engineering, volume 6940 of Lecture Notes in Computer Science, pages 40--59. Springer, July 2011. [ bib | http ] |
| [515] |
Ana Lúcia de Moura and Roberto Ierusalimschy.
Revisiting coroutines. ACM Transactions on Programming Languages and Systems, 31(2):1--31, February 2009. [ bib | http ] |
| [516] |
Leonardo Mendonça de Moura and Nikolaj Bjørner.
Z3: an efficient SMT solver. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 4963 of Lecture Notes in Computer Science, pages 337--340. Springer, April 2008. [ bib | .pdf ] |
| [517] |
Paulo Emílio de Vilhena and François Pottier.
A type system for effect handlers and dynamic labels. In European Symposium on Programming (ESOP), volume 13990 of Lecture Notes in Computer Science, pages 225--252. Springer, April 2023. [ bib | .pdf ] |
| [518] |
Paulo Emílio de Vilhena and François Pottier.
A separation logic for effect handlers. Proceedings of the ACM on Programming Languages, 5(POPL), January 2021. [ bib | .pdf ] |
| [519] |
Paulo Emílio de Vilhena, François Pottier, and Jacques-Henri Jourdan.
Spy game: Verifying a local generic solver in Iris. Proceedings of the ACM on Programming Languages, 4(POPL), January 2020. [ bib | .pdf ] |
| [520] |
Edsko de Vries, Rinus Plasmeijer, and David Abrahamson.
Uniqueness typing redefined. In Implementation of Functional Languages (IFL), volume 4449 of Lecture Notes in Computer Science, pages 181--198. Springer, 2006. [ bib | .pdf ] |
| [521] |
Edsko de Vries, Rinus Plasmeijer, and David Abrahamson.
Equality based uniqueness typing. In Trends in Functional Programming (TFP), 2007. [ bib | .pdf ] |
| [522] |
M. Debbabi, E. Giasson, B. Ktari, F. Michaud, and N. Tawbi.
Secure self-certified COTS. In IEEE International Workshop on Enterprise Security (WETICE'00), June 2000. [ bib | .pdf ] |
| [523] |
Benjamin Delaware, Bruno C. d. S. Oliveira, and Tom Schrijvers.
Meta-theory à la carte. In Principles of Programming Languages (POPL), pages 207--218, January 2013. [ bib | .pdf ] |
| [524] |
Benjamin Delaware, Steven Keuchel, Tom Schrijvers, and Bruno C. d. S. Oliveira.
Modular monadic meta-theory. In International Conference on Functional Programming (ICFP), pages 319--330, September 2013. [ bib | .pdf ] |
| [525] |
Germán Andrés Delbianco and Aleksandar Nanevski.
Hoare-style reasoning with (algebraic) continuations. In International Conference on Functional Programming (ICFP), pages 363--376, September 2013. [ bib | .pdf ] |
| [526] |
Robert DeLine and Manuel Fähndrich.
Enforcing high-level protocols in low-level software. In Programming Language Design and Implementation (PLDI), pages 59--69, June 2001. [ bib | http ] |
| [527] |
Robert DeLine and Manuel Fähndrich.
The Fugue protocol checker: Is your software baroque? Technical Report MSR-TR-2004-07, Microsoft Research, January 2004. [ bib | http ] |
| [528] |
Robert DeLine and Manuel Fähndrich.
Typestates for objects. In European Conference on Object-Oriented Programming (ECOOP), volume 3086 of Lecture Notes in Computer Science, pages 465--490. Springer, June 2004. [ bib | http ] |
| [529] |
Alan Demers, Susan Horwitz, and Tim Teitelbaum.
An efficient general algorithm for dataflow analysis. Acta Informatica, 24(6):679--694, November 1987. [ bib | http ] |
| [530] |
Peter Dencker, Karl Dürre, and Johannes Heuft.
Optimization of parser tables for portable compilers. ACM Transactions on Programming Languages and Systems, 6(4):546--572, 1984. [ bib | http ] |
| [531] |
Dorothy E. Denning.
Cryptography and data security. Addison-Wesley, 1982. [ bib ] |
| [532] |
Dorothy E. Denning and Peter J. Denning.
Certification of programs for secure information flow. Communications of the ACM, 20(7):504--513, July 1977. [ bib ] |
| [533] |
Greg Dennis, Felix Change, and Daniel Jackson.
Modular verification of code with SAT. In International Symposium on Software Testing and Analysis (ISSTA), July 2006. [ bib | .pdf ] |
| [534] |
Joel E. Denny and Brian A. Malloy.
The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution. Science of Computer Programming, 75(11):943--979, 2010. [ bib | http ] |
| [535] |
Paul Denny, James Prather, Brett A. Becker, Catherine Mooney, John Homer,
Zachary C. Albrecht, and Garrett B. Powell.
On designing programming error messages for novices: Readability and its constituent factors. In Human Factors in Computing Systems, pages 55:1--55:15, May 2021. [ bib | http ] |
| [536] |
Frank DeRemer and Thomas Pennello.
Efficient computation of LALR(1) look-ahead sets. ACM Transactions on Programming Languages and Systems, 4(4):615--649, 1982. [ bib | http ] |
| [537] |
Franklin L. DeRemer.
Simple LR(k) grammars. Communications of the ACM, 14(7):453--460, 1971. [ bib | http ] |
| [538] |
Franklin Lewis DeRemer.
Practical translators for LR(k) languages. Technical Report MIT-LCS-TR-065, Massachusetts Institute of Technology, 1969. [ bib | .pdf ] |
| [539] |
David Detlefs, Greg Nelson, and James B. Saxe.
Simplify: a theorem prover for program checking. Journal of the ACM, 52(3):365--473, 2005. [ bib | http ] |
| [540] |
David L. Detlefs, K. Rustan M. Leino, and Greg Nelson.
Wrestling with rep exposure. Research Report 156, SRC, July 1998. [ bib | .pdf ] |
| [541] |
David L. Detlefs, K. Rustan M. Leino, Greg Nelson, and James B. Saxe.
Extended static checking. Research Report 159, Compaq SRC, December 1998. [ bib | .pdf ] |
| [542] |
L. Peter Deutsch and Daniel G. Bobrow.
An efficient, incremental, automatic garbage collector. Communications of the ACM, 19(9):522--526, 1976. [ bib | .pdf ] |
| [543] |
Roberto Di Cosmo.
Deciding type isomorphisms in a type assignment framework. Journal of Functional Programming, 3(3):485--525, 1993. [ bib | .dvi ] |
| [544] |
Roberto Di Cosmo.
Isomorphisms of types: from λ-calculus to information retrieval and language design. Progress in Theoretical Computer Science. Birkhauser, 1995. [ bib | .html ] |
| [545] |
Lukas Diekmann and Laurence Tratt.
Don't panic! better, fewer, syntax errors for LR parsers. In European Conference on Object-Oriented Programming (ECOOP), volume 166 of Leibniz International Proceedings in Informatics, pages 6:1--6:32, November 2020. [ bib | http ] |
| [546] |
Werner Dietl, Sophia Drossopoulou, and Peter Müller.
Separating ownership topology and encapsulation with generic universe types. ACM Transactions on Programming Languages and Systems, 33(6):20, 2011. [ bib | .pdf ] |
| [547] |
Werner Dietl and Peter Müller.
Universes: Lightweight ownership for JML. Journal of Object Technology, 4(8):5--32, 2005. [ bib | .pdf ] |
| [548] |
E. W. Dijkstra.
A note on two problems in connection with graphs. Numerische Mathematik, 1:269--271, 1959. [ bib ] |
| [549] |
Edsger W. Dijkstra.
Guarded commands, nondeterminacy and formal derivation of programs. Communications of the ACM, 18(8):453--457, 1975. [ bib | http ] |
| [550] |
Allyn Dimock.
Type- and flow-directed compilation for specialized data representations. PhD thesis, Harvard University, January 2002. [ bib | .ps.gz ] |
| [551] |
Allyn Dimock, Ian Westmacott, Robert Muller, Franklyn Turbak, and J. B. Wells.
Functioning without closure: type-safe customized function representations for Standard ML. In International Conference on Functional Programming (ICFP), September 2001. [ bib | .ps ] |
| [552] |
Thomas Dinsdale-Young, Lars Birkedal, Philippa Gardner, Matthew J. Parkinson,
and Hongseok Yang.
Views: compositional reasoning for concurrent programs. In Principles of Programming Languages (POPL), pages 287--300, January 2013. [ bib | .pdf ] |
| [553] |
Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew Parkinson, and
Viktor Vafeiadis.
Concurrent abstract predicates. Technical report, University of Cambridge, Computer Laboratory, April 2010. [ bib | .pdf ] |
| [554] |
Thomas Dinsdale-Young, Mike Dodds, Philippa Gardner, Matthew J. Parkinson, and
Viktor Vafeiadis.
Concurrent abstract predicates. In European Conference on Object-Oriented Programming (ECOOP), volume 6183 of Lecture Notes in Computer Science, pages 504--528. Springer, 2010. [ bib | .pdf ] |
| [555] |
Dino Distefano and Matthew J. Parkinson.
jStar: towards practical verification for Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 213--226, October 2008. [ bib | .pdf ] |
| [556] |
Robert Dockins and Aquinas Hobor.
Time bounds for general function pointers. In Mathematical Foundations of Programming Semantics, volume 286 of Electronic Notes in Theoretical Computer Science, pages 139--155. Elsevier, June 2012. [ bib | http ] |
| [557] |
Robert Dockins, Aquinas Hobor, and Andrew W. Appel.
A fresh look at separation algebras and share accounting. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 161--177. Springer, December 2009. [ bib | .pdf ] |
| [558] |
Mike Dodds, Xinyu Feng, Matthew J. Parkinson, and Viktor Vafeiadis.
Deny-guarantee reasoning. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 363--377. Springer, March 2009. [ bib | .pdf ] |
| [559] |
Mike Dodds, Suresh Jagannathan, and Matthew J. Parkinson.
Modular reasoning for deterministic parallelism. In Principles of Programming Languages (POPL), pages 259--270, January 2011. [ bib | .pdf ] |
| [560] |
Mike Dodds, Suresh Jagannathan, Matthew J. Parkinson, Kasper Svendsen, and Lars
Birkedal.
Verifying custom synchronization constructs using higher-order separation logic. ACM Transactions on Programming Languages and Systems, 28(2), January 2016. [ bib | http ] |
| [561] |
Marko Doko and Viktor Vafeiadis.
A program logic for C11 memory fences. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 9583 of Lecture Notes in Computer Science, pages 413--430. Springer, January 2016. [ bib | .pdf ] |
| [562] |
Marko Doko and Viktor Vafeiadis.
Tackling real-life relaxed concurrency with FSL++. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 448--475. Springer, April 2017. [ bib | .pdf ] |
| [563] |
Stephen Dolan.
Malfunctional programming. In ML Family Workshop, September 2016. [ bib | .pdf ] |
| [564] |
Stephen Dolan.
Malfunction. Online repository, September 2022. [ bib | http ] |
| [565] |
Stephen Dolan, Spiros Eliopoulos, Daniel Hillerström, Anil Madhavapeddy,
K. C. Sivaramakrishnan, and Leo White.
Concurrent system programming with effect handlers. In Trends in Functional Programming (TFP), volume 10788 of Lecture Notes in Computer Science, pages 98--117. Springer, June 2017. [ bib | .pdf ] |
| [566] |
Stephen Dolan, K. C. Sivaramakrishnan, and Anil Madhavapeddy.
Bounding data races in space and time. In Programming Language Design and Implementation (PLDI), pages 242--255, June 2018. [ bib | .pdf ] |
| [567] |
Stephen Dolan and Leo White.
Syntax with shifted names. Presented at the Workshop on Type-driven Development (TyDe), August 2019. [ bib | .pdf ] |
| [568] |
Charles Donnelly and Richard Stallman.
Bison, September 2021. [ bib | http ] |
| [569] |
Kevin Donnelly, J. J. Hallett, and Assaf J. Kfoury.
Formal semantics of weak references. In International Symposium on Memory Management, pages 126--137, June 2006. [ bib | http ] |
| [570] |
Kevin Donnelly and Hongwei Xi.
Combining higher-order abstract syntax with first-order abstract syntax in ATS. In ACM Workshop on Mechanized Reasoning about Languages with Variable Binding, pages 58--63, 2005. [ bib | http ] |
| [571] |
Vincent Dornic, Pierre Jouvelot, and David K. Gifford.
Polymorphic time systems for estimating program complexity. ACM Letters on Programming Languages and Systems, 1(1):33--45, 1992. [ bib | .pdf ] |
| [572] |
Gilles Dowek.
Higher-order unification and matching. In J. Alan Robinson and Andrei Voronkov, editors, Handbook of Automated Reasoning, pages 1009--1062. Elsevier, 2001. [ bib | .ps ] |
| [573] |
Gilles Dowek, Thérèse Hardin, and Claude Kirchner.
Higher order unification via explicit substitutions. Research Report 2709, INRIA, November 1995. [ bib | .html ] |
| [574] |
Gilles Dowek, Thérèse Hardin, Claude Kirchner, and Frank Pfenning.
Unification via explicit substitutions: the case of higher-order patterns. Research Report 3591, INRIA, December 1998. [ bib | .html ] |
| [575] |
William F. Dowling and Jean H. Gallier.
Linear-time algorithms for testing the satisfiability of propositional Horn formulae. Journal of Logic Programming, 1(3):267--284, 1984. [ bib ] |
| [576] |
Peter J. Downey, Ravi Sethi, and Robert Endre Tarjan.
Variations on the common subexpression problem. Journal of the ACM, 27(4):758--771, October 1980. [ bib | http ] |
| [577] |
Derek Dreyer, Georg Neis, and Lars Birkedal.
The impact of higher-order state and control effects on local relational reasoning. In International Conference on Functional Programming (ICFP), pages 143--156, September 2010. [ bib | .pdf ] |
| [578] |
Derek Dreyer, Georg Neis, and Lars Birkedal.
The impact of higher-order state and control effects on local relational reasoning. Journal of Functional Programming, 22(4-5):477--528, 2012. [ bib | .pdf ] |
| [579] |
James R. Driscoll, Neil Sarnak, Daniel Dominic Sleator, and Robert Endre
Tarjan.
Making data structures persistent. Journal of Computer and System Sciences, 38(1):86--124, 1989. [ bib | http ] |
| [580] |
Catherine Dubois.
Proving ML type soundness within Coq. In Theorem Proving in Higher Order Logics (TPHOLs), volume 1869 of Lecture Notes in Computer Science, pages 126--144. Springer, August 2000. [ bib | .pdf ] |
| [581] |
Catherine Dubois and Valérie Ménissier-Morain.
Typage de ML: Spécification et preuve en Coq. In Actes du GDR Programmation, November 1997. [ bib | .ps.gz ] |
| [582] |
Catherine Dubois and Valérie Ménissier-Morain.
Certification of a type inference tool for ML: Damas-Milner within Coq. Journal of Automated Reasoning, 23(3--4):319--346, November 1999. [ bib | .pdf ] |
| [583] |
Dominic Duggan and Frederick Bent.
Explaining type inference. Science of Computer Programming, 27(1), June 1996. [ bib ] |
| [584] |
Jana Dunfield and Neelakantan R. Krishnaswami.
Complete and easy bidirectional typechecking for higher-rank polymorphism. In International Conference on Functional Programming (ICFP), pages 429--442, September 2013. [ bib | http ] |
| [585] |
Dirk Dussart, Fritz Henglein, and Christian Mossin.
Polymorphic recursion and subtype qualifications: Polymorphic binding-time analysis in polynomial time. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science, pages 118--135. Springer, September 1995. [ bib | .dvi.gz ] |
| [586] |
Kent Dybvig, Robert Hieb, and Carl Bruggeman.
Syntactic abstraction in Scheme. Lisp and Symbolic Computation, 5(4):295--326, 1993. [ bib | .pdf ] |
| [587] |
R. Kent Dybvig, Simon L. Peyton Jones, and Amr Sabry.
A monadic framework for delimited continuations. Journal of Functional Programming, 17(6):687--730, 2007. [ bib | .pdf ] |
| [588] |
Manuel Eberl.
Proving divide and conquer complexities in Isabelle/HOL. Journal of Automated Reasoning, 58(4):483--508, 2017. [ bib | .pdf ] |
| [589] |
Manuel Eberl, Max W. Haslbeck, and Tobias Nipkow.
Verified analysis of random binary tree structures. Journal of Automated Reasoning, 64(5):879--910, 2020. [ bib | http ] |
| [590] |
Jonathan Eifrig, Scott Smith, and Valery Trifonov.
Sound polymorphic type inference for objects. ACM SIGPLAN Notices, 30(10):169--184, 1995. [ bib | .ps.gz ] |
| [591] |
Jonathan Eifrig, Scott Smith, and Valery Trifonov.
Type inference for recursively constrained types and its application to OOP. In Mathematical Foundations of Programming Semantics, volume 1 of Electronic Notes in Theoretical Computer Science. Elsevier, 1995. [ bib | .ps.gz ] |
| [592] |
Conal Elliott.
The simple essence of automatic differentiation. Proceedings of the ACM on Programming Languages, 2(ICFP):70:1--70:29, 2018. [ bib | http ] |
| [593] |
Conal M. Elliott.
Beautiful differentiation. In International Conference on Functional Programming (ICFP), pages 191--202, September 2009. [ bib | http ] |
| [594] |
Amr Elmasry and Jyrki Katajainen.
Regular numeral systems for data structures. Acta Informatica, 59(2--3):245--281, 2022. [ bib | http ] |
| [595] |
E. Allen Emerson and Chin-Laung Lei.
Efficient model checking in fragments of the propositional mu-calculus. In Logic in Computer Science (LICS), pages 267--278, June 1986. [ bib ] |
| [596] |
Michael Emmi and Constantin Enea.
Weak-consistency specification via visibility relaxation. Proceedings of the ACM on Programming Languages, 3(POPL):60:1--60:28, 2019. [ bib | http ] |
| [597] |
Martin Emms and Hans Leiß.
Extending the type checker for SML by polymorphic recursion --- A correctness proof. Technical Report 96-101, Centrum für Informations- und Sprachverarbeitung, Universität München, 1996. [ bib | .ps.gz ] |
| [598] |
Úlfar Erlingsson and Fred B. Schneider.
SASI enforcement of security policies: a retrospective. In New Security Paradigms Workshop, pages 87--95, September 1999. [ bib | .ps ] |
| [599] |
Úlfar Erlingsson and Fred B. Schneider.
IRM enforcement of Java stack inspection. In IEEE Symposium on Security and Privacy (S&P), pages 246--255, May 2000. [ bib | http ] |
| [600] |
Javier Esparza, David Hansel, Peter Rossmanith, and Stefan Schwoon.
Efficient algorithms for model checking pushdown systems. In Computer Aided Verification (CAV), volume 1855 of Lecture Notes in Computer Science, pages 232--247. Springer, July 2000. [ bib | .pdf ] |
| [601] |
Javier Esparza, Peter Lammich, René Neumann, Tobias Nipkow, Alexander
Schimpf, and Jan-Georg Smaus.
A fully verified executable LTL model checker. In Computer Aided Verification (CAV), volume 8044 of Lecture Notes in Computer Science, pages 463--478. Springer, July 2013. [ bib | .pdf ] |
| [602] |
Sylvain Conchon et Jean-Christophe Filliâtre.
Apprendre à programmer avec OCaml: Algorithmes et structures de données. Eyrolles, 2014. [ bib | http ] |
| [603] |
Manuel Fähndrich, Michael Barnett, and Francesco Logozzo.
Embedded contract languages. In Symposium on Applied Computing, pages 2103--2110, March 2010. [ bib | .pdf ] |
| [604] |
Karl-Filip Faxén.
A static semantics for Haskell. Journal of Functional Programming, 12(4--5):295--357, July 2002. [ bib | .ps.gz ] |
| [605] |
Christian Fecht and Helmut Seidl.
A faster solver for general systems of equations. Science of Computer Programming, 35(2--3):137--162, 1999. [ bib | .ps.gz ] |
| [606] |
Matthias Felleisen.
The theory and practice of first-class prompts. In Principles of Programming Languages (POPL), pages 180--190, January 1988. [ bib | .pdf ] |
| [607] |
Matthias Felleisen.
On the expressive power of programming languages. Science of Computer Programming, 17(1):35--75, 1991. [ bib | http ] |
| [608] |
Matthias Felleisen and Robert Hieb.
The revised report on the syntactic theories of sequential control and state. Theoretical Computer Science, 103(2):235--271, 1992. [ bib | .pdf ] |
| [609] |
Matthias Felleisen, Mitchell Wand, Daniel P. Friedman, and Bruce F. Duba.
Abstract continuations: A mathematical semantics for handling full jumps. In ACM Symposium on Lisp and Functional Programming (LFP), pages 52--62, July 1988. [ bib | .pdf ] |
| [610] |
J. S. Fenton.
Information protection systems. PhD thesis, University of Cambridge, 1973. [ bib ] |
| [611] |
J. S. Fenton.
Memoryless subsystems. Computer Journal, 17(2):143--147, May 1974. [ bib ] |
| [612] |
Kasra Ferdowsi.
The usability of advanced type systems: Rust as a case study. CoRR, abs/2301.02308, 2023. [ bib | http ] |
| [613] |
Francisco Ferreira and Brigitte Pientka.
Programs using syntax with first-class binders. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 504--529. Springer, April 2017. [ bib | .pdf ] |
| [614] |
Colin J. Fidge.
Logical time in distributed computing systems. Computer, 24(8):28--33, 1991. [ bib | .pdf ] |
| [615] |
John Field and Tim Teitelbaum.
Incremental reduction in the lambda calculus. In ACM Symposium on Lisp and Functional Programming (LFP), pages 307--322, 1990. [ bib ] |
| [616] |
Andrzej Filinski.
Controlling effects. PhD thesis, School of Computer Science, Carnegie Mellon University, May 1996. [ bib | .html ] |
| [617] |
Andrzej Filinski.
Representing layered monads. In Principles of Programming Languages (POPL), pages 175--188, January 1999. [ bib | .ps.gz ] |
| [618] |
Jean-Christophe Filliâtre.
Backtracking iterators. In ACM Workshop on ML, pages 55--62, September 2006. [ bib | .ps.gz ] |
| [619] |
Jean-Christophe Filliâtre.
Deductive software verification. Software Tools for Technology Transfer, 13(5):397--403, 2011. [ bib | http ] |
| [620] |
Jean-Christophe Filliâtre and Sylvain Conchon.
Type-safe modular hash-consing. In ACM Workshop on ML, pages 12--19, September 2006. [ bib | .pdf ] |
| [621] |
Jean-Christophe Filliâtre, Léon Gondelman, and Andrei Paskevich.
The spirit of ghost code. In Computer Aided Verification (CAV), volume 8559 of Lecture Notes in Computer Science, pages 1--16. Springer, July 2014. [ bib | .pdf ] |
| [622] |
Jean-Christophe Filliâtre and Andrei Paskevich.
Why3---where programs meet provers. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 125--128. Springer, March 2013. [ bib | http ] |
| [623] |
Jean-Christophe Filliâtre and Mário Pereira.
A modular way to reason about iteration. In NASA Formal Methods (NFM), volume 9690 of Lecture Notes in Computer Science, pages 322--336. Springer, June 2016. [ bib | http ] |
| [624] |
Jean-Christophe Filliâtre.
Verification of non-functional programs using interpretations in type theory. Journal of Functional Programming, 13(4):709--745, July 2003. [ bib | .ps.gz ] |
| [625] |
Jean-Christophe Filliâtre.
Why: a multi-language multi-prover verification tool. Research Report 1366, LRI, Université Paris Sud, March 2003. [ bib | .ps.gz ] |
| [626] |
Jean-Christophe Filliâtre.
Formal proof of a program: Find. Science of Computer Programming, 64:332--240, 2006. [ bib | .ps.gz ] |
| [627] |
Jean-Christophe Filliâtre and Pierre Letouzey.
Functors for proofs and programs. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 370--384. Springer, March 2004. [ bib | http ] |
| [628] |
Jean-Christophe Filliâtre and Claude Marché.
Multi-prover verification of C programs. In International Conference on Formal Engineering Methods (ICFEM), volume 3308 of Lecture Notes in Computer Science, pages 15--29. Springer, November 2004. [ bib | .ps.gz ] |
| [629] |
Jean-Christophe Filliâtre and Claude Marché.
The Why/Krakatoa/Caduceus platform for deductive program verification. In Computer Aided Verification (CAV), volume 4590 of Lecture Notes in Computer Science, pages 173--177. Springer, July 2007. [ bib | .pdf ] |
| [630] |
Jean-Christophe Filliâtre and Clément Pascutto.
Ortac: Runtime Assertion Checking for OCaml (Tool Paper). In Runtime Verification, pages 244--253. Springer, October 2021. [ bib | http ] |
| [631] |
Jean-Christophe Filliâtre and Andrei Paskevich.
Abstraction and genericity in Why3. In Leveraging Applications of Formal Methods, Verification and Validation (ISoLA), volume 12476 of Lecture Notes in Computer Science, pages 122--142. Springer, October 2020. [ bib | http ] |
| [632] |
Robert Bruce Findler and Matthias Felleisen.
Contracts for higher-order functions. In International Conference on Functional Programming (ICFP), pages 48--59, October 2002. [ bib | .pdf ] |
| [633] |
Adam Fischbach and John Hannan.
Specification and correctness of lambda lifting. Journal of Functional Programming, 13(3):509--543, May 2003. [ bib | http ] |
| [634] |
Michael J. Fischer.
Lambda calculus schemata. In Proceedings of the ACM Conference on Proving Assertions About Programs, pages 104--109, 1972. [ bib | http ] |
| [635] |
Michael J. Fischer.
Lambda-calculus schemata. Lisp and Symbolic Computation, 6(3--4):259--288, 1993. [ bib | http ] |
| [636] |
Kathleen Fisher and John C. Mitchell.
On the relationship between classes, objects and data abstraction. Theory and Practice of Object Systems, 4(1):3--25, 1998. [ bib | .ps ] |
| [637] |
Cormac Flanagan.
Effective static debugging via componential set-based analysis. PhD thesis, Rice University, May 1997. [ bib | .ps.gz ] |
| [638] |
Cormac Flanagan and Martín Abadi.
Types for safe locking. In European Symposium on Programming (ESOP), volume 1576 of Lecture Notes in Computer Science, pages 91--108. Springer, March 1999. [ bib | .pdf ] |
| [639] |
Cormac Flanagan and Matthias Felleisen.
Modular and polymorphic set-based analysis: Theory and practice. Technical Report TR96-266, Rice University, November 1996. [ bib | .ps.gz ] |
| [640] |
Cormac Flanagan and Matthias Felleisen.
Componential set-based analysis. In Programming Language Design and Implementation (PLDI), pages 235--248, 1997. [ bib | .ps.gz ] |
| [641] |
Cormac Flanagan, Matthew Flatt, Shriram Krishnamurthi, Stephanie Weirich, and
Matthias Felleisen.
Catching bugs in the web of program invariants. In Programming Language Design and Implementation (PLDI), 1996. [ bib | .ps.gz ] |
| [642] |
Cormac Flanagan, K. Rustan M. Leino, Mark Lillibridge, Greg Nelson, James B.
Saxe, and Raymie Stata.
Extended static checking for Java. In Programming Language Design and Implementation (PLDI), pages 234--245, 2002. [ bib | .ps ] |
| [643] |
Cormac Flanagan, Amr Sabry, Bruce F. Duba, and Matthias Felleisen.
The essence of compiling with continuations. In Programming Language Design and Implementation (PLDI), pages 237--247, 1993. [ bib | .pdf ] |
| [644] |
Cormac Flanagan and James B. Saxe.
Avoiding exponential explosion: generating compact verification conditions. In Principles of Programming Languages (POPL), pages 193--205, 2001. [ bib | .ps ] |
| [645] |
Matthew Flatt, Gang Yu, Robert Bruce Findler, and Matthias Felleisen.
Adding delimited and composable control to a production programming environment. In International Conference on Functional Programming (ICFP), pages 165--176, October 2007. [ bib | .pdf ] |
| [646] |
R. W. Floyd.
Assigning meanings to programs. In Mathematical Aspects of Computer Science, volume 19 of Proceedings of Symposia in Applied Mathematics, pages 19--32. American Mathematical Society, 1967. [ bib | .pdf ] |
| [647] |
Matthew Fluet.
Monadic and substructural type systems for region-based memory management. PhD thesis, Cornell University, January 2007. [ bib | .pdf ] |
| [648] |
Matthew Fluet and Greg Morrisett.
Monadic regions. Journal of Functional Programming, 16(4--5):485--545, 2006. [ bib | http ] |
| [649] |
Matthew Fluet, Greg Morrisett, and Amal Ahmed.
Linear regions are all you need. In European Symposium on Programming (ESOP), volume 3924 of Lecture Notes in Computer Science, pages 7--21. Springer, March 2006. [ bib | .pdf ] |
| [650] |
Matthew Fluet and Riccardo Pucella.
Phantom types and subtyping. In IFIP International Conference on Theoretical Computer Science (TCS), pages 448--460, August 2002. [ bib | http ] |
| [651] |
Matthew Fluet and Riccardo Pucella.
Phantom types and subtyping. In IFIP International Conference on Theoretical Computer Science (TCS), volume 223 of IFIP Conference Proceedings, pages 448--460. Kluwer, August 2002. [ bib | .ps ] |
| [652] |
Matthew Fluet and Riccardo Pucella.
Practical datatype specializations with phantom types and recursion schemes. In ACM Workshop on ML, Electronic Notes in Theoretical Computer Science, September 2005. [ bib | .pdf ] |
| [653] |
Riccardo Focardi and Roberto Gorrieri.
A classification of security properties for process algebras. Journal of Computer Security, 3(1):5--33, 1995. [ bib | .ps.gz ] |
| [654] |
Bryan Ford.
Packrat parsing: simple, powerful, lazy, linear time. In International Conference on Functional Programming (ICFP), pages 36--47, October 2002. [ bib | .pdf ] |
| [655] |
Bryan Ford.
Parsing expression grammars: a recognition-based syntactic foundation. In Principles of Programming Languages (POPL), pages 111--122, January 2004. [ bib | .pdf ] |
| [656] |
Yannick Forster, Ohad Kammar, Sam Lindley, and Matija Pretnar.
On the expressive power of user-defined effects: Effect handlers, monadic reflection, delimited control. Journal of Functional Programming, 29:e15, 2019. [ bib | http ] |
| [657] |
Jeffrey S. Foster and Alex Aiken.
Checking programmer-specified non-aliasing. Technical Report UCB//CSD-01-1160, University of California, Berkeley, October 2001. [ bib | .pdf ] |
| [658] |
Jeffrey S. Foster, Tachio Terauchi, and Alex Aiken.
Flow-sensitive type qualifiers. In Programming Language Design and Implementation (PLDI), pages 1--12, June 2002. [ bib | .pdf ] |
| [659] |
Cédric Fournet and Georges Gonthier.
The reflexive chemical abstract machine and the join-calculus. In Principles of Programming Languages (POPL), pages 372--385, January 1996. [ bib | http ] |
| [660] |
Cédric Fournet and Andrew D. Gordon.
Stack inspection: Theory and variants. In Principles of Programming Languages (POPL), pages 307--318, January 2002. [ bib | .ps ] |
| [661] |
Cédric Fournet and Andrew D. Gordon.
Stack inspection: Theory and variants. ACM Transactions on Programming Languages and Systems, 25(3):360--399, May 2003. [ bib | http ] |
| [662] |
Cédric Fournet, Cosimo Laneve, Luc Maranget, and Didier Rémy.
Inheritance in the join calculus. Journal of Logic and Algebraic Programming, 57(2):23--69, 2003. [ bib | .pdf ] |
| [663] |
Cédric Fournet, Luc Maranget, Cosimo Laneve, and Didier Rémy.
Implicit typing à la ML for the join-calculus. In International Conference on Concurrency Theory (CONCUR), volume 1243 of Lecture Notes in Computer Science, pages 196--212. Springer, 1997. [ bib | .pdf ] |
| [664] |
Adrian Francalanza, Julian Rathke, and Vladimiro Sassone.
Permission-based separation logic for message-passing concurrency. Logical Methods in Computer Science, 7(3), 2011. [ bib | http ] |
| [665] |
Nissim Francez.
Product properties and their direct verification. Acta Informatica, 20:329--344, 1983. [ bib | http ] |
| [666] |
Michael Fredman and Michael Saks.
The cell probe complexity of dynamic data structures. In Annual Symposium on Theory of Computing (STOC), pages 345--354. ACM, May 1989. [ bib | http ] |
| [667] |
Michael L. Fredman and Robert Endre Tarjan.
Fibonacci heaps and their uses in improved network optimization algorithms. Journal of the ACM, 34(3):596--615, 1987. [ bib | http ] |
| [668] |
Tim Freeman and Frank Pfenning.
Refinement types for ML. In Programming Language Design and Implementation (PLDI), pages 268--277, 1991. [ bib | .pdf ] |
| [669] |
Alexandre Frey.
Satisfying subtype inequalities in polynomial space. In Static Analysis Symposium (SAS), number 1302 in Lecture Notes in Computer Science, pages 265--277. Springer, September 1997. [ bib | .html ] |
| [670] |
Alexandre Frey.
Approche algébrique du typage d'un langage à la ML avec objets, sous-typage et multi-méthodes. PhD thesis, École des Mines de Paris, June 2004. [ bib | .pdf ] |
| [671] |
Daniel P. Friedman and Mitchell Wand.
Essentials of programming languages, 3rd edition. MIT Press, 2008. [ bib | http ] |
| [672] |
Daniel P. Friedman and David S. Wise.
Unwinding stylized recursions into iterations. Technical Report 19, Computer Science Department, Indiana University, Bloomington, 1975. [ bib | .pdf ] |
| [673] |
Matteo Frigo and Steven G. Johnson.
The design and implementation of FFTW3. Proceedings of the IEEE, 93(2):216--231, 2005. [ bib | .pdf ] |
| [674] |
Alain Frisch, Giuseppe Castagna, and Véronique Benzaken.
Semantic subtyping. In Logic in Computer Science (LICS), pages 137--146, July 2002. [ bib | .ps.gz ] |
| [675] |
Alain Frisch, Giuseppe Castagna, and Véronique Benzaken.
Semantic subtyping: Dealing set-theoretically with function, union, intersection, and negation types. Journal of the ACM, 55(4), 2008. [ bib | .pdf ] |
| [676] |
Aymeric Fromherz.
A proof-oriented approach to low-level, high-assurance programming. PhD thesis, Carnegie Mellon University, December 2021. [ bib | .pdf ] |
| [677] |
Aymeric Fromherz, Aseem Rastogi, Nikhil Swamy, Sydney Gibson, Guido
Martínez, Denis Merigoux, and Tahina Ramananandro.
Steel: proof-oriented programming in a dependently typed concurrent separation logic. Proceedings of the ACM on Programming Languages, 5(ICFP):1--30, 2021. [ bib | http ] |
| [678] |
Dan Frumin, Léon Gondelman, and Robbert Krebbers.
Semi-automated reasoning about non-determinism in C expressions. In European Symposium on Programming (ESOP), volume 11423 of Lecture Notes in Computer Science, pages 60--87. Springer, April 2019. [ bib | .pdf ] |
| [679] |
Dan Frumin, Robbert Krebbers, and Lars Birkedal.
ReLoC: A mechanised relational logic for fine-grained concurrency. In Logic in Computer Science (LICS), pages 442--451, July 2018. [ bib | .pdf ] |
| [680] |
Dan Frumin, Robbert Krebbers, and Lars Birkedal.
ReLoC reloaded: A mechanized relational logic for fine-grained concurrency and logical atomicity. Logical Methods in Computer Science, 17(3), 2021. [ bib | http ] |
| [681] |
Dan Frumin, Amin Timany, and Lars Birkedal.
Modular denotational semantics for effects with guarded interaction trees. Proceedings of the ACM on Programming Languages, 8(POPL):332--361, 2024. [ bib | http ] |
| [682] |
Ming Fu, Yong Li, Xinyu Feng, Zhong Shao, and Yu Zhang.
Reasoning about optimistic concurrency using a program logic for history. In International Conference on Concurrency Theory (CONCUR), volume 6269 of Lecture Notes in Computer Science, pages 388--402. Springer, 2010. [ bib | http ] |
| [683] |
You-Chin Fuh and Prateek Mishra.
Type inference with subtypes. In European Symposium on Programming (ESOP), volume 300 of Lecture Notes in Computer Science, pages 94--114. Springer, 1988. [ bib | http ] |
| [684] |
You-Chin Fuh and Prateek Mishra.
Polymorphic subtype inference: Closing the theory-practice gap. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 167--183. Springer, March 1989. [ bib | http ] |
| [685] |
Jun Furuse.
Extensional polymorphism by flow graph dispatching. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science. Springer, November 2003. [ bib | .ps.gz ] |
| [686] |
Jun P. Furuse and Jacques Garrigue.
A label-selective lambda-calculus with optional arguments and its compilation method. RIMS Preprint 1041, Kyoto University, October 1995. [ bib | .pdf ] |
| [687] |
Manuel Fähndrich.
Bane: A library for scalable constraint-based program analysis. PhD thesis, University of California at Berkeley, 1999. [ bib | .pdf ] |
| [688] |
Manuel Fähndrich, Mark Aiken, Chris Hawblitzel, Orion Hodson, Galen Hunt,
James R. Larus, and Steven Levi.
Language support for fast and reliable message-based communication in Singularity OS. In EuroSys, pages 177--190, 2006. [ bib | .pdf ] |
| [689] |
Manuel Fähndrich and Robert DeLine.
Adoption and focus: practical linear types for imperative programming. In Programming Language Design and Implementation (PLDI), pages 13--24, June 2002. [ bib | .pdf ] |
| [690] |
Manuel Fähndrich, Jeffrey S. Foster, Zhendong Su, and Alexander S. Aiken.
Partial online cycle elimination in inclusion constraint graphs. In Programming Language Design and Implementation (PLDI), pages 85--96, June 1998. [ bib | .pdf ] |
| [691] |
Manuel Fähndrich and Rustan Leino.
Heap monotonic typestates. In International Workshop on Alias Confinement and Ownership (IWACO), July 2003. [ bib | .pdf ] |
| [692] |
Manuel Fähndrich, Jakob Rehof, and Manuvir Das.
Scalable context-sensitive flow analysis using instantiation constraints. In Programming Language Design and Implementation (PLDI), June 2000. [ bib | .ps ] |
| [693] |
Murdoch J. Gabbay.
A theory of inductive definitions with α-equivalence. PhD thesis, Cambridge University, 2001. [ bib | .pdf ] |
| [694] |
Murdoch J. Gabbay.
A general mathematics of names in syntax. Submitted for publication, March 2004. [ bib | .pdf ] |
| [695] |
Murdoch J. Gabbay and Andrew M. Pitts.
A new approach to abstract syntax with variable binding. Formal Aspects of Computing, 13(3--5):341--363, July 2002. [ bib | .pdf ] |
| [696] |
Lennard Gäher, Michael Sammler, Simon Spies, Ralf Jung, Hoang-Hai Dang,
Robbert Krebbers, Jeehoon Kang, and Derek Dreyer.
Simuliris: a separation logic framework for verifying concurrent program optimizations. Proceedings of the ACM on Programming Languages, 6(POPL):1--31, 2022. [ bib | http ] |
| [697] |
Zvi Galil and Giuseppe F. Italiano.
Data structures and algorithms for disjoint set union problems. ACM Computing Surveys, 23(3):319--344, 1991. [ bib | http ] |
| [698] |
Bernard A. Galler and Michael J. Fischer.
An improved equivalence algorithm. Communications of the ACM, 7(5):301--303, 1964. [ bib | http ] |
| [699] |
Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides.
Design patterns: Elements of reusable object-oriented software. Addison-Wesley, 1995. [ bib ] |
| [700] |
Vladimir Gapeyev, Michael Levin, and Benjamin Pierce.
Recursive subtyping revealed. Journal of Functional Programming, 12(6):511--548, November 2002. [ bib | http ] |
| [701] |
Diego Garbervetsky, Sergio Yovine, Víctor A. Braberman, Martín
Rouaux, and Alejandro Taboada.
Quantitative dynamic-memory analysis for Java. Concurrency and Computation Practice and Experience, 23(14):1665--1678, 2011. [ bib | http ] |
| [702] |
Philippa Gardner, Gian Ntzik, and Adam Wright.
Local reasoning for the POSIX file system. In European Symposium on Programming (ESOP), volume 8410 of Lecture Notes in Computer Science, pages 169--188. Springer, April 2014. [ bib | .pdf ] |
| [703] |
Michael R. Garey and David S. Johnson.
Computers and intractability: A guide to the theory of NP-completeness. W. H. Freeman and Company, 1979. [ bib ] |
| [704] |
Jacques Garrigue.
Programming with polymorphic variants. In ACM Workshop on ML, September 1998. [ bib | .ps.gz ] |
| [705] |
Jacques Garrigue.
Code reuse through polymorphic variants. In Workshop on Foundations of Software Engineering, November 2000. [ bib | .ps.gz ] |
| [706] |
Jacques Garrigue.
Simple type inference for structural polymorphism. In Foundations of Object-Oriented Languages (FOOL), January 2002. [ bib | .ps.gz ] |
| [707] |
Jacques Garrigue.
Relaxing the value restriction. In Functional and Logic Programming, volume 2998 of Lecture Notes in Computer Science, pages 196--213. Springer, April 2004. [ bib | .pdf ] |
| [708] |
Jacques Garrigue.
A certified implementation of ML with structural polymorphism and recursive types. Mathematical Structures in Computer Science, 25(4):867--891, 2015. [ bib | .pdf ] |
| [709] |
Jacques Garrigue and Didier Rémy.
Extending ML with semi-explicit higher-order polymorphism. Information and Computation, 155(1):134--169, 1999. [ bib | .pdf ] |
| [710] |
Jacques Garrigue and Didier Rémy.
Ambivalent types for principal type inference with GADTs. In Asian Symposium on Programming Languages and Systems (APLAS), December 2013. [ bib | .pdf ] |
| [711] |
Benedict R. Gaster.
Records, variants and qualified types. PhD thesis, University of Nottingham, July 1998. [ bib | .ps ] |
| [712] |
Benedict R. Gaster and Mark P. Jones.
A polymorphic type system for extensible records and variants. Technical Report NOTTCS-TR-96-3, Department of Computer Science, University of Nottingham, November 1996. [ bib | .html ] |
| [713] |
Nadji Gauthier and François Pottier.
Numbering matters: First-order canonical forms for second-order recursive types. In International Conference on Functional Programming (ICFP), pages 150--161, September 2004. [ bib | .pdf ] |
| [714] |
Simon J. Gay, Vasco Thudichum Vasconcelos, António Ravara, Nils Gesbert,
and Alexandre Z. Caldeira.
Modular session types for distributed object-oriented programming. In Principles of Programming Languages (POPL), pages 299--312, January 2010. [ bib | .pdf ] |
| [715] |
Steven German, Edmund Clarke, and Joseph Halpern.
Reasoning about procedures as parameters. In Logic of Programs, volume 164 of Lecture Notes in Computer Science, pages 206--220. Springer, 1983. [ bib | http ] |
| [716] |
Alfons Geser, Jens Knoop, Gerald Lüttgen, Oliver Rüthing, and Bernhard
Steffen.
Chaotic fixed point iterations. MIP-Bericht 9403, Fakultät für Mathematik und Informatik, Universität Passau, 1994. [ bib | .html ] |
| [717] |
Giorgio Ghelli.
Divergence of F<= type checking. Theoretical Computer Science, 139(1--2):131--162, March 1995. [ bib | .ps.gz ] |
| [718] |
Cristian Gherghina, Cristina David, Shengchao Qin, and Wei-Ngan Chin.
Structured specifications for better verification of heap-manipulating programs. In Formal Methods (FM), volume 6664 of Lecture Notes in Computer Science, pages 386--401. Springer, June 2011. [ bib | .pdf ] |
| [719] |
Jeremy Gibbons.
Datatype-generic programming. In International Spring School on Datatype-Generic Programming, volume 4719 of Lecture Notes in Computer Science, pages 1--71. Springer, April 2006. [ bib | .pdf ] |
| [720] |
Jeremy Gibbons and Ralf Hinze.
Just do it: simple monadic equational reasoning. In International Conference on Functional Programming (ICFP), pages 2--14, September 2011. [ bib | .pdf ] |
| [721] |
Jürgen Giesl, Cornelius Aschermann, Marc Brockschmidt, Fabian Emmes,
Florian Frohn, Carsten Fuhs, Jera Hensel, Carsten Otto, Martin Plücker,
Peter Schneider-Kamp, Thomas Ströder, Stephanie Swiderski, and René
Thiemann.
Analyzing program termination and complexity automatically with AProVE. Journal of Automated Reasoning, 58(1):3--31, 2017. [ bib | .pdf ] |
| [722] |
David K. Gifford, Pierre Jouvelot, John M. Lucassen, and Mark A. Sheldon.
FX-87 reference manual. Technical Report MIT/LCS/TR-407, Massachusetts Institute of Technology, January 1987. [ bib ] |
| [723] |
David K. Gifford, Pierre Jouvelot, Mark A. Sheldon, and James W. O'Toole.
Report on the FX-91 programming language. Technical Report MIT/LCS/TR-531, Massachusetts Institute of Technology, February 1992. [ bib | http ] |
| [724] |
Jean-Yves Girard.
Interprétation fonctionnelle et élimination des coupures de l'arithmétique d'ordre supérieur. Thèse d'état, Université Paris 7, June 1972. [ bib | .pdf ] |
| [725] |
Jean-Yves Girard.
Linear logic. Theoretical Computer Science, 50(1):1--102, 1987. [ bib | .pdf ] |
| [726] |
Jean-Yves Girard, Yves Lafont, and Paul Taylor.
Proofs and types. Cambridge University Press, 1990. [ bib | .pdf ] |
| [727] |
Neal Glew.
Object closure conversion. In Higher Order Operational Techniques in Semantics (HOOTS), volume 26 of Electronic Notes in Theoretical Computer Science, pages 52--68, September 1999. [ bib | .ps.gz ] |
| [728] |
Neal Glew.
An efficient class and object encoding. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 311--324, October 2000. [ bib | .ps.gz ] |
| [729] |
Neal Glew.
A theory of second-order trees. In European Symposium on Programming (ESOP), volume 2305 of Lecture Notes in Computer Science, pages 147--161. Springer, April 2002. [ bib | .pdf ] |
| [730] |
Andreas Goerdt.
A Hoare calculus for functions defined by recursion on higher types. In Logic of Programs, volume 193 of Lecture Notes in Computer Science, pages 106--117. Springer, 1985. [ bib | http ] |
| [731] |
Joseph Goguen and José Meseguer.
Security policies and security models. In IEEE Symposium on Security and Privacy (S&P), pages 11--20, April 1982. [ bib ] |
| [732] |
Alejandro Gómez-Londoño and Magnus O. Myreen.
A flat reachability-based measure for CakeML's cost semantics. In Implementation of Functional Languages (IFL), pages 1--9, September 2021. [ bib | http ] |
| [733] |
Alejandro Gómez-Londoño, Johannes Åman Pohjola, Hira Taqdees
Syeda, Magnus O. Myreen, and Yong Kiam Tan.
Do you have space for dessert? A verified space cost semantics for CakeML programs. Proceedings of the ACM on Programming Languages, 4(OOPSLA):204:1--204:29, 2020. [ bib | http ] |
| [734] |
Sergey Goncharov and Lutz Schröder.
A relatively complete generic hoare logic for order-enriched effects. In Logic in Computer Science (LICS), pages 273--282, June 2013. [ bib | http ] |
| [735] |
Li Gong, Gary Ellison, and Mary Dageforde.
Inside Java 2 platform security, second edition. Addison-Wesley, 2003. [ bib | http ] |
| [736] |
Li Gong, Marianne Mueller, Hemma Prafullchandra, and Roland Schemers.
Going beyond the sandbox: An overview of the new security architecture in the Java Development Kit 1.2. In USENIX Symposium on Internet Technologies and Systems, pages 103--112, December 1997. [ bib | .ps ] |
| [737] |
Li Gong and Roland Schemers.
Implementing protection domains in the Java development kit 1.2. In Internet Society Symposium on Network and Distributed System Security, March 1998. [ bib | .pdf ] |
| [738] |
John B. Goodenough.
Exception handling: Issues and a proposed notation. Communications of the ACM, 18(12):683--696, 1975. [ bib | .pdf ] |
| [739] |
John B. Goodenough.
Structured exception handling. In Principles of Programming Languages (POPL), pages 204--224, January 1975. [ bib | http ] |
| [740] |
Andrew D. Gordon and Tom Melham.
Five axioms of alpha-conversion. In Theorem Proving in Higher Order Logics (TPHOLs), volume 1125 of Lecture Notes in Computer Science, pages 173--191. Springer, August 1996. [ bib | .ps.gz ] |
| [741] |
Colin S. Gordon, Matthew J. Parkinson, Jared Parsons, Aleks Bromfield, and Joe
Duffy.
Uniqueness and reference immutability for safe parallelism. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 21--40, October 2012. [ bib | .pdf ] |
| [742] |
Donald Gordon and James Noble.
Dynamic ownership in a dynamic language. In Symposium on Dynamic Languages, pages 41--52, 2007. [ bib | http ] |
| [743] |
James Gosling, Bill Joy, Guy Steele, and Gilad Bracha.
The Java language specification, second edition. Addison-Wesley, 2000. [ bib | http ] |
| [744] |
Alexey Gotsman, Josh Berdine, and Byron Cook.
Precision and the conjunction rule in concurrent separation logic. Electronic Notes in Theoretical Computer Science, 276:171--190, 2011. [ bib | .pdf ] |
| [745] |
Alexey Gotsman, Josh Berdine, Byron Cook, Noam Rinetzky, and Mooly Sagiv.
Local reasoning for storable locks and threads. In Asian Symposium on Programming Languages and Systems (APLAS), volume 4807 of Lecture Notes in Computer Science, pages 19--37. Springer, November 2007. [ bib | http ] |
| [746] |
Alexey Gotsman, Josh Berdine, Byron Cook, Noam Rinetzky, and Mooly Sagiv.
Local reasoning for storable locks and threads. Technical Report MSR-TR-2007-39, Microsoft Research, September 2007. [ bib | .pdf ] |
| [747] |
Alexey Gotsman, Noam Rinetzky, and Hongseok Yang.
Verifying concurrent memory reclamation algorithms with grace. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 249--269. Springer, March 2013. [ bib | .pdf ] |
| [748] |
Jean Goubault.
Inférence d'unités physiques en ML. In Journées Françaises des Langages Applicatifs (JFLA), pages 3--20, 1994. [ bib ] |
| [749] |
Ronald L. Graham, Donald E. Knuth, and Oren Patashnik.
Concrete mathematics: a foundation for computer science. Addison-Wesley, 1994. [ bib | .html ] |
| [750] |
David Gries.
Describing an algorithm by Hopcroft. Acta Informatica, 2:97--109, 1973. [ bib | http ] |
| [751] |
Andreas Griewank and Andrea Walther.
Evaluating derivatives -- principles and techniques of algorithmic differentiation, second edition. SIAM, 2008. [ bib | http ] |
| [752] |
Jessica Gronski, Kenneth Knowles, Aaron Tomb, Stephen N. Freund, and Cormac
Flanagan.
Sage: Hybrid checking for flexible specifications. In Scheme and Functional Programming, pages 93--104, September 2006. [ bib | .pdf ] |
| [753] |
Josef Grosch.
Efficient and comfortable error recovery in recursive descent parsers. Structured Programming, 11(3):129--140, 1990. [ bib | .pdf ] |
| [754] |
Jessie Grosen, David M. Kahn, and Jan Hoffmann.
Automatic amortized resource analysis with regular recursive types. In Logic in Computer Science (LICS), pages 1--14, 2023. [ bib | .pdf ] |
| [755] |
Dan Grossman.
Quantified types in an imperative language. ACM Transactions on Programming Languages and Systems, 28(3):429--475, May 2006. [ bib | .pdf ] |
| [756] |
Dan Grossman, Greg Morrisett, Trevor Jim, Michael Hicks, Yanling Wang, and
James Cheney.
Region-based memory management in Cyclone. In Programming Language Design and Implementation (PLDI), pages 282--293, June 2002. [ bib | .pdf ] |
| [757] |
Dick Grune and Ceriel J. H. Jacobs.
Parsing techniques: a practical guide. Ellis Horwood, 1990. [ bib | http ] |
| [758] |
Dick Grune and Ceriel J. H. Jacobs.
Parsing techniques: a practical guide, second edition. Monographs in computer science. Springer, 2008. [ bib | http ] |
| [759] |
Adrien Guatto.
A generalized modality for recursion. In Logic in Computer Science (LICS), pages 482--491, 2018. [ bib | http ] |
| [760] |
Armaël Guéneau.
Mechanized verification of the correctness and asymptotic complexity of programs. PhD thesis, Université de Paris, December 2019. [ bib | http ] |
| [761] |
Louis-Julien Guillemette and Stefan Monnier.
A type-preserving closure conversion in Haskell. In Haskell workshop, pages 83--92, September 2007. [ bib | .pdf ] |
| [762] |
Louis-Julien Guillemette and Stefan Monnier.
Type-safe code transformations in Haskell. Electronic Notes in Theoretical Computer Science, 174(7):23--39, 2007. [ bib | http ] |
| [763] |
Louis-Julien Guillemette and Stefan Monnier.
One vote for type families in Haskell! In Trends in Functional Programming (TFP), 2008. [ bib | .pdf ] |
| [764] |
Louis-Julien Guillemette and Stefan Monnier.
A type-preserving compiler in Haskell. In International Conference on Functional Programming (ICFP), pages 75--86, September 2008. [ bib | .pdf ] |
| [765] |
Sumit Gulwani.
SPEED: symbolic complexity bound analysis. In Computer Aided Verification (CAV), volume 5643 of Lecture Notes in Computer Science, pages 51--62. Springer, July 2009. [ bib | http ] |
| [766] |
Sumit Gulwani, Krishna K. Mehra, and Trishul M. Chilimbi.
SPEED: precise and efficient static estimation of program computational complexity. In Principles of Programming Languages (POPL), pages 127--139, January 2009. [ bib | http ] |
| [767] |
Adam Gundry.
Type inference, Haskell and dependent types. PhD thesis, University of Strathclyde, 2013. [ bib | http ] |
| [768] |
Adam Gundry, Conor McBride, and James McKinna.
Type inference in context. In Workshop on Mathematically Structured Functional Programming (MSFP), pages 43--54, September 2010. [ bib | http ] |
| [769] |
Kartik Gupta and V. Krishna Nandivada.
Lexical state analyzer for JavaCC grammars. Software: Practice and Experience, 2015. [ bib | http ] |
| [770] |
Jörgen Gustavsson and Josef Svenningsson.
Constraint abstractions. In Symposium on Programs as Data Objects, volume 2053 of Lecture Notes in Computer Science. Springer, May 2001. [ bib | .pdf ] |
| [771] |
Juan Carlos Guzmán and Ascánder Suárez.
An extended type system for exceptions. In ACM Workshop on ML and its Applications, number 2265 in INRIA Research Reports, pages 127--135. INRIA, June 1994. [ bib ] |
| [772] |
Armaël Guéneau, Arthur Charguéraud, and François Pottier.
A fistful of dollars: Formalizing asymptotic complexity claims via deductive program verification. In European Symposium on Programming (ESOP), volume 10801 of Lecture Notes in Computer Science, pages 533--560. Springer, April 2018. [ bib | .pdf ] |
| [773] |
Armaël Guéneau, Jacques-Henri Jourdan, Arthur Charguéraud, and François
Pottier.
Formal proof and analysis of an incremental cycle detection algorithm. In Interactive Theorem Proving (ITP), volume 141 of Leibniz International Proceedings in Informatics, pages 18:1--18:20, September 2019. [ bib | .pdf ] |
| [774] |
Armaël Guéneau, Magnus O. Myreen, Ramana Kumar, and Michael Norrish.
Verified characteristic formulae for CakeML. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 584--610. Springer, April 2017. [ bib | .pdf ] |
| [775] |
Armaël Guéneau, François Pottier, and Jonathan Protzenko.
The ins and outs of iteration in Mezzo. Higher-Order Programming and Effects (HOPE), September 2013. http://goo.gl/NrgKc4. [ bib ] |
| [776] |
Christian Haack, Marieke Huisman, and Clément Hurlin.
Reasoning about Java's reentrant locks. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5356 of Lecture Notes in Computer Science, pages 171--187. Springer, December 2008. [ bib | .pdf ] |
| [777] |
Christian Haack and Clément Hurlin.
Resource usage protocols for iterators. Journal of Object Technology, 8(4):55--83, 2009. [ bib | .pdf ] |
| [778] |
Christian Haack and J. B. Wells.
Type error slicing in implicitly typed, higher-order languages. In European Symposium on Programming (ESOP), volume 2618 of Lecture Notes in Computer Science. Springer, 2003. [ bib | .pdf ] |
| [779] |
Jennifer Hackett and Graham Hutton.
Call-by-need is clairvoyant call-by-value. Proceedings of the ACM on Programming Languages, 3(ICFP):114:1--114:23, 2019. [ bib | http ] |
| [780] |
Matthew Hague and C.-H. Luke Ong.
Symbolic backwards-reachability analysis for higher-order pushdown systems. Logical Methods in Computer Science, 4(4), 2008. [ bib | http ] |
| [781] |
Cordelia Hall, Kevin Hammond, Simon Peyton Jones, and Philip Wadler.
Type classes in Haskell. In European Symposium on Programming (ESOP), volume 788 of Lecture Notes in Computer Science, pages 241--256. Springer, April 1994. [ bib | .ps.gz ] |
| [782] |
Cordelia Hall, Kevin Hammond, Simon Peyton Jones, and Philip Wadler.
Type classes in Haskell. ACM Transactions on Programming Languages and Systems, 18(2):109--138, March 1996. [ bib | http ] |
| [783] |
Philipp Haller and Martin Odersky.
Capabilities for uniqueness and borrowing. In European Conference on Object-Oriented Programming (ECOOP), volume 6183 of Lecture Notes in Computer Science, pages 354--378. Springer, June 2010. [ bib | .pdf ] |
| [784] |
Joseph J. Hallett and Assaf J. Kfoury.
Programming examples needing polymorphic recursion. Technical Report BUCS-TR-2004-004, Department of Computer Science, Boston University, January 2004. [ bib | .pdf ] |
| [785] |
Thomas Hallgren, James Hook, Mark P. Jones, and Richard Kieburtz.
An overview of the Programatica ToolSet. High Confidence Software and Systems Conference (HCSS), 2004. [ bib | .pdf ] |
| [786] |
Travis Hance, Andrea Lattuada, Chris Hawblitzel, Jon Howell, Rob Johnson, and
Bryan Parno.
Storage systems are distributed systems (so verify them that way!). In Symposium on Operating Systems Design and Implementation, pages 99--115, November 2020. [ bib | .pdf ] |
| [787] |
Martin A. T. Handley, Niki Vazou, and Graham Hutton.
Liquidate your assets: reasoning about resource usage in Liquid Haskell. Proceedings of the ACM on Programming Languages, 4(POPL):24:1--24:27, 2020. [ bib | http ] |
| [788] |
Michael Hanus.
Horn clause specifications with polymorphic types. PhD thesis, Fachbereich Informatik, Universität Dortmund, 1988. [ bib | .dvi.Z ] |
| [789] |
Michael Hanus.
Horn clause programs with polymorphic types: Semantics and resolution. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 225--240. Springer, 1989. [ bib | .ps ] |
| [790] |
Norm Hardy.
The confused deputy (or why capabilities might have been invented). ACM Operating Systems Review, 22(4):36--38, October 1988. [ bib | .html ] |
| [791] |
Gregory C. Harfst and Edward M. Reingold.
A potential-based amortized analysis of the union-find data structure. SIGACT News, 31(3):86--95, 2000. [ bib | http ] |
| [792] |
Bob Harper and Mark Lillibridge.
ML with callcc is unsound. Message to the TYPES mailing list, July 1991. [ bib | .html ] |
| [793] |
Robert Harper.
A simplified account of polymorphic references. Information Processing Letters, 51(4):201--206, 1994. [ bib | .pdf ] |
| [794] |
Robert Harper.
Proof-directed debugging. Journal of Functional Programming, 9(4):463--469, 1999. [ bib | http ] |
| [795] |
Robert Harper, Furio Honsell, and Gordon D. Plotkin.
A framework for defining logics. Journal of the ACM, 40(1):143--184, 1993. [ bib | .pdf ] |
| [796] |
Robert Harper and Daniel R. Licata.
Mechanizing metatheory in a logical framework. Journal of Functional Programming, 17(4--5):613--673, 2007. [ bib | .pdf ] |
| [797] |
Robert Harper and Mark Lillibridge.
Polymorphic type assignment and CPS conversion. Lisp and Symbolic Computation, 6(3--4):361--380, 1993. [ bib | .pdf ] |
| [798] |
Robert Harper and Benjamin Pierce.
A record calculus based on symmetric concatenation. In Principles of Programming Languages (POPL), pages 131--142, January 1991. [ bib | .ps ] |
| [799] |
Robert Harper and Benjamin C. Pierce.
Design considerations for ML-style module systems. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 8, pages 293--345. MIT Press, 2005. [ bib ] |
| [800] |
John Harrison.
Handbook of practical logic and automated reasoning. Cambridge University Press, 2009. [ bib | http ] |
| [801] |
Michael A. Harrison, Walter L. Ruzzo, and Jeffrey D. Ullman.
Protection in operating systems. Communications of the ACM, 19(8):461--471, August 1976. [ bib | http ] |
| [802] |
William L. Harrison.
The essence of multitasking. In International Conference on Algebraic Methodology and Software Technology (AMAST), volume 4019 of Lecture Notes in Computer Science, pages 158--172. Springer, July 2006. [ bib | http ] |
| [803] |
Philipp G. Haselwarter, Exequiel Rivas, Antoine Van Muylder, Théo
Winterhalter, Carmine Abate, Nikolaj Sidorenco, Catalin Hritcu, Kenji
Maillard, and Bas Spitters.
SSProve: A foundational framework for modular cryptographic proofs in Coq. ACM Transactions on Programming Languages and Systems, 45(3):15:1--15:61, 2023. [ bib | http ] |
| [804] |
Maximilian P. L. Haslbeck and Peter Lammich.
For a few dollars more - verified fine-grained algorithm analysis down to LLVM. In European Symposium on Programming (ESOP), volume 12648 of Lecture Notes in Computer Science, pages 292--319. Springer, March 2021. [ bib | .pdf ] |
| [805] |
Maximilian P. L. Haslbeck and Tobias Nipkow.
Hoare logics for time bounds: A study in meta theory. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 10805 of Lecture Notes in Computer Science, pages 155--171. Springer, April 2018. [ bib | .pdf ] |
| [806] |
Ichiro Hasuo.
Generic weakest precondition semantics from monads enriched with order. Theoretical Computer Science, 604:2--29, 2015. [ bib | http ] |
| [807] |
Chris Hawblitzel.
Linear types for aliased resources. Technical Report MSR-TR-2005-141, Microsoft Research, October 2005. [ bib | .pdf ] |
| [808] |
Chris Hawblitzel and Erez Petrank.
Automated verification of practical garbage collectors. Logical Methods in Computer Science, 6(3), 2010. [ bib | http ] |
| [809] |
Guanhua He, Shengchao Qin, Chenguang Luo, and Wei-Ngan Chin.
Memory usage verification using Hip/Sleek. In Automated Technology for Verification and Analysis (ATVA), volume 5799 of Lecture Notes in Computer Science, pages 166--181. Springer, October 2009. [ bib | http ] |
| [810] |
Mengda He, Viktor Vafeiadis, Shengchao Qin, and João F. Ferreira.
GPS++: Reasoning about fences and relaxed atomics. International Journal of Parallel Programming, 46(6):1157--1183, 2018. [ bib | .pdf ] |
| [811] |
Matthew S. Hecht and Jeffrey D. Ullman.
Analysis of a simple algorithm for global data flow problems. In Principles of Programming Languages (POPL), pages 207--217, 1973. [ bib | http ] |
| [812] |
Bastiaan Heeren.
Top quality type error messages. PhD thesis, Utrecht University, 2005. [ bib | http ] |
| [813] |
Bastiaan Heeren and Jurriaan Hage.
Parametric type inferencing for Helium. Technical Report UU-CS-2002-035, University of Utrecht, Institute of Information and Computing Science, August 2002. [ bib | .pdf ] |
| [814] |
Bastiaan Heeren, Jurriaan Hage, and Doaitse Swierstra.
Generalizing Hindley-Milner type inference algorithms. Technical Report UU-CS-2002-031, University of Utrecht, Institute of Information and Computing Science, July 2002. [ bib | .pdf ] |
| [815] |
Bastiaan Heeren, Johan Jeuring, Doaitse Swierstra, and Pablo Azero Alcocer.
Improving type-error messages in functional languages. Technical Report UU-CS-2002-009, University of Utrecht, Institute of Information and Computing Science, February 2002. [ bib | .pdf ] |
| [816] |
Eric C. R. Hehner.
Abstractions of time, pages 191--210. Prentice Hall, 1994. [ bib | .pdf ] |
| [817] |
Eric C. R. Hehner.
Formalization of time and space. Formal Aspects of Computing, 10:290--206, 1998. [ bib | .pdf ] |
| [818] |
Nevin Heintze.
Set based analysis of ML programs. Technical Report CMU-CS-93-193, Carnegie Mellon University, School of Computer Science, July 1993. [ bib | .ps ] |
| [819] |
Nevin Heintze and David McAllester.
Linear-time subtransitive control flow analysis. In Programming Language Design and Implementation (PLDI), pages 261--272, 1997. [ bib | .ps ] |
| [820] |
Nevin Heintze and Jon G. Riecke.
The SLam calculus: Programming with secrecy and integrity. In Principles of Programming Languages (POPL), pages 365--377, January 1998. [ bib | .ps ] |
| [821] |
Nevin Heintze and Olivier Tardieu.
Ultra-fast aliasing analysis using CLA: A million lines of C code in a second. In Programming Language Design and Implementation (PLDI), pages 254--263, 2001. [ bib | .ps ] |
| [822] |
Simon Helsen and Peter Thiemann.
Syntactic type soundness for the region calculus. In Higher Order Operational Techniques in Semantics (HOOTS), volume 41(3) of Electronic Notes in Theoretical Computer Science, pages 1--19, 2000. [ bib | .pdf ] |
| [823] |
Fergus Henderson.
Strong modes can change the world! Technical Report 96/11, Department of Computer Science, University of Melbourne, November 1992. [ bib | .ps.gz ] |
| [824] |
Dimitri Hendriks and Vincent van Oostrom.
adbmal. In International Conference on Automated Deduction (CADE), volume 2741 of Lecture Notes in Computer Science, pages 136--150. Springer, August 2003. [ bib | http ] |
| [825] |
Dimitri Hendriks and Vincent van Oostrom.
Adbmal. In International Conference on Automated Deduction (CADE), volume 2741 of Lecture Notes in Computer Science, pages 136--150. Springer, 2003. [ bib | http ] |
| [826] |
Fritz Henglein.
Polymorphic type inference and semi-unification. PhD thesis, Rutgers University, April 1989. [ bib | .ps.gz ] |
| [827] |
Fritz Henglein.
Efficient type inference for higher-order binding-time analysis. In Functional Programming Languages and Computer Architecture (FPCA), volume 523 of Lecture Notes in Computer Science, pages 448--472. Springer, 1991. [ bib | .dvi.gz ] |
| [828] |
Fritz Henglein.
Type inference with polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):253--289, April 1993. [ bib | http ] |
| [829] |
Fritz Henglein.
Breaking through the n3 barrier: Faster object type inference. In Foundations of Object-Oriented Languages (FOOL), 1997. [ bib ] |
| [830] |
Fritz Henglein.
Breaking through the n3 barrier: Faster object type inference. Theory and Practice of Object Systems, 5(1):57--72, 1999. [ bib | .ps.gz ] |
| [831] |
Fritz Henglein and Jakob Rehof.
The complexity of subtype entailment for simple types. In Logic in Computer Science (LICS), pages 352--361, June 1997. [ bib | .ps ] |
| [832] |
Fritz Henglein and Jakob Rehof.
Constraint automata and the complexity of recursive subtype entailment. In International Colloquium on Automata, Languages and Programming, July 1998. [ bib | .ps ] |
| [833] |
Matthew Hennessy.
The security picalculus and non-interference. Technical Report 2000:05, University of Sussex, November 2000. [ bib | .ps.Z ] |
| [834] |
Matthew Hennessy and James Riely.
Information flow vs. resource access in the asynchronous pi-calculus. In International Colloquium on Automata, Languages and Programming, Lecture Notes in Computer Science. Springer, July 2000. [ bib | .ps.gz ] |
| [835] |
Mark Hepburn and David Wright.
Trust in the pi-calculus. In Principles and Practice of Declarative Programming (PPDP), September 2001. [ bib ] |
| [836] |
Brian Herlihy, Peter Schachte, and Harald Søndergaard.
Un-Kleene Boolean equation solving. International Journal of Foundations of Computer Science, 18(2):227--250, 2007. [ bib | http ] |
| [837] |
Maurice P. Herlihy and Jeannette M. Wing.
Linearizability: a correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems, 12(3):463--492, July 1990. [ bib | http ] |
| [838] |
Stefan Heule, K. Rustan M. Leino, Peter Müller, and Alexander J. Summers.
Abstract read permissions: Fractional permissions without the fractions. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 7737 of Lecture Notes in Computer Science, pages 315--334. Springer, 2013. [ bib | .pdf ] |
| [839] |
Tomoyuki Higuchi and Atsushi Ohori.
A static type system for JVM access control. In International Conference on Functional Programming (ICFP), pages 227--237, August 2003. [ bib | http ] |
| [840] |
Daniel Hillerström and Sam Lindley.
Liberating effects with rows and handlers. In International Workshop on Type-Driven Development (TyDe@ICFP), pages 15--27, September 2016. [ bib | .pdf ] |
| [841] |
Daniel Hillerström and Sam Lindley.
Shallow effect handlers. In Asian Symposium on Programming Languages and Systems (APLAS), volume 11275 of Lecture Notes in Computer Science, pages 415--435. Springer, December 2018. [ bib | .pdf ] |
| [842] |
Daniel Hillerström, Sam Lindley, and Robert Atkey.
Effect handlers via generalised continuations. Journal of Functional Programming, 30:e5, 2020. [ bib | .pdf ] |
| [843] |
Daniel Hillerström, Sam Lindley, Robert Atkey, and K. C.
Sivaramakrishnan.
Continuation passing style for effect handlers. In Formal Structures for Computation and Deduction (FSCD), volume 84 of Leibniz International Proceedings in Informatics, pages 18:1--18:19, 2017. [ bib | http ] |
| [844] |
J. Roger Hindley.
The principal type-scheme of an object in combinatory logic. Transactions of the American Mathematical Society, 146:29--60, 1969. [ bib | http ] |
| [845] |
Jonas Kastberg Hinrichsen, Jesper Bengtson, and Robbert Krebbers.
Actris: session-type based reasoning in separation logic. Proceedings of the ACM on Programming Languages, 4(POPL):6:1--6:30, 2020. [ bib | .pdf ] |
| [846] |
Ralf Hinze.
Deriving backtracking monad transformers. In International Conference on Functional Programming (ICFP), pages 186--197, September 2000. [ bib | http ] |
| [847] |
Ralf Hinze.
Formatting: a class act. Journal of Functional Programming, 13(5):935--944, 2003. [ bib | http ] |
| [848] |
Ralf Hinze.
Fun with phantom types. In Jeremy Gibbons and Oege de Moor, editors, The Fun of Programming, pages 245--262. Palgrave Macmillan, March 2003. [ bib | .pdf ] |
| [849] |
Ralf Hinze, Johan Jeuring, and Andres Löh.
Comparing approaches to generic programming in Haskell. Technical Report UU-CS-2006-022, Department of Information and Computing Sciences, Utrecht University, 2006. [ bib | .pdf ] |
| [850] |
Ralf Hinze and Andres Löh.
“Scrap your boilerplate” revolutions. In Mathematics of Program Construction (MPC), volume 4014 of Lecture Notes in Computer Science, pages 180--208. Springer, July 2006. [ bib | .pdf ] |
| [851] |
Ralf Hinze, Andres Löh, and Bruno C. d. S. Oliveira.
“Scrap your boilerplate” reloaded. In Functional and Logic Programming, volume 3945 of Lecture Notes in Computer Science, pages 13--29. Springer, April 2006. [ bib | .pdf ] |
| [852] |
Ralf Hinze and Ross Paterson.
Derivation of a typed functional LR parser. Unpublished, November 2005. [ bib | .pdf ] |
| [853] |
Ralf Hinze and Ross Paterson.
Finger trees: a simple general-purpose data structure. Journal of Functional Programming, 16(2):197--217, 2006. [ bib | .pdf ] |
| [854] |
Ralf Hinze and Simon Peyton Jones.
Derivable type classes. In Haskell workshop, 2000. [ bib | .pdf ] |
| [855] |
Tom Hirschowitz, Xavier Leroy, and J. B. Wells.
Call-by-value mixin modules: Reduction semantics, side effects, types. In European Symposium on Programming (ESOP), volume 2986 of Lecture Notes in Computer Science, pages 64--78. Springer, April 2004. [ bib | http ] |
| [856] |
My Hoang and John C. Mitchell.
Lower bounds on type inference with subtypes. In Principles of Programming Languages (POPL), pages 176--185, January 1995. [ bib | http ] |
| [857] |
C. A. R. Hoare.
Algorithm 65: find. Communications of the ACM, 4(7):321--322, July 1961. [ bib | http ] |
| [858] |
C. A. R. Hoare.
An axiomatic basis for computer programming. Communications of the ACM, 12(10):576--580, 1969. [ bib | http ] |
| [859] |
C. A. R. Hoare.
Proof of a program: FIND. Communications of the ACM, 14(1):39--45, January 1971. [ bib | http ] |
| [860] |
C. A. R. Hoare.
Proof of correctness of data representations. Acta Informatica, 4:271--281, 1972. [ bib | http ] |
| [861] |
Aquinas Hobor, Andrew W. Appel, and Francesco Zappa Nardelli.
Oracle semantics for concurrent separation logic. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 353--367. Springer, April 2008. [ bib | .pdf ] |
| [862] |
Aquinas Hobor, Robert Dockins, and Andrew W. Appel.
A theory of indirection via approximation. In Principles of Programming Languages (POPL), January 2010. [ bib | .pdf ] |
| [863] |
Aquinas Hobor and Cristian Gherghina.
Barriers in concurrent separation logic. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, March 2011. [ bib | .pdf ] |
| [864] |
Jan Hoffmann, Klaus Aehlig, and Martin Hofmann.
Multivariate amortized resource analysis. ACM Transactions on Programming Languages and Systems, 34(3):14:1--14:62, 2012. [ bib | .pdf ] |
| [865] |
Jan Hoffmann, Klaus Aehlig, and Martin Hofmann.
Resource aware ML. In Computer Aided Verification (CAV), volume 7358 of Lecture Notes in Computer Science, pages 781--786. Springer, July 2012. [ bib | http ] |
| [866] |
Jan Hoffmann, Ankush Das, and Shu-Chun Weng.
Towards automatic resource bound analysis for OCaml. In Principles of Programming Languages (POPL), pages 359--373, January 2017. [ bib | .pdf ] |
| [867] |
Jan Hoffmann and Martin Hofmann.
Amortized resource analysis with polynomial potential. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 287--306. Springer, March 2010. [ bib | .pdf ] |
| [868] |
Jan Hoffmann and Steffen Jost.
Two decades of automatic amortized resource analysis. Mathematical Structures in Computer Science, 32(6):729--759, 2022. [ bib | http ] |
| [869] |
Jan Hoffmann, Michael Marmar, and Zhong Shao.
Quantitative reasoning for proving lock-freedom. In Logic in Computer Science (LICS), pages 124--133, June 2013. [ bib | .pdf ] |
| [870] |
Martin Hofmann.
Linear types and non-size-increasing polynomial time computation. In Logic in Computer Science (LICS), pages 464--473, July 1999. [ bib | http ] |
| [871] |
Martin Hofmann.
A type system for bounded space and functional in-place update. Nordic Journal of Computing, 7(4):258--289, 2000. [ bib | .ps.gz ] |
| [872] |
Martin Hofmann.
Linear types and non-size-increasing polynomial time computation. Information and Computation, 183(1):57--85, 2003. [ bib | http ] |
| [873] |
Martin Hofmann and Steffen Jost.
Static prediction of heap space usage for first-order functional programs. In Principles of Programming Languages (POPL), pages 185--197, January 2003. [ bib | .pdf ] |
| [874] |
Martin Hofmann and Steffen Jost.
Type-based amortised heap-space analysis. In European Symposium on Programming (ESOP), volume 3924 of Lecture Notes in Computer Science, pages 22--37. Springer, March 2006. [ bib | .pdf ] |
| [875] |
Martin Hofmann, Aleksandr Karbyshev, and Helmut Seidl.
Verifying a local generic solver in Coq. In Static Analysis Symposium (SAS), volume 6337 of Lecture Notes in Computer Science, pages 340--355. Springer, September 2010. [ bib | .pdf ] |
| [876] |
Martin Hofmann, Aleksandr Karbyshev, and Helmut Seidl.
What is a pure functional? In International Colloquium on Automata, Languages and Programming, volume 6199 of Lecture Notes in Computer Science, pages 199--210. Springer, July 2010. [ bib | .pdf ] |
| [877] |
Martin Hofmann and Georg Moser.
Amortised resource analysis and typed polynomial interpretations. In Typed Lambda Calculi and Applications (TLCA), volume 8560 of Lecture Notes in Computer Science, pages 272--286. Springer, July 2014. [ bib | .pdf ] |
| [878] |
Martin Hofmann and Mariela Pavlova.
Elimination of ghost variables in program logics. In Trustworthy Global Computing, volume 4912 of Lecture Notes in Computer Science, pages 1--20. Springer, 2008. [ bib | .pdf ] |
| [879] |
Martin Hofmann and Benjamin Pierce.
A unifying type-theoretic framework for objects. Journal of Functional Programming, 5(4):593--635, October 1995. Previous versions appeared in the Symposium on Theoretical Aspects of Computer Science, 1994, (pages 251--262) and, under the title “An Abstract View of Objects and Subtyping (Preliminary Report),” as University of Edinburgh, LFCS technical report ECS-LFCS-92-226, 1992. [ bib | .ps ] |
| [880] |
Martin Hofmann and Dulma Rodriguez.
Efficient type-checking for amortised heap-space analysis. In Computer Science Logic, volume 5771 of Lecture Notes in Computer Science, pages 317--331. Springer, September 2009. [ bib | http ] |
| [881] |
Martin Hofmann and Dulma Rodriguez.
Automatic type inference for amortised heap-space analysis. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 593--613. Springer, March 2013. [ bib | http ] |
| [882] |
John Hogg.
Islands: Aliasing protection in object-oriented languages. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 271--285, 1991. [ bib | http ] |
| [883] |
Benjamin Holland, Ganesh Ram Santhanam, Payas Awadhutkar, and Suresh Kothari.
Statically-informed dynamic analysis tools to detect algorithmic complexity vulnerabilities. In Source Code Analysis and Manipulation (SCAM), pages 79--84, October 2016. [ bib | .pdf ] |
| [884] |
Kohei Honda, Vasco Vasconcelos, and Nobuko Yoshida.
Secure information flow as typed process behaviour. Technical Report QMW-DCS-1999-767, Queen Mary and Westfield College, University of London, December 1999. [ bib | .ps.gz ] |
| [885] |
Kohei Honda, Vasco Vasconcelos, and Nobuko Yoshida.
Secure information flow as typed process behaviour. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 180--199. Springer, March 2000. [ bib | .ps.gz ] |
| [886] |
Kohei Honda and Nobuko Yoshida.
A uniform type structure for secure information flow. In Principles of Programming Languages (POPL), pages 81--92, January 2002. [ bib | .ps.gz ] |
| [887] |
Kohei Honda and Nobuko Yoshida.
A compositional logic for polymorphic higher-order functions. In Principles and Practice of Declarative Programming (PPDP), pages 191--202, August 2004. [ bib | .pdf.gz ] |
| [888] |
Furio Honsell, Marino Miculan, and Ivan Scagnetto.
An axiomatic approach to metareasoning on nominal algebras in HOAS. In International Colloquium on Automata, Languages and Programming, volume 2076 of Lecture Notes in Computer Science, pages 963--978. Springer, 2001. [ bib | .pdf ] |
| [889] |
John E. Hopcroft.
An nlogn algorithm for minimizing states in a finite automaton. In Zvi Kohavi and Azaria Paz, editors, Theory of Machines and Computations, pages 189--196. Academic Press, 1971. [ bib | http ] |
| [890] |
John E. Hopcroft.
Computer science: The emergence of a discipline. Communications of the ACM, 30(3):198--202, 1987. [ bib | http ] |
| [891] |
John E. Hopcroft, Rajeev Motwani, and Jeffrey D. Ullman.
Introduction to automata theory, languages, and computation. Addison-Wesley, 2000. [ bib | .html ] |
| [892] |
John E. Hopcroft and Jeffrey D. Ullman.
Set merging algorithms. SIAM Journal on Computing, 2(4):294--303, 1973. [ bib | http ] |
| [893] |
James J. Horning.
What the compiler should tell the user. In Compiler Construction (CC), volume 21 of Lecture Notes in Computer Science, pages 525--548. Springer, 1974. [ bib | http ] |
| [894] |
R. Nigel Horspool and Michael Whitney.
Even faster LR parsing. Software: Practice and Experience, 20(6):515--535, June 1990. [ bib | .pdf ] |
| [895] |
Susan Horwitz, Thomas Reps, and Mooly Sagiv.
Demand interprocedural dataflow analysis. In ACM Symposium on the Foundations of Software Engineering (FSE), October 1995. [ bib | .ps ] |
| [896] |
Haruo Hosoya and Benjamin C. Pierce.
Regular expression pattern matching for XML. Journal of Functional Programming, 13(6):961--1004, November 2003. [ bib | http ] |
| [897] |
Rodney R. Howell.
On asymptotic notation with multiple variables. Technical Report 2007-4, Kansas State University, January 2008. [ bib | .pdf ] |
| [898] |
Rodney R. Howell.
Algorithms: A top-down approach, July 2012. Draft. [ bib | http ] |
| [899] |
Thierry Hubert and Claude Marché.
Separation analysis for deductive verification. In Heap Analysis and Verification (HAV), March 2007. [ bib | .pdf ] |
| [900] |
Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler.
A history of Haskell: being lazy with class. In History of Programming Languages, June 2007. [ bib | .pdf ] |
| [901] |
Gérard Huet.
Résolution d'équations dans des langages d'ordre 1, 2, ..., ω. PhD thesis, Université Paris 7, September 1976. [ bib ] |
| [902] |
Gérard Huet.
The zipper. Journal of Functional Programming, 7(5):549--554, 1997. [ bib | .pdf ] |
| [903] |
Gérard Huet.
Regular Böhm trees. Mathematical Structures in Computer Science, 8:671--680, 1998. [ bib | .pdf ] |
| [904] |
Brian Huffman and Christian Urban.
A new foundation for Nominal Isabelle. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 35--50. Springer, July 2010. [ bib | .pdf ] |
| [905] |
John Hughes.
Why functional programming matters. Computer Journal, 32(2):98--107, 1989. [ bib | .pdf ] |
| [906] |
John Hughes.
The design of a pretty-printing library. In Advanced Functional Programming, volume 925 of Lecture Notes in Computer Science, pages 53--96. Springer, May 1995. [ bib | .pdf ] |
| [907] |
John Hughes.
Generalising monads to arrows. Science of Computer Programming, 37(1--3):67--111, 2000. [ bib | .pdf ] |
| [908] |
John Hughes.
QuickCheck testing for fun and profit. In Practical Aspects of Declarative Languages (PADL), volume 4354 of Lecture Notes in Computer Science, pages 1--32. Springer, January 2007. [ bib | .pdf ] |
| [909] |
John Hughes and Lars Pareto.
Recursion and dynamic data-structures in bounded space: Towards embedded ML programming. In International Conference on Functional Programming (ICFP), pages 70--81, September 1999. [ bib | http ] |
| [910] |
John Hughes, Lars Pareto, and Amr Sabry.
Proving the correctness of reactive systems using sized types. In Principles of Programming Languages (POPL), pages 410--423, January 1996. [ bib | http ] |
| [911] |
Mathieu Huot, Sam Staton, and Matthijs Vákár.
Correctness of automatic differentiation via diffeologies and categorical gluing. In Foundations of Software Science and Computation Structures (FOSSACS), volume 12077 of Lecture Notes in Computer Science, pages 319--338. Springer, April 2020. [ bib | http ] |
| [912] |
Mathieu Huot, Sam Staton, and Matthijs Vákár.
Higher order automatic differentiation of higher order functions. Logical Methods in Computer Science, 18(1), 2022. [ bib | http ] |
| [913] |
Chung-Kil Hur, Derek Dreyer, and Viktor Vafeiadis.
Separation logic in the presence of garbage collection. In Logic in Computer Science (LICS), pages 247--256, 2011. [ bib | .pdf ] |
| [914] |
Chung-Kil Hur, Georg Neis, Derek Dreyer, and Viktor Vafeiadis.
The power of parameterization in coinductive proof. In Principles of Programming Languages (POPL), pages 193--206, January 2013. [ bib | .pdf ] |
| [915] |
Graham Hutton.
A tutorial on the universality and expressiveness of fold. Journal of Functional Programming, 9(4):355--372, 1999. [ bib | .pdf ] |
| [916] |
Atsushi Igarashi and Naoki Kobayashi.
Type reconstruction for linear π-calculus with I/O subtyping. Information and Computation, 161:1--44, August 2000. [ bib | .ps.gz ] |
| [917] |
Samin S. Ishtiaq and Peter W. O'Hearn.
BI as an assertion language for mutable data structures. In Principles of Programming Languages (POPL), pages 14--26, January 2001. [ bib | .pdf ] |
| [918] |
ISO.
ISO/IEC 9899:2011 -- programming languages -- C, 2011. [ bib | .pdf ] |
| [919] |
Anastasia Izmaylova, Ali Afroozeh, and Tijs van der Storm.
Practical, general parser combinators. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 1--12, January 2016. [ bib | .pdf ] |
| [920] |
Daniel Jackson and Mandana Vaziri.
Finding bugs with a constraint solver. In International Symposium on Software Testing and Analysis (ISSTA), August 2000. [ bib | .pdf ] |
| [921] |
Bart Jacobs.
Java's integral types in PVS. In Formal Methods for Open Object-Based Distributed Systems (FMOODS), volume 2884 of Lecture Notes in Computer Science, pages 1--15. Springer, November 2003. [ bib | http ] |
| [922] |
Bart Jacobs, Dragan Bosnacki, and Ruurd Kuipe.
Modular termination verification. In European Conference on Object-Oriented Programming (ECOOP), Leibniz International Proceedings in Informatics, pages 99--1023, July 2015. [ bib | .pdf ] |
| [923] |
Bart Jacobs and Frank Piessens.
The VeriFast program verifier. Technical Report CW-520, Department of Computer Science, Katholieke Universiteit Leuven, August 2008. [ bib | .pdf ] |
| [924] |
Bart Jacobs, Jan Smans, and Frank Piessens.
The VeriFast program verifier: A tutorial. Unpublished, November 2017. [ bib | .pdf ] |
| [925] |
Suresh Jagannathan and Andrew Wright.
Effective flow analysis for avoiding run-time checks. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science. Springer, September 1995. [ bib | .ps.gz ] |
| [926] |
Patrik Jansson.
Functional polytypic programming. PhD thesis, Chalmers University of Technology, 2000. [ bib | .pdf ] |
| [927] |
Mauro Jaskelioff and Exequiel Rivas.
Functional pearl: a smart view on datatypes. In International Conference on Functional Programming (ICFP), pages 355--361, September 2015. [ bib | http ] |
| [928] |
C. Barry Jay.
The pattern calculus. ACM Transactions on Programming Languages and Systems, 26(6):911--937, November 2004. [ bib | .pdf ] |
| [929] |
Clinton L. Jeffery.
Merr user's guide, July 2002. [ bib | .pdf ] |
| [930] |
Clinton L. Jeffery.
Generating LR syntax error messages from examples. ACM Transactions on Programming Languages and Systems, 25(5):631--640, 2003. [ bib | http ] |
| [931] |
Jonas Braband Jensen, Nick Benton, and Andrew Kennedy.
High-level separation logic for low-level code. In Principles of Programming Languages (POPL), pages 301--314, January 2013. [ bib | .pdf ] |
| [932] |
Jonas Braband Jensen and Lars Birkedal.
Fictional separation logic. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 377--396. Springer, March 2012. [ bib | .pdf ] |
| [933] |
Jonas Braband Jensen, Lars Birkedal, and Peter Sestoft.
Modular verification of linked lists with views via separation logic. Journal of Object Technology, 10:2:1--20, 2011. [ bib | .pdf ] |
| [934] |
Thomas Jensen.
Inference of polymorphic and conditional strictness properties. In Principles of Programming Languages (POPL), pages 209--221. ACM Press, January 1998. [ bib | .ps ] |
| [935] |
Thomas Jensen, Daniel Le Métayer, and Tommy Thorn.
Verifying security properties of control-flow graphs. In IEEE Symposium on Security and Privacy (S&P), pages 89--105, May 1999. [ bib | .ps ] |
| [936] |
Thomas Jensen, Florimond Ployette, and Olivier Ridoux.
Iteration schemes for fixed point computation. In International workshop on Fixed Points in Computer Science (FICS), pages 69--76, 2002. [ bib | .ps ] |
| [937] |
Johan Jeuring, Sean Leather, José Pedro Magalhães, and Alexey Rodriguez
Yakushev.
Libraries for generic programming in Haskell. In Advanced Functional Programming, volume 5832 of Lecture Notes in Computer Science, pages 165--229. Springer, May 2008. [ bib | .pdf ] |
| [938] |
Somesh Jha, Jens Palsberg, and Tian Zhao.
Efficient type matching. In Foundations of Software Science and Computation Structures (FOSSACS), volume 2303 of Lecture Notes in Computer Science, pages 187--204. Springer, April 2002. [ bib | .pdf ] |
| [939] |
Ranjit Jhala, Eric Seidel, and Niki Vazou.
Programming with refinement types. Unpublished, March 2017. [ bib | .pdf ] |
| [940] |
Limin Jia, Frances Spalding, David Walker, and Neal Glew.
Certifying compilation for a language with stack allocation. In Logic in Computer Science (LICS), pages 407--416, June 2005. [ bib | .pdf ] |
| [941] |
Limin Jia and David Walker.
ILC: A foundation for automated reasoning about pointer programs. In European Symposium on Programming (ESOP), volume 3924 of Lecture Notes in Computer Science, pages 131--145. Springer, March 2006. [ bib | .pdf ] |
| [942] |
Trevor Jim.
What are principal typings and what are they good for? Technical Report MIT/LCS TM-532, Massachusetts Institute of Technology, August 1995. [ bib | .ps.gz ] |
| [943] |
Trevor Jim.
A polar type system. In Workshop on Intersection Types and Related Systems (ITRS), volume 8 of Proceedings in Informatics. Carleton Scientific, 2000. [ bib | .ps.gz ] |
| [944] |
Trevor Jim and Jens Palsberg.
Type inference in systems of recursive types with subtyping. Manuscript, 1999. [ bib | .pdf ] |
| [945] |
Jang-Wu Jo, Byeong-Mo Chang, Kwangkeun Yi, and Kwang-Moo Choe.
An uncaught exception analysis for Java. Journal of Systems and Software, 72(1):59--69, 2004. [ bib | .pdf ] |
| [946] |
Gregory F. Johnson and Janet A. Walz.
A maximum-flow approach to anomaly isolation in unification-based incremental type inference. In Principles of Programming Languages (POPL), pages 44--57, January 1986. [ bib ] |
| [947] |
Stephen C. Johnson.
Yacc: Yet another compiler-compiler. Computing Science Technical Report 32, Bell Laboratories, 1975. [ bib | http ] |
| [948] |
Steven C. Johnson.
Yacc: Yet another compiler compiler. In UNIX Programmer's Manual, volume 2, pages 353--387. Holt, Rinehart, and Winston, 1979. [ bib | http ] |
| [949] |
Thomas Johnsson.
Lambda lifting: Transforming programs to recursive equations. In Jean-Pierre Jouannaud, editor, Functional Programming Languages and Computer Architecture (FPCA), volume 201 of Lecture Notes in Computer Science, pages 190--203. Springer, 1985. [ bib | http ] |
| [950] |
Mark P. Jones.
A theory of qualified types. In European Symposium on Programming (ESOP), volume 582 of Lecture Notes in Computer Science. Springer, February 1992. [ bib | .html ] |
| [951] |
Mark P. Jones.
Dictionary-free overloading by partial evaluation. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), June 1994. [ bib | .ps ] |
| [952] |
Mark P. Jones.
Qualified types: Theory and practice. Cambridge University Press, November 1994. [ bib ] |
| [953] |
Mark P. Jones.
Simplifying and improving qualified types. Technical Report YALEU/DCS/RR-1040, Yale University, June 1994. [ bib | .ps.Z ] |
| [954] |
Mark P. Jones.
From Hindley-Milner types to first-class structures. Research Report YALEU/DCS/RR-1075, Yale University, June 1995. [ bib | .html ] |
| [955] |
Mark P. Jones.
Using parameterized signatures to express modular structure. In Principles of Programming Languages (POPL), January 1996. [ bib | .html ] |
| [956] |
Mark P. Jones.
Typing Haskell in Haskell. In Haskell workshop, November 2000. [ bib | http ] |
| [957] |
Mark P. Jones.
jacc: Just another compiler compiler for Java, February 2004. [ bib | .pdf ] |
| [958] |
Mark P. Jones and Simon Peyton Jones.
Lightweight extensible records for Haskell. In Haskell workshop, October 1999. [ bib | .ps.gz ] |
| [959] |
Neil D. Jones and Alan Mycroft.
Data flow analysis of applicative programs using minimal function graphs. In Principles of Programming Languages (POPL), pages 296--306, 1986. [ bib | http ] |
| [960] |
Steffen Jost, Kevin Hammond, Hans-Wolfgang Loidl, and Martin Hofmann.
Static determination of quantitative resource usage for higher-order programs. In Principles of Programming Languages (POPL), pages 223--236, January 2010. [ bib | .pdf ] |
| [961] |
Steffen Jost, Hans-Wolfgang Loidl, Kevin Hammond, Norman Scaife, and Martin
Hofmann.
"carbon credits" for resource-bounded computations using amortised analysis. In Formal Methods (FM), volume 5850 of Lecture Notes in Computer Science, pages 354--369. Springer, November 2009. [ bib | .pdf ] |
| [962] |
Steffen Jost, Pedro B. Vasconcelos, Mário Florido, and Kevin Hammond.
Type-based cost analysis for lazy functional languages. Journal of Automated Reasoning, 59(1):87--120, 2017. [ bib | .pdf ] |
| [963] |
Jean-Pierre Jouannaud and Claude Kirchner.
Solving equations in abstract algebras: a rule-based survey of unification. Technical Report 561, Université Paris-Sud, April 1990. [ bib ] |
| [964] |
Jean-Pierre Jouannaud and Claude Kirchner.
Solving equations in abstract algebras: a rule-based survey of unification. In Jean-Louis Lassez and Gordon Plotkin, editors, Computational Logic. Essays in honor of Alan Robinson, chapter 8, pages 257--321. MIT Press, 1991. [ bib ] |
| [965] |
Jacques-Henri Jourdan.
Verasco: a formally verified C static analyzer. PhD thesis, Université Paris Diderot, May 2016. [ bib | .pdf ] |
| [966] |
Jacques-Henri Jourdan, Vincent Laporte, Sandrine Blazy, Xavier Leroy, and
David Pichardie.
A formally-verified C static analyzer. In Principles of Programming Languages (POPL), pages 247--259, January 2015. [ bib | .pdf ] |
| [967] |
Jacques-Henri Jourdan, François Pottier, and Xavier Leroy.
Validating LR(1) parsers. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 397--416. Springer, March 2012. [ bib | .pdf ] |
| [968] |
Jaehwang Jung, Janggun Lee, Jaemin Choi, Jaewoo Kim, Sunho Park, and Jeehoon
Kang.
Modular verification of safe memory reclamation in concurrent separation logic. Proceedings of the ACM on Programming Languages, 7(OOPSLA2):828--856, 2023. [ bib | http ] |
| [969] |
Ralf Jung, Jacques-Henri Jourdan, Robbert Krebbers, and Derek Dreyer.
RustBelt: Securing the foundations of the Rust programming language. Proceedings of the ACM on Programming Languages, 2(POPL):66:1--66:34, 2018. [ bib | .pdf ] |
| [970] |
Ralf Jung, Robbert Krebbers, Lars Birkedal, and Derek Dreyer.
Higher-order ghost state. In International Conference on Functional Programming (ICFP), pages 256--269, September 2016. [ bib | .pdf ] |
| [971] |
Ralf Jung, Robbert Krebbers, Jacques-Henri Jourdan, Aleš Bizjak, Lars
Birkedal, and Derek Dreyer.
Iris from the ground up: A modular foundation for higher-order concurrent separation logic. Journal of Functional Programming, 28:e20, 2018. [ bib | .pdf ] |
| [972] |
Ralf Jung, Rodolphe Lepigre, Gaurav Parthasarathy, Marianna Rapoport, Amin
Timany, Derek Dreyer, and Bart Jacobs.
The future is ours: Prophecy variables in separation logic. Proceedings of the ACM on Programming Languages, 4(POPL):45:1--45:32, January 2020. [ bib | .pdf ] |
| [973] |
Ralf Jung, David Swasey, Filip Sieczkowski, Kasper Svendsen, Aaron Turon, Lars
Birkedal, and Derek Dreyer.
Iris: monoids and invariants as an orthogonal basis for concurrent reasoning. In Principles of Programming Languages (POPL), pages 637--650, January 2015. [ bib | .pdf ] |
| [974] |
Niels Jørgensen.
Chaotic fixpoint iteration guided by dynamic dependency. In International Workshop on Static Analysis (WSA), volume 724 of Lecture Notes in Computer Science, pages 27--44. Springer, 1993. [ bib | .ps ] |
| [975] |
David M. Kahn and Jan Hoffmann.
Automatic amortized resource analysis with the quantum physicist's method. Proceedings of the ACM on Programming Languages, 5(ICFP):1--29, 2021. [ bib | http ] |
| [976] |
Jan-Oliver Kaiser, Hoang-Hai Dang, Derek Dreyer, Ori Lahav, and Viktor
Vafeiadis.
Strong logic for weak memory: Reasoning about release-acquire consistency in Iris. In European Conference on Object-Oriented Programming (ECOOP), pages 17:1--17:29, June 2017. [ bib | .pdf ] |
| [977] |
Jonas Kaiser, Tobias Tebbi, and Gert Smolka.
Equivalence of System F and λ2 in Coq based on context morphism lemmas. In Certified Programs and Proofs (CPP), pages 222--234, January 2017. [ bib | .pdf ] |
| [978] |
John B. Kam and Jeffrey D. Ullman.
Global data flow analysis and iterative algorithms. Journal of the ACM, 23(1):158--171, January 1976. [ bib | http ] |
| [979] |
John B. Kam and Jeffrey D. Ullman.
Monotone data flow analysis frameworks. Acta Informatica, 7(3):305--317, September 1977. [ bib | http ] |
| [980] |
Ohad Kammar, Sam Lindley, and Nicolas Oury.
Handlers in action. In International Conference on Functional Programming (ICFP), pages 145--158, September 2013. [ bib | .pdf ] |
| [981] |
Ohad Kammar and Matija Pretnar.
No value restriction is needed for algebraic effects and handlers. Journal of Functional Programming, 27:e7, 2017. [ bib | .pdf ] |
| [982] |
Hrutvik Kanabar.
Verified compilation of a purely functional language to a realistic machine semantics. PhD thesis, School of Computing, University of Kent, December 2023. [ bib | .pdf ] |
| [983] |
Hrutvik Kanabar, Samuel Vivien, Oskar Abrahamsson, Magnus O. Myreen, Michael
Norrish, Johannes Åman Pohjola, and Riccardo Zanetti.
PureCake: A verified compiler for a lazy functional language. Proceedings of the ACM on Programming Languages, 7(PLDI):952--976, 2023. [ bib | http ] |
| [984] |
Jeehoon Kang, Chung-Kil Hur, Ori Lahav, Viktor Vafeiadis, and Derek Dreyer.
A promising semantics for relaxed-memory concurrency. In Principles of Programming Languages (POPL), pages 175--189, January 2017. [ bib | .pdf ] |
| [985] |
Johannes Kanig.
Specification and proof of higher-order programs. PhD thesis, Université Paris-Sud, November 2010. [ bib | .pdf ] |
| [986] |
E. Kantorowitz and H. Laor.
Automatic generation of useful syntax error messages. Software: Practice and Experience, 16(7):627--640, 1986. [ bib | http ] |
| [987] |
Haim Kaplan, Chris Okasaki, and Robert E. Tarjan.
Simple confluently persistent catenable lists. SIAM Journal on Computing, 30(3):965--977, 2000. [ bib | .pdf ] |
| [988] |
Haim Kaplan, Nira Shafrir, and Robert E. Tarjan.
Union-find with deletions. In Symposium on Discrete Algorithms (SODA), pages 19--28, January 2002. [ bib | http ] |
| [989] |
Haim Kaplan and Robert E. Tarjan.
Purely functional representations of catenable sorted lists. In Symposium on the Theory of Computing, pages 202--211, May 1996. [ bib | http ] |
| [990] |
Haim Kaplan and Robert E. Tarjan.
Purely functional, real-time deques with catenation. Journal of the ACM, 46(5):577--603, 1999. [ bib | .pdf ] |
| [991] |
Deepak Kapur and Hantao Zhang.
An overview of Rewrite Rule Laboratory (RRL). J. Comput. Appl. Math., 29(2):91--114, 1995. [ bib | .ps.gz ] |
| [992] |
Aleksandr Karbyshev.
Monadic parametricity of second-order functionals. PhD thesis, Technische Universität München, 2013. [ bib | http ] |
| [993] |
Jerzy Karczmarczuk.
Functional differentiation of computer programs. In International Conference on Functional Programming (ICFP), pages 195--203, September 1998. [ bib | http ] |
| [994] |
Jerzy Karczmarczuk.
Functional differentiation of computer programs. Higher-Order and Symbolic Computation, 14(1):35--57, 2001. [ bib | http ] |
| [995] |
Yugo Kashiwagi and David S. Wise.
Graph algorithms in a lazy functional programming language. Technical Report 330, Indiana University, April 1991. [ bib | .pdf ] |
| [996] |
Ioannis T. Kassios.
Dynamic frames: Support for framing, dependencies and sharing without restrictions. In Formal Methods (FM), volume 4085 of Lecture Notes in Computer Science, pages 268--283. Springer, August 2006. [ bib | .pdf ] |
| [997] |
Ioannis T. Kassios and Eleftherios Kritikos.
A discipline for program verification based on backpointers and its use in observational disjointness. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 149--168. Springer, March 2013. [ bib | http ] |
| [998] |
Lennart C. L. Kats, Eelco Visser, and Guido Wachsmuth.
Pure and declarative syntax definition: Paradise lost and regained. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 918–--932, 2010. [ bib | http ] |
| [999] |
Misa Keinänen.
Techniques for solving Boolean equation systems. PhD thesis, Helsinki University of Technology, 2006. Research Report HUT-TCS-A105. [ bib | .pdf ] |
| [1000] |
Torbjörn Keisu.
Finite and rational tree constraints. Bulletin of the IGPL, 2(2):167--204, 1994. [ bib | .ps.gz ] |
| [1001] |
Torbjörn Keisu.
Tree constraints. PhD thesis, The Royal Institute of Technology (KTH), May 1994. [ bib | .ps.gz ] |
| [1002] |
Andrew Kennedy.
Dimension types. In European Symposium on Programming (ESOP), volume 788 of Lecture Notes in Computer Science. Springer, 1994. [ bib | .pdf ] |
| [1003] |
Andrew Kennedy.
Type inference and equational theories. Technical Report LIX/RR/96/09, École Polytechnique, September 1996. [ bib ] |
| [1004] |
Andrew Kennedy.
Compiling with continuations, continued. In International Conference on Functional Programming (ICFP), pages 177--190, September 2007. [ bib | .pdf ] |
| [1005] |
Ken W. Kennedy.
Node listings applied to data flow analysis. In Principles of Programming Languages (POPL), pages 10--21, January 1975. [ bib | http ] |
| [1006] |
Manfred Kerber.
How to prove higher order theorems in first order logic. In International Joint Conferences on Artificial Intelligence, pages 137--142, 1991. [ bib | .pdf ] |
| [1007] |
Brian W. Kernighan and Dennis Ritchie.
The C programming language, second edition. Prentice Hall, 1988. [ bib ] |
| [1008] |
Steven Keuchel, Sander Huyghebaert, Georgy Lukyanov, and Dominique Devriese.
Verified symbolic execution with Kripke specification monads (and no meta-programming). Proceedings of the ACM on Programming Languages, 6(ICFP):194--224, 2022. [ bib | http ] |
| [1009] |
Steven Keuchel and Tom Schrijvers.
InBound: simple yet powerful specification of syntax with binders. Unpublished, February 2015. [ bib | .pdf ] |
| [1010] |
Steven Keuchel, Stephanie Weirich, and Tom Schrijvers.
Needle & knot: Binder boilerplate tied up. In European Symposium on Programming (ESOP), volume 9632 of Lecture Notes in Computer Science, pages 419--445. Springer, April 2016. [ bib | .pdf ] |
| [1011] |
A. J. Kfoury, J. Tiuryn, and P. Urzyczyn.
Type reconstruction in the presence of polymorphic recursion. ACM Transactions on Programming Languages and Systems, 15(2):290--311, 1993. [ bib | http ] |
| [1012] |
Assaf J. Kfoury, Jerzy Tiuryn, and Pawel Urzyczyn.
ML typability is DEXPTIME-complete. In Colloquium on Trees in Algebra and Programming, volume 431 of Lecture Notes in Computer Science, pages 206--220. Springer, May 1990. [ bib | http ] |
| [1013] |
Assaf J. Kfoury and J. B. Wells.
Principality and type inference for intersection types using expansion variables. Theoretical Computer Science, 311(1--3):1--70, 2004. [ bib | .html ] |
| [1014] |
Adam Khayam, Louis Noizet, and Alan Schmitt.
A faithful description of ECMAScript algorithms. In Principles and Practice of Declarative Programming (PPDP), pages 8:1--8:14, September 2022. [ bib | http ] |
| [1015] |
Donnacha Oisín Kidney, Zhixuan Yang, and Nicolas Wu.
Algebraic effects meet hoare logic in Cubical Agda. Proceedings of the ACM on Programming Languages, 8(POPL):1663--1695, 2024. [ bib | http ] |
| [1016] |
Richard B. Kieburtz.
Taming effects with monadic typing. In International Conference on Functional Programming (ICFP), pages 51--62, 1998. [ bib | http ] |
| [1017] |
Richard B. Kieburtz.
P-logic: Property verification for Haskell programs. Draft, August 2002. [ bib | .pdf ] |
| [1018] |
Gary A. Kildall.
A unified approach to global program optimization. In Principles of Programming Languages (POPL), pages 194--206, October 1973. [ bib | http ] |
| [1019] |
Ik-Soon Kim, Kwangkeun Yi, and Cristiano Calcagno.
A polymorphic modal type system for Lisp-like multi-staged languages. In Principles of Programming Languages (POPL), pages 257--268, 2006. [ bib | .pdf ] |
| [1020] |
David King and Philip Wadler.
Combining monads. In Workshop on Functional Programming. Springer, 1992. [ bib | .ps.gz ] |
| [1021] |
Oleg Kiselyov.
Typed tagless final interpreters. In International Spring School on Generic and Indexed Programming (SSGIP), volume 7470 of Lecture Notes in Computer Science, pages 130--174. Springer, March 2010. [ bib | .pdf ] |
| [1022] |
Oleg Kiselyov.
Beyond Church encoding: Boehm-Berarducci isomorphism of algebraic data types and polymorphic lambda-terms. http://okmij.org/ftp/tagless-final/course/Boehm-Berarducci.html, April 2012. [ bib ] |
| [1023] |
Oleg Kiselyov.
Undelimited continuations are co-values rather than functions. https://okmij.org/ftp/continuations/undelimited.html, October 2014. [ bib ] |
| [1024] |
Oleg Kiselyov and Hiromi Ishii.
Freer monads, more extensible effects. In Haskell symposium, pages 94--105, September 2015. [ bib | .pdf ] |
| [1025] |
Oleg Kiselyov, Shin-Cheng Mu, and Amr Sabry.
Not by equations alone: Reasoning with extensible effects. Journal of Functional Programming, 31:e2, 2021. [ bib | http ] |
| [1026] |
Oleg Kiselyov, Amr Sabry, and Cameron Swords.
Extensible effects: an alternative to monad transformers. In Haskell symposium, pages 59--70, September 2013. [ bib | http ] |
| [1027] |
Oleg Kiselyov and Chung-chieh Shan.
A substructural type system for delimited continuations. In Typed Lambda Calculi and Applications (TLCA), volume 4583 of Lecture Notes in Computer Science, pages 223--239. Springer, June 2007. [ bib | .pdf ] |
| [1028] |
George Klees, Andrew Ruef, Benji Cooper, Shiyi Wei, and Michael Hicks.
Evaluating fuzz testing. In Conference on Computer and Communications Security (CCS), pages 2123--2138. ACM, October 2018. [ bib | http ] |
| [1029] |
Casey Klein, Matthew Flatt, and Robert Bruce Findler.
Random testing for higher-order, stateful programs. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 555--566, October 2010. [ bib | .pdf ] |
| [1030] |
Gerwin Klein, June Andronick, Kevin Elphinstone, Gernot Heiser, David Cock,
Philip Derrin, Dhammika Elkaduwe, Kai Engelhardt, Rafal Kolanski, Michael
Norrish, Thomas Sewell, Harvey Tuch, and Simon Winwood.
seL4: formal verification of an operating-system kernel. Communications of the ACM, 53(6):107--115, 2010. [ bib | .pdf ] |
| [1031] |
Paul Klint.
A survey of three language-independent programming environments. Technical Report RR-0257, INRIA, December 1983. [ bib | http ] |
| [1032] |
Paul Klint, Ralf Lämmel, and Chris Verhoef.
Toward an engineering discipline for grammarware. ACM Transactions on Software Engineering and Methodology, 14(3):331--380, 2005. [ bib | .pdf ] |
| [1033] |
Paul Klint and Eelco Visser.
Using filters for the disambiguation of context-free grammars. Technical Report P9426, University of Amsterdam, December 1994. [ bib | .pdf ] |
| [1034] |
Johannes Kloos, Rupak Majumdar, and Viktor Vafeiadis.
Asynchronous liquid separation types. In European Conference on Object-Oriented Programming (ECOOP), pages 396--420, July 2015. [ bib | .pdf ] |
| [1035] |
Edward Kmett.
Bound. Blog post, November 2014. [ bib | http ] |
| [1036] |
Kevin Knight.
Unification: a multidisciplinary survey. ACM Computing Surveys, 21(1):93--124, March 1989. [ bib | http ] |
| [1037] |
Donald E. Knuth.
On the translation of languages from left to right. Information & Control, 8(6):607--639, December 1965. [ bib | http ] |
| [1038] |
Donald E. Knuth.
A generalization of Dijkstra's algorithm. Information Processing Letters, 6(1):1--5, February 1977. [ bib | http ] |
| [1039] |
Naoki Kobayashi.
A partially deadlock-free typed process calculus. ACM Transactions on Programming Languages and Systems, 20(2):436--482, March 1998. [ bib | http ] |
| [1040] |
Naoki Kobayashi.
Type-based useless variable elimination. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 84--93, January 2000. [ bib | .ps.gz ] |
| [1041] |
Naoki Kobayashi, Benjamin C. Pierce, and David N. Turner.
Linearity and the Pi-Calculus. ACM Transactions on Programming Languages and Systems, 21(5):914--947, September 1999. [ bib | http ] |
| [1042] |
Naoki Kobayashi, Shin Saito, and Eijiro Sumii.
An implicitly-typed deadlock-free process calculus. In International Conference on Concurrency Theory (CONCUR), volume 1877 of Lecture Notes in Computer Science, pages 489--503. Springer, August 2000. [ bib | .ps.gz ] |
| [1043] |
Ikuo Kobori, Yukiyoshi Kameyama, and Oleg Kiselyov.
Answer-type modification without tears: Prompt-passing style translation for typed delimited-control operators. In Workshop on Continuations (WoC), volume 212 of EPTCS, pages 36--52, 2016. [ bib | .pdf ] |
| [1044] |
Yasunori Koda and Frank Ruskey.
A Gray code for the ideals of a forest poset. Journal of Algorithms, 15(2):324--340, September 1993. [ bib | .ps ] |
| [1045] |
Andrew Koenig and Bjarne Stroustrup.
Exception handling for C++. In Proceedings of the C++ Conference, pages 149--176. USENIX Association, April 1990. [ bib | .pdf ] |
| [1046] |
Eugene Kohlbecker, Daniel P. Friedman, Matthias Felleisen, and Bruce Duba.
Hygienic macro expansion. In ACM Symposium on Lisp and Functional Programming (LFP), pages 151--161, 1986. [ bib | http ] |
| [1047] |
Eugene E. Kohlbecker and Mitchell Wand.
Macro-by-example: Deriving syntactic transformations from their specifications. In Principles of Programming Languages (POPL), pages 77--84, January 1987. [ bib | http ] |
| [1048] |
Gabriël Konat, Lennart Kats, Guido Wachsmuth, and Eelco Visser.
Declarative name binding and scope rules. In Software Language Engineering, volume 7745 of Lecture Notes in Computer Science, pages 311--331. Springer, September 2013. [ bib | .pdf ] |
| [1049] |
Pieter W. M. Koopman, Peter Achten, and Rinus Plasmeijer.
Model based testing with logical properties versus state machines. In Implementation of Functional Languages (IFL), volume 7257 of Lecture Notes in Computer Science, pages 116--133. Springer, October 2011. [ bib | http ] |
| [1050] |
Pieter W. M. Koopman, Artem Alimarine, Jan Tretmans, and Marinus J. Plasmeijer.
Gast: Generic automated software testing. In Implementation of Functional Languages (IFL), volume 2670 of Lecture Notes in Computer Science, pages 84--100. Springer, September 2002. [ bib | http ] |
| [1051] |
Adam Koprowski and Henri Binsztok.
TRX: A formally verified parser interpreter. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 345--365. Springer, March 2010. [ bib | .pdf ] |
| [1052] |
Adam Koprowski and Henri Binsztok.
TRX: A formally verified parser interpreter. Logical Methods in Computer Science, 7(2), 2011. [ bib | http ] |
| [1053] |
Larry Koved, Marco Pistoia, and Aaron Kershenbaum.
Access rights analysis for Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 359--372, November 2002. [ bib | .pdf ] |
| [1054] |
Dexter Kozen, Jens Palsberg, and Michael I. Schwartzbach.
Efficient recursive subtyping. Mathematical Structures in Computer Science, 5(1):113--125, 1995. [ bib | .pdf ] |
| [1055] |
Dexter C. Kozen.
The design and analysis of algorithms. Texts and Monographs in Computer Science. Springer, 1992. [ bib | .pdf ] |
| [1056] |
Faustyna Krawiec, Neel Krishnaswami, Simon Peyton-Jones, Tom Ellis, Andrew
Fitzgibbon, and Richard A. Eisenberg.
Provably correct, asymptotically efficient, higher-order reverse-mode automatic differentiation. Proceedings of the ACM on Programming Languages, 6(POPL), 2022. [ bib | .pdf ] |
| [1057] |
Robbert Krebbers.
An operational and axiomatic semantics for non-determinism and sequence points in C. In Principles of Programming Languages (POPL), pages 101--112, January 2014. [ bib | http ] |
| [1058] |
Robbert Krebbers, Jacques-Henri Jourdan, Ralf Jung, Joseph Tassarotti,
Jan-Oliver Kaiser, Amin Timany, Arthur Charguéraud, and Derek Dreyer.
MoSeL: a general, extensible modal framework for interactive proofs in separation logic. Proceedings of the ACM on Programming Languages, 2(ICFP):77:1--77:30, 2018. [ bib | http ] |
| [1059] |
Robbert Krebbers, Ralf Jung, Aleš Bizjak, Jacques-Henri Jourdan, Derek
Dreyer, and Lars Birkedal.
The essence of higher-order concurrent separation logic. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 696--723. Springer, April 2017. [ bib | .pdf ] |
| [1060] |
Robbert Krebbers, Xavier Leroy, and Freek Wiedijk.
Formal C semantics: CompCert and the C standard. In Interactive Theorem Proving (ITP), volume 8558 of Lecture Notes in Computer Science, pages 543--548. Springer, July 2014. [ bib | .pdf ] |
| [1061] |
Robert Krebbers, Amin Timany, and Lars Birkedal.
Interactive proofs in higher-order concurrent separation logic. In Principles of Programming Languages (POPL), January 2017. [ bib | .pdf ] |
| [1062] |
Siddharth Krishna, Michael Emmi, Constantin Enea, and Dejan Jovanovic.
Verifying visibility-based weak consistency. In European Symposium on Programming (ESOP), volume 12075 of Lecture Notes in Computer Science, pages 280--307. Springer, April 2020. [ bib | .pdf ] |
| [1063] |
Siddharth Krishna, Alexander J. Summers, and Thomas Wies.
Local reasoning for global graph properties. In European Symposium on Programming (ESOP), volume 12075 of Lecture Notes in Computer Science, pages 308--335. Springer, April 2020. [ bib | http ] |
| [1064] |
Shriram Krishnamurthi, Matthias Felleisen, and Bruce F. Duba.
From macros to reusable generative programming. In Generative and Component-Based Software Engineering, volume 1799 of Lecture Notes in Computer Science, pages 105--120. Springer, September 1999. [ bib | .ps ] |
| [1065] |
Neelakantan R. Krishnaswami.
Verifying higher-order imperative programs with higher-order separation logic. PhD thesis, School of Computer Science, Carnegie Mellon University, 2012. [ bib | .pdf ] |
| [1066] |
Neelakantan R. Krishnaswami, Jonathan Aldrich, Lars Birkedal, Kasper
Svendsen, and Alexandre Buisse.
Design patterns in separation logic. In Types in Language Design and Implementation (TLDI), pages 105--116, January 2009. [ bib | .pdf ] |
| [1067] |
Neelakantan R. Krishnaswami, Aaron Turon, Derek Dreyer, and Deepak Garg.
Superficially substructural types. In International Conference on Functional Programming (ICFP), pages 41--54, September 2012. [ bib | .pdf ] |
| [1068] |
Daniel Kroening and Ofer Strichman.
Decision procedures -- an algorithmic point of view. Springer, 2008. [ bib | http ] |
| [1069] |
Morten Krogh-Jespersen, Amin Timany, Marit Edna Ohlenbusch, Simon Oddershede
Gregersen, and Lars Birkedal.
Aneris: A mechanised logic for modular reasoning about distributed systems. In European Symposium on Programming (ESOP), volume 12075 of Lecture Notes in Computer Science, pages 336--365. Springer, April 2020. [ bib | .pdf ] |
| [1070] |
Mortern Krogh-Jespersen, Kasper Svendsen, and Lars Birkedal.
A relational model of type-and-effects in higher-order concurrent separation logic. In Principles of Programming Languages (POPL), pages 218--231, January 2017. [ bib | .pdf ] |
| [1071] |
George Kuan and David MacQueen.
Efficient type inference using ranked type variables. In ACM Workshop on ML, pages 3--14, October 2007. [ bib | .pdf ] |
| [1072] |
George Kuan, David MacQueen, and Robert Bruce Findler.
A rewriting semantics for type inference. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 426--440. Springer, March 2007. [ bib | .pdf ] |
| [1073] |
Ramana Kumar, Magnus O. Myreen, Michael Norrish, and Scott Owens.
CakeML: a verified implementation of ML. In Principles of Programming Languages (POPL), pages 179--192, January 2014. [ bib | .pdf ] |
| [1074] |
Viktor Kuncak and Martin Rinard.
On the theory of structural subtyping. Technical Report 879, MIT Laboratory for Computer Science, January 2003. [ bib | .ps ] |
| [1075] |
Viktor Kuncak and Martin Rinard.
Structural subtyping of non-recursive types is decidable. In Logic in Computer Science (LICS), June 2003. [ bib | .pdf ] |
| [1076] |
Ori Lahav, Viktor Vafeiadis, Jeehoon Kang, Chung-Kil Hur, and Derek Dreyer.
Repairing sequential consistency in C/C++11. In Programming Language Design and Implementation (PLDI), pages 618--632, June 2017. [ bib | .pdf ] |
| [1077] |
Charlie Lai, Li Gong, Larry Koved, Anthony J. Nadalin, and Roland Schemers.
User authentication and authorization in the Java platform. In Annual Computer Security Applications Conference, pages 285--290, December 1999. [ bib | .pdf ] |
| [1078] |
Akash Lal and Thomas W. Reps.
Improving pushdown system model checking. In Computer Aided Verification (CAV), volume 4144 of Lecture Notes in Computer Science, pages 343--357. Springer, August 2006. [ bib | http ] |
| [1079] |
Wilf R. LaLonde and Jim des Rivières.
Handling operator precedence in arithmetic expressions with tree transformations. ACM Transactions on Programming Languages and Systems, 3(1):83--103, 1981. [ bib | http ] |
| [1080] |
Ralf Lämmel and Simon Peyton Jones.
Scrap your boilerplate: a practical design pattern for generic programming. In Types in Language Design and Implementation (TLDI), pages 26--37, January 2003. [ bib | .pdf ] |
| [1081] |
Ralf Lämmel and Simon Peyton Jones.
Scrap more boilerplate: reflection, zips, and generalised casts. In International Conference on Functional Programming (ICFP), pages 244--255, September 2004. [ bib | http ] |
| [1082] |
Ralf Lämmel and Simon Peyton Jones.
Scrap your boilerplate with class: extensible generic functions. In International Conference on Functional Programming (ICFP), pages 204--215, September 2005. [ bib | .pdf ] |
| [1083] |
Peter Lammich.
Automatic data refinement. In Interactive Theorem Proving (ITP), volume 7998 of Lecture Notes in Computer Science, pages 84--99. Springer, July 2013. [ bib | .pdf ] |
| [1084] |
Peter Lammich.
Verified efficient implementation of Gabow's strongly connected component algorithm. In Interactive Theorem Proving (ITP), volume 8558 of Lecture Notes in Computer Science, pages 325--340. Springer, July 2014. [ bib | .pdf ] |
| [1085] |
Peter Lammich.
Refinement to Imperative/HOL. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 253--269. Springer, August 2015. [ bib | .pdf ] |
| [1086] |
Peter Lammich.
Refinement based verification of imperative data structures. In Certified Programs and Proofs (CPP), pages 27--36, January 2016. [ bib | .pdf ] |
| [1087] |
Peter Lammich.
Refinement to Imperative HOL. Journal of Automated Reasoning, 62(4):481--503, April 2019. [ bib | .pdf ] |
| [1088] |
Peter Lammich and Andreas Lochbihler.
The Isabelle collections framework. In Interactive Theorem Proving (ITP), volume 6172 of Lecture Notes in Computer Science, pages 339--354. Springer, July 2010. [ bib | .pdf ] |
| [1089] |
Peter Lammich and Rene Meis.
A separation logic framework for Imperative HOL. Archive of Formal Proofs, 2012. [ bib | http ] |
| [1090] |
Peter Lammich and René Neumann.
A framework for verifying depth-first search algorithms. In Certified Programs and Proofs (CPP), pages 137--146, January 2015. [ bib | .pdf ] |
| [1091] |
Leslie Lamport.
Time, clocks, and the ordering of events in a distributed system. Communications of the ACM, 21(7):558--565, 1978. [ bib | .pdf ] |
| [1092] |
Leslie Lamport.
How to make a multiprocessor computer that correctly executes multiprocess programs. IEEE Trans. Computers, 28(9):690--691, 1979. [ bib | .pdf ] |
| [1093] |
Leslie Lamport.
How to make a correct multiprocess program execute correctly on a multiprocessor. IEEE Trans. Computers, 46(7):779--782, 1997. [ bib | .pdf ] |
| [1094] |
Leslie Lamport and Stephan Merz.
Auxiliary variables in TLA+. CoRR, abs/1703.05121, 2017. [ bib | http ] |
| [1095] |
Butler W. Lampson.
A note on the confinement problem. Communications of the ACM, 16(10):613--615, October 1973. [ bib | .html ] |
| [1096] |
Peter J. Landin.
The mechanical evaluation of expressions. Computer Journal, 6(4):308--320, January 1964. [ bib ] |
| [1097] |
Peter J. Landin.
Correspondence between ALGOL 60 and Church's lambda-notation: part I. Communications of the ACM, 8(2):89--101, 1965. [ bib | http ] |
| [1098] |
James Richard Larus.
Restructuring symbolic programs for concurrent execution on multiprocessors. PhD thesis, EECS Department, University of California, Berkeley, May 1989. Technical Report UCB/CSD-89-502. [ bib | .pdf ] |
| [1099] |
Soren B. Lassen.
Bisimulation in untyped lambda calculus: Böhm trees and bisimulation up to context. In Mathematical Foundations of Programming Semantics, volume 20 of Electronic Notes in Theoretical Computer Science, pages 346--374. Elsevier, April 1999. [ bib | .ps ] |
| [1100] |
Soren B. Lassen.
Head normal form bisimulation for pairs and the λμ-calculus. In Logic in Computer Science (LICS), pages 297--306, August 2006. [ bib | .pdf ] |
| [1101] |
Jean-Louis Lassez, Michael J. Maher, and Kim G. Marriott.
Unification revisited. In Jack Minker, editor, Foundations of Deductive Databases and Logic Programming, chapter 15, pages 587--625. Morgan Kaufmann, 1988. [ bib ] |
| [1102] |
Jean-Louis Lassez, V. L. Nguyen, and Liz Sonenberg.
Fixed point theorems and semantics: a folk tale. Information Processing Letters, 14(3):112--116, May 1982. [ bib | http ] |
| [1103] |
Konstantin Läufer and Martin Odersky.
Polymorphic type inference and abstract data types. ACM Transactions on Programming Languages and Systems, 16(5):1411--1430, September 1994. [ bib | .pdf ] |
| [1104] |
John Launchbury and Simon Peyton Jones.
State in Haskell. LISP and Symbolic Computation, 8(4):293--341, 1995. [ bib | http ] |
| [1105] |
Vincent Laviron, Bor-Yuh Evan Chang, and Xavier Rival.
Separating shape graphs. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 387--406. Springer, March 2010. [ bib | .pdf ] |
| [1106] |
Julia L. Lawall and Olivier Danvy.
Separating stages in the continuation-passing style transformation. In Principles of Programming Languages (POPL), pages 124--136, January 1993. [ bib | .ps.gz ] |
| [1107] |
Didier Le Botlan and Didier Rémy.
MLF: Raising ML to the power of system F. In International Conference on Functional Programming (ICFP), pages 27--38, August 2003. [ bib | .pdf ] |
| [1108] |
Baudouin Le Charlier and Pascal Van Hentenryck.
A universal top-down fixpoint algorithm. Technical Report CS-92-25, Brown University, May 1992. [ bib | .ps.gz ] |
| [1109] |
Fabrice Le Fessant and Luc Maranget.
Optimizing pattern matching. In International Conference on Functional Programming (ICFP), 2001. [ bib | .ps.gz ] |
| [1110] |
Daniel Le Métayer.
ACE: an automatic complexity evaluator. ACM Transactions on Programming Languages and Systems, 10(2):248--266, 1988. [ bib | http ] |
| [1111] |
Christopher League, Zhong Shao, and Valery Trifonov.
Representing Java classes in a typed intermediate language. In International Conference on Functional Programming (ICFP), pages 183--196, September 1999. [ bib | .html ] |
| [1112] |
Christopher League, Zhong Shao, and Valery Trifonov.
Type-preserving compilation of Featherweight Java. ACM Transactions on Programming Languages and Systems, 24(2):112--152, March 2002. [ bib | .html ] |
| [1113] |
Christopher League, Zhong Shao, and Valery Trifonov.
Precision in practice: a type-preserving Java compiler. In Compiler Construction (CC), volume 2622 of Lecture Notes in Computer Science, pages 106--120. Springer, April 2003. [ bib | .html ] |
| [1114] |
Gary T. Leavens and Albert L. Baker.
Enhancing the pre- and postcondition technique for more expressive specifications. In Formal Methods (FM), volume 1709 of Lecture Notes in Computer Science, pages 1087--1106. Springer, January 1999. [ bib | http ] |
| [1115] |
Gary T. Leavens, Albert L. Baker, and Clyde Ruby.
Preliminary design of JML: a behavioral interface specification language for Java. ACM SIGSOFT Softw. Eng. Notes, 31(3):1--38, 2006. [ bib | .pdf ] |
| [1116] |
Gary T. Leavens, K. Rustan M. Leino, and Peter Müller.
Specification and verification challenges for sequential object-oriented programs. Formal Aspects of Computing, 19(2):159--189, 2007. [ bib | .pdf ] |
| [1117] |
Gary T. Leavens, Erik Poll, Curtis Clifton, Yoonsik Cheon, Clyde Ruby, David
Cok, Peter Müller, Joseph Kiniry, Patrice Chalin, and Daniel M. Zimmerman.
JML reference manual, May 2008. [ bib | .pdf ] |
| [1118] |
Sylvain Lebresne.
A system F with call-by-name exceptions. In International Colloquium on Automata, Languages and Programming, volume 5126 of Lecture Notes in Computer Science, pages 323--335. Springer, June 2008. [ bib | .pdf ] |
| [1119] |
Gyesik Lee, Bruno C. d. S. Oliveira, Sungkeun Cho, and Kwangkeun Yi.
GMeta: A generic formal metatheory framework for first-order representations. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 436--455. Springer, April 2012. [ bib | .pdf ] |
| [1120] |
Jonathan K. Lee and Jens Palsberg.
Featherweight X10: a core calculus for async-finish parallelism. In Principles and Practice of Parallel Programming (PPoPP), pages 25--36, January 2010. [ bib | http ] |
| [1121] |
Oukseh Lee and Kwangkeun Yi.
Proofs about a folklore let-polymorphic type inference algorithm. ACM Transactions on Programming Languages and Systems, 20(4):707--723, 1998. [ bib | http ] |
| [1122] |
Tony T. Lee.
Order-preserving representations of the partitions on the finite set. Journal of Combinatorial Theory, Series A, 31(2):136--145, 1981. [ bib | .pdf ] |
| [1123] |
Wonyeol Lee, Hangyeol Yu, Xavier Rival, and Hongseok Yang.
On correctness of automatic differentiation for non-differentiable functions. In Advances in Neural Information Processing Systems 33 (NeurIPS 2020), December 2020. [ bib | .pdf ] |
| [1124] |
René Leermakers.
The functional treatment of parsing. The Springer International Series in Engineering and Computer Science. Kluwer, 1993. [ bib ] |
| [1125] |
Daniel J. Lehmann.
Algebraic structures for transitive closure. Theoretical Computer Science, 4(1):59--76, 1977. [ bib | http ] |
| [1126] |
Daan Leijen.
Koka: Programming with row polymorphic effect types. In Workshop on Mathematically Structured Functional Programming (MSFP), volume 153, pages 100--126, April 2014. [ bib | .pdf ] |
| [1127] |
Daan Leijen.
Algebraic effects for functional programming. Technical Report MSR-TR-2016-29, Microsoft Research, August 2016. [ bib | http ] |
| [1128] |
Daan Leijen.
Structured asynchrony with algebraic effects. In Type-Driven Development (TyDe), pages 16--29, September 2017. [ bib | .pdf ] |
| [1129] |
Daan Leijen.
Type directed compilation of row-typed algebraic effects. In Principles of Programming Languages (POPL), pages 486--499, January 2017. [ bib | .pdf ] |
| [1130] |
Daan Leijen.
Algebraic effect handlers with resources and deep finalization. Technical Report MSR-TR-2018-10, Microsoft Research, April 2018. [ bib | http ] |
| [1131] |
Daan Leijen.
Koka. https://www.microsoft.com/en-us/research/project/koka/, 2020. [ bib ] |
| [1132] |
Daan Leijen and Anton Lorenzen.
Tail recursion modulo context -- an equational approach. Technical Report MSR-TR-2022-18, Microsoft Research, July 2022. [ bib | http ] |
| [1133] |
K. Rustan M. Leino.
Efficient weakest preconditions. Information Processing Letters, 93(6):281--288, 2005. [ bib | .pdf ] |
| [1134] |
K. Rustan M. Leino.
Dafny: An automatic program verifier for functional correctness. In Logic for Programming Artificial Intelligence and Reasoning (LPAR), volume 6355 of Lecture Notes in Computer Science, pages 348--370. Springer, April 2010. [ bib | .pdf ] |
| [1135] |
K. Rustan M. Leino and Michal Moskal.
VACID-0: Verification of ample correctness of invariants of data-structures, edition 0. Manuscript KRML 209, July 2010. [ bib | .pdf ] |
| [1136] |
K. Rustan M. Leino and Peter Müller.
A basis for verifying multi-threaded programs. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 378--393. Springer, March 2009. [ bib | .pdf ] |
| [1137] |
K. Rustan M. Leino, Peter Müller, and Jan Smans.
Verification of concurrent programs with Chalice. In Foundations of Security Analysis and Design, volume 5705 of Lecture Notes in Computer Science, pages 195--222. Springer, 2009. [ bib | .pdf ] |
| [1138] |
K. Rustan M. Leino, Peter Müller, and Jan Smans.
Deadlock-free channels and locks. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 407--426. Springer, March 2010. [ bib | .pdf ] |
| [1139] |
K. Rustan M. Leino and Greg Nelson.
Data abstraction and information hiding. ACM Transactions on Programming Languages and Systems, 24(5):491--553, 2002. [ bib | .pdf ] |
| [1140] |
K. Rustan M. Leino and Wolfram Schulte.
Using history invariants to verify observers. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 80--94. Springer, 2007. [ bib | .pdf ] |
| [1141] |
Caroline Lemieux, Rohan Padhye, Koushik Sen, and Dawn Song.
PerfFuzz: Automatically generating pathological inputs. In International Symposium on Software Testing and Analysis (ISSTA), pages 254--265, 2018. [ bib | .pdf ] |
| [1142] |
Xavier Leroy.
Polymorphic typing of an algorithmic language. Research Report 1778, INRIA, October 1992. [ bib | http ] |
| [1143] |
Xavier Leroy.
Typage polymorphe d'un langage algorithmique. PhD thesis, Université Paris 7, June 1992. [ bib | .pdf ] |
| [1144] |
Xavier Leroy.
A modular module system. Journal of Functional Programming, 10(3):269--303, 2000. [ bib | .pdf ] |
| [1145] |
Xavier Leroy.
Formal certification of a compiler back-end or: programming a compiler with a proof assistant. In Principles of Programming Languages (POPL), pages 42--54, January 2006. [ bib | .pdf ] |
| [1146] |
Xavier Leroy.
Formal verification of a realistic compiler. Communications of the ACM, 52(7):107--115, 2009. [ bib | http ] |
| [1147] |
Xavier Leroy.
A formally verified compiler back-end. Journal of Automated Reasoning, 43(4):363--446, 2009. [ bib | .pdf ] |
| [1148] |
Xavier Leroy.
Mechanized semantics for compiler verification. In Certified Programs and Proofs (CPP), volume 7679 of Lecture Notes in Computer Science, pages 4--6. Springer, December 2012. [ bib | .pdf ] |
| [1149] |
Xavier Leroy.
The CompCert C compiler. http://compcert.org/, 2024. [ bib ] |
| [1150] |
Xavier Leroy, Damien Doligez, Alain Frisch, Jacques Garrigue, Didier Rémy, and
Jérôme Vouillon.
The OCaml system, February 2024. [ bib | http ] |
| [1151] |
Xavier Leroy, Damien Doligez, Jacques Garrigue, Didier Rémy, and Jérôme
Vouillon.
The Objective Caml system, October 2005. [ bib | http ] |
| [1152] |
Xavier Leroy, Damien Doligez, Michel Mauny, and Pierre Weis.
The Caml Light system, release 0.75, 2002. [ bib | http ] |
| [1153] |
Xavier Leroy and Hervé Grall.
Coinductive big-step operational semantics. Information and Computation, 207(2):284--304, 2009. [ bib | http ] |
| [1154] |
Xavier Leroy and François Pottier.
Notes du cours de DEA « Typage et programmation », December 2002. [ bib | .ps.gz ] |
| [1155] |
Stéphane Lescuyer.
Codage de la logique du premier ordre polymorphe multi-sortée dans la logique sans sortes. Master's thesis, Master Parisien de Recherche en Informatique, 2006. [ bib | .pdf ] |
| [1156] |
Stéphane Lescuyer.
First-class containers in Coq. Studia Informatica Universalis, 9(1):87--127, 2011. [ bib | .pdf ] |
| [1157] |
Thomas Letan, Yann Régis-Gianas, Pierre Chifflier, and Guillaume Hiet.
Modular verification of programs with effects and effect handlers in Coq. In Formal Methods (FM), volume 10951 of Lecture Notes in Computer Science, pages 338--354. Springer, July 2018. [ bib | http ] |
| [1158] |
Thomas Letan, Yann Régis-Gianas, Pierre Chifflier, and Guillaume Hiet.
Modular verification of programs with effects and effects handlers. Formal Aspects of Computing, 33(1):127--150, 2021. [ bib | http ] |
| [1159] |
Pierre Letouzey.
Programmation fonctionnelle certifiée -- l'extraction de programmes dans l'assistant Coq. PhD thesis, Université Paris 11, July 2004. [ bib | .ps.gz ] |
| [1160] |
Paul Blain Levy.
Possible world semantics for general storage in call-by-value. In Computer Science Logic, volume 2471 of Lecture Notes in Computer Science. Springer, 2002. [ bib | .ps ] |
| [1161] |
Jeffrey Lewis, Mark Shields, Erik Meijer, and John Launchbury.
Implicit parameters: Dynamic scoping with static types. In Principles of Programming Languages (POPL), pages 108--118, January 2000. [ bib | .ps ] |
| [1162] |
Ruy Ley-Wild and Aleksandar Nanevski.
Subjective auxiliary state for coarse-grained concurrency. In Principles of Programming Languages (POPL), pages 561--574, January 2013. [ bib | .pdf ] |
| [1163] |
Xin Li and Mizuhito Ogawa.
Conditional weighted pushdown systems and applications. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 141--150, January 2010. [ bib | .pdf ] |
| [1164] |
Xupeng Li, Xuheng Li, Wei Qiang, Ronghui Gu, and Jason Nieh.
Spoq: Scaling machine-checkable systems verification in Coq. In Symposium on Operating Systems Design and Implementation, pages 851--869. USENIX Association, July 2023. [ bib | http ] |
| [1165] |
Yao Li and Stephanie Weirich.
Program adverbs and Tlön embeddings. Proceedings of the ACM on Programming Languages, 6(ICFP):312--342, 2022. [ bib | http ] |
| [1166] |
Yao Li, Li-yao Xia, and Stephanie Weirich.
Reasoning about the garden of forking paths. Proceedings of the ACM on Programming Languages, 5(ICFP):1--28, 2021. [ bib | http ] |
| [1167] |
Sheng Liang, Paul Hudak, and Mark P. Jones.
Monad transformers and modular interpreters. In Principles of Programming Languages (POPL), pages 333--343, January 1995. [ bib | http ] |
| [1168] |
Daniel R. Licata and Robert Harper.
A universe of binding and computation. In International Conference on Functional Programming (ICFP), pages 123--134, September 2009. [ bib | .pdf ] |
| [1169] |
Daniel R. Licata, Noam Zeilberger, and Robert Harper.
Focusing on binding and computation. In Logic in Computer Science (LICS), pages 241--252, June 2008. [ bib | .pdf ] |
| [1170] |
Daniel R. Licata, Noam Zeilberger, and Robert Harper.
Focusing on binding and computation. Technical Report CMU-CS-08-101, Carnegie Mellon University, February 2008. [ bib | .pdf ] |
| [1171] |
Sam Lindley, Conor McBride, and Craig McLaughlin.
Do be do be do. In Principles of Programming Languages (POPL), January 2017. [ bib | .pdf ] |
| [1172] |
Nathan Linger and Tim Sheard.
Programming with static invariants in Ωmega. Unpublished, September 2004. [ bib | .ps ] |
| [1173] |
Barbara Liskov and John V. Guttag.
Program development in Java -- abstraction, specification, and object-oriented design. Addison-Wesley, 2001. [ bib | http ] |
| [1174] |
Barbara Liskov and Jeannette M. Wing.
A behavioral notion of subtyping. ACM Transactions on Programming Languages and Systems, 16(6):1811--1841, 1994. [ bib | .pdf ] |
| [1175] |
Barbara H. Liskov and Alan Snyder.
Exception handling in CLU. IEEE Transactions on Software Engineering, 5(6):546--558, 1979. [ bib | .pdf ] |
| [1176] |
Xinxin Liu and Scott A. Smolka.
Simple linear-time algorithms for minimal fixed points. In International Colloquium on Automata, Languages and Programming, volume 1443 of Lecture Notes in Computer Science, pages 53--66. Springer, July 1998. [ bib | http ] |
| [1177] |
Fang-Yi Lo, Chao-Hong Chen, and Ying-Ping Chen.
Shrinking counterexamples in property-based testing with genetic algorithms. In IEEE Congress on Evolutionary Computation, pages 1--8, July 2020. [ bib | .pdf ] |
| [1178] |
Andreas Lochbihler.
Java and the Java memory model -- a unified, machine-checked formalisation. In European Symposium on Programming (ESOP), volume 7211 of Lecture Notes in Computer Science, pages 497--517. Springer, March 2012. [ bib | .pdf ] |
| [1179] |
Andreas Lochbihler.
Light-weight containers for Isabelle: efficient, extensible, nestable. In Interactive Theorem Proving (ITP), volume 7998 of Lecture Notes in Computer Science, pages 116--132. Springer, July 2013. [ bib | .pdf ] |
| [1180] |
John Longley.
When is a functional program not a functional program? In International Conference on Functional Programming (ICFP), pages 1--7, September 1999. [ bib | http ] |
| [1181] |
John Longley and Randy Pollack.
Reasoning about CBV functional programs in Isabelle/HOL. In Theorem Proving in Higher Order Logics (TPHOLs), volume 3223 of Lecture Notes in Computer Science, pages 201--216. Springer, September 2004. [ bib | .pdf ] |
| [1182] |
Anton Lorenzen, Daan Leijen, and Wouter Swierstra.
FP2: Fully in-place functional programming. Proceedings of the ACM on Programming Languages, 7(ICFP):275--304, August 2023. [ bib | http ] |
| [1183] |
John M. Lucassen and David K. Gifford.
Polymorphic effect systems. In Principles of Programming Languages (POPL), pages 47--57, January 1988. [ bib | .pdf ] |
| [1184] |
Kasper Søe Luckow, Rody Kersten, and Corina S. Pasareanu.
Symbolic complexity analysis using context-preserving histories. In Software Testing, Verification and Validation (ICST), pages 58--68, March 2017. [ bib | http ] |
| [1185] |
Ralf Lämmel and Simon Peyton Jones.
Scrap your boilerplate with class: extensible generic functions. Submitted, April 2005. [ bib | .ps ] |
| [1186] |
Ralf Lämmel, Joost Visser, and Jan Kort.
Dealing with large bananas. In Workshop on Generic Programming, pages 46--59, July 2000. [ bib | .ps ] |
| [1187] |
Kenneth MacKenzie and Nicholas Wolverson.
Camelot and Grail: resource-aware functional programming for the JVM. In Trends in Functional Programming (TFP), volume 4, pages 29--46, September 2003. [ bib | .ps ] |
| [1188] |
David B. MacQueen, Gordon D. Plotkin, and Ravi Sethi.
An ideal model for recursive polymorphic types. Information and Control, 71(1--2):95--130, October--November 1986. [ bib ] |
| [1189] |
Angelika Mader.
Verification of modal properties using Boolean equation systems. PhD thesis, Technische Universität München, 1997. [ bib | .pdf ] |
| [1190] |
Ravichandhran Madhavan, Sumith Kulal, and Viktor Kuncak.
Contract-based resource verification for higher-order functions with memoization. In Principles of Programming Languages (POPL), pages 330--343, January 2017. [ bib | http ] |
| [1191] |
Jean-Marie Madiot and François Pottier.
A separation logic for heap space under garbage collection. Proceedings of the ACM on Programming Languages, 6(POPL):718--747, January 2022. [ bib | .pdf ] |
| [1192] |
Magnus Madsen, Ming-Ho Yee, and Ondrej Lhoták.
From Datalog to Flix: a declarative language for fixed points on lattices. In Programming Language Design and Implementation (PLDI), pages 194--208, June 2016. [ bib | .pdf ] |
| [1193] |
Toshiyuki Maeda, Haruki Sato, and Akinori Yonezawa.
Extended alias type system using separating implication. In Types in Language Design and Implementation (TLDI), pages 29--42, January 2011. [ bib | http ] |
| [1194] |
Michael J. Maher.
Complete axiomatizations of the algebras of finite, rational and infinite trees. In Logic in Computer Science (LICS), pages 348--357, July 1988. [ bib ] |
| [1195] |
Kenji Maillard, Danel Ahman, Robert Atkey, Guido Martínez, Catalin
Hritcu, Exequiel Rivas, and éric Tanter.
Dijkstra monads for all. Proceedings of the ACM on Programming Languages, 3(ICFP):104:1--104:29, 2019. [ bib | http ] |
| [1196] |
Harry G. Mairson.
Deciding ML typability is complete for deterministic exponential time. In Principles of Programming Languages (POPL), pages 382--401, 1990. [ bib | http ] |
| [1197] |
Harry G. Mairson, Paris C. Kanellakis, and John C. Mitchell.
Unification and ML type reconstruction. In J.-L. Lassez and G. Plotkin, editors, Computational Logic: Essays in Honor of Alan Robinson, pages 444--478. MIT Press, 1991. [ bib ] |
| [1198] |
Donna Malayeri and Jonathan Aldrich.
Practical exception specifications. In Advanced Topics in Exception Handling Techniques, volume 4119 of Lecture Notes in Computer Science, pages 200--220. Springer, 2006. [ bib | .pdf ] |
| [1199] |
William Mansky, Yuanfeng Peng, Steve Zdancewic, and Joseph Devietti.
Verifying dynamic race detection. In Certified Programs and Proofs (CPP), pages 151--163, January 2017. [ bib | http ] |
| [1200] |
Jeremy Manson, William Pugh, and Sarita V. Adve.
The Java memory model. In Principles of Programming Languages (POPL), pages 378--391, January 2005. [ bib | .pdf ] |
| [1201] |
Oleksandr Manzyuk.
A simply typed λ-calculus of forward automatic differentiation. In Mathematical Foundations of Programming Semantics, volume 286 of Electronic Notes in Theoretical Computer Science, pages 257--272. Elsevier, June 2012. [ bib | http ] |
| [1202] |
Claude Marché, Christine Paulin-Mohring, and Xavier Urbain.
The Krakatoa tool for certification of Java/JavaCard programs annotated in JML. Journal of Logic and Algebraic Programming, 58(1--2):89--106, 2004. [ bib | .ps.gz ] |
| [1203] |
Filip Marić.
Formalization and implementation of modern SAT solvers. Journal of Automated Reasoning, 43:81--119, 2009. [ bib | .pdf ] |
| [1204] |
Filip Marić.
Formal verification of a modern SAT solver. Unpublished, January 2010. [ bib | .pdf ] |
| [1205] |
Simon Marlow and Andy Gill.
Happy: the parser generator for Haskell, April 2004. [ bib | http ] |
| [1206] |
Simon Marlow, Simon L. Peyton Jones, and Satnam Singh.
Runtime support for multicore Haskell. In International Conference on Functional Programming (ICFP), pages 65--78, September 2009. [ bib | .pdf ] |
| [1207] |
Simon Marlow and Philip Wadler.
A practical subtyping system for Erlang. In International Conference on Functional Programming (ICFP), pages 136--149, June 1997. [ bib ] |
| [1208] |
Kim Marriott and Martin Odersky.
Negative Boolean constraints. Technical Report 94/203, Monash University, August 1994. [ bib | .ps.gz ] |
| [1209] |
Alberto Martelli and Ugo Montanari.
An efficient unification algorithm. ACM Transactions on Programming Languages and Systems, 4(2):258--282, April 1982. [ bib | http ] |
| [1210] |
Guido Martínez, Danel Ahman, Victor Dumitrescu, Nick Giannarakis, Chris
Hawblitzel, Catalin Hritcu, Monal Narasimhamurthy, Zoe Paraskevopoulou,
Clément Pit-Claudel, Jonathan Protzenko, Tahina Ramananandro, Aseem
Rastogi, and Nikhil Swamy.
Meta-F*: Proof automation with SMT, tactics, and metaprograms. In European Symposium on Programming (ESOP), volume 11423 of Lecture Notes in Computer Science, pages 30--59. Springer, April 2019. [ bib | .pdf ] |
| [1211] |
Radu Mateescu and Mihaela Sighireanu.
Efficient on-the-fly model-checking for regular alternation-free mu-calculus. Science of Computer Programming, 46(3):255--281, 2003. [ bib | .pdf ] |
| [1212] |
Nicholas D. Matsakis and Felix S. Klock,II.
The Rust language. In ACM SIGAda Annual Conference on High Integrity Language Technology (HILT), pages 103--104, 2014. [ bib | http ] |
| [1213] |
Kazutaka Matsuda and Meng Wang.
FliPpr: A prettier invertible printing system. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 101--120. Springer, March 2013. [ bib | .pdf ] |
| [1214] |
Friedemann Mattern.
Virtual time and global states of distributed systems. In International Workshop on Parallel and Distributed Algorithms, October 1988. [ bib | .pdf ] |
| [1215] |
Michel Mauny and François Pottier.
An implementation of Caml Light with existential types. Technical Report 2183, INRIA, 1993. [ bib | .ps.gz ] |
| [1216] |
Karl Mazurak, Jianzhou Zhao, and Steve Zdancewic.
Lightweight linear types in system Fo. In Types in Language Design and Implementation (TLDI), pages 77--88, January 2010. [ bib | .pdf ] |
| [1217] |
Damiano Mazza and Michele Pagani.
Automatic differentiation in PCF. Proceedings of the ACM on Programming Languages, 5(POPL):1--27, 2021. [ bib | http ] |
| [1218] |
Bruce J. McAdam.
On the Unification of Substitutions in Type Inference. In Implementation of Functional Languages (IFL), volume 1595 of Lecture Notes in Computer Science, pages 139--154. Springer, September 1998. [ bib | .ps ] |
| [1219] |
David McAllester.
On the complexity analysis of static analyses. Journal of the ACM, 49(4):512--537, July 2002. [ bib | http ] |
| [1220] |
David McAllester.
A logical algorithm for ML type inference. In Rewriting Techniques and Applications (RTA), volume 2706 of Lecture Notes in Computer Science, pages 436--451. Springer, June 2003. [ bib | .ps ] |
| [1221] |
Conor McBride.
The derivative of a regular type is its type of one-hole contexts. Unpublished. [ bib | .pdf ] |
| [1222] |
Conor McBride.
Dependently typed functional programs and their proofs. PhD thesis, University of Edinburgh, 2000. [ bib | http ] |
| [1223] |
Conor McBride.
First-order unification by structural recursion. Journal of Functional Programming, 13(6):1061--1075, 2003. [ bib | .ps.gz ] |
| [1224] |
Conor McBride.
Turing-completeness totally free. In Mathematics of Program Construction (MPC), volume 9129 of Lecture Notes in Computer Science, pages 257--275. Springer, June 2015. [ bib | .pdf ] |
| [1225] |
Conor McBride and James McKinna.
I am not a number: I am a free variable. In Haskell workshop, September 2004. [ bib | .pdf ] |
| [1226] |
Conor McBride and Ross Paterson.
Applicative programming with effects. Journal of Functional Programming, 18(1):1--13, 2008. [ bib | .pdf ] |
| [1227] |
Jay A. McCarthy, Burke Fetscher, Max S. New, Daniel Feltey, and Robert Bruce
Findler.
A Coq library for internal verification of running-times. In Functional and Logic Programming, volume 9613 of Lecture Notes in Computer Science, pages 144--162. Springer, March 2016. [ bib | .pdf ] |
| [1228] |
Andrew McCreight, Tim Chevalier, and Andrew P. Tolmach.
A certified framework for compiling and executing garbage-collected languages. In International Conference on Functional Programming (ICFP), pages 273--284, September 2010. [ bib | .pdf ] |
| [1229] |
Andrew McCreight, Zhong Shao, Chunxiao Lin, and Long Li.
A general framework for certifying garbage collectors and their mutators. In Programming Language Design and Implementation (PLDI), pages 468--479, June 2007. [ bib | http ] |
| [1230] |
James McKinna and Randy Pollack.
Pure type systems formalized. In Typed Lambda Calculi and Applications (TLCA), number 664 in Lecture Notes in Computer Science, pages 289--305. Springer, March 1993. [ bib | .ps.gz ] |
| [1231] |
James McKinna and Randy Pollack.
Some lambda calculus and type theory formalized. Journal of Automated Reasoning, 23(3--4):373--409, 1999. [ bib ] |
| [1232] |
John McLean.
A general theory of composition for trace sets closed under selective interleaving functions. In IEEE Symposium on Security and Privacy (S&P), 1994. [ bib | .ps ] |
| [1233] |
John McLean.
Security models. In John Marciniak, editor, Encyclopedia of Software Engineering. John Wiley & Sons, 1994. [ bib | .ps ] |
| [1234] |
Catherine Meadows.
Formal verification of cryptographic protocols: A survey. In Advances in Cryptology -- ASIACRYPT'94, volume 917 of Lecture Notes in Computer Science, pages 133--150. Springer, 1995. [ bib | .ps ] |
| [1235] |
Hannes Mehnert, Filip Sieczkowski, Lars Birkedal, and Peter Sestoft.
Formalized verification of snapshotable trees: Separation and sharing. In Verified Software: Theories, Tools and Experiments, volume 7152 of Lecture Notes in Computer Science, pages 179--195. Springer, January 2012. [ bib | .pdf ] |
| [1236] |
Farhad Mehta and Tobias Nipkow.
Proving pointer programs in higher-order logic. Information and Computation, 199(1--2):200--227, 2005. [ bib | .ps.gz ] |
| [1237] |
Thomas F. Melham.
The HOL logic extended with quantification over type variables. Formal Methods in System Design, 3(1--2):7--24, August 1993. [ bib | .pdf ] |
| [1238] |
David Melski and Thomas Reps.
Interconvertibility of a class of set constraints and context-free language reachability. Theoretical Computer Science, 248(1--2), November 2000. [ bib | .ps ] |
| [1239] |
Denis Merigoux, Nicolas Chataing, and Jonathan Protzenko.
Catala: a programming language for the law. Proceedings of the ACM on Programming Languages, 5(ICFP):1--29, 2021. [ bib | http ] |
| [1240] |
Stephan Merz.
Model checking: A tutorial overview. In Fourth Summer School on Modeling and Verification of Parallel Processes, volume 2067 of Lecture Notes in Computer Science, pages 3--38. Springer, 2001. [ bib | .pdf ] |
| [1241] |
Stephan Merz.
An introduction to model checking. In N. Navet and S. Merz, editors, Modeling and Verification of Real-Time Systems: Formalisms and Software Tools, pages 77--109. ISTE Publishing, 2008. [ bib | .pdf ] |
| [1242] |
Albert R. Meyer and Mitchell Wand.
Continuation semantics in typed lambda-calculi. In Logics of Programs, volume 193 of Lecture Notes in Computer Science, pages 219--224. Springer, June 1985. [ bib | .ps ] |
| [1243] |
Jan Midtgaard.
QuickChecking Patricia trees. In Trends in Functional Programming (TFP), volume 10788 of Lecture Notes in Computer Science, pages 59--78. Springer, 2017. [ bib | .pdf ] |
| [1244] |
Radu Mihaescu and Robert E. Tarjan.
Notes on catenable deques in pure Lisp. Unpublished course notes, COS 528, 2003. [ bib | http ] |
| [1245] |
Mae Milano, Joshua Turcotti, and Andrew C. Myers.
A flexible type system for fearless concurrency. In Programming Language Design and Implementation (PLDI), pages 458--473, June 2022. [ bib | http ] |
| [1246] |
Barton P. Miller, Lars Fredriksen, and Bryan So.
An empirical study of the reliability of UNIX utilities. Communications of the ACM, 33(12):32--44, 1990. [ bib | .pdf ] |
| [1247] |
Dale Miller.
An extension to ML to handle bound variables in data structures. In Logical Frameworks BRA Workshop, May 1990. [ bib | .pdf ] |
| [1248] |
Dale Miller.
Unification under a mixed prefix. Journal of Symbolic Computation, 14(4):321--358, 1992. [ bib | .pdf ] |
| [1249] |
Dale Miller.
Abstract syntax for variable binders: An overview. In Computational Logic, volume 1861 of Lecture Notes in Computer Science, pages 239--253. Springer, July 2000. [ bib | .pdf ] |
| [1250] |
Todd Millstein and Craig Chambers.
Modular statically typed multimethods. In European Conference on Object-Oriented Programming (ECOOP), volume 1628 of Lecture Notes in Computer Science, pages 279--303. Springer, June 1999. [ bib | .ps ] |
| [1251] |
Todd Millstein and Craig Chambers.
Modular statically typed multimethods. Information and Computation, 175(1):76--118, May 2002. [ bib | .ps ] |
| [1252] |
Robin Milner.
Implementation and applications of Scott's logic for computable functions. In Proceedings of the ACM conference on proving assertions about programs, pages 1--6, January 1972. [ bib | http ] |
| [1253] |
Robin Milner.
Logic for computable functions -- description of a machine implementation. Technical Report CS-TR-72-288, Stanford University, Department of Computer Science, May 1972. [ bib | .pdf ] |
| [1254] |
Robin Milner.
Models of LCF. Technical Report CS-TR-73-332, Stanford University, Department of Computer Science, January 1973. [ bib | .pdf ] |
| [1255] |
Robin Milner.
A theory of type polymorphism in programming. Journal of Computer and System Sciences, 17(3):348--375, December 1978. [ bib | http ] |
| [1256] |
Robin Milner.
The polyadic π-calculus: a tutorial. Technical Report ECS--LFCS--91--180, Laboratory for Foundations of Computer Science, Department of Computer Science, University of Edinburgh, October 1991. [ bib | .ps.Z ] |
| [1257] |
Robin Milner, Joachim Parrow, and David Walker.
A calculus of mobile processes, part 2. Technical Report ECS-LFCS-89-86, Laboratory for Foundations of Computer Science, School of Informatics at the University of Edinburgh, 1989. [ bib | .ps ] |
| [1258] |
Robin Milner and Davide Sangiorgi.
Barbed bisimulation. In International Colloquium on Automata, Languages and Programming, volume 623 of Lecture Notes in Computer Science, pages 685--695. Springer, July 1992. [ bib | .ps.gz ] |
| [1259] |
Robin Milner, Mads Tofte, Robert Harper, and David MacQueen.
The definition of Standard ML -- revised. MIT Press, May 1997. [ bib ] |
| [1260] |
Yasuhiko Minamide.
A functional representation of data structures with a hole. In Principles of Programming Languages (POPL), pages 75--84, January 1998. [ bib | .pdf ] |
| [1261] |
Yasuhiko Minamide.
Space-profiling semantics of the call-by-value lambda calculus and the CPS transformation. Electronic Notes in Theoretical Computer Science, 26:105--120, 1999. [ bib | http ] |
| [1262] |
Yasuhiko Minamide and Shunsuke Mori.
Reachability analysis of the HTML5 parser specification and its application to compatibility testing. In Formal Methods (FM), volume 7436 of Lecture Notes in Computer Science, pages 293--307. Springer, August 2012. [ bib | .pdf ] |
| [1263] |
Yasuhiko Minamide, Greg Morrisett, and Robert Harper.
Typed closure conversion. In Principles of Programming Languages (POPL), pages 271--283, January 1996. [ bib | .pdf ] |
| [1264] |
Yasuhiko Minamide and Koji Okuma.
Verifying CPS transformations in Isabelle/HOL. In ACM Workshop on Mechanized Reasoning about Languages with Variable Binding, 2003. [ bib | http ] |
| [1265] |
Yaron Minsky, Anil Madhavapeddy, and Jason Hickey.
Real world OCaml: Functional programming for the masses, second edition. Cambridge University Press, October 2022. [ bib | http ] |
| [1266] |
David G. Mitchell.
A SAT solver primer. Bulletin of the EATCS, 85:112--133, February 2005. [ bib | .pdf ] |
| [1267] |
John C. Mitchell.
Coercion and type inference. In Principles of Programming Languages (POPL), pages 175--185, January 1984. [ bib | http ] |
| [1268] |
John C. Mitchell.
Representation independence and data abstraction. In Principles of Programming Languages (POPL), pages 263--276, 1986. [ bib | http ] |
| [1269] |
John C. Mitchell.
Polymorphic type inference and containment. Information and Computation, 76(2--3):211--249, 1988. [ bib | http ] |
| [1270] |
John C. Mitchell.
Type inference with simple subtypes. Journal of Functional Programming, 1(3):245--286, July 1991. [ bib ] |
| [1271] |
John C. Mitchell.
Foundations for programming languages. MIT Press, 1996. [ bib ] |
| [1272] |
John C. Mitchell and Gordon D. Plotkin.
Abstract types have existential type. ACM Transactions on Programming Languages and Systems, 10(3):470--502, 1988. [ bib | .pdf ] |
| [1273] |
Masaaki Mizuno and David A. Schmidt.
A security flow control algorithm and its denotational semantics correctness proof. Formal Aspects of Computing, 4(6A):727--754, 1992. [ bib | .ps.Z ] |
| [1274] |
Eugenio Moggi.
An abstract view of programming languages. Technical Report ECS-LFCS-90-113, University of Edinburgh, June 1989. [ bib | .ps.gz ] |
| [1275] |
Eugenio Moggi.
Computational λ-calculus and monads. In Logic in Computer Science (LICS), pages 14--23, June 1989. [ bib | .ps.gz ] |
| [1276] |
Eugenio Moggi.
Notions of computation and monads. Information and Computation, 93(1), 1991. [ bib | .pdf ] |
| [1277] |
Eugenio Moggi and Amr Sabry.
An abstract monadic semantics for value recursion. Informatique théorique et applications, 38(4):377--400, 2004. [ bib | .pdf ] |
| [1278] |
Anshuman Mohan, Wei Xiang Leow, and Aquinas Hobor.
Functional correctness of C implementations of Dijkstra's, Kruskal's, and Prim's algorithms. In Computer Aided Verification (CAV), volume 12760 of Lecture Notes in Computer Science, pages 801--826. Springer, July 2021. [ bib | .pdf ] |
| [1279] |
Alexandre Moine, Arthur Charguéraud, and François Pottier.
A high-level separation logic for heap space under garbage collection. Proceedings of the ACM on Programming Languages, 7(POPL):718--747, January 2023. [ bib | http ] |
| [1280] |
Anders Møller and Michael I. Schwartzbach.
The pointer assertion logic engine. In Programming Language Design and Implementation (PLDI), pages 221--231, June 2001. [ bib | .pdf ] |
| [1281] |
Jean-François Monin.
Proof pearl: From concrete to functional unparsing. In Theorem Proving in Higher Order Logics (TPHOLs), volume 3223, pages 217--224. Springer, September 2004. [ bib | http ] |
| [1282] |
Stefan Monnier.
Statically tracking state with typed regions. Unpublished, May 2008. [ bib | .pdf ] |
| [1283] |
Benoît Montagu and Didier Rémy.
Modeling abstract types in modules with open existential types. In Principles of Programming Languages (POPL), pages 63--74, January 2009. [ bib | .pdf ] |
| [1284] |
Andrew Moran and David Sands.
Improvement in a lazy context: An operational theory for call-by-need. In Principles of Programming Languages (POPL), pages 43--56, January 1999. [ bib | .pdf ] |
| [1285] |
James H. Morris, Donald E. Knuth, and Vaughan R. Pratt.
Fast pattern matching in strings. SIAM Journal on Computing, 6(2):323--350, June 1977. [ bib | .pdf ] |
| [1286] |
Greg Morrisett and Robert Harper.
Typed closure conversion for recursively-defined functions (extended abstract). In Higher Order Operational Techniques in Semantics (HOOTS), volume 10 of Electronic Notes in Theoretical Computer Science. Elsevier, 1998. [ bib | .ps ] |
| [1287] |
Greg Morrisett, David Walker, Karl Crary, and Neal Glew.
From system F to typed assembly language. ACM Transactions on Programming Languages and Systems, 21(3):528--569, May 1999. [ bib | .pdf ] |
| [1288] |
J. Gregory Morrisett, Matthias Felleisen, and Robert Harper.
Abstract models of memory management. In Functional Programming Languages and Computer Architecture (FPCA), pages 66--77, June 1995. [ bib | .pdf ] |
| [1289] |
Matthew W. Moskewicz, Conor F. Madigan, Ying Zhao, Lintao Zhang, and Sharad
Malik.
Chaff: Engineering an efficient SAT solver. In Design Automation Conference (DAC), July 2001. [ bib | .pdf ] |
| [1290] |
Peter D. Mosses.
Modular structural operational semantics. Journal of Logic and Algebraic Programming, 60--61:195--228, 2004. [ bib | .pdf ] |
| [1291] |
Rashmi Mudduluru and Murali Krishna Ramanathan.
Efficient flow profiling for detecting performance bugs. In International Symposium on Software Testing and Analysis (ISSTA), pages 413--424, 2016. [ bib | .pdf ] |
| [1292] |
Ike Mulder, Robbert Krebbers, and Herman Geuvers.
Diaframe: automated verification of fine-grained concurrent programs in Iris. In Programming Language Design and Implementation (PLDI), pages 809--824, June 2022. [ bib | http ] |
| [1293] |
Gilles Muller, Renaud Marlet, Eugen-Nicolae Volanschi, Charles Consel, Calton
Pu, and Ashvin Goel.
Fast, optimized Sun RPC using automatic program specialization. In International Conference on Distributed Computing Systems (CDCS), pages 240--249, May 1998. [ bib | .pdf ] |
| [1294] |
Martin Müller.
A constraint-based recast of ML-polymorphism. In International Workshop on Unification, June 1994. Technical Report 94-R-243, CRIN, Nancy, France. [ bib | .ps ] |
| [1295] |
Martin Müller.
Notes on HM(X). Unpublished, August 1998. [ bib | .ps.gz ] |
| [1296] |
Martin Müller, Joachim Niehren, and Ralf Treinen.
The first-order theory of ordering constraints over feature trees. Discrete Mathematics and Theoretical Computer Science, 4(2):193--234, 2001. [ bib | .ps ] |
| [1297] |
Martin Müller and Susumu Nishimura.
Type inference for first-class messages with feature constraints. In Asian Computer Science Conference (ASIAN), volume 1538 of Lecture Notes in Computer Science, pages 169--187. Springer, December 1998. [ bib | .ps ] |
| [1298] |
Martin Müller and Susumu Nishimura.
Type inference for first-class messages with feature constraints. International Journal of Foundations of Computer Science, 11(1):29--63, 2000. [ bib ] |
| [1299] |
Peter Müller and Arnd Poetzsch-Heffter.
Universes: A type system for alias and dependency control. Technical Report 279, Fernuniversität Hagen, 2001. [ bib | .pdf ] |
| [1300] |
Peter Müller and Arsenii Rudich.
Ownership transfer in universe types. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 461--478, October 2007. [ bib | http ] |
| [1301] |
Peter Müller, Malte Schwerhoff, and Alexander J. Summers.
Automatic verification of iterated separating conjunctions using symbolic execution. In Computer Aided Verification (CAV), volume 9779 of Lecture Notes in Computer Science, pages 405--425. Springer, July 2016. [ bib | http ] |
| [1302] |
Peter Müller, Malte Schwerhoff, and Alexander J. Summers.
Viper: A verification infrastructure for permission-based reasoning. In Dependable Software Systems Engineering, NATO Science for Peace and Security Series - D: Information and Communication Security, pages 104--125. IOS Press, 2017. [ bib | http ] |
| [1303] |
Peter Müller and Natarajan Shankar.
The first fifteen years of the verified software project. In Cliff B. Jones and Jayadev Misra, editors, Theories of Programming: The Life and Works of Tony Hoare, pages 93--124. ACM / Morgan & Claypool, 2021. [ bib | http ] |
| [1304] |
K. Muthukumar and M. V. Hermenegildo.
Deriving A fixpoint computation algorithm for top-down abstract interpretation of logic programs. Technical Report ACT-DC-153-90, Microelectronics and Computer Technology Corporation, April 1990. [ bib | .pdf ] |
| [1305] |
Alan Mycroft.
Polymorphic type schemes and recursive definitions. In International Symposium on Programming, volume 167 of Lecture Notes in Computer Science, pages 217--228. Springer, April 1984. [ bib | http ] |
| [1306] |
Andrew C. Myers.
JFlow: practical mostly-static information flow control. In Principles of Programming Languages (POPL), pages 228--241, January 1999. [ bib | .ps.gz ] |
| [1307] |
Andrew C. Myers.
Mostly-static decentralized information flow control. PhD thesis, Massachusetts Institute of Technology, January 1999. Technical Report MIT/LCS/TR-783. [ bib | .ps.gz ] |
| [1308] |
Andrew C. Myers and Barbara Liskov.
A decentralized model for information flow control. ACM Operating Systems Review, 31(5):129--142, October 1997. [ bib | .html ] |
| [1309] |
Andrew C. Myers and Barbara Liskov.
Complete, safe information flow with decentralized labels. In IEEE Symposium on Security and Privacy (S&P), pages 186--197, May 1998. [ bib | .html ] |
| [1310] |
Andrew C. Myers and Barbara Liskov.
Protecting privacy using the decentralized label model. ACM Transactions on Software Engineering and Methodology, 9(4):410--442, October 2000. [ bib | .ps.gz ] |
| [1311] |
Andrew C. Myers and Andrei Sabelfeld.
Language-based information-flow security. IEEE Journal on Selected Areas in Communications, 21(1):5--19, January 2003. [ bib | .pdf ] |
| [1312] |
Magnus O. Myreen.
The CakeML project's quest for ever stronger correctness theorems. In Interactive Theorem Proving (ITP), volume 193 of Leibniz International Proceedings in Informatics, pages 1:1--1:10. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, June 2021. [ bib | http ] |
| [1313] |
Glen Mével and Jacques-Henri Jourdan.
Formal verification of a concurrent bounded queue in a weak memory model. Proceedings of the ACM on Programming Languages, 5(ICFP):1--29, 2021. [ bib | http ] |
| [1314] |
Glen Mével, Jacques-Henri Jourdan, and François Pottier.
Time credits and time receipts in Iris. In European Symposium on Programming (ESOP), volume 11423 of Lecture Notes in Computer Science, pages 1--27. Springer, April 2019. [ bib | .pdf ] |
| [1315] |
Glen Mével, Jacques-Henri Jourdan, and François Pottier.
Cosmo: A concurrent separation logic for Multicore OCaml. Proceedings of the ACM on Programming Languages, 4(ICFP), June 2020. [ bib | .pdf ] |
| [1316] |
Rasmus Ejlers Møgelberg and Sam Staton.
Full abstraction in a metalanguage for state. In Workshop on Syntax and Semantics of Low Level Languages, July 2010. [ bib ] |
| [1317] |
Martin Müller, Joachim Niehren, and Andreas Podelski.
Ordering constraints over feature trees. Constraints, an International Journal, 5(1--2):7--42, 2000. [ bib | .ps.gz ] |
| [1318] |
Olaf Müller, Tobias Nipkow, David von Oheimb, and Oskar Slotosch.
HOLCF = HOL + LCF. Journal of Functional Programming, 9:191--223, 1999. [ bib | .ps.gz ] |
| [1319] |
Gopalan Nadathur and Dale Miller.
An overview of lambda-prolog. In Logic Programming, pages 810--827, August 1988. [ bib | http ] |
| [1320] |
Gopalan Nadathur and Xiaochu Qi.
Explicit substitutions in the reduction of lambda terms. In Principles and Practice of Declarative Programming (PPDP), pages 195--206, August 2003. [ bib | .ps ] |
| [1321] |
Karl Naden, Robert Bocchino, Jonathan Aldrich, and Kevin Bierhoff.
A type system for borrowing permissions. In Principles of Programming Languages (POPL), pages 557--570, January 2012. [ bib | .pdf ] |
| [1322] |
Maurice Naftalin and Philip Wadler.
Java generics and collections. O'Reilly, 2006. [ bib | http ] |
| [1323] |
Ramana Nagasamudram, Anindya Banerjee, and David A. Naumann.
Alignment complete relational Hoare logics for some and all. 2023. [ bib | http ] |
| [1324] |
Ramana Nagasamudram, Anindya Banerjee, and David A. Naumann.
The WhyRel prototype for modular relational verification of pointer programs. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 13994 of Lecture Notes in Computer Science, pages 133--151. Springer, April 2023. [ bib | http ] |
| [1325] |
Hiroshi Nakano.
A modality for recursion. In Logic in Computer Science (LICS), pages 255--266, June 2000. [ bib | .ps.gz ] |
| [1326] |
Hiroshi Nakano.
Fixed-point logic with the approximation modality and its Kripke completeness. In International Symposium on Theoretical Aspects of Computer Software (TACS), volume 2215 of Lecture Notes in Computer Science, pages 165--182. Springer, October 2001. [ bib | .pdf ] |
| [1327] |
Aleksandar Nanevski.
Meta-programming with names and necessity. Technical Report CMU-CS-02-123R, School of Computer Science, Carnegie Mellon University, November 2002. [ bib | .pdf ] |
| [1328] |
Aleksandar Nanevski, Amal Ahmed, Greg Morrisett, and Lars Birkedal.
Abstract predicates and mutable ADTs in Hoare type theory. In European Symposium on Programming (ESOP), volume 4421 of Lecture Notes in Computer Science, pages 189--204. Springer, March 2007. [ bib | .pdf ] |
| [1329] |
Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal.
Polymorphism and separation in Hoare type theory. In International Conference on Functional Programming (ICFP), pages 62--73, September 2006. [ bib | http ] |
| [1330] |
Aleksandar Nanevski, Greg Morrisett, and Lars Birkedal.
Hoare type theory, polymorphism and separation. Journal of Functional Programming, 18(5--6):865--911, 2008. [ bib | .pdf ] |
| [1331] |
Aleksandar Nanevski, Greg Morrisett, Avraham Shinnar, Paul Govereau, and Lars
Birkedal.
Ynot: dependent types for imperative programs. In International Conference on Functional Programming (ICFP), pages 229--240, September 2008. [ bib | .pdf ] |
| [1332] |
Aleksandar Nanevski, Viktor Vafeiadis, and Josh Berdine.
Structuring the verification of heap-manipulating programs. In Principles of Programming Languages (POPL), pages 261--274, January 2010. [ bib | .pdf ] |
| [1333] |
Wolfgang Naraschewski and Tobias Nipkow.
Type inference verified: Algorithm W in Isabelle/HOL. Journal of Automated Reasoning, 23:299--318, 1999. [ bib | .ps.gz ] |
| [1334] |
David A. Naumann.
On assertion-based encapsulation for object invariants and simulations. Formal Aspects of Computing, 19(2):205--224, 2007. [ bib | .pdf ] |
| [1335] |
David A. Naumann.
Thirty-seven years of relational hoare logic: Remarks on its principles and history. In International Symposium on Leveraging Applications of Formal Methods, volume 12477 of Lecture Notes in Computer Science, pages 93--116. Springer, October 2020. [ bib | http ] |
| [1336] |
Uwe Naumann.
The art of differentiating computer programs -- an introduction to algorithmic differentiation, volume 24 of Software, environments, tools. SIAM, 2012. [ bib | http ] |
| [1337] |
Juan Antonio Navarro Pérez and Andrey Rybalchenko.
Separation logic + superposition calculus = heap theorem prover. In Programming Language Design and Implementation (PLDI), pages 556--566, June 2011. [ bib | .pdf ] |
| [1338] |
Dieter Nazareth and Tobias Nipkow.
Formal verification of algorithm W: The monomorphic case. In Theorem Proving in Higher Order Logics (TPHOLs), volume 1125 of Lecture Notes in Computer Science, pages 331--345. Springer, August 1996. [ bib | .html ] |
| [1339] |
Pierre Neron, Andrew P. Tolmach, Eelco Visser, and Guido Wachsmuth.
A theory of name resolution. In European Symposium on Programming (ESOP), volume 9032 of Lecture Notes in Computer Science, pages 205--231. Springer, April 2015. [ bib | .pdf ] |
| [1340] |
René Neumann.
A framework for verified depth-first algorithms. In ATx/WInG: Joint Proceedings of the Workshops on Automated Theory eXploration and on Invariant Generation, volume 17 of EPiC Series, pages 36--45. EasyChair, June 2012. [ bib | http ] |
| [1341] |
Huu Hai Nguyen, Cristina David, Shengchao Qin, and Wei-Ngan Chin.
Automated verification of shape and size properties via separation logic. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 4349 of Lecture Notes in Computer Science, pages 251--266. Springer, January 2007. [ bib | http ] |
| [1342] |
Huu Hai Nguyen, Viktor Kuncak, and Wei-Ngan Chin.
Runtime checking for separation logic. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 4905 of Lecture Notes in Computer Science, pages 203--217. Springer, January 2008. [ bib | .pdf ] |
| [1343] |
Phuc C. Nguyen and David Van Horn.
Relatively complete counterexamples for higher-order programs. In Programming Language Design and Implementation (PLDI), pages 446--456, June 2015. [ bib | http ] |
| [1344] |
Jan Nicklisch and Simon Peyton Jones.
An exploration of modular programs. In Functional Programming Workshop, July 1996. [ bib | .ps.gz ] |
| [1345] |
Joachim Niehren, Martin Müller, and Andreas Podelski.
Inclusion constraints over non-empty sets of trees. In Theory and Practice of Software Development (TAPSOFT), volume 1214 of Lecture Notes in Computer Science, pages 217--231. Springer, April 1997. [ bib | .ps ] |
| [1346] |
Joachim Niehren and Tim Priesnitz.
Non-structural subtype entailment in automata theory. In International Symposium on Theoretical Aspects of Computer Software (TACS). Springer, October 2001. [ bib | .ps.gz ] |
| [1347] |
Joachim Niehren and Tim Priesnitz.
Non-structural subtype entailment in automata theory. Information and Computation, 186(2):319--354, 2003. [ bib | .pdf ] |
| [1348] |
Lasse R. Nielsen.
A denotational investigation of defunctionalization. Technical Report RS-00-47, BRICS, December 2000. [ bib | http ] |
| [1349] |
Lasse R. Nielsen.
A selective CPS transformation. Electronic Notes in Theoretical Computer Science, 45:311--331, November 2001. [ bib | http ] |
| [1350] |
Flemming Nielson and Hanne Riis Nielson.
Two-level semantics and code generation. Theoretical Computer Science, 56(1):59--133, January 1988. [ bib | http ] |
| [1351] |
Flemming Nielson, Hanne Riis Nielson, and Helmut Seidl.
A succinct solver for ALFP. Nordic Journal of Computing, 9(4):335--372, 2002. [ bib | .pdf ] |
| [1352] |
Marie-Hélène Nienaltowski, Michela Pedroni, and Bertrand Meyer.
Compiler error messages: what can help novices? In Technical Symposium on Computer Science Education, pages 168--172, March 2008. [ bib | .pdf ] |
| [1353] |
Robert Nieuwenhuis, Albert Oliveras, and Cesare Tinelli.
Solving SAT and SAT Modulo Theories: From an abstract Davis--Putnam--Logemann--Loveland procedure to DPLL(T). Journal of the ACM, 53(6):937--977, 2006. [ bib | .pdf ] |
| [1354] |
Pierre Nigron and Pierre-évariste Dagand.
Reaching for the star: Tale of a monad in Coq. In Interactive Theorem Proving (ITP), volume 193 of Leibniz International Proceedings in Informatics, pages 29:1--29:19. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, June 2021. [ bib | http ] |
| [1355] |
Tobias Nipkow.
Amortized complexity verified. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 310--324. Springer, August 2015. [ bib | .pdf ] |
| [1356] |
Tobias Nipkow, Jasmin Blanchette, Manuel Eberl, Alejandro Gómez-Londoño,
Peter Lammich, Christian Sternagel, Simon Wimmer, and Bohua Zhan.
Functional algorithms, verified! 2021. [ bib | http ] |
| [1357] |
Tobias Nipkow and Hauke Brinkop.
Amortized complexity verified. Journal of Automated Reasoning, 62(3):367--391, 2019. [ bib | .pdf ] |
| [1358] |
Tobias Nipkow, Manuel Eberl, and Maximilian P. L. Haslbeck.
Verified textbook algorithms: a biased survey. In Automated Technology for Verification and Analysis (ATVA), volume 12302 of Lecture Notes in Computer Science, pages 25--53. Springer, 2020. [ bib | .pdf ] |
| [1359] |
Susumu Nishimura.
Static typing for dynamic messages. In Principles of Programming Languages (POPL), pages 266--278, January 1998. [ bib | .ps.gz ] |
| [1360] |
Yue Niu and Jan Hoffmann.
Automatic space bound analysis for functional programs with garbage collection. In Logic for Programming Artificial Intelligence and Reasoning (LPAR), volume 57 of EPiC Series in Computing, pages 543--563, November 2018. [ bib | http ] |
| [1361] |
Louis Noizet and Alan Schmitt.
Semantics in Skel and Necro. In Italian Conference on Theoretical Computer Science (ICTCS), volume 3284 of CEUR Workshop Proceedings, pages 99--115, September 2022. [ bib | .pdf ] |
| [1362] |
Gian Ntzik and Philippa Gardner.
Reasoning about the POSIX file system: local update and global pathnames. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 201--220, October 2015. [ bib | .pdf ] |
| [1363] |
Russell O'Connor.
Assembly: Circular programming with recursive do. The Monad.Reader, 6, January 2007. [ bib | .pdf ] |
| [1364] |
Martin Odersky.
Observers for linear types. In European Symposium on Programming (ESOP), volume 582 of Lecture Notes in Computer Science, pages 390--407. Springer, 1992. [ bib | .ps.gz ] |
| [1365] |
Martin Odersky.
A functional theory of local names. In Principles of Programming Languages (POPL), pages 48--59, January 1994. [ bib | .ps.gz ] |
| [1366] |
Martin Odersky, Aleksander Boruch-Gruszecki, Jonathan Immanuel
Brachthäuser, Edward Lee, and Ondrej Lhoták.
Safer exceptions for Scala. In Symposium on Scala, pages 1--11, October 2021. [ bib | http ] |
| [1367] |
Martin Odersky and Konstantin Läufer.
An extension of ML with first-class abstract types. In ACM Workshop on ML and its Applications, pages 78--91, June 1992. [ bib | .pdf ] |
| [1368] |
Martin Odersky and Konstantin Läufer.
Putting type annotations to work. In Principles of Programming Languages (POPL), pages 54--67, January 1996. [ bib | .ps.gz ] |
| [1369] |
Martin Odersky, Lex Spoon, and Bill Venners.
Programming in Scala, third edition: A comprehensive step-by-step guide. Artima Incorporation, 2016. [ bib | http ] |
| [1370] |
Martin Odersky, Martin Sulzmann, and Martin Wehr.
Type inference with constrained types. Theory and Practice of Object Systems, 5(1):35--55, 1999. [ bib | http ] |
| [1371] |
Martin Odersky, Philip Wadler, and Martin Wehr.
A second look at overloading. In Functional Programming Languages and Computer Architecture (FPCA), pages 135--146, June 1995. [ bib | .ps.gz ] |
| [1372] |
Martin Odersky, Christoph Zenger, Matthias Zenger, and Gang Chen.
A functional view of join. Technical Report ACRC-99-016, University of South Australia, 1999. [ bib | .ps.gz ] |
| [1373] |
Martin Odersky and Matthias Zenger.
Scalable component abstractions. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 41--57, October 2005. [ bib | .pdf ] |
| [1374] |
Martin Odersky, Matthias Zenger, and Christoph Zenger.
Colored local type inference. In Principles of Programming Languages (POPL), pages 41--53, 2001. [ bib | .ps.gz ] |
| [1375] |
Peter O'Hearn.
On bunched typing. Journal of Functional Programming, 13(4):747--796, 2003. [ bib | .pdf ] |
| [1376] |
Peter W. O'Hearn.
Resources, concurrency and local reasoning. Theoretical Computer Science, 375(1--3):271--307, May 2007. [ bib | .pdf ] |
| [1377] |
Peter W. O'Hearn.
Separation logic tutorial. In International Conference on Logic Programming (ICLP), volume 5366 of Lecture Notes in Computer Science, pages 15--21. Springer, 2008. [ bib | http ] |
| [1378] |
Peter W. O'Hearn.
Separation logic. Communications of the ACM, 62(2):86--95, 2019. [ bib | http ] |
| [1379] |
Peter W. O'Hearn, John Power, Makoto Takeyama, and Robert D. Tennent.
Syntactic control of interference revisited. Theoretical Computer Science, 228(1-2):211--252, 1999. [ bib | http ] |
| [1380] |
Peter W. O'Hearn and John C. Reynolds.
From Algol to polymorphic linear lambda-calculus. Journal of the ACM, 47(1):167--223, 2000. [ bib | .ps ] |
| [1381] |
Peter W. O'Hearn, John C. Reynolds, and Hongseok Yang.
Local reasoning about programs that alter data structures. In Computer Science Logic, volume 2142 of Lecture Notes in Computer Science, pages 1--19. Springer, September 2001. [ bib | .pdf ] |
| [1382] |
Peter W. O'Hearn, Hongseok Yang, and John C. Reynolds.
Separation and information hiding. In Principles of Programming Languages (POPL), pages 268--280, January 2004. [ bib | .pdf ] |
| [1383] |
Peter W. O'Hearn, Hongseok Yang, and John C. Reynolds.
Separation and information hiding. ACM Transactions on Programming Languages and Systems, 31(3), 2009. [ bib | .pdf ] |
| [1384] |
Atsushi Ohori.
A polymorphic record calculus and its compilation. ACM Transactions on Programming Languages and Systems, 17(6):844--895, November 1995. [ bib | http ] |
| [1385] |
Atsushi Ohori and Peter Buneman.
Type inference in a database programming language. In ACM Symposium on Lisp and Functional Programming (LFP), pages 174--183, 1988. [ bib | .pdf ] |
| [1386] |
Chris Okasaki.
Simple and efficient purely functional queues and deques. Journal of Functional Programming, 5(4):583--592, 1995. [ bib | http ] |
| [1387] |
Chris Okasaki.
Purely functional data structures. Technical Report CMU-CS-96-177, School of Computer Science, Carnegie Mellon University, September 1996. [ bib | http ] |
| [1388] |
Chris Okasaki.
The role of lazy evaluation in amortized data structures. In International Conference on Functional Programming (ICFP), pages 62--72, May 1996. [ bib | .ps ] |
| [1389] |
Chris Okasaki.
Views for Standard ML. In ACM Workshop on ML, pages 14--23, September 1998. [ bib | .ps ] |
| [1390] |
Chris Okasaki.
Purely functional data structures. Cambridge University Press, 1999. [ bib | http ] |
| [1391] |
Chris Okasaki and Andy Gill.
Fast mergeable integer maps. In ACM Workshop on ML, pages 77--86, September 1998. [ bib | .pdf ] |
| [1392] |
Ernst-Rüdiger Olderog.
A characterization of Hoare's logic for programs with Pascal-like procedures. In Symposium on the Theory of Computing, pages 320--329, 1983. [ bib | http ] |
| [1393] |
Oswaldo Olivo, Isil Dillig, and Calvin Lin.
Static detection of asymptotic performance bugs in collection traversals. In Programming Language Design and Implementation (PLDI), pages 369--378, June 2015. [ bib | .pdf ] |
| [1394] |
Peter Ørbæk and Jens Palsberg.
Trust in the λ-calculus. Journal of Functional Programming, 7(6):557--591, November 1997. [ bib | .pdf ] |
| [1395] |
Joseph O'Rourke.
Computational geometry in C, second edition. Cambridge University Press, 1998. [ bib | .html ] |
| [1396] |
Nicolas Osborne and Clément Pascutto.
Leveraging formal specifications to generate fuzzing suites. In OCaml Users and Developers Workshop, August 2021. [ bib | http ] |
| [1397] |
James William O'Toole, Jr. and David K. Gifford.
Type reconstruction with first-class polymorphic values. In Programming Language Design and Implementation (PLDI), pages 207--217, 1989. [ bib | .ps ] |
| [1398] |
Scott Owens.
A sound semantics for OCamllight. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 1--15. Springer, March 2008. [ bib | http ] |
| [1399] |
Scott Owens, Magnus O. Myreen, Ramana Kumar, and Yong Kiam Tan.
Functional big-step semantics. In European Symposium on Programming (ESOP), volume 9632 of Lecture Notes in Computer Science, pages 589--615. Springer, April 2016. [ bib | http ] |
| [1400] |
Scott Owens, John H. Reppy, and Aaron Turon.
Regular-expression derivatives re-examined. Journal of Functional Programming, 19(2):173--190, 2009. [ bib | .pdf ] |
| [1401] |
David Pager.
A practical general method for constructing LR(k) parsers. Acta Informatica, 7:249--268, 1977. [ bib | http ] |
| [1402] |
Robert Paige and Fritz Henglein.
Mechanical translation of set theoretic problem specifications into efficient RAM code -- A case study. Journal of Symbolic Computation, 4(2):207--232, 1987. [ bib | http ] |
| [1403] |
Robert Paige and Robert E. Tarjan.
Three partition refinement algorithms. SIAM Journal on Computing, 16(6):973--989, December 1987. [ bib | http ] |
| [1404] |
Jens Palsberg.
Efficient inference of object types. Information and Computation, 123(2):198--209, 1995. [ bib | .pdf ] |
| [1405] |
Jens Palsberg and Patrick M. O'Keefe.
A type system equivalent to flow analysis. ACM Transactions on Programming Languages and Systems, 17(4):576--599, July 1995. [ bib | .pdf ] |
| [1406] |
Jens Palsberg and Peter Ørbæk.
Trust in the λ-calculus. In Static Analysis Symposium (SAS), volume 983 of Lecture Notes in Computer Science, pages 314--330, September 1995. [ bib | .dvi.gz ] |
| [1407] |
Jens Palsberg and Scott Smith.
Constrained types and their expressiveness. ACM Transactions on Programming Languages and Systems, 18(5):519--527, September 1996. [ bib | .pdf ] |
| [1408] |
Jens Palsberg, Mitchell Wand, and Patrick M. O'Keefe.
Type inference with non-structural subtyping. Formal Aspects of Computing, 9:49--67, 1997. [ bib | .pdf ] |
| [1409] |
Jens Palsberg and Tian Zhao.
Efficient and flexible matching of recursive types. Information and Computation, 171:364--387, 2001. [ bib | .pdf ] |
| [1410] |
Jens Palsberg and Tian Zhao.
Efficient type inference for record concatenation and subtyping. In Logic in Computer Science (LICS), pages 125--136, July 2002. [ bib ] |
| [1411] |
Jens Palsberg and Tian Zhao.
Type inference for record concatenation and subtyping. Information and Computation, 189:54--86, 2004. [ bib | .pdf ] |
| [1412] |
Zoe Paraskevopoulou.
Verified optimizations for functional languages. PhD thesis, Princeton University, 2020. [ bib | http ] |
| [1413] |
Zoe Paraskevopoulou and Andrew W. Appel.
Closure conversion is safe for space. Proceedings of the ACM on Programming Languages, 3(ICFP):83:1--83:29, 2019. [ bib | http ] |
| [1414] |
Matthew Parkinson and Gavin Bierman.
Separation logic and abstraction. In Principles of Programming Languages (POPL), pages 247--258, January 2005. [ bib | http ] |
| [1415] |
Matthew Parkinson and Gavin Bierman.
Separation logic, abstraction and inheritance. In Principles of Programming Languages (POPL), pages 75--86, January 2008. [ bib | http ] |
| [1416] |
Matthew J. Parkinson, Richard Bornat, and Peter W. O'Hearn.
Modular verification of a non-blocking stack. In Principles of Programming Languages (POPL), pages 297--302, 2007. [ bib | http ] |
| [1417] |
Matthew J. Parkinson and Alexander J. Summers.
The relationship between separation logic and implicit dynamic frames. Logical Methods in Computer Science, 8(3), 2012. [ bib | http ] |
| [1418] |
Matthew J. Parkinson, Dimitrios Vytiniotis, Kapil Vaswani, Manuel Costa,
Pantazis Deligiannis, Dylan McDermott, Aaron Blankstein, and Jonathan
Balkind.
Project Snowflake: non-blocking safe manual memory management in .NET. Proceedings of the ACM on Programming Languages, 1(OOPSLA):95:1--95:25, 2017. [ bib | http ] |
| [1419] |
David Lorge Parnas.
Information distribution aspects of design methodology. In Information Processing 71, volume 1, pages 339--344, 1971. [ bib | .PDF ] |
| [1420] |
David Lorge Parnas.
On the criteria to be used in decomposing systems into modules. Communications of the ACM, 15(12):1053--1058, 1972. [ bib | http ] |
| [1421] |
Terence Parr.
The definitive ANTLR 4 reference, 2nd edition. Pragmatic Bookshelf, 2013. [ bib ] |
| [1422] |
Pašalić and Nathan Linger.
Meta-programming with typed object-language representations. In Generative Programming and Component Engineering (GPCE), pages 136--167, October 2004. [ bib | .ps ] |
| [1423] |
Emir Pašalić, Tim Sheard, and Walid Taha.
DALI: An untyped, CBV functional language supporting first-order datatypes with binders (technical development). Technical Report 00-007, Oregon Graduate Institute, March 2000. [ bib | .pdf ] |
| [1424] |
Emir Pašalić, Walid Taha, and Tim Sheard.
Tagless staged interpreters for typed languages. In International Conference on Functional Programming (ICFP), pages 218--229, October 2002. [ bib | .pdf ] |
| [1425] |
Adam Paszke, Daniel D. Johnson, David Duvenaud, Dimitrios Vytiniotis, Alexey
Radul, Matthew J. Johnson, Jonathan Ragan-Kelley, and Dougal Maclaurin.
Getting to the point: index sets and parallelism-preserving autodiff for pointful array programming. Proceedings of the ACM on Programming Languages, 5(POPL):1--29, 2021. [ bib | .pdf ] |
| [1426] |
M. S. Paterson and M. N. Wegman.
Linear unification. In Annual ACM Symposium on Theory of Computing, pages 181--186, 1976. [ bib ] |
| [1427] |
Md. Mostofa Ali Patwary, Jean Blair, and Fredrik Manne.
Experiments on union-find algorithms for the disjoint-set data structure. In International Symposium on Experimental Algorithms (SEA), volume 6049 of Lecture Notes in Computer Science, pages 411--423. Springer, May 2010. [ bib | .pdf ] |
| [1428] |
Christine Paulin-Mohring.
Extracting Fω's programs from proofs in the calculus of constructions. In Principles of Programming Languages (POPL), pages 89--104, January 1989. [ bib | http ] |
| [1429] |
Christine Paulin-Mohring.
Inductive definitions in the system Coq: rules and properties. Research Report RR1992-49, ENS Lyon, 1992. [ bib | .ps.Z ] |
| [1430] |
Barak A. Pearlmutter and Jeffrey Mark Siskind.
Reverse-mode AD in a functional framework: Lambda the ultimate backpropagator. ACM Transactions on Programming Languages and Systems, 30(2):7:1--7:36, 2008. [ bib | .pdf ] |
| [1431] |
Thomas J. Pennello.
Very fast LR parsing. In Symposium on Compiler Construction, pages 145--151, 1986. [ bib | http ] |
| [1432] |
Mário Pereira and António Ravara.
Cameleer: A deductive verification tool for OCaml. In Computer Aided Verification (CAV), volume 12760 of Lecture Notes in Computer Science, pages 677--689. Springer, July 2021. [ bib | .pdf ] |
| [1433] |
François Pessaux and Xavier Leroy.
Type-based analysis of uncaught exceptions. ACM Transactions on Programming Languages and Systems, 22(2):340--377, 2000. [ bib | .pdf ] |
| [1434] |
John Peterson and Mark P. Jones.
Implementing type classes. In Programming Language Design and Implementation (PLDI), pages 227--236, June 1993. [ bib | .ps ] |
| [1435] |
Theofilos Petsios, Jason Zhao, Angelos D. Keromytis, and Suman Jana.
SlowFuzz: Automated domain-independent detection of algorithmic complexity vulnerabilities. In Computer and Communications Security (CCS), pages 2155--2168, October 2017. [ bib | http ] |
| [1436] |
Simon Peyton Jones.
The implementation of functional programming languages. Prentice Hall, 1987. [ bib | http ] |
| [1437] |
Simon Peyton Jones, editor.
Haskell 98 language and libraries: The revised report. Cambridge University Press, April 2003. [ bib | http ] |
| [1438] |
Simon Peyton Jones.
Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell. Online lecture notes, January 2009. [ bib | .pdf ] |
| [1439] |
Simon Peyton Jones.
Type inference as constraint solving: how GHC's type inference engine actually works. Zurihac keynote talk, June 2019. [ bib | http ] |
| [1440] |
Simon Peyton Jones and Simon Marlow.
Secrets of the Glasgow Haskell Compiler inliner. Journal of Functional Programming, 12(4&5):393--433, 2002. [ bib | .ps.gz ] |
| [1441] |
Simon Peyton Jones and Mark Shields.
Lexically-scoped type variables. Manuscript, April 2004. [ bib | http ] |
| [1442] |
Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Mark
Shields.
Practical type inference for arbitrary-rank types. Journal of Functional Programming, 17(1):1--82, 2007. [ bib | .pdf ] |
| [1443] |
Simon Peyton Jones, Dimitrios Vytiniotis, Stephanie Weirich, and Geoffrey
Washburn.
Simple unification-based type inference for GADTs. In International Conference on Functional Programming (ICFP), pages 50--61, September 2006. [ bib | .pdf ] |
| [1444] |
Simon Peyton Jones and Philip Wadler.
Imperative functional programming. In Principles of Programming Languages (POPL), pages 71--84, January 1993. [ bib | .ps.gz ] |
| [1445] |
Simon Peyton Jones, Geoffrey Washburn, and Stephanie Weirich.
Wobbly types: type inference for generalised algebraic data types. Technical Report MS-CIS-05-26, University of Pennsylvania, July 2004. [ bib | .pdf ] |
| [1446] |
Simon L. Peyton Jones, Simon Marlow, and Conal Elliott.
Stretching the storage manager: Weak pointers and stable names in Haskell. In Implementation of Functional Languages (IFL), volume 1868 of Lecture Notes in Computer Science, pages 37--58. Springer, September 1999. [ bib | .pdf ] |
| [1447] |
Peter Pfahler.
Optimizing directly executable LR parsers. In Compiler Construction (CC), pages 179--192. Springer, 1991. [ bib | http ] |
| [1448] |
Frank Pfenning and Conal Elliott.
Higher-order abstract syntax. In Programming Language Design and Implementation (PLDI), pages 199--208, June 1988. [ bib | http ] |
| [1449] |
Frank Pfenning and Peter Lee.
LEAP: A language with eval and polymorphism. In Theory and Practice of Software Development (TAPSOFT), volume 352 of Lecture Notes in Computer Science, pages 345--359. Springer, 1989. [ bib | http ] |
| [1450] |
David Pichardie.
Interprétation abstraite en logique intuitionniste: extraction d'analyseurs Java certifiés. PhD thesis, Université Rennes 1, 2005. [ bib | .pdf ] |
| [1451] |
David Pichardie.
Building certified static analysers by modular construction of well-founded lattices. Electronic Notes in Theoretical Computer Science, 212:225--239, 2008. [ bib | http ] |
| [1452] |
Brigitte Pientka.
Proof pearl: The power of higher-order encodings in the logical framework LF. In Theorem Proving in Higher Order Logics (TPHOLs), volume 4732 of Lecture Notes in Computer Science, pages 246--261. Springer, September 2007. [ bib | .pdf ] |
| [1453] |
Brigitte Pientka.
A type-theoretic foundation for programming with higher-order abstract syntax and first-class substitutions. In Principles of Programming Languages (POPL), pages 371--382, January 2008. [ bib | .pdf ] |
| [1454] |
Brigitte Pientka and Joshua Dunfield.
Programming with proofs and explicit contexts. In Principles and Practice of Declarative Programming (PPDP), pages 163--173, July 2008. [ bib | .pdf ] |
| [1455] |
Benjamin Pierce and Davide Sangiorgi.
Typing and subtyping for mobile processes. In Logic in Computer Science (LICS), pages 376--385, June 1993. [ bib | .ps ] |
| [1456] |
Benjamin C. Pierce.
Bounded quantification is undecidable. Information and Computation, 112(1):131--165, July 1994. [ bib | .ps ] |
| [1457] |
Benjamin C. Pierce.
Types and programming languages. MIT Press, 2002. [ bib | http ] |
| [1458] |
Benjamin C. Pierce.
Types and programming languages. MIT Press, 2002. [ bib ] |
| [1459] |
Benjamin C. Pierce and David N. Turner.
Statically typed friendly functions via partially abstract types. Technical Report ECS-LFCS-93-256, University of Edinburgh, LFCS, April 1993. Also available as INRIA Research Report 1899. [ bib | .ps ] |
| [1460] |
Benjamin C. Pierce and David N. Turner.
Simple type-theoretic foundations for object-oriented programming. Journal of Functional Programming, 4(2):207--247, April 1994. [ bib | .ps ] |
| [1461] |
Benjamin C. Pierce and David N. Turner.
Local type inference. ACM Transactions on Programming Languages and Systems, 22(1):1--44, January 2000. [ bib | http ] |
| [1462] |
Alexandre Pilkiewicz and François Pottier.
The essence of monotonic state. In Types in Language Design and Implementation (TLDI), January 2011. [ bib | .pdf ] |
| [1463] |
Maciej Piróg and Jeremy Gibbons.
The coinductive resumption monad. In Mathematical Foundations of Programming Semantics, volume 308 of Electronic Notes in Theoretical Computer Science, pages 273--288. Elsevier, June 2014. [ bib | .pdf ] |
| [1464] |
Ruzica Piskac, Thomas Wies, and Damien Zufferey.
Automating separation logic using SMT. In Computer Aided Verification (CAV), volume 8044 of Lecture Notes in Computer Science, pages 773--789. Springer, July 2013. [ bib | .pdf ] |
| [1465] |
Ruzica Piskac, Thomas Wies, and Damien Zufferey.
Automating separation logic with trees and data. In Computer Aided Verification (CAV), volume 8559 of Lecture Notes in Computer Science, pages 711--728. Springer, July 2014. [ bib | .pdf ] |
| [1466] |
Andrew M. Pitts.
Parametric polymorphism and operational equivalence. Mathematical Structures in Computer Science, 10:321--359, 2000. [ bib | .pdf ] |
| [1467] |
Andrew M. Pitts.
Nominal logic, A first order theory of names and binding. Information and Computation, 186:165--193, 2003. [ bib | .pdf ] |
| [1468] |
Andrew M. Pitts.
Alpha-structural recursion and induction. In Theorem Proving in Higher Order Logics (TPHOLs), Lecture Notes in Computer Science. Springer, August 2005. [ bib | .pdf ] |
| [1469] |
Andrew M. Pitts.
Alpha-structural recursion and induction. Journal of the ACM, 53:459--506, 2006. [ bib | .pdf ] |
| [1470] |
Andrew M. Pitts.
Nominal System T. In Principles of Programming Languages (POPL), pages 159--170, January 2010. [ bib | .pdf ] |
| [1471] |
Andrew M. Pitts and Murdoch J. Gabbay.
A metalanguage for programming with bound names modulo renaming. In Mathematics of Program Construction (MPC), volume 1837 of Lecture Notes in Computer Science, pages 230--255. Springer, 2000. [ bib | .pdf ] |
| [1472] |
Gordon Plotkin.
An illative theory of relations. In Situation Theory and its Applications, number 22 in CSLI Lecture Notes, pages 133--146. Stanford University, 1990. [ bib | .pdf ] |
| [1473] |
Gordon D. Plotkin.
Call-by-name, call-by-value and the λ-calculus. Theoretical Computer Science, 1(2):125--159, 1975. [ bib | .pdf ] |
| [1474] |
Gordon D. Plotkin.
LCF considered as a programming language. Theoretical Computer Science, 5(3):225--255, 1977. [ bib | .pdf ] |
| [1475] |
Gordon D. Plotkin and A. John Power.
Computational effects and operations: An overview. Electronic Notes in Theoretical Computer Science, 73:149--163, 2004. [ bib | http ] |
| [1476] |
Gordon D. Plotkin and Matija Pretnar.
A logic for algebraic effects. In Logic in Computer Science (LICS), pages 118--129, June 2008. [ bib | .pdf ] |
| [1477] |
Gordon D. Plotkin and Matija Pretnar.
Handlers of algebraic effects. In European Symposium on Programming (ESOP), volume 5502 of Lecture Notes in Computer Science, pages 80--94. Springer, March 2009. [ bib | .pdf ] |
| [1478] |
Gordon D. Plotkin and Matija Pretnar.
Handling algebraic effects. Logical Methods in Computer Science, 9(4), December 2013. [ bib | http ] |
| [1479] |
Johannes Åman Pohjola, Henrik Rostedt, and Magnus O. Myreen.
Characteristic formulae for liveness properties of non-terminating CakeML programs. In Interactive Theorem Proving (ITP), volume 141 of Leibniz International Proceedings in Informatics, pages 32:1--32:19. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, September 2019. [ bib | http ] |
| [1480] |
Nadia Polikarpova, Julian Tschannen, and Carlo A. Furia.
A fully verified container library. In Formal Methods (FM), volume 9109 of Lecture Notes in Computer Science, pages 414--434. Springer, June 2015. [ bib | .pdf ] |
| [1481] |
Randy Pollack, Masahiko Sato, and Wilmer Ricciotti.
A canonical locally named representation of binding. Journal of Automated Reasoning, 49(2):185--207, 2012. [ bib | .pdf ] |
| [1482] |
Satya Kiran Popuri.
Understanding C parsers generated by GNU Bison, September 2006. [ bib | .html ] |
| [1483] |
Adam Poswolsky and Carsten Schürmann.
Practical programming with higher-order encodings and dependent types. In European Symposium on Programming (ESOP), volume 4960 of Lecture Notes in Computer Science, pages 93--107. Springer, March 2008. [ bib | .pdf ] |
| [1484] |
Adam Poswolsky and Carsten Schürmann.
System description: Delphin -- A functional programming language for deductive systems. Electronic Notes in Theoretical Computer Science, 228:113--120, 2009. [ bib | .pdf ] |
| [1485] |
Alex Potanin, Johan Östlund, Yoav Zibin, and Michael D. Ernst.
Immutability. In Aliasing in Object-Oriented Programming. Types, Analysis and Verification, volume 7850 of Lecture Notes in Computer Science, pages 233--269. Springer, 2013. [ bib | .pdf ] |
| [1486] |
François Pottier.
Implémentation d'un système de modules évolué en Caml-Light. Research Report 2449, INRIA, 1995. [ bib | .ps.gz ] |
| [1487] |
François Pottier.
Type inference and simplification for recursively constrained types. In Actes du GDR Programmation 1995 (journée du pôle Programmation Fonctionnelle), November 1995. [ bib | .ps.gz ] |
| [1488] |
François Pottier.
Simplifying subtyping constraints. In International Conference on Functional Programming (ICFP), pages 122--133, January 1996. [ bib | .ps.gz ] |
| [1489] |
François Pottier.
A framework for type inference with subtyping. In International Conference on Functional Programming (ICFP), pages 228--238, September 1998. [ bib | .ps.gz ] |
| [1490] |
François Pottier.
Synthèse de types en présence de sous-typage: de la théorie à la pratique. PhD thesis, Université Paris 7, July 1998. [ bib | .ps.gz ] |
| [1491] |
François Pottier.
Type inference in the presence of subtyping: from theory to practice. Research Report 3483, INRIA, September 1998. [ bib | .pdf ] |
| [1492] |
François Pottier.
A 3-part type inference engine. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 320--335. Springer, March 2000. [ bib | .ps.gz ] |
| [1493] |
François Pottier.
A versatile constraint-based type inference system. Nordic Journal of Computing, 7(4):312--347, November 2000. [ bib | .ps.gz ] |
| [1494] |
François Pottier.
Wallace: an efficient implementation of type inference with subtyping, February 2000. [ bib | http ] |
| [1495] |
François Pottier.
A semi-syntactic soundness proof for HM(X). Research Report 4150, INRIA, March 2001. [ bib | .pdf ] |
| [1496] |
François Pottier.
Simplifying subtyping constraints: a theory. Information and Computation, 170(2):153--183, November 2001. [ bib | .ps.gz ] |
| [1497] |
François Pottier.
A simple view of type-secure information flow in the π-calculus. In IEEE Computer Security Foundations Workshop, pages 320--330, June 2002. [ bib | .ps.gz ] |
| [1498] |
François Pottier.
A constraint-based presentation and generalization of rows. In Logic in Computer Science (LICS), pages 331--340, June 2003. [ bib | .ps.gz ] |
| [1499] |
François Pottier.
Cαml, June 2005. [ bib | http ] |
| [1500] |
François Pottier.
An overview of Cαml. In ACM Workshop on ML, volume 148(2) of Electronic Notes in Theoretical Computer Science, pages 27--52, March 2006. [ bib | .pdf ] |
| [1501] |
François Pottier.
Static name control for FreshML. In Logic in Computer Science (LICS), pages 356--365, July 2007. [ bib | .pdf ] |
| [1502] |
François Pottier.
Hiding local state in direct style: a higher-order anti-frame rule. In Logic in Computer Science (LICS), pages 331--340, June 2008. [ bib | .pdf ] |
| [1503] |
François Pottier.
Generalizing the higher-order frame and anti-frame rules. Unpublished, July 2009. [ bib | .pdf ] |
| [1504] |
François Pottier.
Lazy least fixed points in ML. Unpublished, December 2009. [ bib | .pdf ] |
| [1505] |
François Pottier.
Three comments on the anti-frame rule. Unpublished, July 2009. [ bib | .pdf ] |
| [1506] |
François Pottier.
Syntactic soundness proof of a type-and-capability system with hidden state. Journal of Functional Programming, 23(1):38--144, January 2013. [ bib | .pdf ] |
| [1507] |
François Pottier.
Hindley-Milner elaboration in applicative style. In International Conference on Functional Programming (ICFP), September 2014. [ bib | .pdf ] |
| [1508] |
François Pottier.
Depth-first search and strong connectivity in Coq. In Journées Françaises des Langages Applicatifs (JFLA), January 2015. [ bib | .pdf ] |
| [1509] |
François Pottier.
Reachability and error diagnosis in LR(1) automata. In Journées Françaises des Langages Applicatifs (JFLA), January 2016. [ bib | .pdf ] |
| [1510] |
François Pottier.
Reachability and error diagnosis in LR(1) parsers. In Compiler Construction (CC), pages 88--98, March 2016. [ bib | .pdf ] |
| [1511] |
François Pottier.
AlphaLib. https://gitlab.inria.fr/fpottier/alphaLib, 2017. [ bib ] |
| [1512] |
François Pottier.
The visitors package. https://gitlab.inria.fr/fpottier/visitors, April 2017. [ bib ] |
| [1513] |
François Pottier.
Verifying a hash table and its iterators in higher-order separation logic. In Certified Programs and Proofs (CPP), pages 3--16, January 2017. [ bib | .pdf ] |
| [1514] |
François Pottier and Sylvain Conchon.
Information flow inference for free. In International Conference on Functional Programming (ICFP), pages 46--57, September 2000. [ bib | .ps.gz ] |
| [1515] |
François Pottier and Nadji Gauthier.
Polymorphic typed defunctionalization. In Principles of Programming Languages (POPL), pages 89--98, January 2004. [ bib | .pdf ] |
| [1516] |
François Pottier and Nadji Gauthier.
Polymorphic typed defunctionalization and concretization. Higher-Order and Symbolic Computation, 19:125--162, March 2006. [ bib | .pdf ] |
| [1517] |
François Pottier and Jonathan Protzenko.
Programming with permissions in Mezzo. In International Conference on Functional Programming (ICFP), pages 173--184, September 2013. [ bib | .pdf ] |
| [1518] |
François Pottier and Jonathan Protzenko.
A few lessons from the Mezzo project. In Summit on Advances in Programming Languages (SNAPL), May 2015. [ bib | .pdf ] |
| [1519] |
François Pottier and Yann Régis-Gianas.
The Menhir parser generator, 2005--2023. https://gitlab.inria.fr/fpottier/menhir/. [ bib ] |
| [1520] |
François Pottier and Yann Régis-Gianas.
Stratified type inference for generalized algebraic data types. In Principles of Programming Languages (POPL), pages 232--244, January 2006. [ bib | .pdf ] |
| [1521] |
François Pottier and Yann Régis-Gianas.
Towards efficient, typed LR parsers. Electronic Notes in Theoretical Computer Science, 148(2):155--180, 2006. [ bib | .pdf ] |
| [1522] |
François Pottier and Didier Rémy.
The essence of ML type inference. Draft of an extended version. Unpublished, September 2003. [ bib | .pdf ] |
| [1523] |
François Pottier and Didier Rémy.
The essence of ML type inference. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 10, pages 389--489. MIT Press, 2005. [ bib | .pdf ] |
| [1524] |
François Pottier and Vincent Simonet.
Information flow inference for ML. In Principles of Programming Languages (POPL), pages 319--330, January 2002. [ bib | .ps.gz ] |
| [1525] |
François Pottier and Vincent Simonet.
Information flow inference for ML. ACM Transactions on Programming Languages and Systems, 25(1):117--158, January 2003. [ bib | .ps.gz ] |
| [1526] |
François Pottier, Christian Skalka, and Scott Smith.
A systematic approach to static access control. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 30--45. Springer, April 2001. [ bib | .ps.gz ] |
| [1527] |
François Pottier, Christian Skalka, and Scott Smith.
A systematic approach to static access control. ACM Transactions on Programming Languages and Systems, 27(2):344--382, 2005. [ bib | .ps.gz ] |
| [1528] |
Garrel Pottinger.
A type assignment for the strongly normalizable λ-terms. In J. Roger Hindley and Jonathan P. Seldin, editors, To H. B. Curry: Essays on Combinatory Logic, Lambda Calculus, and Formalism, pages 561--577. Academic Press, 1980. [ bib ] |
| [1529] |
Nicolas Pouillard.
Nameless, painless. In International Conference on Functional Programming (ICFP), pages 320--332, September 2011. [ bib | .pdf ] |
| [1530] |
Nicolas Pouillard and François Pottier.
A fresh look at programming with names and binders. In International Conference on Functional Programming (ICFP), pages 217--228, September 2010. [ bib | .pdf ] |
| [1531] |
Nicolas Pouillard and François Pottier.
A unified treatment of syntax with binders. Journal of Functional Programming, 22(4--5):614--704, September 2012. [ bib | .pdf ] |
| [1532] |
Casper Bach Poulsen, Arjen Rouvoet, Andrew Tolmach, Robbert Krebbers, and Eelco
Visser.
Intrinsically-typed definitional interpreters for imperative languages. Proceedings of the ACM on Programming Languages, 2(POPL):16:1--16:34, 2018. [ bib | http ] |
| [1533] |
Damien Pous.
Coinduction all the way up. In Logic in Computer Science (LICS), pages 307--316, July 2016. [ bib | http ] |
| [1534] |
Damien Pous and Davide Sangiorgi.
Bisimulation and coinduction enhancements: A historical perspective. Formal Aspects of Computing, 31(6):733--749, 2019. [ bib | http ] |
| [1535] |
I. S. Wishnu B. Prasetya.
T3, a combinator-based random testing tool for Java: Benchmarking. In Workshop on Future Internet Testing (FITTEST), volume 8432 of Lecture Notes in Computer Science, pages 101--110. Springer, November 2013. [ bib | http ] |
| [1536] |
Vaughan Pratt and Jerzy Tiuryn.
Satisfiability of inequalities in a poset. Fundamenta Informaticæ, 28(1--2):165--182, 1996. [ bib | .ps.gz ] |
| [1537] |
Matija Pretnar.
Inferring algebraic effects. Logical Methods in Computer Science, 10(3):3--21, 2014. [ bib | .pdf ] |
| [1538] |
Matija Pretnar.
An introduction to algebraic effects and handlers. Electronic Notes in Theoretical Computer Science, 319:19--35, 2015. [ bib | .pdf ] |
| [1539] |
Matija Pretnar.
An introduction to algebraic effects and handlers. In Mathematical Foundations of Programming Semantics, volume 319 of Electronic Notes in Theoretical Computer Science, pages 19--35. Elsevier, June 2015. [ bib | http ] |
| [1540] |
Siddharth Priya, Xiang Zhou, Yusen Su, Yakir Vizel, Yuyan Bao, and Arie
Gurfinkel.
Verifying verified code. In Automated Technology for Verification and Analysis (ATVA), volume 12971 of Lecture Notes in Computer Science, pages 187--202. Springer, October 2021. [ bib | .pdf ] |
| [1541] |
Jonathan Protzenko.
Mezzo: a typed language for safe effectful concurrent programs. PhD thesis, Université Paris Diderot, September 2014. [ bib | http ] |
| [1542] |
Jonathan Protzenko, Jean Karim Zinzindohoué, Aseem Rastogi, Tahina
Ramananandro, Peng Wang, Santiago Zanella Béguelin, Antoine
Delignat-Lavaud, Catalin Hritcu, Karthikeyan Bhargavan, Cédric Fournet,
and Nikhil Swamy.
Verified low-level programming embedded in F*. Proceedings of the ACM on Programming Languages, 1(ICFP):17:1--17:29, 2017. [ bib | http ] |
| [1543] |
William Pugh and Grant Weddell.
Two-directional record layout for multiple inheritance. In Programming Language Design and Implementation (PLDI), pages 85--91, 1990. [ bib | http ] |
| [1544] |
Paul Purdom.
The size of LALR(1) parsers. BIT Numerical Mathematics, 14(3):326--337, 1974. [ bib | http ] |
| [1545] |
Zhenyu Qian.
Unification of higher-order patterns in linear time and space. Journal of Logic and Computation, 6(3):315--341, 1996. [ bib ] |
| [1546] |
Azalea Raad, Josh Berdine, Hoang-Hai Dang, Derek Dreyer, Peter W. O'Hearn,
and Jules Villard.
Local reasoning about the presence of bugs: Incorrectness separation logic. In Computer Aided Verification (CAV), volume 12225 of Lecture Notes in Computer Science, pages 225--252. Springer, July 2020. [ bib | http ] |
| [1547] |
Azalea Raad, Marko Doko, Lovro Rozic, Ori Lahav, and Viktor Vafeiadis.
On library correctness under weak memory consistency: specifying and verifying concurrent libraries under declarative consistency models. Proceedings of the ACM on Programming Languages, 3(POPL):68:1--68:31, 2019. [ bib | .pdf ] |
| [1548] |
Gabriel Radanne.
Typed parsing and unparsing for untyped regular expression engines. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 35--46, January 2019. [ bib | .pdf ] |
| [1549] |
Alexey Radul, Adam Paszke, Roy Frostig, Matthew J. Johnson, and Dougal
Maclaurin.
You only linearize once: Tangents transpose to gradients. Proceedings of the ACM on Programming Languages, 7(POPL), January 2023. [ bib | http ] |
| [1550] |
Christophe Raffalli.
Type checking in system Fη. Prépublication 98-05a, LAMA, Université de Savoie, 1998. [ bib | .ps ] |
| [1551] |
Christophe Raffalli.
An optimized complete semi-algorithm for system Fη. Unpublished, 1999. [ bib | .ps ] |
| [1552] |
Viswanath Ramachandran and Pascal Van Hentenryck.
Incremental algorithms for constraint solving and entailment over rational trees. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), pages 205--217, 1993. [ bib ] |
| [1553] |
G. Ramalingam, Alex Varshavsky, John Field, Deepak Goyal, and Shmuel Sagiv.
Deriving specialized program analyses for certifying component-client conformance. In Programming Language Design and Implementation (PLDI), pages 83--94, June 2002. [ bib | .pdf ] |
| [1554] |
Norman Ramsey.
Unparsing expressions with prefix and postfix operators. Software: Practice and Experience, 28(12):1327--1356, 1998. [ bib | .html ] |
| [1555] |
Nicole Rauch and Burkhart Wolff.
Formalizing Java's two's-complement integral type in Isabelle/HOL. In Formal Methods for Industrial Critical Systems (FMICS), volume 80 of Electronic Notes in Theoretical Computer Science, pages 41--58. Elsevier, June 2003. [ bib | http ] |
| [1556] |
Michel Raynal.
Concurrent programming: Algorithms, principles, and foundations. Springer, 2013. [ bib | http ] |
| [1557] |
Eric Reed.
Patina: A formalization of the Rust programming language. Technical Report UW-CSE-15-03-02, University of Washington, March 2015. [ bib | .pdf ] |
| [1558] |
Franz Regensburger.
HOLCF: Higher order logic of computable functions. In Theorem Proving in Higher Order Logics (TPHOLs), volume 971 of Lecture Notes in Computer Science, pages 293--307. Springer, September 1995. [ bib | .pdf ] |
| [1559] |
Jakob Rehof.
Minimal typings in atomic subtyping. Technical Report D-278, Department of Computer Science, University of Copenhagen, 1996. [ bib | .ps.gz ] |
| [1560] |
Jakob Rehof.
Minimal typings in atomic subtyping. In Principles of Programming Languages (POPL), pages 278--291, January 1997. [ bib | .ps ] |
| [1561] |
Jakob Rehof and Manuel Fähndrich.
Type-based flow analysis: From polymorphic subtyping to CFL-reachability. In Principles of Programming Languages (POPL), pages 54--66, January 2001. [ bib | .ps ] |
| [1562] |
Alex Reinking, Ningning Xie, Leonardo de Moura, and Daan Leijen.
Perceus: Garbage free reference counting with reuse. Technical Report MSR-TR-2020-42, Microsoft Research, January 2021. [ bib | .pdf ] |
| [1563] |
Brian Reistad and David K. Gifford.
Static dependent costs for estimating execution time. In ACM Symposium on Lisp and Functional Programming (LFP), pages 65--78, 1994. [ bib | .pdf ] |
| [1564] |
Didier Rémy.
Extending ML type system with a sorted equational theory. Technical Report 1766, INRIA, 1992. [ bib | .pdf ] |
| [1565] |
Didier Rémy.
Projective ML. In ACM Symposium on Lisp and Functional Programming (LFP), pages 66--75, 1992. [ bib | .pdf ] |
| [1566] |
Didier Rémy.
Syntactic theories and the algebra of record terms. Research Report 1869, INRIA, 1993. [ bib | .pdf ] |
| [1567] |
Didier Rémy.
Programming objects with ML-ART: An extension to ML with abstract and record types. In International Symposium on Theoretical Aspects of Computer Software (TACS), pages 321--346. Springer, April 1994. [ bib | .pdf ] |
| [1568] |
Didier Rémy.
Type inference for records in a natural extension of ML. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
| [1569] |
Didier Rémy.
Typing record concatenation for free. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming. Types, Semantics and Language Design. MIT Press, 1994. [ bib | .pdf ] |
| [1570] |
Didier Rémy.
A case study of typechecking with constrained types: Typing record concatenation. Workshop on Advances in Types for Computer Science, August 1995. [ bib | .dvi.gz ] |
| [1571] |
Didier Rémy.
From classes to objects via subtyping. In European Symposium on Programming (ESOP), volume 1381 of Lecture Notes in Computer Science, pages 200--220. Springer, March 1998. [ bib | .pdf ] |
| [1572] |
Didier Rémy and Jérôme Vouillon.
Objective ML: A simple object-oriented extension of ML. In Principles of Programming Languages (POPL), pages 40--53, January 1997. [ bib | .pdf ] |
| [1573] |
Didier Rémy and Jérôme Vouillon.
Objective ML: An effective object-oriented extension to ML. Theory and Practice of Object Systems, 4(1):27--50, 1998. [ bib | .pdf ] |
| [1574] |
Didier Rémy and Boris Yakobowski.
A Church-style intermediate language for MLF. Theoretical Computer Science, 435(1):77--105, June 2012. [ bib | .pdf ] |
| [1575] |
Tillmann Rendel and Klaus Ostermann.
Invertible syntax descriptions: unifying parsing and pretty printing. In Symposium on Haskell, pages 1--12, September 2010. [ bib | http ] |
| [1576] |
Thomas Reps.
Program analysis via graph reachability. Information and Software Technology, 40(11--12):701--726, 1998. [ bib | .pdf ] |
| [1577] |
Thomas W. Reps, Stefan Schwoon, Somesh Jha, and David Melski.
Weighted pushdown systems and their application to interprocedural dataflow analysis. Science of Computer Programming, 58(1-2):206--263, 2005. [ bib | http ] |
| [1578] |
William S. Retert.
Implementing permission analysis. PhD thesis, University of Wisconsin-Milwaukee, May 2009. [ bib ] |
| [1579] |
Bernhard Reus and Jan Schwinghammer.
Separation logic for higher-order store. In Computer Science Logic, volume 4207 of Lecture Notes in Computer Science, pages 575--590. Springer, September 2006. [ bib | .pdf ] |
| [1580] |
Dominique Revuz.
Minimization of acyclic deterministic automata in linear time. Theoretical Computer Science, 92(1):181--189, 1992. [ bib ] |
| [1581] |
John C. Reynolds.
Automatic computation of data set definitions. In Information Processing 68, volume 1, pages 456--461. North Holland, 1969. [ bib ] |
| [1582] |
John C. Reynolds.
Towards a theory of type structure. In Colloque sur la Programmation, volume 19 of Lecture Notes in Computer Science, pages 408--425. Springer, April 1974. [ bib | .pdf ] |
| [1583] |
John C. Reynolds.
User-defined types and procedural data structures as complementary approaches to data abstraction. Technical Report 1278, Carnegie Mellon University, August 1975. [ bib | http ] |
| [1584] |
John C. Reynolds.
Syntactic control of interference. In Principles of Programming Languages (POPL), pages 39--46, January 1978. [ bib | http ] |
| [1585] |
John C. Reynolds.
Types, abstraction and parametric polymorphism. In Information Processing 83, pages 513--523. Elsevier, 1983. [ bib ] |
| [1586] |
John C. Reynolds.
Three approaches to type structure. In Theory and Practice of Software Development (TAPSOFT), volume 185 of Lecture Notes in Computer Science, pages 97--138. Springer, March 1985. [ bib | http ] |
| [1587] |
John C. Reynolds.
An introduction to the polymorphic lambda calculus. In Gérard Huet, editor, Logical Foundations of Functional Programming, pages 77--86. Addison-Wesley, 1990. [ bib | http ] |
| [1588] |
John C. Reynolds.
The discoveries of continuations. Lisp and Symbolic Computation, 6(3--4):233--248, 1993. [ bib | .pdf ] |
| [1589] |
John C. Reynolds.
User defined types and procedural data structures as complementary approaches to data abstraction. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design, pages 13--23. MIT Press, 1994. [ bib ] |
| [1590] |
John C. Reynolds.
Definitional interpreters for higher-order programming languages. Higher-Order and Symbolic Computation, 11(4):363--397, December 1998. [ bib | http ] |
| [1591] |
John C. Reynolds.
Definitional interpreters revisited. Higher-Order and Symbolic Computation, 11(4):355--361, December 1998. [ bib | http ] |
| [1592] |
John C. Reynolds.
Separation logic: A logic for shared mutable data structures. In Logic in Computer Science (LICS), pages 55--74, 2002. [ bib | .pdf ] |
| [1593] |
Morten Rhiger.
A foundation for embedded languages. ACM Transactions on Programming Languages and Systems, 25(3):291--315, May 2003. [ bib | http ] |
| [1594] |
Dustin Rhodes, Cormac Flanagan, and Stephen N. Freund.
BigFoot: static check placement for dynamic race detection. In Programming Language Design and Implementation (PLDI), pages 141--156, June 2017. [ bib | http ] |
| [1595] |
Colin Riba.
On the values of reducibility candidates. In Typed Lambda Calculi and Applications (TLCA), volume 5608 of Lecture Notes in Computer Science, pages 264--278. Springer, July 2009. [ bib | .pdf ] |
| [1596] |
Michael F. Ringenburg and Dan Grossman.
Types for describing coordinated data structures. In Types in Language Design and Implementation (TLDI), pages 25--36, January 2005. [ bib | .pdf ] |
| [1597] |
Tore Risch.
REMREC -- A program for automatic recursion removal in Lisp. Technical Report DLU73/24, Dept. of Computer Science, Uppsala University, 1973. [ bib | .pdf ] |
| [1598] |
Mikael Rittri.
Using types as search keys in function libraries. Journal of Functional Programming, 1(1):71--89, 1991. [ bib ] |
| [1599] |
Mikael Rittri.
Retrieving library functions by unifying types modulo linear isomorphism. RAIRO Theoretical Informatics and Applications, 27(6):523--540, 1993. [ bib ] |
| [1600] |
Xavier Rival.
Abstract domains for the static analysis of programs manipulating complex data structures. Habilitation à diriger des recherches, École Normale Supérieure, 2011. [ bib | .pdf ] |
| [1601] |
J. Alan Robinson.
A machine-oriented logic based on the resolution principle. Journal of the ACM, 12(1):23--41, 1965. [ bib | http ] |
| [1602] |
Dulma Rodriguez.
Amortised resource analysis for object-oriented programs. PhD thesis, Ludwig Maximilians University Munich, 2012. [ bib | http ] |
| [1603] |
Ekkehard Rohwedder.
ForML -- a pretty-printing facility for SML. Online documentation, January 1993. [ bib | http ] |
| [1604] |
Tiark Rompf and Nada Amin.
Type soundness for dependent object types (DOT). In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 624--641, November 2016. [ bib | .pdf ] |
| [1605] |
Tiark Rompf, Ingo Maier, and Martin Odersky.
Implementing first-class polymorphic delimited continuations by a type-directed selective CPS transform. In International Conference on Functional Programming (ICFP), pages 317--328, September 2009. [ bib | .pdf ] |
| [1606] |
Mads Rosendahl.
Automatic complexity analysis. In Functional Programming Languages and Computer Architecture (FPCA), pages 144--156, 1989. [ bib | http ] |
| [1607] |
John L. Ross and Mooly Sagiv.
Building a bridge between pointer aliases and program dependences. Nordic Journal of Computing, 5(4):361--386, 1998. [ bib | .ps ] |
| [1608] |
Andreas Rossberg.
1ML -- core and modules united (F-ing first-class modules). In International Conference on Functional Programming (ICFP), pages 35--47, September 2015. [ bib | .pdf ] |
| [1609] |
Andreas Rossberg, Claudio V. Russo, and Derek Dreyer.
F-ing modules. Journal of Functional Programming, 24(5):529--607, 2014. [ bib | .pdf ] |
| [1610] |
Andreas Rossberg, Peter J. Stuckey, Martin Sulzmann, and Jeremy Wazny.
The Chameleon language. [ bib | http ] |
| [1611] |
Colin Runciman and Ian Toyn.
Retrieving re-usable software components by polymorphic type. Journal of Functional Programming, 1(2):191--211, 1991. [ bib ] |
| [1612] |
Stuart Russell and Peter Norvig.
Artificial intelligence: A modern approach. Prentice Hall, 2009. [ bib | http ] |
| [1613] |
Claudio V. Russo.
Types for modules. PhD thesis, University of Edinburgh, 1998. [ bib | .html ] |
| [1614] |
Vlad Rusu and David Nowak.
Defining corecursive functions in Coq using approximations. In European Conference on Object-Oriented Programming (ECOOP), volume 222 of Leibniz International Proceedings in Informatics, pages 12:1--12:24. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, June 2022. [ bib | http ] |
| [1615] |
Barbara G. Ryder and Mary Lou Soffa.
Influences on the design of exception handling. ACM SIGSOFT Software Engineering Notes, 28(4):29--35, 2003. [ bib | .pdf ] |
| [1616] |
Lukas Rytz, Martin Odersky, and Philipp Haller.
Lightweight polymorphic effects. In European Conference on Object-Oriented Programming (ECOOP), volume 7313 of Lecture Notes in Computer Science, pages 258--282. Springer, June 2012. [ bib | .pdf ] |
| [1617] |
Yann Régis-Gianas.
Des types aux assertions logiques : preuve automatique ou assistée de propriétés sur les programmes fonctionnels. PhD thesis, Université Paris 7, November 2007. [ bib | .pdf ] |
| [1618] |
Yann Régis-Gianas.
The Pangolin programming language, 2008. http://code.google.com/p/pangolin-programming-language/. [ bib | http ] |
| [1619] |
Yann Régis-Gianas and François Pottier.
A Hoare logic for call-by-value functional programs. In Mathematics of Program Construction (MPC), volume 5133 of Lecture Notes in Computer Science, pages 305--335. Springer, July 2008. [ bib | .pdf ] |
| [1620] |
Didier Rémy.
Type checking records and variants in a natural extension of ML. In Principles of Programming Languages (POPL), pages 77--88, 1989. [ bib | http ] |
| [1621] |
Didier Rémy.
Efficient representation of extensible records. In ACM Workshop on ML and its Applications, June 1992. [ bib | .pdf ] |
| [1622] |
Didier Rémy.
Simple, partial type inference for system F based on type containment. In International Conference on Functional Programming (ICFP), September 2005. [ bib | .pdf ] |
| [1623] |
Didier Rémy.
Simple, partial type inference for system F based on type containment. In International Conference on Functional Programming (ICFP), September 2005. [ bib | .pdf ] |
| [1624] |
Andrei Sabelfeld and David Sands.
A PER model of secure information flow in sequential programs. In European Symposium on Programming (ESOP), volume 1575 of Lecture Notes in Computer Science, pages 40--58. Springer, 1999. [ bib | .ps ] |
| [1625] |
Daniel Sabin and Eugene C. Freuder.
Contradicting conventional wisdom in constraint satisfaction. In International Workshop on Principles and Practice of Constraint Programming (PPCP), volume 874 of Lecture Notes in Computer Science, pages 10--20. Springer, May 1994. [ bib | .pdf ] |
| [1626] |
Amr Sabry.
What is a purely functional language? Journal of Functional Programming, 8(1):1--22, January 1998. [ bib | http ] |
| [1627] |
Amr Sabry and Matthias Felleisen.
Reasoning about programs in continuation-passing style. Lisp and Symbolic Computation, 6(3--4):289--360, 1993. [ bib | .ps.gz ] |
| [1628] |
Ayesha Sadiq, Yuan-Fang Li, and Sea Ling.
A survey on the use of access permission-based specifications for program verification. Journal of Systems and Software, 159, 2020. [ bib | http ] |
| [1629] |
Bratin Saha, Nevin Heintze, and Dino Oliva.
Subtransitive CFA using types. Technical Report YALEU/DCS/TR-1166, Yale University, October 1998. [ bib | .ps.gz ] |
| [1630] |
Ayumu Saito and Reynald Affeldt.
Towards a practical library for monadic equational reasoning in Coq. In Mathematics of Program Construction (MPC), volume 13544 of Lecture Notes in Computer Science, pages 151--177. Springer, September 2022. [ bib | .pdf ] |
| [1631] |
Amr Hany Saleh, Georgios Karachalias, Matija Pretnar, and Tom Schrijvers.
Explicit effect subtyping. In European Symposium on Programming (ESOP), volume 10801 of Lecture Notes in Computer Science, pages 327--354. Springer, April 2018. [ bib | .pdf ] |
| [1632] |
Adam Sandberg Ericsson, Magnus O. Myreen, and Johannes Åman Pohjola.
A verified generational garbage collector for CakeML. Journal of Automated Reasoning, 63(2):463--488, 2019. [ bib | http ] |
| [1633] |
David Sands.
Complexity analysis for a lazy higher-order language. In European Symposium on Programming (ESOP), volume 432 of Lecture Notes in Computer Science, pages 361--376. Springer, May 1990. [ bib | http ] |
| [1634] |
David Sands, Jörgen Gustavsson, and Andrew Moran.
Lambda calculi and linear speedups. In The Essence of Computation, Complexity, Analysis, Transformation. Essays Dedicated to Neil D. Jones, volume 2566 of Lecture Notes in Computer Science, pages 60--84. Springer, 2002. [ bib | .pdf ] |
| [1635] |
Davide Sangiorgi.
On the bisimulation proof method. Mathematical Structures in Computer Science, 8(5):447--479, 1998. [ bib | .ps.gz ] |
| [1636] |
Patrick M. Sansom.
Time profiling a lazy functional compiler. In Functional Programming, Workshops in Computing. Springer, July 1993. [ bib | .ps.gz ] |
| [1637] |
José Fragoso Santos, Petar Maksimovic, Sacha-élie Ayoun, and Philippa
Gardner.
Gillian, part I: a multi-language platform for symbolic execution. In Programming Language Design and Implementation (PLDI), pages 927--942, June 2020. [ bib | http ] |
| [1638] |
Olivier Savary Belanger, Stefan Monnier, and Brigitte Pientka.
Programming type-safe transformations using higher-order abstract syntax. In Certified Programs and Proofs (CPP), volume 8307 of Lecture Notes in Computer Science, pages 243--258. Springer, December 2013. [ bib | http ] |
| [1639] |
Olivier Savary Belanger, Stefan Monnier, and Brigitte Pientka.
Programming type-safe transformations using higher-order abstract syntax. Journal of Formalized Reasoning, 8(1), December 2015. [ bib | http ] |
| [1640] |
Steven Schäfer, Sigurd Schneider, and Gert Smolka.
Axiomatic semantics for compiler verification. In Certified Programs and Proofs (CPP), pages 188--196, January 2016. [ bib | .pdf ] |
| [1641] |
Steven Schäfer, Gert Smolka, and Tobias Tebbi.
Completeness and decidability of de Bruijn substitution algebra in Coq. In Certified Programs and Proofs (CPP), pages 67--73, January 2015. [ bib | http ] |
| [1642] |
Steven Schäfer, Tobias Tebbi, and Gert Smolka.
Autosubst: Reasoning with de Bruijn terms and parallel substitutions. In Interactive Theorem Proving (ITP), volume 9236 of Lecture Notes in Computer Science, pages 359--374. Springer, August 2015. [ bib | .pdf ] |
| [1643] |
Fabian Schaub.
Purely functional real-time deques. Seminar report, Universität Innsbruck, 2023. [ bib | .pdf ] |
| [1644] |
Karl Max Schimpf.
Construction methods of LR parsers. PhD thesis, University of Pennsylvania, May 1981. [ bib | http ] |
| [1645] |
Fred B. Schneider.
On concurrent programming. Springer, 1997. [ bib ] |
| [1646] |
Fred B. Schneider.
Enforceable security policies. ACM Transactions on Information and System Security, 3(1):1--50, February 2000. [ bib | .pdf ] |
| [1647] |
Lutz Schröder and Till Mossakowski.
HasCASL: Towards integrated specification and development of functional programs. In International Conference on Algebraic Methodology and Software Technology (AMAST), volume 2422 of Lecture Notes in Computer Science, pages 99--116. Springer, September 2002. [ bib | .ps ] |
| [1648] |
Lutz Schröder and Till Mossakowski.
Monad-independent Hoare logic in HASCASL. In Fundamental Approaches to Software Engineering (FASE), volume 2621 of Lecture Notes in Computer Science, pages 261--277. Springer, April 2003. [ bib | .pdf ] |
| [1649] |
Lenhart K. Schubert, Mary Angela Papalaskaris, and Jay Taugher.
Determining type, part, color, and time relationships. Computer, 16(10):53--60, October 1983. [ bib ] |
| [1650] |
Philipp Schuster, Jonathan Immanuel Brachthäuser, Marius Müller, and Klaus
Ostermann.
A typed continuation-passing translation for lexical effect handlers. In Programming Language Design and Implementation (PLDI), pages 566--579, June 2022. [ bib | http ] |
| [1651] |
Michael I. Schwartzbach.
Polymorphic type inference. Technical Report BRICS-LS-95-3, BRICS, June 1995. [ bib | .ps.gz ] |
| [1652] |
Jan Schwinghammer, Lars Birkedal, François Pottier, Bernhard Reus, Kristian
Støvring, and Hongseok Yang.
A step-indexed Kripke model of hidden state. Mathematical Structures in Computer Science, January 2012. To appear. [ bib | .pdf ] |
| [1653] |
Jan Schwinghammer, Lars Birkedal, Bernhard Reus, and Hongseok Yang.
Nested Hoare triples and frame rules for higher-order store. In Computer Science Logic, volume 5771 of Lecture Notes in Computer Science, pages 440--454. Springer, September 2009. [ bib | .pdf ] |
| [1654] |
Jan Schwinghammer, Lars Birkedal, and Kristian Støvring.
A step-indexed Kripke model of hidden state via recursive properties on recursively defined metric spaces. In Foundations of Software Science and Computation Structures (FOSSACS), number 6604 in Lecture Notes in Computer Science, pages 305--319. Springer, March 2011. [ bib | .pdf ] |
| [1655] |
Jan Schwinghammer, Hongseok Yang, Lars Birkedal, François Pottier, and
Bernhard Reus.
A semantic foundation for hidden state. In Foundations of Software Science and Computation Structures (FOSSACS), volume 6014 of Lecture Notes in Computer Science, pages 2--17. Springer, March 2010. [ bib | .pdf ] |
| [1656] |
Stefan Schwoon.
Model-checking pushdown systems. PhD thesis, Technische Universität München, 2002. [ bib | .pdf ] |
| [1657] |
Steven Schäfer and Gert Smolka.
Tower induction and up-to techniques for CCS with fixed points. In Relational and Algebraic Methods in Computer Science, volume 10226 of Lecture Notes in Computer Science, pages 274--289, May 2017. [ bib | .pdf ] |
| [1658] |
Carsten Schürmann, Adam Poswolsky, and Jeffrey Sarnat.
The nabla-calculus: Functional programming with higher-order encodings. Technical Report YALEU/DCS/TR-1272, Yale University, November 2004. [ bib | .pdf ] |
| [1659] |
Carsten Schürmann, Adam Poswolsky, and Jeffrey Sarnat.
The nabla-calculus: Functional programming with higher-order encodings. In Typed Lambda Calculi and Applications (TLCA), volume 3461 of Lecture Notes in Computer Science, pages 339--353. Springer, April 2005. [ bib | .pdf ] |
| [1660] |
Dana S. Scott.
A type-theoretical alternative to ISWIM, CUCH, OWHY. Theoretical Computer Science, 121(1--2):411--440, 1993. [ bib | http ] |
| [1661] |
Robert Sedgewick and Michael Schidlowsky.
Algorithms in Java: Graph algorithms. Addison-Wesley, 2003. [ bib ] |
| [1662] |
Raimund Seidel and Micha Sharir.
Top-down analysis of path compression. SIAM Journal on Computing, 34(3):515--525, 2005. [ bib | http ] |
| [1663] |
Helmut Seidl and Ralf Vogler.
Three improvements to the top-down solver. In Principles and Practice of Declarative Programming (PPDP), pages 21:1--21:14, September 2018. [ bib | http ] |
| [1664] |
Helmut Seidl, Reinhard Wilhelm, and Sebastian Hack.
Compiler design: Analysis and transformation. Springer, 2012. [ bib | http ] |
| [1665] |
R. C. Sekar, R. Ramesh, and I. V. Ramakrishnan.
Adaptive pattern matching. SIAM Journal on Computing, 24(6):1207--1234, December 1995. [ bib | .ps ] |
| [1666] |
Ilya Sergey, Aleksandar Nanevski, and Anindya Banerjee.
Mechanized verification of fine-grained concurrent programs. In Programming Language Design and Implementation (PLDI), pages 77--87, June 2015. [ bib | .pdf ] |
| [1667] |
Ravi Sethi and J. D. Ullman.
The generation of optimal code for arithmetic expressions. Journal of the ACM, 17(4):715--728, 1970. [ bib | http ] |
| [1668] |
Peter Sewell and Jan Vitek.
Secure composition of untrusted code: Wrappers and causality types. Technical Report 478, Computer Laboratory, University of Cambridge, November 1999. [ bib | .ps ] |
| [1669] |
Peter Sewell and Jan Vitek.
Secure composition of untrusted code: Wrappers and causality types. In IEEE Computer Security Foundations Workshop, July 2000. [ bib | .ps ] |
| [1670] |
Peter Sewell, Francesco Zappa Nardelli, Scott Owens, Gilles Peskine, Thomas
Ridge, Susmit Sarkar, and Rok Strnisa.
Ott: Effective tool support for the working semanticist. Journal of Functional Programming, 20(1):71--122, 2010. [ bib | .pdf ] |
| [1671] |
Edwin Hsing-Mean Sha and Kenneth Steiglitz.
Maintaining bipartite matchings in the presence of failures. Networks, 23(5):459--471, August 1993. [ bib | .ps ] |
| [1672] |
Amir Shaikhha, Andrew W. Fitzgibbon, Simon Peyton Jones, and Dimitrios
Vytiniotis.
Destination-passing style for efficient memory management. In Workshop on Functional High-Performance Computing, pages 12--23, September 2017. [ bib | .pdf ] |
| [1673] |
Amir Shaikhha, Andrew W. Fitzgibbon, Dimitrios Vytiniotis, and Simon Peyton
Jones.
Efficient differentiable programming in a functional array-processing language. Proceedings of the ACM on Programming Languages, 3(ICFP):97:1--97:30, 2019. [ bib | http ] |
| [1674] |
Zhong Shao, Valery Trifonov, Bratin Saha, and Nikolaos Papaspyrou.
A type system for certified binaries. ACM Transactions on Programming Languages and Systems, 27(1):1--45, 2005. [ bib | .pdf ] |
| [1675] |
Tim Sheard.
Using MetaML: A staged programming language. In Advanced Functional Programming, volume 1608 of Lecture Notes in Computer Science, pages 207--239. Springer, September 1998. [ bib | .ps ] |
| [1676] |
Tim Sheard.
Accomplishments and research challenges in meta-programming. In International Workshop on Semantics, Applications, and Implementation of Program Generation (SAIG), volume 2196 of Lecture Notes in Computer Science, pages 2--44. Springer, 2001. [ bib | .pdf ] |
| [1677] |
Tim Sheard.
Languages of the future. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 116--119, October 2004. [ bib | http ] |
| [1678] |
Tim Sheard.
Ωmega, November 2005. [ bib | http ] |
| [1679] |
Tim Sheard.
Putting Curry-Howard to work. In Haskell workshop, pages 74--85, September 2005. [ bib | .ps ] |
| [1680] |
Tim Sheard and Emir Pašalić.
Meta-programming with built-in type equality. In Workshop on Logical Frameworks and Meta-Languages (LFM), July 2004. [ bib | .pdf ] |
| [1681] |
Tim Sheard and Simon Peyton Jones.
Template metaprogramming for Haskell. In Haskell workshop, pages 1--16, October 2002. [ bib | .pdf ] |
| [1682] |
Benjamin Sherman, Jesse Michel, and Michael Carbin.
λS: Computable semantics for differentiable programming with higher-order functions and datatypes. Proceedings of the ACM on Programming Languages, 5(POPL):1--31, 2021. [ bib | http ] |
| [1683] |
Mark B. Shields and Simon Peyton Jones.
First class modules for Haskell. In Foundations of Object-Oriented Languages (FOOL), pages 28--40, January 2002. [ bib | .pdf ] |
| [1684] |
Mark R. Shinwell.
The fresh approach: functional programming with names and binders. PhD thesis, University of Cambridge, February 2005. [ bib | .pdf ] |
| [1685] |
Mark R. Shinwell.
Fresh O'Caml: nominal abstract syntax for the masses. Electronic Notes in Theoretical Computer Science, 148(2):53--77, 2006. [ bib | http ] |
| [1686] |
Mark R. Shinwell and Andrew M. Pitts.
Fresh Objective Caml user manual. Technical Report 621, University of Cambridge, February 2005. [ bib | .pdf ] |
| [1687] |
Mark R. Shinwell and Andrew M. Pitts.
On a monadic semantics for freshness. Theoretical Computer Science, 342:28--55, 2005. [ bib | .pdf ] |
| [1688] |
Mark R. Shinwell, Andrew M. Pitts, and Murdoch J. Gabbay.
FreshML: Programming with binders made simple. In International Conference on Functional Programming (ICFP), pages 263--274, August 2003. [ bib | .pdf ] |
| [1689] |
Olin Shivers.
A universal scripting framework or, Lambda: the ultimate “little language”. In Concurrency and Parallelism: Programming, Networking and Security, volume 1179 of Lecture Notes in Computer Science, pages 254--265. Springer, 1996. [ bib | .ps ] |
| [1690] |
Olha Shkaravska, Marko C. J. D. van Eekelen, and Ron van Kesteren.
Polynomial size analysis of first-order shapely functions. Log. Methods Comput. Sci., 5(2), 2009. [ bib | http ] |
| [1691] |
Filip Sieczkowski, Kasper Svendsen, Lars Birkedal, and Jean Pichon-Pharabod.
A separation logic for fictional sequential consistency. In European Symposium on Programming (ESOP), volume 9032 of Lecture Notes in Computer Science, pages 736--761. Springer, April 2015. [ bib | .pdf ] |
| [1692] |
Rafael Castro G. Silva, Cristiano D. Vasconcellos, and Karina Girardi Roggia.
Monadic W in Coq. In Brazilian Symposium on Programming Languages (SBLP), pages 25--32, October 2020. [ bib | http ] |
| [1693] |
Lucas Silver and Steve Zdancewic.
Dijkstra monads forever: termination-sensitive specifications for interaction trees. Proceedings of the ACM on Programming Languages, 5(POPL):1--28, 2021. [ bib | http ] |
| [1694] |
Hugo R. Simões, Pedro B. Vasconcelos, Mário Florido, Steffen Jost,
and Kevin Hammond.
Automatic amortised analysis of dynamic memory allocation for lazy functional programs. In International Conference on Functional Programming (ICFP), pages 165--176, September 2012. [ bib | .pdf ] |
| [1695] |
Vincent Simonet.
Fine-grained information flow analysis for a λ-calculus with sum types. In IEEE Computer Security Foundations Workshop, pages 223--237, June 2002. [ bib | .ps.gz ] |
| [1696] |
Vincent Simonet.
An extension of HM(X) with bounded existential and universal data-types. In International Conference on Functional Programming (ICFP), June 2003. [ bib | .ps.gz ] |
| [1697] |
Vincent Simonet.
The Flow Caml system: documentation and user's manual. Technical Report 0282, INRIA, July 2003. [ bib | http ] |
| [1698] |
Vincent Simonet.
Type inference with structural subtyping: a faithful formalization of an efficient constraint solver. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science. Springer, November 2003. [ bib | .pdf ] |
| [1699] |
Vincent Simonet.
Inférence de flots d'information pour ML: formalisation et implantation. PhD thesis, Université Paris 7, March 2004. [ bib | .pdf ] |
| [1700] |
Vincent Simonet and François Pottier.
Constraint-based type inference for guarded algebraic data types. Research Report 5462, INRIA, January 2005. [ bib | .html ] |
| [1701] |
Dorai Sitaram.
Handling control. In Programming Language Design and Implementation (PLDI), pages 147--155, June 1993. [ bib | .ps.gz ] |
| [1702] |
Murali Sitaraman, Gregory Kulczycki, Joan Krone, William F. Ogden, and
A. L. Narasimha Reddy.
Performance specification of software components. In Symposium on Software Reusability (SSR), pages 3--10, May 2001. [ bib | .pdf ] |
| [1703] |
K. C. Sivaramakrishnan, Stephen Dolan, Leo White, Sadiq Jaffer, Tom Kelly,
Anmol Sahoo, Sudha Parimala, Atul Dhiman, and Anil Madhavapeddy.
Retrofitting parallelism onto OCaml. Proceedings of the ACM on Programming Languages, 4(ICFP):113:1--113:30, August 2020. [ bib | http ] |
| [1704] |
K. C. Sivaramakrishnan, Stephen Dolan, Leo White, Tom Kelly, Sadiq Jaffer, and
Anil Madhavapeddy.
Retrofitting effect handlers onto OCaml. In Programming Language Design and Implementation (PLDI), pages 206--221, June 2021. [ bib | http ] |
| [1705] |
Christian Skalka.
Types for programming language-based security. PhD thesis, The Johns Hopkins University, August 2002. [ bib | .ps ] |
| [1706] |
Christian Skalka and François Pottier.
Syntactic type soundness for HM(X). In Workshop on Types in Programming (TIP), volume 75 of Electronic Notes in Theoretical Computer Science, July 2002. [ bib | .ps.gz ] |
| [1707] |
Christian Skalka and Scott Smith.
Static enforcement of security with types. In International Conference on Functional Programming (ICFP), pages 34--45, September 2000. [ bib | .ps ] |
| [1708] |
Jan Smans, Bart Jacobs, and Frank Piessens.
Implicit dynamic frames: Combining dynamic frames and separation logic. In European Conference on Object-Oriented Programming (ECOOP), volume 5653 of Lecture Notes in Computer Science, pages 148--172. Springer, July 2009. [ bib | http ] |
| [1709] |
Jan Smans, Bart Jacobs, and Frank Piessens.
Heap-dependent expressions in separation logic. In Formal Techniques for Distributed Systems, volume 6117 of Lecture Notes in Computer Science, pages 170--185. Springer, June 2010. [ bib | http ] |
| [1710] |
Jan Smans, Bart Jacobs, and Frank Piessens.
Implicit dynamic frames. ACM Transactions on Programming Languages and Systems, 34(1):2:1--2:58, 2012. [ bib | http ] |
| [1711] |
Tom Smeding and Matthijs Vákár.
Efficient dual-numbers reverse AD via well-known program transformations. Proceedings of the ACM on Programming Languages, 7(POPL), January 2023. [ bib | http ] |
| [1712] |
Sjaak Smetsers, Erik Barendsen, Marko C. J. D. van Eekelen, and Marinus J.
Plasmeijer.
Guaranteeing safe destructive updates through a type system with uniqueness information for graphs. In Dagstuhl Seminar on Graph Transformations in Computer Science, volume 776 of Lecture Notes in Computer Science, pages 358--379. Springer, 1994. [ bib | .pdf ] |
| [1713] |
Frederick Smith, David Walker, and Greg Morrisett.
Alias types. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 366--381. Springer, March 2000. [ bib | .pdf ] |
| [1714] |
Geoffrey Smith and Dennis Volpano.
Secure information flow in a multi-threaded imperative language. In Principles of Programming Languages (POPL), pages 355--364, January 1998. [ bib | .ps.Z ] |
| [1715] |
Geoffrey S. Smith.
Polymorphic type inference with overloading and subtyping. In Theory and Practice of Software Development (TAPSOFT), volume 668 of Lecture Notes in Computer Science, pages 671--685. Springer, April 1993. [ bib | http ] |
| [1716] |
Geoffrey S. Smith.
Principal type schemes for functional programs with overloading and subtyping. Science of Computer Programming, 23(2--3):197--226, December 1994. [ bib | .pdf ] |
| [1717] |
Geoffrey S. Smith.
A new type system for secure information flow. In IEEE Computer Security Foundations Workshop, pages 115--125, June 2001. [ bib | .pdf ] |
| [1718] |
Scott Smith and Tiejun Wang.
Polyvariant flow analysis with constrained types. In European Symposium on Programming (ESOP), volume 1782 of Lecture Notes in Computer Science, pages 382--396. Springer, March 2000. [ bib | .pdf ] |
| [1719] |
Scott Fraser Smith.
Partial objects in type theory. PhD thesis, Cornell University, January 1989. [ bib | .pdf ] |
| [1720] |
Gert Smolka and Ralf Treinen.
Records for logic programming. Journal of Logic Programming, 18(3):229--258, April 1994. [ bib | .ps ] |
| [1721] |
Michael B. Smyth and Gordon D. Plotkin.
The category-theoretic solution of recursive domain equations. SIAM Journal on Computing, 11(4):761--783, 1982. [ bib | .pdf ] |
| [1722] |
Alan Snyder.
Encapsulation and inheritance in object-oriented programming languages. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 38--45, 1986. [ bib | http ] |
| [1723] |
Jonathan Sobel and Daniel P. Friedman.
Recycling continuations. In International Conference on Functional Programming (ICFP), pages 251--260, September 1998. [ bib | .ps ] |
| [1724] |
Eljas Soisalon-Soininen.
Inessential error entries and their use in LR parser optimization. ACM Transactions on Programming Languages and Systems, 4(2):179--195, April 1982. [ bib | http ] |
| [1725] |
Marvin H. Solomon.
Type definitions with parameters. In Principles of Programming Languages (POPL), pages 31--38, January 1978. [ bib | http ] |
| [1726] |
Sergei V. Soloviev.
The category of finite sets and cartesian closed categories. Journal of Soviet Mathematics, 22(3):1387--1400, 1983. [ bib ] |
| [1727] |
Matthieu Sozeau.
Subset coercions in Coq. In Types for Proofs and Programs, volume 4502, pages 237--252, 2006. [ bib | .pdf ] |
| [1728] |
Matthieu Sozeau.
Program-ing finger trees in Coq. In International Conference on Functional Programming (ICFP), pages 13--24, September 2007. [ bib | .pdf ] |
| [1729] |
Matthieu Sozeau and Cyprien Mangin.
Equations reloaded: high-level dependently-typed functional programming and proving in Coq. In Proceedings of the ACM on Programming Languages, volume 3, pages 1--29, 2019. [ bib | http ] |
| [1730] |
Matthieu Sozeau and Nicolas Tabareau.
Universe polymorphism in Coq. In Interactive Theorem Proving (ITP), volume 8558 of Lecture Notes in Computer Science, pages 499--514. Springer, July 2014. [ bib | .pdf ] |
| [1731] |
Michael Sperber and Peter Thiemann.
The essence of LR parsing. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 146--155, June 1995. [ bib | .pdf ] |
| [1732] |
Michael Sperber and Peter Thiemann.
Generation of LR parsers by partial evaluation. ACM Transactions on Programming Languages and Systems, 22(2):224--264, 2000. [ bib | http ] |
| [1733] |
Simon Spies, Lennard Gäher, Daniel Gratzer, Joseph Tassarotti, Robbert
Krebbers, Derek Dreyer, and Lars Birkedal.
Transfinite Iris: resolving an existential dilemma of step-indexed separation logic. In Programming Language Design and Implementation (PLDI), pages 80--95, June 2021. [ bib | http ] |
| [1734] |
Simon Spies, Lennard Gäher, Joseph Tassarotti, Ralf Jung, Robbert
Krebbers, Lars Birkedal, and Derek Dreyer.
Later credits: resourceful reasoning for the later modality. Proceedings of the ACM on Programming Languages, 6(ICFP):283--311, 2022. [ bib | http ] |
| [1735] |
Mike Spivey.
A functional theory of exceptions. Science of Computer Programming, 14:25--42, 1990. [ bib ] |
| [1736] |
Daniel Spoonhower, Guy E. Blelloch, Robert Harper, and Phillip B. Gibbons.
Space profiling for parallel functional programs. Journal of Functional Programming, 20(5-6):417--461, 2010. [ bib | .pdf ] |
| [1737] |
Akhilesh Srikanth, Burak Sahin, and William R. Harris.
Complexity verification using guided theorem enumeration. In Principles of Programming Languages (POPL), pages 639--652, January 2017. [ bib | .pdf ] |
| [1738] |
R. Stata and M. Abadi.
A type system for Java bytecode subroutines. In Principles of Programming Languages (POPL), pages 149--160, January 1998. [ bib | .html ] |
| [1739] |
Paul A. Steckler and Mitchell Wand.
Lightweight closure conversion. ACM Transactions on Programming Languages and Systems, 19(1):48--86, 1997. [ bib | .ps ] |
| [1740] |
Guy Steele.
Debunking the “expensive procedure call” myth or, procedure call implementations considered harmful or, LAMBDA: the ultimate GOTO. In Proceedings of the 1977 annual conference, pages 153--162. ACM, October 1977. [ bib | http ] |
| [1741] |
Bjarne Steensgaard.
Points-to analysis in almost linear time. In Principles of Programming Languages (POPL), pages 32--41, January 1996. [ bib | .ps ] |
| [1742] |
Bernhard Steffen, Andreas Claßen, Marion Klein, Jens Knoop, and Tiziana
Margaria.
The fixpoint-analysis machine. In International Conference on Concurrency Theory (CONCUR), volume 962 of Lecture Notes in Computer Science, pages 72--87. Springer, August 1995. [ bib | http ] |
| [1743] |
Mark-Oliver Stehr.
CINNI -- A generic calculus of explicit substitutions and its application to λ-, σ- and π-calculi. In International Workshop on Rewriting Logic and its Applications (WRLA), volume 36 of Electronic Notes in Theoretical Computer Science. Elsevier, September 2000. [ bib | .ps ] |
| [1744] |
Gordon Stewart, Lennart Beringer, and Andrew W. Appel.
Verified heap theorem prover by paramodulation. In International Conference on Functional Programming (ICFP), pages 3--14, September 2012. [ bib | .pdf ] |
| [1745] |
Allen Stoughton.
Access flow: A protection model which integrates access control and information flow. In IEEE Symposium on Security and Privacy (S&P), pages 9--18, 1981. [ bib ] |
| [1746] |
Christopher Strachey.
Fundamental concepts in programming languages. Higher-Order and Symbolic Computation, 13(1--2):11--49, April 2000. [ bib | http ] |
| [1747] |
Robert E. Strom and Shaula Yemini.
Typestate: A programming language concept for enhancing software reliability. IEEE Transactions on Software Engineering, 12(1):157--171, 1986. [ bib | .pdf ] |
| [1748] |
Peter J. Stuckey and Martin Sulzmann.
A theory of overloading. In International Conference on Functional Programming (ICFP), pages 167--178, 2002. [ bib | http ] |
| [1749] |
Peter J. Stuckey, Martin Sulzmann, and Jeremy Wazny.
Interactive type debugging in Haskell. In Haskell workshop, pages 72--83, 2003. [ bib | .pdf ] |
| [1750] |
Nicolas Stucki, Tiark Rompf, Vlad Ureche, and Phil Bagwell.
RRB vector: a practical general purpose immutable sequence. In International Conference on Functional Programming (ICFP), pages 342--354, September 2015. [ bib | http ] |
| [1751] |
Zhendong Su and Alexander Aiken.
Entailment with conditional equality constraints. In European Symposium on Programming (ESOP), volume 2028 of Lecture Notes in Computer Science, pages 170--189, April 2001. [ bib | .pdf ] |
| [1752] |
Zhendong Su, Alexander Aiken, Joachim Niehren, Tim Priesnitz, and Ralf Treinen.
The first-order theory of subtyping constraints. In Principles of Programming Languages (POPL), pages 203--216, January 2002. [ bib | .pdf ] |
| [1753] |
Martin Sulzmann.
Designing record systems. Research Report YALEU/DCS/RR-1128, Yale University, April 1997. [ bib | .ps.gz ] |
| [1754] |
Martin Sulzmann.
A general framework for Hindley/Milner type systems with constraints. PhD thesis, Yale University, Department of Computer Science, May 2000. [ bib | http ] |
| [1755] |
Martin Sulzmann.
A general type inference framework for Hindley/Milner style systems. In International Symposium on Functional and Logic Programming, volume 2024 of Lecture Notes in Computer Science, pages 246--263. Springer, March 2001. [ bib | .pdf ] |
| [1756] |
Martin Sulzmann, Martin Müller, and Christoph Zenger.
Hindley/Milner style type systems in constraint form. Research Report ACRC--99--009, University of South Australia, School of Computer and Information Science, July 1999. [ bib | .ps.gz ] |
| [1757] |
Martin Sulzmann, Martin Odersky, and Martin Wehr.
Type inference with constrained types. In Foundations of Object-Oriented Languages (FOOL), January 1997. [ bib | .ps.gz ] |
| [1758] |
Martin Sulzmann and Meng Wang.
A systematic translation of guarded recursive data types to existential types. Technical Report TR22/04, National University of Singapore, 2004. [ bib | .ps.gz ] |
| [1759] |
Eijiro Sumii.
A complete characterization of observational equivalence in polymorphic lambda-calculus with general references. In Computer Science Logic, volume 5771 of Lecture Notes in Computer Science, pages 455--469. Springer, September 2009. [ bib | .pdf ] |
| [1760] |
Eijiro Sumii and Naoki Kobayashi.
A generalized deadlock-free process calculus. In High-Level Concurrent Languages (HLCL), volume 16 of Electronic Notes in Theoretical Computer Science, pages 55--77. Elsevier, September 1998. [ bib | .ps ] |
| [1761] |
Yihan Sun, Daniel Ferizovic, and Guy E. Blelloch.
PAM: parallel augmented maps. In Principles and Practice of Parallel Programming (PPoPP), pages 290--304, February 2018. [ bib | .pdf ] |
| [1762] |
Dejvuth Suwimonteerabuth, Stefan Schwoon, and Javier Esparza.
Efficient algorithms for alternating pushdown systems with an application to the computation of certificate chains. In Automated Technology for Verification and Analysis (ATVA), volume 4218 of Lecture Notes in Computer Science, pages 141--153. Springer, October 2006. [ bib | .pdf ] |
| [1763] |
Kasper Svendsen and Lars Birkedal.
Impredicative concurrent abstract predicates. In European Symposium on Programming (ESOP), volume 8410 of Lecture Notes in Computer Science, pages 149--168. Springer, April 2014. [ bib | .pdf ] |
| [1764] |
Kasper Svendsen, Lars Birkedal, and Matthew J. Parkinson.
Joins: A case study in modular specification of a concurrent reentrant higher-order library. In European Conference on Object-Oriented Programming (ECOOP), volume 7920 of Lecture Notes in Computer Science, pages 327--351. Springer, July 2013. [ bib | .pdf ] |
| [1765] |
Kasper Svendsen, Lars Birkedal, and Matthew J. Parkinson.
Modular reasoning about separation of concurrent data structures. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 169--188. Springer, March 2013. [ bib | .pdf ] |
| [1766] |
Kasper Svendsen, Jean Pichon-Pharabod, Marko Doko, Ori Lahav, and Viktor
Vafeiadis.
A separation logic for a promising semantics. In European Symposium on Programming (ESOP), volume 10801 of Lecture Notes in Computer Science, pages 357--384. Springer, April 2018. [ bib | .pdf ] |
| [1767] |
Josef Svenningsson and Emil Axelsson.
Combining deep and shallow embedding of domain-specific languages. Computer Languages, Systems & Structures, 44:143--165, 2015. [ bib | http ] |
| [1768] |
Nikhil Swamy, Juan Chen, Cédric Fournet, Pierre-Yves Strub, Karthik
Bhargavan, and Jean Yang.
Secure distributed programming with value-dependent types. In International Conference on Functional Programming (ICFP), pages 266--278, September 2011. [ bib | .pdf ] |
| [1769] |
Nikhil Swamy, Michael Hicks, Greg Morrisett, Dan Grossman, and Trevor Jim.
Safe manual memory management in Cyclone. Science of Computer Programming, 62(2):122--144, October 2006. [ bib | .pdf ] |
| [1770] |
Nikhil Swamy, Catalin Hritcu, Chantal Keller, Aseem Rastogi, Antoine
Delignat-Lavaud, Simon Forest, Karthikeyan Bhargavan, Cédric Fournet,
Pierre-Yves Strub, Markulf Kohlweiss, Jean Karim Zinzindohoue, and
Santiago Zanella Béguelin.
Dependent types and multi-monadic effects in F*. In Principles of Programming Languages (POPL), pages 256--270, January 2016. [ bib | http ] |
| [1771] |
Nikhil Swamy, Joel Weinberger, Cole Schlesinger, Juan Chen, and Benjamin
Livshits.
Verifying higher-order programs with the Dijkstra monad. In Programming Language Design and Implementation (PLDI), pages 387--398, June 2013. [ bib | .pdf ] |
| [1772] |
S. Doaitse Swierstra and Luc Duponcheel.
Deterministic, error-correcting combinator parsers. In Advanced Functional Programming, volume 1129 of Lecture Notes in Computer Science, pages 184--207. Springer, August 1996. [ bib | .pdf ] |
| [1773] |
Wouter Swierstra.
Data types à la carte. Journal of Functional Programming, 18(4):423--436, 2008. [ bib | http ] |
| [1774] |
Wouter Swierstra.
A Hoare logic for the state monad. In Theorem Proving in Higher Order Logics (TPHOLs), volume 5674 of Lecture Notes in Computer Science, pages 440--451. Springer, August 2009. [ bib | .pdf ] |
| [1775] |
Wouter Swierstra and Tim Baanen.
A predicate transformer semantics for effects (functional pearl). Proceedings of the ACM on Programming Languages, 3(ICFP):103:1--103:26, 2019. [ bib | http ] |
| [1776] |
Walid Taha.
Multi-stage programming: Its theory and applications. PhD thesis, Oregon Graduate Institute, November 1999. [ bib | .pdf ] |
| [1777] |
Walid Taha.
A gentle introduction to multi-stage programming. In Domain-Specific Program Generation (DSPG), volume 3016 of Lecture Notes in Computer Science, pages 30--50. Springer, November 2004. [ bib | .pdf ] |
| [1778] |
Walid Taha and Michael Florentin Nielsen.
Environment classifiers. In Principles of Programming Languages (POPL), pages 26--37, January 2003. [ bib | .pdf ] |
| [1779] |
Masako Takahashi.
Parallel reductions in λ-calculus. Information and Computation, 118(1):120--127, 1995. [ bib | http ] |
| [1780] |
Asumu Takikawa, T. Stephen Strickland, and Sam Tobin-Hochstadt.
Constraining delimited control with contracts. In European Symposium on Programming (ESOP), volume 7792 of Lecture Notes in Computer Science, pages 229--248. Springer, March 2013. [ bib | .pdf ] |
| [1781] |
Carolyn Talcott.
A theory of binding structures and applications to rewriting. Theoretical Computer Science, 112(1):99--143, 1993. [ bib | http ] |
| [1782] |
Jean-Pierre Talpin and Pierre Jouvelot.
The type and effect discipline. Information and Computation, 11(2):245--296, 1994. [ bib | .pdf ] |
| [1783] |
Gang Tan, Zhong Shao, Xinyu Feng, and Hongxu Cai.
Weak updates and separation logic. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 178--193. Springer, December 2009. [ bib | .pdf ] |
| [1784] |
Yong Kiam Tan, Magnus O. Myreen, Ramana Kumar, Anthony C. J. Fox, Scott Owens,
and Michael Norrish.
A new verified compiler backend for CakeML. In International Conference on Functional Programming (ICFP), pages 60--73, September 2016. [ bib | .pdf ] |
| [1785] |
Yong Kiam Tan, Magnus O. Myreen, Ramana Kumar, Anthony C. J. Fox, Scott Owens,
and Michael Norrish.
The verified CakeML compiler backend. Journal of Functional Programming, 29:e2, 2019. [ bib | .pdf ] |
| [1786] |
Yong Kiam Tan, Scott Owens, and Ramana Kumar.
A verified type system for CakeML. In Implementation of Functional Languages (IFL), pages 7:1--7:12, September 2015. [ bib | .pdf ] |
| [1787] |
David R. Tarditi and Andrew W. Appel.
ML-Yacc user's manual, April 2000. [ bib | http ] |
| [1788] |
Robert Tarjan.
Depth-first search and linear graph algorithms. SIAM Journal on Computing, 1(2):146--160, June 1972. [ bib | http ] |
| [1789] |
Robert E. Tarjan.
Disjoint set union. Class notes, 1999. [ bib | .pdf ] |
| [1790] |
Robert E. Tarjan and Jan van Leeuwen.
Worst-case analysis of set union algorithms. Journal of the ACM, 31(2):245--281, April 1984. [ bib | http ] |
| [1791] |
Robert E. Tarjan and Mihalis Yannakakis.
Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs. SIAM Journal on Computing, 13(3):566--579, August 1984. [ bib | http ] |
| [1792] |
Robert Endre Tarjan.
Efficiency of a good but not linear set union algorithm. Journal of the ACM, 22(2):215--225, April 1975. [ bib | .pdf ] |
| [1793] |
Robert Endre Tarjan.
Applications of path compression on balanced trees. Journal of the ACM, 26(4):690--715, October 1979. [ bib | http ] |
| [1794] |
Robert Endre Tarjan.
Fast algorithms for solving path problems. Journal of the ACM, 28(3):594--614, 1981. [ bib | http ] |
| [1795] |
Robert Endre Tarjan.
A unified approach to path problems. Journal of the ACM, 28(3):577--593, 1981. [ bib | http ] |
| [1796] |
Robert Endre Tarjan.
Amortized computational complexity. SIAM Journal on Algebraic and Discrete Methods, 6(2):306--318, 1985. [ bib | http ] |
| [1797] |
Robert Endre Tarjan.
Algorithmic design. Communications of the ACM, 30(3):204--212, 1987. [ bib | http ] |
| [1798] |
Robert Endre Tarjan and Andrew Chi-Chih Yao.
Storing a sparse table. Communications of the ACM, 22(11):606--611, 1979. [ bib | http ] |
| [1799] |
Joseph Tassarotti, Ralf Jung, and Robert Harper.
A higher-order logic for concurrent termination-preserving refinement. In European Symposium on Programming (ESOP), volume 10201 of Lecture Notes in Computer Science, pages 909--936. Springer, April 2017. [ bib | .pdf ] |
| [1800] |
The GHC team.
The Glasgow Haskell compiler, March 2005. [ bib | http ] |
| [1801] |
Robert D. Tennent and Dan Ghica.
Abstract models of storage. Higher-Order and Symbolic Computation, 13:119--129, 2000. [ bib | http ] |
| [1802] |
Arshavir Ter-Gabrielyan, Alexander J. Summers, and Peter Müller.
Modular verification of heap reachability properties in separation logic. Proceedings of the ACM on Programming Languages, 3(OOPSLA):121:1--121:28, 2019. [ bib | http ] |
| [1803] |
Satish R. Thatté.
Automated synthesis of interface adapters for reusable classes. In Principles of Programming Languages (POPL), pages 174--187, January 1994. [ bib | http ] |
| [1804] |
The Coq development team.
The Coq proof assistant, 2020. [ bib | http ] |
| [1805] |
The Mozilla foundation.
The Rust programming language, 2014. [ bib | http ] |
| [1806] |
Hayo Thielecke.
Comparing control constructs by double-barrelled CPS. Higher-Order and Symbolic Computation, 15(2--3):141--160, 2002. [ bib | .pdf ] |
| [1807] |
Hayo Thielecke.
From control effects to typed continuation passing. In Principles of Programming Languages (POPL), pages 139--149, January 2003. [ bib | .pdf ] |
| [1808] |
Hayo Thielecke.
Frame rules from answer types for code pointers. In Principles of Programming Languages (POPL), pages 309--319, January 2006. [ bib | .pdf ] |
| [1809] |
Peter Thiemann.
ML-style typing, lambda lifting, and partial evaluation. In Latin American Conference on Functional Programming, March 1999. [ bib | .ps.gz ] |
| [1810] |
Peter Thiemann.
Enforcing security properties using type specialization. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, April 2001. [ bib | .ps.gz ] |
| [1811] |
Simon J. Thompson and Huiqing Li.
Refactoring tools for functional languages. Journal of Functional Programming, 23(3):293--350, 2013. [ bib | http ] |
| [1812] |
Ye Henry Tian.
Mechanically verifying correctness of CPS compilation. In Computing: The Australasian Theory Symposium (CATS), volume 51 of CRPIT, pages 41--51. Australian Computer Society, January 2006. [ bib | .pdf ] |
| [1813] |
Amin Timany and Lars Birkedal.
Mechanized relational verification of concurrent programs with continuations. Proceedings of the ACM on Programming Languages, 3(ICFP):105:1--105:28, July 2019. [ bib | http ] |
| [1814] |
Amin Timany and Lars Birkedal.
Reasoning about monotonicity in separation logic. In Certified Programs and Proofs (CPP), pages 91--104, January 2021. [ bib | .pdf ] |
| [1815] |
Amin Timany, Simon Oddershede Gregersen, Léo Stefanesco, Léon Gondelman, Abel
Nieto, and Lars Birkedal.
Trillium: Unifying refinement and higher-order distributed separation logic. Submitted, October 2021. [ bib | .pdf ] |
| [1816] |
Jerzy Tiuryn.
Subtype inequalities. In Logic in Computer Science (LICS), pages 308--317, June 1992. [ bib ] |
| [1817] |
Jerzy Tiuryn and Pawel Urzyczyn.
The subtyping problem for second-order types is undecidable. Information and Computation, 179(1):1--18, 2002. [ bib | http ] |
| [1818] |
Jerzy Tiuryn and Mitchell Wand.
Type reconstruction with recursive types and atomic subtyping. In Theory and Practice of Software Development (TAPSOFT), volume 668 of Lecture Notes in Computer Science, pages 686--701. Springer, April 1993. [ bib | .dvi ] |
| [1819] |
Bogdan Tofan, Gerhard Schellhorn, and Wolfgang Reif.
Formal verification of a lock-free stack with hazard pointers. In Theoretical Aspects of Computing (ICTAC), volume 6916 of Lecture Notes in Computer Science, pages 239--255. Springer, August 2011. [ bib | http ] |
| [1820] |
Luca Della Toffola, Michael Pradel, and Thomas R. Gross.
Synthesizing programs that expose performance bottlenecks. In Code Generation and Optimization (CGO), pages 314--326, February 2018. [ bib | .pdf ] |
| [1821] |
Mads Tofte.
Operational semantics and polymorphic type inference. PhD thesis, University of Edinburgh, 1988. [ bib | http ] |
| [1822] |
Mads Tofte.
Type inference for polymorphic references. Information and Computation, 89(1):1--34, 1990. [ bib | http ] |
| [1823] |
Mads Tofte, Lars Birkedal, Martin Elsman, and Niels Hallenberg.
A retrospective on region-based memory management. Higher-Order and Symbolic Computation, 17(3):245--265, September 2004. [ bib | .ps.gz ] |
| [1824] |
Mads Tofte and Jean-Pierre Talpin.
Implementation of the typed call-by-value λ-calculus using a stack of regions. In Principles of Programming Languages (POPL), pages 188--201, January 1994. [ bib | .pdf ] |
| [1825] |
Mads Tofte and Jean-Pierre Talpin.
Region-based memory management. Information and Computation, 132(2):109--176, 1997. [ bib | .pdf ] |
| [1826] |
Andrew Tolmach.
Combining closure conversion with closure analysis using algebraic types. In Types in Compilation (TIC), June 1997. [ bib | .ps ] |
| [1827] |
Andrew Tolmach and Dino P. Oliva.
From ML to Ada: Strongly-typed language interoperability via source translation. Journal of Functional Programming, 8(4):367--412, July 1998. [ bib | http ] |
| [1828] |
Aaron Tomb and Cormac Flanagan.
Automatic type inference via partial evaluation. In Principles and Practice of Declarative Programming (PPDP), pages 106--116, July 2005. [ bib | .pdf ] |
| [1829] |
Rodney W. Topor.
A note on error recovery in recursive descent parsers. ACM SIGPLAN Notices, 17(2):37--40, February 1982. [ bib | http ] |
| [1830] |
Jesse A. Tov and Riccardo Pucella.
Stateful contracts for affine types. In European Symposium on Programming (ESOP), volume 6012 of Lecture Notes in Computer Science, pages 550--569. Springer, March 2010. [ bib | .pdf ] |
| [1831] |
Jesse A. Tov and Riccardo Pucella.
Practical affine types. In Principles of Programming Languages (POPL), pages 447--458, January 2011. [ bib | http ] |
| [1832] |
Valery Trifonov and Scott Smith.
Subtyping constrained types. In Static Analysis Symposium (SAS), volume 1145 of Lecture Notes in Computer Science, pages 349--365. Springer, September 1996. [ bib | .pdf ] |
| [1833] |
Nicolas Troquard and Philippe Balbiani.
Propositional dynamic logic. In Edward N. Zalta, editor, The Stanford Encyclopedia of Philosophy. Metaphysics Research Lab, Stanford University, 2019. [ bib | http ] |
| [1834] |
Matthew S. Tschantz and Michael D. Ernst.
Javari: adding reference immutability to Java. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 211--230, October 2005. [ bib | .pdf ] |
| [1835] |
Stephen Tse and Steve Zdancewic.
Run-time principals in information-flow type systems. In IEEE Symposium on Security and Privacy (S&P), May 2004. [ bib | .pdf ] |
| [1836] |
Hideki Tsuiki.
On typed calculi with a merge operator. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 880 of Lecture Notes in Computer Science, pages 101--112. Springer, 1994. [ bib | .ps.gz ] |
| [1837] |
Thomas Tuerk.
Local reasoning about while-loops. Unpublished, August 2010. [ bib | .pdf ] |
| [1838] |
David N. Turner.
The polymorphic pi-calculus: Theory and implementation. PhD thesis, University of Edinburgh, 1995. [ bib | http ] |
| [1839] |
David N. Turner, Philip Wadler, and Christian Mossin.
Once upon a type. In Functional Programming Languages and Computer Architecture (FPCA), pages 1--11. ACM Press, June 1995. [ bib | .dvi ] |
| [1840] |
Aaron Turon.
Reagents: expressing and composing fine-grained concurrency. In Programming Language Design and Implementation (PLDI), pages 157--168, June 2012. [ bib | .pdf ] |
| [1841] |
Aaron Turon, Derek Dreyer, and Lars Birkedal.
Unifying refinement and Hoare-style reasoning in a logic for higher-order concurrency. In International Conference on Functional Programming (ICFP), pages 377--390, September 2013. [ bib | .pdf ] |
| [1842] |
Aaron Turon, Viktor Vafeiadis, and Derek Dreyer.
GPS: navigating weak memory with ghosts, protocols, and separation. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 691--707, October 2014. [ bib | .pdf ] |
| [1843] |
Sebastian Ullrich and Leonardo de Moura.
Counting immutable beans: Reference counting optimized for purely functional programming. In Implementation of Functional Languages (IFL), September 2019. [ bib | http ] |
| [1844] |
Unicon.
http://unicon.sourceforge.net/. [ bib | http ] |
| [1845] |
Leena Unnikrishnan and Scott D. Stoller.
Parametric heap usage analysis for functional programs. In International Symposium on Memory Management, pages 139--148, June 2009. [ bib | .pdf ] |
| [1846] |
Leena Unnikrishnan, Scott D. Stoller, and Yanhong A. Liu.
Automatic accurate live memory analysis for garbage-collected languages. In Languages, Compilers, and Tools for Embedded Systems (LCTES), pages 102--111, June 2001. [ bib | .pdf ] |
| [1847] |
Leena Unnikrishnan, Scott D. Stoller, and Yanhong A. Liu.
Optimized live heap bound analysis. In Verification, Model Checking and Abstract Interpretation (VMCAI), volume 2575 of Lecture Notes in Computer Science, pages 70--85. Springer, January 2003. [ bib | .pdf ] |
| [1848] |
Christian Urban.
Nominal techniques in Isabelle/HOL. Journal of Automated Reasoning, 40(4):327--356, 2008. [ bib | .pdf ] |
| [1849] |
Christian Urban and Tobias Nipkow.
Nominal verification of algorithm W. In Yves Bertot, Gérard Huet, Jean-Jacques Lévy, and Gordon Plotkin, editors, From Semantics to Computer Science: Essays in Honour of Gilles Kahn, page 363–382. Cambridge University Press, 2009. [ bib | .pdf ] |
| [1850] |
Christian Urban, Andrew Pitts, and Murdoch Gabbay.
Nominal unification. Theoretical Computer Science, 323:473--497, 2004. [ bib | .pdf ] |
| [1851] |
Christian Urban and Christine Tasson.
Nominal techniques in Isabelle/HOL. In International Conference on Automated Deduction (CADE), volume 3632 of Lecture Notes in Computer Science, pages 38--53. Springer, July 2005. [ bib | .ps ] |
| [1852] |
Viktor Vafeiadis.
Concurrent separation logic and operational semantics. Electronic Notes in Theoretical Computer Science, 276:335--351, 2011. [ bib | .pdf ] |
| [1853] |
Viktor Vafeiadis.
Program verification under weak memory consistency using separation logic. In Computer Aided Verification (CAV), volume 10426 of Lecture Notes in Computer Science, pages 30--46. Springer, July 2017. [ bib | .pdf ] |
| [1854] |
Viktor Vafeiadis and Chinmay Narayan.
Relaxed separation logic: a program logic for C11 concurrency. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 867--884, October 2013. [ bib | .pdf ] |
| [1855] |
Matthijs Vákár.
Reverse AD at higher types: Pure, principled and denotationally correct. In European Symposium on Programming (ESOP), volume 12648 of Lecture Notes in Computer Science, pages 607--634. Springer, April 2021. [ bib | http ] |
| [1856] |
Antti Valmari.
Fast brief practical DFA minimization. Information Processing Letters, 112(6):213--217, 2012. [ bib | http ] |
| [1857] |
Mark van den Brand and Eelco Visser.
Generation of formatters for context-free languages. ACM Transactions on Software Engineering and Methodology, 5(1):1--41, 1996. [ bib | http ] |
| [1858] |
Eelis van der Weegen and James McKinna.
A machine-checked proof of the average-case complexity of Quicksort in Coq. In Types for Proofs and Programs, volume 5497 of Lecture Notes in Computer Science, pages 256--271. Springer, March 2008. [ bib | .pdf ] |
| [1859] |
Marko van Dooren, Bart Jacobs, and Wouter Joosen.
Modular type checking of anchored exception declarations. Science of Computer Programming, 87:44--61, 2014. [ bib | http ] |
| [1860] |
Marko van Dooren and Eric Steegmans.
Combining the robustness of checked exceptions with the flexibility of unchecked exceptions using anchored exception declarations. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 455--471, October 2005. [ bib | http ] |
| [1861] |
Vincent van Oostrom.
Confluence by decreasing diagrams. Theoretical Computer Science, 126(2):259--280, April 1994. [ bib | .ps.Z ] |
| [1862] |
Stephan van Staden, Cristiano Calcagno, and Bertrand Meyer.
Verifying executable object-oriented specifications with separation logic. In European Conference on Object-Oriented Programming (ECOOP), volume 6183 of Lecture Notes in Computer Science, pages 151--174. Springer, June 2010. [ bib | http ] |
| [1863] |
Eric van Wyk, Oege de Moor, and Simon Peyton Jones.
Aspect-oriented compilers. In Generative and Component-Based Software Engineering, volume 1799 of Lecture Notes in Computer Science, pages 121--133. Springer, September 1999. [ bib | .pdf ] |
| [1864] |
Mandana Vaziri and Daniel Jackson.
Checking heap-manipulating procedures with a constraint solver. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 2619 of Lecture Notes in Computer Science. Springer, April 2003. [ bib | .pdf ] |
| [1865] |
Niki Vazou, Leonidas Lampropoulos, and Jeff Polakow.
A tale of two provers: verifying monoidal string matching in Liquid Haskell and Coq. In Haskell symposium, pages 63--74, September 2017. [ bib | .pdf ] |
| [1866] |
Niccolò Veltri and Niels van der Weide.
Guarded recursion in Agda via sized types. In Formal Structures for Computation and Deduction (FSCD), volume 131 of Leibniz International Proceedings in Informatics, pages 32:1--32:19. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, June 2019. [ bib | http ] |
| [1867] |
Bart Vergauwen and Johan Lewi.
Efficient local correctness checking for single and alternating Boolean equation systems. In International Colloquium on Automata, Languages and Programming, volume 820 of Lecture Notes in Computer Science, pages 304--315. Springer, 1994. [ bib | http ] |
| [1868] |
Bart Vergauwen, Johan Lewi, I. Avau, and A. Poté.
Efficient computation of nested fix-points, with applications to model checking. In International Conference on Temporal Logic (ICTL), volume 827 of Lecture Notes in Computer Science, pages 165--179. Springer, July 1994. [ bib | http ] |
| [1869] |
Bart Vergauwen, J. Wauman, and Johan Lewi.
Efficient fixpoint computation. In Static Analysis Symposium (SAS), volume 864 of Lecture Notes in Computer Science, pages 314--328. Springer, 1994. [ bib | http ] |
| [1870] |
Jules Villard, Étienne Lozes, and Cristiano Calcagno.
Proving copyless message passing. In Asian Symposium on Programming Languages and Systems (APLAS), volume 5904 of Lecture Notes in Computer Science, pages 194--209. Springer, December 2009. [ bib | .pdf ] |
| [1871] |
Jules Villard, Étienne Lozes, and Cristiano Calcagno.
Tracking heaps that hop with Heap-Hop. In Tools and Algorithms for Construction and Analysis of Systems (TACAS), volume 6015 of Lecture Notes in Computer Science, pages 275--279. Springer, March 2010. [ bib | .pdf ] |
| [1872] |
Simon Friis Vindum and Lars Birkedal.
Contextual refinement of the Michael-Scott queue. In Certified Programs and Proofs (CPP), pages 76--90, January 2021. [ bib | .pdf ] |
| [1873] |
Eelco Visser.
A case study in optimizing parsing schemata by disambiguation filters. In Workshop on Parsing Technologies, pages 210--224. Association for Computational Linguistics, September 1997. [ bib | http ] |
| [1874] |
Jan Vitek and Boris Bokowski.
Confined types in Java. Software: Practice and Experience, 31(6):507--532, 2001. [ bib | .pdf ] |
| [1875] |
Janis Voigtländer.
Asymptotic improvement of computations over free monads. In Mathematics of Program Construction (MPC), volume 5133 of Lecture Notes in Computer Science, pages 388--403. Springer, 2008. [ bib | .pdf ] |
| [1876] |
Dennis Volpano.
Provably-secure programming languages for remote evaluation. ACM SIGPLAN Notices, 32(1):117--119, January 1997. [ bib ] |
| [1877] |
Dennis Volpano and Geoffrey Smith.
Eliminating covert flows with minimum typings. In IEEE Computer Security Foundations Workshop, pages 156--168, June 1997. [ bib | .ps.Z ] |
| [1878] |
Dennis Volpano and Geoffrey Smith.
A type-based approach to program security. Lecture Notes in Computer Science, 1214:607--621, April 1997. [ bib | .ps.Z ] |
| [1879] |
Dennis Volpano, Geoffrey Smith, and Cynthia Irvine.
A sound type system for secure flow analysis. Journal of Computer Security, 4(3):167--187, 1996. [ bib | .ps.Z ] |
| [1880] |
Sergei G. Vorobyov.
An improved lower bound for the elementary theories of trees. In International Conference on Automated Deduction (CADE), volume 1104 of Lecture Notes in Computer Science, pages 275--287. Springer, 1996. [ bib | .ps.Z ] |
| [1881] |
Jérôme Vouillon and Paul-André Melliès.
Semantic types: a fresh look at the ideal model for types. In Principles of Programming Languages (POPL), pages 52--63, January 2004. [ bib | .ps.gz ] |
| [1882] |
Dimitrios Vytiniotis, Simon Peyton Jones, Tom Schrijvers, and Martin
Sulzmann.
OutsideIn(X): Modular type inference with local assumptions. Journal of Functional Programming, 21(4--5):333--412, 2011. [ bib | .pdf ] |
| [1883] |
Dimitrios Vytiniotis and Stephanie Weirich.
Dependent types: Easy as PIE. In Trends in Functional Programming (TFP), April 2007. [ bib | .pdf ] |
| [1884] |
Dimitrios Vytiniotis, Stephanie Weirich, and Simon Peyton Jones.
Boxy types: type inference for higher-rank types and impredicativity. Manuscript, April 2005. [ bib | http ] |
| [1885] |
Matthijs Vákár and Tom Smeding.
CHAD: Combinatory homomorphic automatic differentiation. ACM Transactions on Programming Languages and Systems, 44(3):1--49, September 2022. [ bib | http ] |
| [1886] |
Philip Wadler.
Theorems for free! In Functional Programming Languages and Computer Architecture (FPCA), pages 347--359, September 1989. [ bib | .ps.gz ] |
| [1887] |
Philip Wadler.
Linear types can change the world! In M. Broy and C. Jones, editors, Programming Concepts and Methods. North Holland, April 1990. [ bib | .ps ] |
| [1888] |
Philip Wadler.
Comprehending monads. Mathematical Structures in Computer Science, 2:461--493, 1992. [ bib | .ps.gz ] |
| [1889] |
Philip Wadler.
The essence of functional programming. In Principles of Programming Languages (POPL), pages 1--14, 1992. Invited talk. [ bib | .ps ] |
| [1890] |
Philip Wadler.
The Girard-Reynolds isomorphism (second edition). Theoretical Computer Science, 375(1--3):201--226, May 2007. [ bib | .pdf ] |
| [1891] |
Philip Wadler and Stephen Blott.
How to make ad-hoc polymorphism less ad-hoc. In Principles of Programming Languages (POPL), pages 60--76, January 1989. [ bib | .ps.gz ] |
| [1892] |
Philip Wadler and Peter Thiemann.
The marriage of effects and monads. ACM Transactions on Computational Logic, 4(1):1--32, January 2003. [ bib | .ps.gz ] |
| [1893] |
Philip L. Wadler.
How to replace failure by a list of successes. In Functional Programming Languages and Computer Architecture (FPCA), volume 201 of Lecture Notes in Computer Science, pages 113--128. Springer, September 1985. [ bib | http ] |
| [1894] |
David Walker.
A type system for expressive security policies. In Principles of Programming Languages (POPL), pages 254--267, January 2000. [ bib | http ] |
| [1895] |
David Walker.
Substructural type systems. In Benjamin C. Pierce, editor, Advanced Topics in Types and Programming Languages, chapter 1, pages 3--43. MIT Press, 2005. [ bib ] |
| [1896] |
David Walker, Karl Crary, and Greg Morrisett.
Typed memory management via static capabilities. ACM Transactions on Programming Languages and Systems, 22(4):701--771, 2000. [ bib | .pdf ] |
| [1897] |
David Walker and Greg Morrisett.
Alias types for recursive data structures. In Types in Compilation (TIC), volume 2071 of Lecture Notes in Computer Science, pages 177--206. Springer, September 2000. [ bib | .pdf ] |
| [1898] |
Dan S. Wallach.
A new approach to mobile code security. PhD thesis, Princeton University, January 1999. [ bib | .html ] |
| [1899] |
Dan S. Wallach, Andrew W. Appel, and Edward W. Felten.
Safkasi: A security mechanism for language-based systems. ACM Transactions on Software Engineering and Methodology, 9(4):341--378, October 2000. [ bib | .ps ] |
| [1900] |
Dan S. Wallach and Edward Felten.
Understanding Java stack inspection. In IEEE Symposium on Security and Privacy (S&P), May 1998. [ bib | http ] |
| [1901] |
Andrea Walther, Andreas Griewank, and Olaf Vogel.
ADOL-C: Automatic differentiation using operator overloading in C++. Proceedings in Applied Mathematics and Mechanics, 2(1):41--44, March 2003. [ bib | http ] |
| [1902] |
Mitchell Wand.
Continuation-based program transformation strategies. Journal of the ACM, 27(1):164--180, 1980. [ bib | http ] |
| [1903] |
Mitchell Wand.
Embedding type structure in semantics. In Principles of Programming Languages (POPL), pages 1--6, January 1985. [ bib | http ] |
| [1904] |
Mitchell Wand.
Finding the source of type errors. In Principles of Programming Languages (POPL), pages 38--43, January 1986. [ bib | http ] |
| [1905] |
Mitchell Wand.
A simple algorithm and proof for type inference. Fundamenta Informaticæ, 10:115--122, 1987. [ bib | .pdf ] |
| [1906] |
Mitchell Wand.
Correctness of procedure representations in higher-order assembly language. In Mathematical Foundations of Programming Semantics, volume 598 of Lecture Notes in Computer Science, pages 294--311. Springer, March 1991. [ bib | .dvi ] |
| [1907] |
Mitchell Wand.
Type inference for record concatenation and multiple inheritance. Information and Computation, 93(1):1--15, July 1991. [ bib | .dvi ] |
| [1908] |
Mitchell Wand.
Type inference for objects with instance variables and inheritance. In Carl A. Gunter and John C. Mitchell, editors, Theoretical Aspects Of Object-Oriented Programming: Types, Semantics and Language Design, pages 97--120. MIT Press, 1994. [ bib | .dvi ] |
| [1909] |
Mitchell Wand and Paul A. Steckler.
Selective and lightweight closure conversion. In Principles of Programming Languages (POPL), pages 435--445, January 1994. [ bib | http ] |
| [1910] |
Fei Wang and Tiark Rompf.
A language and compiler view on differentiable programming. In International Conference on Learning Representations (ICLR), Workshop Track, 2018. [ bib | http ] |
| [1911] |
Fei Wang, Daniel Zheng, James M. Decker, Xilun Wu, Grégory M. Essertel, and
Tiark Rompf.
Demystifying differentiable programming: shift/reset the penultimate backpropagator. Proceedings of the ACM on Programming Languages, 3(ICFP):96:1--96:31, 2019. [ bib | http ] |
| [1912] |
Peng Wang, Di Wang, and Adam Chlipala.
TiML: A functional language for practical complexity analysis with invariants. Proceedings of the ACM on Programming Languages, 1(OOPSLA):79:1--79:26, October 2017. [ bib | .pdf ] |
| [1913] |
Shengyi Wang, Qinxiang Cao, Anshuman Mohan, and Aquinas Hobor.
Certifying graph-manipulating C programs via localizations within data structures. Proceedings of the ACM on Programming Languages, 3(OOPSLA):171:1--171:30, 2019. [ bib | http ] |
| [1914] |
Martin Ward.
Derivation of data intensive algorithms by formal transformation -- the Schorr-Waite graph marking algorithm. IEEE Transactions on Software Engineering, 22(9):665--686, September 1996. [ bib | .pdf ] |
| [1915] |
D. H. D. Warren.
Higher-order extensions to PROLOG: are they needed? In J. E. Hayes, D. Michie, and Y-H. Pao, editors, Machine Intelligence 10, pages 441--454. Ellis Horwood, 1982. [ bib ] |
| [1916] |
Alessandro Warth, James R. Douglass, and Todd D. Millstein.
Packrat parsers can support left recursion. In Workshop on Evaluation and Semantics-Based Program Manipulation (PEPM), pages 103--110, January 2008. [ bib | .pdf ] |
| [1917] |
Conrad Watt, Maja Trela, Peter Lammich, and Florian Märkl.
WasmRef-Isabelle: A verified monadic interpreter and industrial fuzzing oracle for WebAssembly. Proceedings of the ACM on Programming Languages, 7(PLDI):100--123, 2023. [ bib | http ] |
| [1918] |
Ben Wegbreit.
Mechanical program analysis. Communications of the ACM, 18(9):528--539, September 1975. [ bib | http ] |
| [1919] |
Ingo Wegener.
A simplified correctness proof for a well-known algorithm computing strongly connected components. Information Processing Letters, 83(1):17--19, 2002. [ bib | .pdf ] |
| [1920] |
Guannan Wei, Oliver Bracevac, Songlin Jia, Yuyan Bao, and Tiark Rompf.
Polymorphic reachability types: Tracking freshness, aliasing, and separation in higher-order generic programs. Proceedings of the ACM on Programming Languages, 8(POPL):393--424, 2024. [ bib | http ] |
| [1921] |
Stephanie Weirich.
Type-safe cast: Functional pearl. In International Conference on Functional Programming (ICFP), pages 58--67, September 2000. [ bib | .pdf ] |
| [1922] |
Stephanie Weirich.
A typechecker that produces a typed term from an untyped source. Part of the Glasgow Haskell compiler's test suite, September 2004. [ bib | http ] |
| [1923] |
Stephanie Weirich.
RepLib: a library for derivable type classes. In Haskell workshop, pages 1--12, 2006. [ bib | .pdf ] |
| [1924] |
Stephanie Weirich.
Type-safe run-time polytypic programming. Journal of Functional Programming, 16(10):681--710, November 2006. [ bib | .pdf ] |
| [1925] |
Stephanie Weirich, Brent A. Yorgey, and Tim Sheard.
Binders unbound. In International Conference on Functional Programming (ICFP), pages 333--345, September 2011. [ bib | .pdf ] |
| [1926] |
J. B. Wells.
The undecidability of Mitchell's subtyping relation. Technical Report 95-019, Computer Science Department, Boston University, December 1995. [ bib | .ps.gz ] |
| [1927] |
J. B. Wells.
Typability and type checking in system F are equivalent and undecidable. Annals of Pure and Applied Logic, 98(1--3):111--156, 1999. [ bib | http ] |
| [1928] |
J. B. Wells.
The essence of principal typings. In International Colloquium on Automata, Languages and Programming, volume 2380 of Lecture Notes in Computer Science, pages 913--925. Springer, 2002. [ bib | .pdf ] |
| [1929] |
Cheng Wen, Haijun Wang, Yuekang Li, Shengchao Qin, Yang Liu, Zhiwu Xu, Hongxu
Chen, Xiaofei Xie, Geguang Pu, and Ting Liu.
MemLock: memory usage guided fuzzing. In International Conference on Software Engineering (ICSE), pages 765--777, June 2020. [ bib | .pdf ] |
| [1930] |
Benjamin Werner.
Une théorie des constructions inductives. PhD thesis, Université Paris 7, 1994. [ bib ] |
| [1931] |
Edwin Westbrook, Aaron Stump, and Ian Wehrman.
A language-based approach to functionally correct imperative programming. In International Conference on Functional Programming (ICFP), pages 268--279, 2005. [ bib | .pdf ] |
| [1932] |
Edwin M. Westbrook.
Higher-order encodings with constructors. PhD thesis, Washington University, December 2008. [ bib | .pdf ] |
| [1933] |
James R. Wilcox, Cormac Flanagan, and Stephen N. Freund.
VerifiedFT: a verified, high-performance precise dynamic race detector. In Principles and Practice of Parallel Programming (PPoPP), pages 354--367, February 2018. [ bib | .pdf ] |
| [1934] |
J. W. J. Williams.
Algorithm 232: Heapsort. Communications of the ACM, 7(6):347--348, June 1964. [ bib | http ] |
| [1935] |
Simon Wimmer, Shuwei Hu, and Tobias Nipkow.
Verified memoization and dynamic programming. In Interactive Theorem Proving (ITP), volume 10895 of Lecture Notes in Computer Science, pages 579--596. Springer, July 2018. [ bib | .pdf ] |
| [1936] |
Jeannette M. Wing, Eugene Rollins, and Amy Moormann Zaremski.
Thoughts on a Larch/ML and a new application for LP. In First International Workshop on Larch, pages 297--312, July 1992. [ bib | .ps ] |
| [1937] |
Niklaus Wirth.
Algorithms + data structures = programs. Prentice Hall, 1978. [ bib ] |
| [1938] |
Ryan Wisnesky, Gregory Malecha, and Greg Morrisett.
Certified web services in Ynot. In Workshop on Automated Specification and Verification of Web Systems, July 2009. [ bib | .pdf ] |
| [1939] |
Roger Wolff, Ronald Garcia, Éric Tanter, and Jonathan Aldrich.
Gradual typestate. In European Conference on Object-Oriented Programming (ECOOP), volume 6813 of Lecture Notes in Computer Science, pages 459--483. Springer, July 2011. [ bib | .pdf ] |
| [1940] |
J. P. L. Woodward.
Applications for multilevel secure operating systems. In Proceedings NCC, volume 48, pages 319--328. AFIPS Press, June 1979. [ bib ] |
| [1941] |
Andrew K. Wright.
Polymorphism for imperative languages without imperative types. Technical Report 93-200, Rice University, February 1993. [ bib ] |
| [1942] |
Andrew K. Wright.
Simple imperative polymorphism. Lisp and Symbolic Computation, 8(4):343--356, December 1995. [ bib | .ps.gz ] |
| [1943] |
Andrew K. Wright and Robert Cartwright.
A practical soft type system for Scheme. ACM Transactions on Programming Languages and Systems, 19(1):87--152, January 1997. [ bib | http ] |
| [1944] |
Andrew K. Wright and Matthias Felleisen.
A syntactic approach to type soundness. Information and Computation, 115(1):38--94, November 1994. [ bib | http ] |
| [1945] |
Hongwei Xi.
Dependent types in practical programming. PhD thesis, Carnegie Mellon University, December 1998. [ bib | .pdf ] |
| [1946] |
Hongwei Xi.
Dead code elimination through dependent types. In Practical Aspects of Declarative Languages (PADL), volume 1551 of Lecture Notes in Computer Science, pages 228--242. Springer, January 1999. [ bib | .pdf ] |
| [1947] |
Hongwei Xi.
Dependently Typed Pattern Matching. Journal of Universal Computer Science, 9(8):851--872, 2003. [ bib | .pdf ] |
| [1948] |
Hongwei Xi.
Applied type system. In TYPES 2003, volume 3085 of Lecture Notes in Computer Science, pages 394--408. Springer, February 2004. [ bib | http ] |
| [1949] |
Hongwei Xi.
Dependent ML: an approach to practical programming with dependent types. Journal of Functional Programming, 17(2):215--286, 2007. [ bib | http ] |
| [1950] |
Hongwei Xi, Chiyan Chen, and Gang Chen.
Guarded recursive datatype constructors. In Principles of Programming Languages (POPL), pages 224--235, January 2003. [ bib | .pdf ] |
| [1951] |
Hongwei Xi and Frank Pfenning.
Dependent types in practical programming. In Principles of Programming Languages (POPL), pages 214--227, January 1999. [ bib | http ] |
| [1952] |
Hongwei Xi and Carsten Schürmann.
CPS transform for Dependent ML. In Workshop on Logic, Language, Information and Computation (WoLLIC), August 2001. [ bib ] |
| [1953] |
Li-yao Xia, Yannick Zakowski, Paul He, Chung-Kil Hur, Gregory Malecha,
Benjamin C. Pierce, and Steve Zdancewic.
Interaction trees: representing recursive and impure programs in Coq. Proceedings of the ACM on Programming Languages, 4(POPL):51:1--51:32, 2020. [ bib | .pdf ] |
| [1954] |
Yichen Xie and Alex Aiken.
Scalable error detection using Boolean satisfiability. In Principles of Programming Languages (POPL), pages 351--363, January 2005. [ bib | .pdf ] |
| [1955] |
Dana N. Xu.
Extended static checking for Haskell. In Haskell workshop, pages 48--59. ACM Press, 2006. [ bib | .ps ] |
| [1956] |
Dana N. Xu, Simon Peyton Jones, and Koen Claessen.
Static contract checking for Haskell. In Principles of Programming Languages (POPL), pages 41--52, January 2009. [ bib | .ps ] |
| [1957] |
Yichen Xu, Aleksander Boruch-Gruszecki, and Martin Odersky.
Degrees of separation: A flexible type system for safe concurrency. Proceedings of the ACM on Programming Languages, 8(OOPSLA1):1181--1207, 2024. [ bib | http ] |
| [1958] |
Jeremy Yallop.
Staged generic programming. Proceedings of the ACM on Programming Languages, 1(ICFP):29:1--29:29, 2017. [ bib | .pdf ] |
| [1959] |
Hongseok Yang.
Relational separation logic. Theoretical Computer Science, 375(1-3):308--334, 2007. [ bib | http ] |
| [1960] |
Hongseok Yang, Oukseh Lee, Josh Berdine, Cristiano Calcagno, Byron Cook, Dino
Distefano, and Peter W. O'Hearn.
Scalable shape analysis for systems code. In Computer Aided Verification (CAV), volume 5123 of Lecture Notes in Computer Science, pages 385--398. Springer, July 2008. [ bib | .pdf ] |
| [1961] |
Kwangkeun Yi.
Educational pearl: 'proof-directed debugging' revisited for a first-order version. Journal of Functional Programming, 16(6):663--670, 2006. [ bib | .pdf ] |
| [1962] |
Irene Yoon, Yannick Zakowski, and Steve Zdancewic.
Formal reasoning about layered monadic interpreters. Proceedings of the ACM on Programming Languages, 6(ICFP):254--282, 2022. [ bib | http ] |
| [1963] |
Nobuko Yoshida.
Graph types for monadic mobile processes. In Foundations of Software Technology and Theoretical Computer Science (FSTTCS), volume 1180 of Lecture Notes in Computer Science, pages 371--386. Springer, 1996. [ bib | .ps.gz ] |
| [1964] |
Nobuko Yoshida.
Graph types for monadic mobile processes. Technical Report ECS-LFCS-96-350, University of Edinburgh, 1996. [ bib | http ] |
| [1965] |
Nobuko Yoshida, Kohei Honda, and Martin Berger.
Linearity and bisimulation. Technical Report MSC-2001/48, University of Leicester, December 2001. [ bib | .ps.gz ] |
| [1966] |
Nobuko Yoshida, Kohei Honda, and Martin Berger.
Linearity and bisimulation. In Foundations of Software Science and Computation Structures (FOSSACS), Lecture Notes in Computer Science. Springer, April 2002. [ bib | .ps.gz ] |
| [1967] |
Nobuko Yoshida, Kohei Honda, and Martin Berger.
Logical reasoning for higher-order functions with local state. In Foundations of Software Science and Computation Structures (FOSSACS), volume 4423 of Lecture Notes in Computer Science, pages 361--377. Springer, April 2007. [ bib | .pdf ] |
| [1968] |
Yannick Zakowski, Calvin Beck, Irene Yoon, Ilia Zaichuk, Vadim Zaliva, and
Steve Zdancewic.
Modular, compositional, and executable formal semantics for LLVM IR. Proceedings of the ACM on Programming Languages, 5(ICFP):1--30, 2021. [ bib | http ] |
| [1969] |
Yannick Zakowski, Paul He, Chung-Kil Hur, and Steve Zdancewic.
An equational theory for weak bisimulation via generalized parameterized coinduction. In Certified Programs and Proofs (CPP), pages 71--84, January 2020. [ bib | http ] |
| [1970] |
Vadim Zaytsev and Anya Helene Bagge.
Parsing in a broad sense. In Model-Driven Engineering Languages and Systems (MODELS), volume 8767 of Lecture Notes in Computer Science, pages 50--67. Springer, September 2014. [ bib | .pdf ] |
| [1971] |
Steve Zdancewic and Andrew C. Myers.
Secure information flow and CPS. In European Symposium on Programming (ESOP), Lecture Notes in Computer Science. Springer, April 2001. [ bib | .ps ] |
| [1972] |
Steve Zdancewic and Andrew C. Myers.
Secure information flow via linear continuations. Higher Order and Symbolic Computation, 15(2--3):209--234, September 2002. [ bib | .pdf ] |
| [1973] |
Olivier Zendra, Dominique Colnet, and Suzanne Collin.
Efficient dynamic dispatch without virtual function tables. the SmallEiffel compiler. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 125--141, October 1997. [ bib | .ps.gz ] |
| [1974] |
Christoph Zenger.
Indexed types. Theoretical Computer Science, 187(1--2):147--165, 1997. [ bib | http ] |
| [1975] |
Christoph Zenger.
Indizierte typen. PhD thesis, Universität Karlsruhe, July 1998. [ bib | .ps.gz ] |
| [1976] |
Bohua Zhan and Maximilian P. L. Haslbeck.
Verifying asymptotic time complexity of imperative programs in Isabelle. In International Joint Conference on Automated Reasoning, July 2018. [ bib | http ] |
| [1977] |
Hongbo Zhang and Steve Zdancewic.
Fan: compile-time metaprogramming for OCaml. Unpublished, March 2013. [ bib | .pdf ] |
| [1978] |
Yihong Zhang, Yisu Remy Wang, Max Willsey, and Zachary Tatlock.
Relational E-matching. Proceedings of the ACM on Programming Languages, 6(POPL):1--22, 2022. [ bib | http ] |
| [1979] |
Yizhou Zhang and Andrew C. Myers.
Abstraction-safe effect handlers via tunneling. Proceedings of the ACM on Programming Languages, 3(POPL):5:1--5:29, 2019. [ bib | .pdf ] |
| [1980] |
Yizhou Zhang, Guido Salvaneschi, Quinn Beightol, Barbara Liskov, and Andrew C.
Myers.
Accepting blame for safe tunneled exceptions. In Programming Language Design and Implementation (PLDI), pages 281--295, June 2016. [ bib | .pdf ] |
| [1981] |
Zipeng Zhang, Xinyu Feng, Ming Fu, Zhong Shao, and Yong Li.
A structural approach to prophecy variables. In Theory and Applications of Models of Computation (TAMC), volume 7287 of Lecture Notes in Computer Science, pages 61--71. Springer, May 2012. [ bib | .pdf ] |
| [1982] |
Jinxu Zhao, Bruno C. d. S. Oliveira, and Tom Schrijvers.
A mechanical formalization of higher-ranked polymorphic type inference. Proceedings of the ACM on Programming Languages, 3(ICFP):112:1--112:29, 2019. [ bib | http ] |
| [1983] |
Yang Zhao.
Concurrency analysis based on fractional permission system. PhD thesis, University of Wisconsin, August 2007. [ bib | .pdf ] |
| [1984] |
Lantian Zheng and Andrew C. Myers.
Dynamic security labels and noninterference. Technical Report 2004-1924, Cornell University, January 2004. [ bib | .pdf ] |
| [1985] |
Dengping Zhu and Hongwei Xi.
A typeful and tagless representation for XML documents. In Asian Symposium on Programming Languages and Systems (APLAS), volume 2895 of Lecture Notes in Computer Science, pages 89--104. Springer, November 2003. [ bib | http ] |
| [1986] |
Dengping Zhu and Hongwei Xi.
Safe programming with pointers through stateful views. In Practical Aspects of Declarative Languages (PADL), volume 3350 of Lecture Notes in Computer Science, pages 83--97. Springer, January 2005. [ bib | .pdf ] |
| [1987] |
Zirun Zhu, Hsiang-Shang Ko, Yongzhe Zhang, Pedro Martins, João Saraiva,
and Zhenjiang Hu.
Unifying parsing and reflective printing for fully disambiguated grammars. New Generation Computing, 38(3):423--476, 2020. [ bib | http ] |
| [1988] |
Zirun Zhu, Yongzhe Zhang, Hsiang-Shang Ko, Pedro Martins, João Saraiva,
and Zhenjiang Hu.
Parsing and reflective printing, bidirectionally. In Software Language Engineering, pages 2--14, November 2016. [ bib | .pdf ] |
| [1989] |
Yoav Zibin and Yossi Gil.
Theory and practice of incremental subtyping tests and message dispatching, December 2001. [ bib | .ps.gz ] |
| [1990] |
Yoav Zibin and Yossi Gil.
Fast algorithm for creating space efficient dispatching tables with application to multi-dispatching. In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA), pages 142--160, November 2002. [ bib | .pdf ] |
| [1991] |
Yoav Zibin and Yossi Gil.
Incremental algorithms for dispatching in dynamically typed languages. In Principles of Programming Languages (POPL), January 2003. [ bib | .pdf ] |
| [1992] |
Jan Zwanenburg.
A type system for record concatenation and subtyping. Technical report, Eindhoven University of Technology, July 1997. [ bib | .ps ] |
| [1993] |
Nikita Zyuzin and Aleksander Nanevski.
Contextual modal types for algebraic effects and handlers. In International Conference on Functional Programming (ICFP), pages 1--29, August 2021. [ bib | .pdf ] |
| [1994] |
Pierre Évariste Dagand.
The essence of ornaments. Journal of Functional Programming, 27, 2017. [ bib | http ] |
This file was generated by bibtex2html 1.99.