References
Artima - Java Design Issues. URL: https://www.artima.com/articles/java-design-issues (visited on 2022-12-13).
missing author in CrossTalkCostEstimation2005
Programming language ideas that work and don't work. June 2022. URL: https://www.youtube.com/watch?v=y7KWGv_t-MU (visited on 2023-07-19).
Moez AbdelGawad and Robert Cartwright. NOOP: a domain-theoretic model of nominally-typed OOP. January 2018. Comment: 23 pages. URL: http://arxiv.org/abs/1801.06793 (visited on 2022-12-27), arXiv:1801.06793.
Andreas Abel and Jan Reineke. uiCA: accurate throughput prediction of basic blocks on recent Intel microarchitectures. arXiv:2107.14210 [cs], July 2021. URL: http://arxiv.org/abs/2107.14210 (visited on 2021-07-30), arXiv:2107.14210.
Michael D. Adams. Principled parsing for indentation-sensitive languages: revisiting Landin's offside rule. ACM SIGPLAN Notices, 48(1):511–522, January 2013. URL: https://doi.org/10.1145/2480359.2429129 (visited on 2022-05-18), doi:10.1145/2480359.2429129.
Elvira Albert, Miquel Bofill, Cristina Borralleras, Enrique Martin-Martin, and Albert Rubio. Resource analysis driven by (conditional) termination proofs. Theory and Practice of Logic Programming, 19(5-6):722–739, September 2019. Comment: Paper presented at the 35th International Conference on Logic Programming (ICLP 2019), Las Cruces, New Mexico, USA, 20-25 September 2019, 16 pages. URL: http://arxiv.org/abs/1907.10096 (visited on 2020-06-22), arXiv:1907.10096, doi:10.1017/S1471068419000152.
A.J. Albrecht and J.E. Gaffney. Software function, source lines of code, and development effort prediction: a software science validation. IEEE Transactions on Software Engineering, SE-9(6):639–648, November 1983. URL: http://ieeexplore.ieee.org/document/1703110/ (visited on 2023-12-28), doi:10.1109/TSE.1983.235271.
Frances E Allen and John Cocke. A catalogue of optimizing transformations. IBM Research Center, pages 30, 1971. URL: https://www.clear.rice.edu/comp512/Lectures/Papers/1971-allen-catalog.pdf.
Luís Eduardo de Souza Amorim, Michael J. Steindorfer, Sebastian Erdweg, and Eelco Visser. Declarative specification of indentation rules: a tooling perspective on parsing and pretty-printing layout-sensitive languages. In Proceedings of the 11th ACM SIGPLAN International Conference on Software Language Engineering - SLE 2018, 3–15. Boston, MA, USA, 2018. ACM Press. URL: http://udesou.info/wp-content/uploads/2018/10/layout-pp.pdf (visited on 2020-06-15), doi:10.1145/3276604.3276607.
Sundaram Ananthanarayanan, Masoud Saeida Ardekani, Denis Haenikel, Balaji Varadarajan, Simon Soriano, Dhaval Patel, and Ali-Reza Adl-Tabatabai. Keeping master green at scale. In Proceedings of the Fourteenth EuroSys Conference 2019, EuroSys '19, 1–15. Dresden, Germany, March 2019. Association for Computing Machinery. URL: https://doi.org/10.1145/3302424.3303970 (visited on 2020-07-06), doi:10.1145/3302424.3303970.
Andrew W. Appel. Garbage collection can be faster than stack allocation. Information Processing Letters, 25(4):275–279, June 1987. URL: https://www.cs.princeton.edu/~appel/papers/45.pdf (visited on 2020-07-24), doi:10.1016/0020-0190(87)90175-X.
Andrew W. Appel. SSA is functional programming. ACM SIGPLAN Notices, 33(4):17–20, April 1998. URL: https://dl.acm.org/doi/10.1145/278283.278285 (visited on 2023-05-03), doi:10.1145/278283.278285.
Krzysztof R. Apt and Alessandro Pellegrini. Why the occur-check is not a problem. In Maurice Bruynooghe and Martin Wirsing, editors, Programming Language Implementation and Logic Programming, volume 631, pages 69–86. Springer-Verlag, Berlin/Heidelberg, 1992. URL: http://link.springer.com/10.1007/3-540-55844-6_128 (visited on 2022-07-14), doi:10.1007/3-540-55844-6_128.
Aries Arditi, Kenneth Knoblauch, and Ilana Grunwald. Reading with fixed and variable character pitch. Journal of the Optical Society of America A, 7(10):2011, October 1990. URL: https://opg.optica.org/abstract.cfm?URI=josaa-7-10-2011 (visited on 2022-05-25), doi:10.1364/JOSAA.7.002011.
Andrea Asperti, Cecilia Giovannetti, and Andrea Naletto. The bologna optimal higher-order machine. Journal of Functional Programming, 6(6):763–810, November 1996. URL: https://www.cambridge.org/core/product/identifier/S0956796800001994/type/journal_article (visited on 2020-06-15), doi:10.1017/S0956796800001994.
Andrea Asperti and Stefano Guerrini. The Optimal Implementation of Functional Programming Languages. Number 45 in Cambridge Tracts in Theoretical Computer Science. Cambridge University Press, USA, 1st edition, January 1999. ISBN 978-0-521-62112-0.
Andrea Asperti and Harry G. Mairson. Parallel beta reduction is not elementary recursive. Information and Computation, 170(1):49–80, October 2001. URL: https://linkinghub.elsevier.com/retrieve/pii/S089054010192869X (visited on 2020-06-15), doi:10.1006/inco.2001.2869.
Jongmoon Baik and Ellis Horowitz. COCOMO II model manual 2000.0. Technical Report, University of Southern California, 2000. URL: http://web.archive.org/web/20181123110403/http://csse.usc.edu/csse/research/COCOMOII/cocomo2000.0/CII_modelman2000.0.pdf (visited on 2023-12-26).
missing journal in balabonskiUnifiedApproachFully2011
Titus Barik. Error Messages as Rational Reconstructions. PhD thesis, North Carolina State University, 2018.
Titus Barik, Denae Ford, Emerson Murphy-Hill, and Chris Parnin. How should compilers explain problems to developers? In Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering, 633–643. Lake Buena Vista FL USA, October 2018. ACM. URL: https://dl.acm.org/doi/10.1145/3236024.3236040 (visited on 2022-10-15), doi:10.1145/3236024.3236040.
Jennifer Bauer, Janet Siegmund, Norman Peitek, Johannes C. Hofmeister, and Sven Apel. Indentation: simply a matter of style or support for program comprehension? In 2019 IEEE/ACM 27th International Conference on Program Comprehension (ICPC), 154–164. Montreal, QC, Canada, May 2019. IEEE. URL: https://ieeexplore.ieee.org/document/8813302/ (visited on 2022-05-19), doi:10.1109/ICPC.2019.00033.
Brett A. Becker. What does saying that 'programming is hard' really say, and about whom? Communications of the ACM, 64(8):27–29, August 2021. URL: https://cacm.acm.org/magazines/2021/8/254304-what-does-saying-that-programming-is-hard-really-say-and-about-whom/fulltext (visited on 2021-08-28), doi:10.1145/3469115.
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, 177–210. Aberdeen Scotland Uk, December 2019. ACM. URL: https://dl.acm.org/doi/10.1145/3344429.3372508 (visited on 2021-03-30), doi:10.1145/3344429.3372508.
Sofie Beier. Typeface Legibility: Towards Defining Familiarity. Thesis, Royal College of Art, May 2009. URL: https://researchonline.rca.ac.uk/957/ (visited on 2023-02-11).
Sofie Beier and Kevin Larson. How does typeface familiarity affect reading performance and reader preference? Information Design Journal, 20(1):16–31, October 2013. URL: http://www.jbe-platform.com/content/journals/10.1075/idj.20.1.02bei (visited on 2023-01-13), doi:10.1075/idj.20.1.02bei.
Emery D. Berger, Celeste Hollenbeck, Petr Maj, Olga Vitek, and Jan Vitek. On the Impact of Programming Languages on Code Quality: A Reproduction Study. ACM Transactions on Programming Languages and Systems, 41(4):1–24, December 2019. URL: https://dl.acm.org/doi/10.1145/3340571 (visited on 2023-12-27), doi:10.1145/3340571.
R.D. Bergeron, J.D. Gannon, D.P. Shecter, F.W. Tompa, and A. Van Dam. Systems Programming Languages. In Advances in Computers, volume 12, pages 175–284. Elsevier, 1972. URL: https://linkinghub.elsevier.com/retrieve/pii/S0065245808605100 (visited on 2023-12-23), doi:10.1016/S0065-2458(08)60510-0.
Pramod Bhatotia, Pedro Fonseca, Umut A. Acar, Björn B. Brandenburg, and Rodrigo Rodrigues. iThreads: a threading library for parallel incremental computation. In Proceedings of the Twentieth International Conference on Architectural Support for Programming Languages and Operating Systems - ASPLOS '15, 645–659. Istanbul, Turkey, 2015. ACM Press. URL: https://www.cs.purdue.edu/homes/pfonseca/papers/asplos2015-ithreads.pdf (visited on 2020-10-25), doi:10.1145/2694344.2694371.
Sylvie Billot and Bernard Lang. The structure of shared forests in ambiguous parsing. In Proceedings of the 27th Annual Meeting on Association for Computational Linguistics, ACL '89, 143–151. USA, June 1989. Association for Computational Linguistics. URL: https://dl.acm.org/doi/10.3115/981623.981641 (visited on 2023-05-22), doi:10.3115/981623.981641.
Richard Bird, Geraint Jones, and Oege De Moor. More haste, less speed: lazy versus eager evaluation. Journal of Functional Programming, 7(5):541–547, September 1997. URL: https://www.cambridge.org/core/journals/journal-of-functional-programming/article/more-haste-less-speed-lazy-versus-eager-evaluation/162B391CBCD864794C766CA2A2EC7CBE (visited on 2022-01-06), doi:10.1017/S0956796897002827.
Eben Blaisdell, Max Kanovich, Stepan L. Kuznetsov, Elaine Pimentel, and Andre Scedrov. Non-associative, non-commutative multi-modal linear logic. In Jasmin Blanchette, Laura Kovács, and Dirk Pattinson, editors, Automated Reasoning, Lecture Notes in Computer Science, 449–467. Cham, 2022. Springer International Publishing. doi:10.1007/978-3-031-10769-6_27.
Barry W. Boehm. Software Engineering Economics. Englewood Cliffs, N.J. : Prentice-Hall, 1981. ISBN 978-0-13-822122-5. URL: http://archive.org/details/softwareengineer0000boeh (visited on 2023-12-29).
Maximilian Bolingbroke and Simon Peyton Jones. Supercompilation by evaluation. In Proceedings of the Third ACM Haskell Symposium on Haskell, Haskell '10, 135–146. New York, NY, USA, September 2010. Association for Computing Machinery. URL: https://www.microsoft.com/en-us/research/publication/supercompilation-by-evaluation/ (visited on 2021-03-24), doi:10.1145/1863523.1863540.
Maximilian C. Bolingbroke and Simon L. Peyton Jones. Types are calling conventions. In Proceedings of the 2nd ACM SIGPLAN Symposium on Haskell - Haskell '09, 1. Edinburgh, Scotland, May 2009. ACM Press. URL: https://www.microsoft.com/en-us/research/publication/types-are-calling-conventions/ (visited on 2020-06-15), doi:10.1145/1596638.1596640.
A. H. Borning. Classes versus prototypes in object-oriented languages. In Proceedings of 1986 ACM Fall Joint Computer Conference, ACM '86, 36–40. Washington, DC, USA, November 1986. IEEE Computer Society Press.
missing journal in boucherTrojanSourceInvisible
missing journal in brachthauserParsingFirstclassDerivatives
Franz Brauße, Konstantin Korovin, Margarita Korovina, and Norbert Th Müller. A CDCL-style calculus for solving non-linear constraints. arXiv:1905.09227 [cs], July 2019. Comment: 17 pages, 3 figures; accepted at FroCoS 2019; software available at $<$http://informatik.uni-trier.de/~brausse/ksmt/$>$. URL: http://arxiv.org/abs/1905.09227 (visited on 2020-07-25), arXiv:1905.09227.
missing publisher in brooksMythicalManmonth1995
A. Bucciarelli, A. Carraro, G. Favro, and A. Salibra. Graph easy sets of mute lambda terms. Theoretical Computer Science, 629:51–63, May 2016. URL: https://www.sciencedirect.com/science/article/pii/S0304397515011858 (visited on 2022-07-01), doi:10.1016/j.tcs.2015.12.024.
Raymond P.L. Buse and Westley R. Weimer. A metric for software readability. In Proceedings of the 2008 International Symposium on Software Testing and Analysis - ISSTA '08, 121. Seattle, WA, USA, 2008. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=1390630.1390647 (visited on 2022-05-19), doi:10.1145/1390630.1390647.
William E. Byrd. Relational Programming in Minikanren: Techniques, Applications, and Implementations. PhD thesis, Indiana University, August 2009. URL: https://scholarworks.iu.edu/dspace/handle/2022/8777 (visited on 2022-07-14).
Zixian Cai, Stephen M Blackburn, Michael D Bond, and Martin Maas. Distilling the real cost of production garbage collectors. IEEE International Symposium on Performance Analysis of Systems and Software, pages 12, 2022. URL: https://users.cecs.anu.edu.au/~steveb/pubs/papers/lbo-ispass-2022.pdf.
Chao-Hong Chen and Amr Sabry. A computational interpretation of compact closed categories: reversible programming with negative and fractional types. Proceedings of the ACM on Programming Languages, 5(POPL):1–29, January 2021. URL: https://dl.acm.org/doi/10.1145/3434290 (visited on 2021-08-04), doi:10.1145/3434290.
missing journal in clarkDoDSoftwareFactbook2015
missing journal in clarkDepartmentDefenseSoftware2017
Keith L. Clark. Negation as Failure. In Hervé Gallaire and Jack Minker, editors, Logic and Data Bases, pages 293–322. Springer US, Boston, MA, 1978. URL: http://www.doc.ic.ac.uk/~klc/NegAsFailure.pdf (visited on 2022-07-15), doi:10.1007/978-1-4684-3384-5_11.
Cliff Click, Gil Tene, and Michael Wolf. The pauseless GC algorithm. In Proceedings of the 1st ACM/USENIX International Conference on Virtual Execution Environments - VEE '05, 46. Chicago, IL, USA, 2005. ACM Press. URL: https://static.usenix.org/events/vee05/full_papers/p46-click.pdf (visited on 2021-04-25), doi:10.1145/1064979.1064988.
Pip Coburn. The Change Function: Why Some Technologies Take off and Others Crash and Burn. Penguin, 2006. ISBN 978-1-59184-132-6.
Marcelo Coniglio and Francisco Miraglia. Equality in linear logic. Logique et Analyse, 39(153/154):113–151, January 2002. URL: https://www.researchgate.net/profile/Marcelo-Coniglio/publication/2387274_Equality_In_Linear_Logic/links/0deec5165a6babbd8a000000/Equality-In-Linear-Logic.pdf.
William R Cook. A Denotational Semantics of Inheritance. PhD thesis, Brown University, May 1989. URL: https://www.cs.utexas.edu/~wcook/papers/thesis/cook89.pdf.
missing journal in cookUnderstandingDataAbstraction2009
William R. Cook, Walter Hill, and Peter S. Canning. Inheritance is not subtyping. In Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '90, 125–135. New York, NY, USA, December 1989. Association for Computing Machinery. URL: https://doi.org/10.1145/96709.96721 (visited on 2022-12-15), doi:10.1145/96709.96721.
Paolo Coppola. On the Complexity of Optimal Reduction of Functional Programming Languages. PhD thesis, Università degli Studi di Udine, February 2002.
Nathan Corbyn. Practical Static Memory Management. Bachelor's Thesis, King’s College, May 2020. URL: http://nathancorbyn.com/nc513.pdf.
Russ Cox. Version SAT. December 2016. URL: https://research.swtch.com/version-sat (visited on 2021-01-26).
Tristan Crolard. A formulae-as-types interpretation of subtractive logic. Journal of Logic and Computation, 14(4):529–570, August 2004. URL: https://academic.oup.com/logcom/article/14/4/529/933555 (visited on 2020-06-18), doi:10.1093/logcom/14.4.529.
Ole-Johan Dahl, Bjørn Myhrhaug, and Kristen Nygaard. Common Base Language. October 1970. URL: https://www.ics.uci.edu/~jajones/INF102-S18/readings/10_Simula.pdf (visited on 2022-12-20).
Vincent Danos, Jean-Baptiste Joinet, and Harold Schellinx. The structure of exponentials: uncovering the dynamics of linear logic proofs. In G. Gottlob, A. Leitsch, and D. Mundici, editors, Proceedings of the Third Kurt Gödel Colloquium on Computational Logic and Proof Theory, 159–171. Brno, Czech Republic, August 1993. Springer-Verlag LNCS 348. URL: https://eprints.illc.uva.nl/1334/.
Jack W. Davidson and Christopher W. Fraser. The design and application of a retargetable peephole optimizer. ACM Transactions on Programming Languages and Systems, 2(2):191–202, April 1980. URL: https://dl.acm.org/doi/10.1145/357094.357098 (visited on 2021-07-30), doi:10.1145/357094.357098.
Benjamin Delaware, Sorawit Suriyakarn, Clément Pit-Claudel, Qianchuan Ye, and Adam Chlipala. Narcissus: correct-by-construction derivation of decoders and encoders from binary formats. Proceedings of the ACM on Programming Languages, 3(ICFP):1–29, July 2019. URL: https://www.cs.purdue.edu/homes/bendy/Narcissus/narcissus.pdf (visited on 2020-07-26), doi:10.1145/3341686.
Daniel Delorey, Charles Knutson, and Scott Chun. Do programming languages affect productivity? A case study using data from open source projects. In First International Workshop on Emerging Trends in FLOSS Research and Development, FLOSS'07, 8–8. June 2007. doi:10.1109/FLOSS.2007.5.
Nachum Dershowitz, Stéphane Kaplan, and David A. Plaisted. Rewrite, rewrite, rewrite, rewrite, rewrite, …. Theoretical Computer Science, 83(1):71–96, June 1991. URL: https://www.sciencedirect.com/science/article/pii/0304397591900409 (visited on 2022-07-02), doi:10.1016/0304-3975(91)90040-9.
Roberto Di Cosmo. Introduction to Linear Logic. MPRI course notes, 2015. URL: https://www.dicosmo.org/CourseNotes/LinLog/IntroductionLinearLogic.pdf (visited on 2020-05-13).
Stephen Dolan. Algebraic Subtyping. PhD thesis, University of Cambridge, September 2016. URL: https://www.cs.tufts.edu/~nr/cs257/archive/stephen-dolan/thesis.pdf.
Stephen Dolan and Alan Mycroft. Polymorphism, subtyping, and type inference in MLsub. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages, POPL 2017, 60–72. Paris, France, January 2017. Association for Computing Machinery. URL: https://doi.org/10.1145/3009837.3009882 (visited on 2020-06-15), doi:10.1145/3009837.3009882.
Paul Downen, Luke Maurer, Zena M. Ariola, and Simon Peyton Jones. Sequent calculus as a compiler intermediate language. In Proceedings of the 21st ACM SIGPLAN International Conference on Functional Programming, ICFP 2016, 74–88. Nara, Japan, September 2016. Association for Computing Machinery. URL: https://www.microsoft.com/en-us/research/publication/sequent-calculus-as-a-compiler-intermediate-language/ (visited on 2020-06-14), doi:10.1145/2951913.2951931.
Paul Downen, Zachary Sullivan, Zena M. Ariola, and Simon Peyton Jones. Making a faster curry with extensional types. In Proceedings of the 12th ACM SIGPLAN International Symposium on Haskell, Haskell 2019, 58–70. Berlin, Germany, August 2019. Association for Computing Machinery. URL: https://www.microsoft.com/en-us/research/publication/making-a-faster-curry-with-extensional-types/ (visited on 2020-06-14), doi:10.1145/3331545.3342594.
R. Kent Dyvbig, Simon Peyton Jones, and Amr Sabry. A monadic framework for delimited continuations. Journal of Functional Programming, 17(6):687–730, November 2007. URL: https://doi.org/10.1017/S0956796807006259 (visited on 2020-06-19), doi:10.1017/S0956796807006259.
Vijay D’Silva and Caterina Urban. Conflict-driven conditional termination. In Daniel Kroening and Corina S. Păsăreanu, editors, Computer Aided Verification, Lecture Notes in Computer Science, 271–286. Cham, 2015. Springer International Publishing. URL: https://link.springer.com/content/pdf/10.1007%2F978-3-319-21668-3_16.pdf, doi:10.1007/978-3-319-21668-3_16.
Giorgios Economopoulos, Paul Klint, and Jurgen Vinju. Faster scannerless GLR parsing. In Oege de Moor and Michael I. Schwartzbach, editors, Compiler Construction, volume 5501, pages 126–141. Springer Berlin Heidelberg, Berlin, Heidelberg, 2009. URL: http://link.springer.com/10.1007/978-3-642-00722-4_10 (visited on 2020-06-15), doi:10.1007/978-3-642-00722-4_10.
J. Egger, R. E. Mogelberg, and A. Simpson. The enriched effect calculus: syntax and semantics. Journal of Logic and Computation, 24(3):615–654, June 2014. URL: https://academic.oup.com/logcom/article-lookup/doi/10.1093/logcom/exs025 (visited on 2021-11-09), doi:10.1093/logcom/exs025.
K. El Emam, S. Benlarbi, N. Goel, and S.N. Rai. The confounding effect of class size on the validity of object-oriented metrics. IEEE Transactions on Software Engineering, 27(7):630–650, July 2001. URL: http://ieeexplore.ieee.org/document/935855/ (visited on 2023-02-24), doi:10.1109/32.935855.
Roman Elizarov, Mikhail Belyaev, Marat Akhin, and Ilmir Usmanov. Kotlin coroutines: design and implementation. In Proceedings of the 2021 ACM SIGPLAN International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software, Onward! 2021, 68–84. New York, NY, USA, October 2021. Association for Computing Machinery. URL: https://doi.org/10.1145/3486607.3486751 (visited on 2022-11-29), doi:10.1145/3486607.3486751.
Jörg Endrullis, Clemens Grabmayer, Dimitri Hendriks, Jan Willem Klop, and Vincent Oostrom. Infinitary term rewriting for weakly orthogonal systems: properties and counterexamples. Logical Methods in Computer Science, 10(2):7, June 2014. URL: https://lmcs.episciences.org/752 (visited on 2022-07-10), doi:10.2168/LMCS-10(2:7)2014.
missing journal in endrullisCoinductiveFoundationsInfinitary2018
Jörg Endrullis, Dimitri Hendriks, and Jan Willem Klop. Highlights in infinitary rewriting and lambda calculus. Theoretical Computer Science, 464:48–71, December 2012. URL: https://www.sciencedirect.com/science/article/pii/S030439751200792X (visited on 2022-07-02), doi:10.1016/j.tcs.2012.08.018.
Sebastian Erdweg, Tillmann Rendel, Christian Kästner, and Klaus Ostermann. Layout-sensitive generalized parsing. In David Hutchison, Takeo Kanade, Josef Kittler, Jon M. Kleinberg, Friedemann Mattern, John C. Mitchell, Moni Naor, Oscar Nierstrasz, C. Pandu Rangan, Bernhard Steffen, Madhu Sudan, Demetri Terzopoulos, Doug Tygar, Moshe Y. Vardi, Gerhard Weikum, Krzysztof Czarnecki, and Görel Hedin, editors, Software Language Engineering, volume 7745, pages 244–263. Springer Berlin Heidelberg, Berlin, Heidelberg, 2013. URL: http://link.springer.com/10.1007/978-3-642-36089-3_14 (visited on 2020-06-15), doi:10.1007/978-3-642-36089-3_14.
Levent Erkok. Value Recursion in Monadic Computations. PhD thesis, Oregon Health and Science University, October 2002. URL: http://leventerkok.github.io/papers/erkok-thesis.pdf.
Andrzej Filinski. Declarative continuations and categorical duality. Master's thesis, University of Copenhagen, August 1989. URL: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.43.8729&rep=rep1&type=pdf.
Andrzej Filinski. Linear continuations. In Proceedings of the 19th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '92, 27–38. Albuquerque, New Mexico, USA, February 1992. Association for Computing Machinery. URL: https://doi.org/10.1145/143165.143174 (visited on 2020-06-19), doi:10.1145/143165.143174.
missing institution in fisherCommonProgrammingLanguage1976
Cormac Flanagan, Amr Sabry, Bruce F. Duba, and Matthias Felleisen. The essence of compiling with continuations. ACM SIGPLAN Notices, 28(6):237–247, June 1993. URL: https://dl.acm.org/doi/10.1145/173262.155113 (visited on 2023-05-03), doi:10.1145/173262.155113.
Thomas Forster. Quine’s New Foundations. In Edward N. Zalta, editor, The Stanford Encyclopedia of Philosophy. Metaphysics Research Lab, Stanford University, summer 2019 edition, 2019. URL: https://plato.stanford.edu/archives/sum2019/entries/quine-nf/ (visited on 2021-03-04).
Yannick Forster, Ohad Kammar, Sam Lindley, and Matija Pretnar. On the expressive power of user-defined effects: Effect handlers, monadic reflection, delimited control. arXiv:1610.09161 [cs], February 2017. URL: http://arxiv.org/abs/1610.09161 (visited on 2021-11-29), arXiv:1610.09161.
Carlo A. Furia, Richard Torkar, and Robert Feldt. Applying Bayesian analysis guidelines to empirical software engineering data: the case of programming languages and code quality. July 2021. URL: http://arxiv.org/abs/2101.12591 (visited on 2023-12-27), arXiv:2101.12591.
Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides, and Grady Booch. Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley Professional, Reading, Mass, 1st edition edition, October 1994. ISBN 978-0-201-63361-0.
Silvia Ghilezan. Strong normalization and typability with intersection types. Notre Dame Journal of Formal Logic, 37(1):44–52, January 1996. URL: https://projecteuclid.org/journals/notre-dame-journal-of-formal-logic/volume-37/issue-1/Strong-Normalization-and-Typability-with-Intersection-Types/10.1305/ndjfl/1040067315.full (visited on 2022-06-23), doi:10.1305/ndjfl/1040067315.
Jean-Yves Girard. Towards a geometry of interaction. In J. W. Gray and A. Scedrov, editors, Categories in Computer Science and Logic, volume 92 of Contemporary Mathematics, 69–108. University of Colorado in Boulder, 1989. American Mathematical Society. Proceedings of the AMS-IMS-SIAM Joint Summer Research Conference, June 14–20, 1987, Boulder, Colorado; Contemporary Mathematics Volume 92. URL: https://jb55.com/linear/pdf/Towards%20a%20geometry%20of%20interaction.pdf.
Jean-Yves Girard. Locus Solum: From the rules of logic to the logic of rules. Mathematical Structures in Computer Science, 11(3):301–506, June 2001. URL: https://www.cambridge.org/core/journals/mathematical-structures-in-computer-science/article/abs/locus-solum-from-the-rules-of-logic-to-the-logic-of-rules/6318E18EA633F9692D9CDBA9DE4438C9 (visited on 2022-03-27), doi:10.1017/S096012950100336X.
Aviral Goel and Jan Vitek. On the design, implementation, and use of laziness in R. Proceedings of the ACM on Programming Languages, 3(OOPSLA):1–27, October 2019. Comment: 27 pages, 4 tables, 21 figures. URL: http://arxiv.org/abs/1909.08958 (visited on 2022-10-25), arXiv:1909.08958, doi:10.1145/3360579.
missing publisher in graverCostReportingElements1977
Norberto M. Grzywacz and Hassan Aleem. Does amount of information support aesthetic values? Frontiers in Neuroscience, 2022. URL: https://www.frontiersin.org/articles/10.3389/fnins.2022.805658 (visited on 2024-01-08).
Stefano Guerrini. Theoretical and Practical Issues of Optimal Implementations of Functional Languages. PhD thesis, Università di Pisa. Dipartimento di Informatica, 1996. URL: https://www-lipn.univ-paris13.fr/~guerrini/mysite/sites/default/files/biblio/PhDThesis.pdf.
Stefano Guerrini and Marco Solieri. Is the optimal implementation inefficient? Elementarily not. In 2nd International Conference on Formal Structures for Computation and Deduction, 16 pages. Schloss Dagstuhl - Leibniz-Zentrum fuer Informatik GmbH, Wadern/Saarbruecken, Germany, September 2017. \subsection Other Sharing graphs are a local and asynchronous implementation of lambda-calculus beta-reduction (or linear logic proof-net cut-elimination) that avoids useless duplications. Empirical benchmarks suggest that they are one of the most efficient machineries, when one wants to fully exploit the higher-order features of lambda-calculus. However, we still lack confirming grounds with theoretical solidity to dispel uncertainties about the adoption of sharing graphs. Aiming at analysing in detail the worst-case overhead cost of sharing operators, we restrict to the case of elementary and light linear logic, two subsystems with bounded computational complexity of multiplicative exponential linear logic. In these two cases, the bookkeeping component is unnecessary, and sharing graphs are simplified to the so-called "abstract algorithm". By a modular cost comparison over a syntactical simulation, we prove that the overhead of shared reductions is quadratically bounded to cost of the naive implementation, i.e. proof-net reduction. This result generalises and strengthens a previous complexity result, and implies that the price of sharing is negligible, if compared to the obtainable benefits on reductions requiring a large amount of duplication. URL: http://drops.dagstuhl.de/opus/volltexte/2017/7733/ (visited on 2021-09-06), doi:10.4230/LIPICS.FSCD.2017.17.
Samuel Z. Guyer, Kathryn S. McKinley, and Daniel Frampton. Free-Me: a static analysis for automatic individual object reclamation. In Proceedings of the 27th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '06, 364–375. New York, NY, USA, June 2006. Association for Computing Machinery. URL: https://doi.org/10.1145/1133981.1134024 (visited on 2023-07-18), doi:10.1145/1133981.1134024.
Yaǧmur Güçlütürk and Rob van Lier. Decomposing complexity preferences for music. Frontiers in Psychology, 2019. URL: https://www.frontiersin.org/articles/10.3389/fpsyg.2019.00674 (visited on 2024-01-08).
Jennifer Hackett and Graham Hutton. Call-by-need is clairvoyant call-by-value. Proceedings of the ACM on Programming Languages, 3(ICFP):1–23, July 2019. URL: https://www.cs.nott.ac.uk/~pszgmh/clairvoyant.pdf (visited on 2022-01-20), doi:10.1145/3341718.
Jason Hemann and Daniel P. Friedman. A framework for extending microkanren with constraints. Electronic Proceedings in Theoretical Computer Science, 234:135–149, January 2017. Comment: In Proceedings WLP'15/'16/WFLP'16, arXiv:1701.00148. URL: http://arxiv.org/abs/1701.00633 (visited on 2022-07-15), arXiv:1701.00633, doi:10.4204/EPTCS.234.10.
Jason Hemann and Daniel P. . Friedman. microKanren: a minimal functional core for relational programming. In Proceedings of the 2013 Workshop on Scheme and Functional Programming. 2013. URL: http://webyrd.net/scheme-2013/papers/HemannMuKanren2013.pdf (visited on 2022-07-14).
Fergus Henderson, Zoltan Somogyi, and Thomas Conway. Determinism analysis in the Mercury compiler. In In Proceedings of the Australian Computer Science Conference, 337–346. 1996. URL: https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.17.3967&rep=rep1&type=pdf.
Nao Hirokawa and Aart Middeldorp. Decreasing diagrams and relative termination. arXiv:0910.2853 [cs], October 2009. Comment: v3: missing references added. URL: http://arxiv.org/abs/0910.2853 (visited on 2021-09-14), arXiv:0910.2853.
Nao Hirokawa and Aart Middeldorp. Strategies for decreasingly confluent rewrite systems. Reduction Strategies in Rewriting and Programming, pages 23, 2011. URL: http://elp.webs.upv.es/workshops/wrs2011/pre-proceedings.pdf#page=31.
M. Randall Holmes. Elementary Set Theory with a Universal Set. Bruylant-Academia, 1998. ISBN 978-2-87209-488-2. URL: https://randall-holmes.github.io/head.pdf.
W. N. Holmes. Is APL a Programming Language? The Computer Journal, 21(2):128–131, May 1978. URL: https://doi.org/10.1093/comjnl/21.2.128 (visited on 2022-12-01), doi:10.1093/comjnl/21.2.128.
Paul Hudak and Adrienne Bloss. The aggregate update problem in functional programming systems. In Proceedings of the 12th ACM SIGACT-SIGPLAN Symposium on Principles of Programming Languages - POPL '85, 300–314. New Orleans, Louisiana, United States, 1985. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=318593.318660 (visited on 2022-01-04), doi:10.1145/318593.318660.
Paul Hudak, John Hughes, Simon Peyton Jones, and Philip Wadler. A history of Haskell: being lazy with class. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages. San Diego California, June 2007. ACM. URL: https://dl.acm.org/doi/10.1145/1238844.1238856 (visited on 2022-06-03), doi:10.1145/1238844.1238856.
Paul Hudak and Mark P Jones. Haskell vs. Ada vs. C++ vs. Awk vs. ... An experiment in software prototyping productivity. Technical Report YALEU/DCS/RR-1049, Yale University, October 1994.
missing journal in hudakExpressivenessPurelyFunctional1989
J. Hughes. Why functional programming matters. The Computer Journal, 32(2):98–107, February 1989. URL: https://academic.oup.com/comjnl/article-lookup/doi/10.1093/comjnl/32.2.98 (visited on 2022-01-20), doi:10.1093/comjnl/32.2.98.
missing institution in ichbiahRationaleDesignADA1979
Kenneth E. Iverson. Notation as a tool of thought. Communications of the ACM, 23(8):444–465, August 1980. URL: https://doi.org/10.1145/358896.358899 (visited on 2022-07-18), doi:10.1145/358896.358899.
Marie-Christine Jakobs. Differential modular software verification. URL: https://www.sosy-lab.org/research/prs/2019-10-01-CPA19-Differntial-Verification.pdf (visited on 2020-07-25).
Roshan P James and Amr Sabry. Theseus: a high level language for reversible computing. In Work-in-Progress Report at Conference on Reversible Computation, 12. 2014. URL: https://legacy.cs.indiana.edu/~sabry/papers/theseus.pdf.
G. F. Johnson and D. Duggan. Stores and partial continuations as first-class objects in a language and its environment. In Proceedings of the 15th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, POPL '88, 158–168. New York, NY, USA, January 1988. Association for Computing Machinery. URL: https://doi.org/10.1145/73560.73574 (visited on 2022-12-02), doi:10.1145/73560.73574.
Gregory F Johnson and Dominic Duggan. First-class stores and partial continuations in a programming language and environment. Computer Languages, 20(1):53–68, March 1994. URL: https://linkinghub.elsevier.com/retrieve/pii/0096055194900140 (visited on 2022-12-05), doi:10.1016/0096-0551(94)90014-0.
Mark Johnson. The Computational Complexity of GLR Parsing. In Masaru Tomita, editor, Generalized LR Parsing, pages 35–42. Springer US, Boston, MA, 1991. URL: https://doi.org/10.1007/978-1-4615-4034-2_3 (visited on 2023-05-22), doi:10.1007/978-1-4615-4034-2_3.
Capers Jones. Estimating Software Costs: Bringing Realism to Estimating. McGraw Hill, New York, 2nd edition edition, May 2007. ISBN 978-0-07-148300-1.
missing institution in jonesSoftwareEconomicsFunction2017
Neil D. Jones and Nina Bohr. Call-by-value termination in the untyped lambda-calculus. Logical Methods in Computer Science, 4(1):3, March 2008. URL: http://arxiv.org/abs/0801.0882 (visited on 2021-03-06), arXiv:0801.0882, doi:10.2168/LMCS-4(1:3)2008.
Simon Peyton Jones. The Implementation of Functional Programming Languages. Prentice-Hall, 1987. \textbf Errata \begin itemize \item Section 5.2.4, p87. We need an extra rule \end itemize match us [] E = E This accounts for the possibility that in the constructor rule (Section 5.2.4) there may be some non-nullary constructors for which there are no equations. \begin itemize \item P168, line 2, “VAR” should be “TVAR”. \end itemize. URL: https://www.microsoft.com/en-us/research/publication/the-implementation-of-functional-programming-languages/ (visited on 2020-08-02).
Simon Peyton Jones. Tackling the awkward squad: monadic input/output, concurrency, exceptions, and foreign-language calls in Haskell. In Engineering Theories of Software Construction, 47–96. 2001. URL: https://www.microsoft.com/en-us/research/publication/tackling-awkward-squad-monadic-inputoutput-concurrency-exceptions-foreign-language-calls-haskell/.
missing journal in jonesWearingHairShirt2003
Stef Joosten, Klaas Van Den Berg, and Gerrit Van Der Hoeven. Teaching functional programming to first-year students. Journal of Functional Programming, 3(1):49–65, January 1993. URL: https://www.cambridge.org/core/journals/journal-of-functional-programming/article/teaching-functional-programming-to-firstyear-students/041D6A27806B921685CD562695270216 (visited on 2022-11-14), doi:10.1017/S0956796800000599.
Tomasz Jurkiewicz and Kurt Mehlhorn. The cost of address translation. arXiv:1212.0703 [cs], April 2014. Comment: A extended abstract of this paper was published in the proceedings of ALENEX13, New Orleans, USA. URL: http://arxiv.org/abs/1212.0703 (visited on 2022-01-04), arXiv:1212.0703.
M. Jørgensen. A review of studies on expert estimation of software development effort. Journal of Systems and Software, 70(1-2):37–60, February 2004. URL: https://linkinghub.elsevier.com/retrieve/pii/S0164121202001565 (visited on 2023-12-26), doi:10.1016/S0164-1212(02)00156-5.
Magne Jørgensen and Barbara Kitchenham. Interpretation problems related to the use of regression models to decide on economy of scale in software development. Journal of Systems and Software, 85(11):2494–2503, November 2012. URL: https://linkinghub.elsevier.com/retrieve/pii/S0164121212001549 (visited on 2023-12-26), doi:10.1016/j.jss.2012.05.068.
Stefan Kahrs. Infinitary rewriting: closure operators, equivalences and models. Acta Informatica, 50(2):123–156, March 2013. URL: http://link.springer.com/10.1007/s00236-012-0174-y (visited on 2022-10-22), doi:10.1007/s00236-012-0174-y.
Stefan Kahrs and Connor Smith. Non-omega-overlapping TRSs are UN. In Delia Kesner and Brigitte Pientka, editors, 1st International Conference on Formal Structures for Computation and Deduction (FSCD 2016), volume 52 of Leibniz International Proceedings in Informatics (LIPIcs), 22:1–22:17. Dagstuhl, Germany, 2016. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik. URL: http://drops.dagstuhl.de/opus/volltexte/2016/5996 (visited on 2021-09-11), doi:10.4230/LIPIcs.FSCD.2016.22.
Jeehoon Kang, Chung-Kil Hur, William Mansky, Dmitri Garbuzov, Steve Zdancewic, and Viktor Vafeiadis. A formal C memory model supporting integer-pointer casts. In Proceedings of the 36th ACM SIGPLAN Conference on Programming Language Design and Implementation, 326–335. Portland OR USA, June 2015. ACM. URL: https://dl.acm.org/doi/10.1145/2737924.2738005 (visited on 2021-06-14), doi:10.1145/2737924.2738005.
Panagis Karazeris, Apostolos Matzaris, and Jiří Velebil. Final coalgebras in accessible categories. Mathematical Structures in Computer Science, 21(5):1067–1108, October 2011. URL: https://www.cambridge.org/core/product/identifier/S0960129511000351/type/journal_article (visited on 2021-03-11), doi:10.1017/S0960129511000351.
J.R. Kennaway, J.W. Klop, M.R. Sleep, and F.J. de Vries. Infinitary lambda calculus. Theoretical Computer Science, 175(1):93–125, March 1997. URL: https://linkinghub.elsevier.com/retrieve/pii/S0304397596001715 (visited on 2022-11-05), doi:10.1016/S0304-3975(96)00171-5.
R. Kennaway, V. van Oostrom, and F.-J. de Vries. Meaningless terms in rewriting. Artificial Intelligence Preprint Series, May 1999. URL: https://dspace.library.uu.nl/handle/1874/26465 (visited on 2022-07-09).
missing journal in kennawayComparingCurriedUncurried1995
Andrew Kennedy. Compiling with continuations, continued. In Proceedings of the 12th ACM SIGPLAN International Conference on Functional Programming, ICFP '07, 177–190. New York, NY, USA, October 2007. Association for Computing Machinery. URL: https://doi.org/10.1145/1291151.1291179 (visited on 2023-05-03), doi:10.1145/1291151.1291179.
Jeroen Ketema, Jan Willem Klop, and Vincent van Oostrom. Vicious circles in rewriting systems. In 5th International Workshop on Reduction Strategies in Rewriting and Programming, 20. Nara, Japan, April 2005. URL: https://www.dicosmo.org/WRS05/proceedings/jeroen.pdf.
Oleg Kiselyov. How to write seemingly unhygienic and referentially opaque macros with syntax-rules. In Third Workshop on Scheme and Functional Programming, 77. October 2002. URL: https://okmij.org/ftp/Scheme/Dirty-Macros.pdf.
Oleg Kiselyov. Many faces of the fixed-point combinator. August 2013. URL: http://okmij.org/ftp/Computation/fixed-point-combinators.html (visited on 2020-07-31).
Oleg Kiselyov, Chung-chieh Shan, Daniel P. Friedman, and Amr Sabry. Backtracking, interleaving, and terminating monad transformers: (functional pearl). In Proceedings of the Tenth ACM SIGPLAN International Conference on Functional Programming - ICFP '05, 192. Tallinn, Estonia, 2005. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=1086365.1086390 (visited on 2022-07-15), doi:10.1145/1086365.1086390.
Jan Willem Klop. Combinatory Reduction Systems. PhD thesis, Rijksuniversiteit Utrecht, June 1980. URL: https://eprints.illc.uva.nl/id/eprint/1876/ (visited on 2022-09-24).
Jan Willem Klop and Roel C. de Vrijer. Infinitary normalization. In Sergei N. Artëmov, Howard Barringer, Artur S. d'Avila Garcez, Luís C. Lamb, and John Woods, editors, We Will Show Them! Essays in Honour of Dov Gabbay, Volume Two, 169–192. College Publications, 2005.
Jan Willem Klop and Roel de Vrijer. Extended term rewriting systems. In S. Kaplan and M. Okada, editors, Conditional and Typed Rewriting Systems, Lecture Notes in Computer Science, 26–50. Berlin, Heidelberg, 1991. Springer. URL: https://ir.cwi.nl/pub/20015/20015A.pdf, doi:10.1007/3-540-54317-1_79.
Donald E. Knuth. Structured programming with go to statements. ACM Computing Surveys (CSUR), 6(4):261–301, December 1974. URL: http://dl.acm.org/doi/10.1145/356635.356640 (visited on 2020-08-25), doi:10.1145/356635.356640.
Shriram Krishnamurthi. Linguistic Reuse. PhD thesis, Rice University, 2001. URL: https://scholarship.rice.edu/handle/1911/17993 (visited on 2021-08-06).
Bent Bruun Kristensen, Ole Lehrmann Madsen, and Birger Møller-Pedersen. The when, why and why not of the BETA programming language. In Proceedings of the Third ACM SIGPLAN Conference on History of Programming Languages, HOPL III, 10–1–10–57. New York, NY, USA, June 2007. Association for Computing Machinery. URL: https://beta.alexandra.dk/sites/default/files/pdf/BETA-HOPL-V4.7_ref.pdf (visited on 2023-08-04), doi:10.1145/1238844.1238854.
Yves Lafont. Linear logic pages. URL: http://iml.univ-mrs.fr/~lafont/pub/llpages.pdf.
Robert Lagerström, Liv Marcks von Würtemberg, Hannes Holm, and Oscar Luczak. Identifying factors affecting software development cost and productivity. Software Quality Journal, 20(2):395–417, June 2012. URL: http://link.springer.com/10.1007/s11219-011-9137-8 (visited on 2023-12-26), doi:10.1007/s11219-011-9137-8.
Doug Lea. A Java fork/join framework. In Proceedings of the ACM 2000 Conference on Java Grande, JAVA '00, 36–43. New York, NY, USA, June 2000. Association for Computing Machinery. URL: https://doi.org/10.1145/337449.337465 (visited on 2021-07-09), doi:10.1145/337449.337465.
Paul Blain Levy. Jumbo λ-calculus. In Michele Bugliesi, Bart Preneel, Vladimiro Sassone, and Ingo Wegener, editors, Automata, Languages and Programming, Lecture Notes in Computer Science, 444–455. Berlin, Heidelberg, 2006. Springer. URL: https://www.cs.bham.ac.uk/~pbl/papers/jumboicalp.pdf, doi:10.1007/11787006_38.
Ian Mackie. The geometry of interaction machine. In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages - POPL '95, 198–208. San Francisco, California, United States, 1995. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=199448.199483 (visited on 2023-04-28), doi:10.1145/199448.199483.
Guy Madison and Gunilla Schiölde. Repeated listening increases the liking for music regardless of its complexity: implications for the appreciation and aesthetics of music. Frontiers in Neuroscience, 11:147, March 2017. URL: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5374342/ (visited on 2024-01-08), doi:10.3389/fnins.2017.00147.
Ole Lehrmann Madsen, Birger Moller-Pedersen, and Kristen Nygaard. Object-Oriented Programming in the Beta Programming Language. Assn for Computing Machinery, Wokingham, England ; Reading, Mass, 2nd edition edition, January 1993. ISBN 978-0-201-62430-4. URL: https://beta.cs.au.dk/Books/betabook.pdf.
Ole Lehrmann Madsen and Birger Møller-Pedersen. What object-oriented programming may be - and what it does not have to be. In Stein Gjessing and Kristen Nygaard, editors, ECOOP ’88 European Conference on Object-Oriented Programming, Lecture Notes in Computer Science, 1–20. Berlin, Heidelberg, 1988. Springer. URL: https://tidsskrift.dk/daimipb/article/view/7627, doi:10.1007/3-540-45910-3_1.
John Maraist, Martin Odersky, David N. Turner, and Philip Wadler. Call-by-name, call-by-value, call-by-need, and the linear lambda calculus. Electronic Notes in Theoretical Computer Science, 1:370–392, January 1995. URL: http://www.sciencedirect.com/science/article/pii/S1571066104000222 (visited on 2020-08-23), doi:10.1016/S1571-0661(04)00022-2.
Simon Marlow and Simon Peyton Jones. Making a fast curry: push/enter vs. eval/apply for higher-order languages. Journal of Functional Programming, 16(4-5):415–449, July 2006. URL: https://www.cambridge.org/core/product/identifier/S0956796806005995/type/journal_article (visited on 2020-06-15), doi:10.1017/S0956796806005995.
Simon Marlow, Simon Peyton Jones, Edward Kmett, and Andrey Mokhov. Desugaring Haskell's do-notation into applicative operations. In Proceedings of the 9th International Symposium on Haskell, Haskell 2016, 92–104. New York, NY, USA, September 2016. Association for Computing Machinery. URL: https://doi.org/10.1145/2976002.2976007 (visited on 2021-07-16), doi:10.1145/2976002.2976007.
T. Martin. PEARL at the age of three: Case study of development and application of a common high order realtime programming language. In Proceedings of the 4th International Conference on Software Engineering, ICSE '79, 100–109. Munich, Germany, September 1979. IEEE Press.
S. Martini and A. Masini. On the fine structure of the exponential rule. In Jean-Yves Girard, Yves Lafont, and Laurent Regnier, editors, Advances in Linear Logic, pages 197–210. Cambridge University Press, Cambridge, 1995. URL: https://pdfs.semanticscholar.org/b2cb/538c8ef21af42e48134a17a3c62ce5167837.pdf (visited on 2020-08-01), doi:10.1017/CBO9780511629150.010.
Laurent Mauborgne. Representation of Sets of Trees for Abstract Interpretation. PhD thesis, Ecole Polytechnique, November 1999. URL: http://software.imdea.org/~mauborgn/publi/t.pdf.
Laurent Mauborgne. An incremental unique representation for regular trees. Nordic Journal of Computing, 7(4):290–311, December 2000.
missing journal in maurerCompilingContinuations2016
missing journal in maziarzHashingModuloAlphaEquivalence2021
Davin McCall and Michael Kölling. A new look at novice programmer errors. ACM Transactions on Computing Education, 19(4):1–30, December 2019. URL: https://dl.acm.org/doi/10.1145/3335814 (visited on 2022-10-15), doi:10.1145/3335814.
Dylan McDermott and Alan Mycroft. Extended call-by-push-value: reasoning about effectful programs and evaluation order. In Luís Caires, editor, Programming Languages and Systems, volume 11423, pages 235–262. Springer International Publishing, Cham, 2019. URL: http://link.springer.com/10.1007/978-3-030-17184-1_9 (visited on 2021-11-09), doi:10.1007/978-3-030-17184-1_9.
Leo A. Meyerovich and Ariel S. Rabkin. Socio-PLT: principles for programming language adoption. In Proceedings of the ACM International Symposium on New Ideas, New Paradigms, and Reflections on Programming and Software - Onward! '12, 39. Tucson, Arizona, USA, 2012. ACM Press. URL: http://dl.acm.org/citation.cfm?doid=2384592.2384597 (visited on 2020-06-15), doi:10.1145/2384592.2384597.
Richard J. Miara, Joyce A. Musselman, Juan A. Navarro, and Ben Shneiderman. Program indentation and comprehensibility. Communications of the ACM, 26(11):861–867, November 1983. URL: https://dl.acm.org/doi/10.1145/182.358437 (visited on 2023-03-29), doi:10.1145/182.358437.
Aart Middeldorp. Modular aspects of properties of term rewriting systems related to normal forms. In G. Goos, J. Hartmanis, D. Barstow, W. Brauer, P. Brinch Hansen, D. Gries, D. Luckham, C. Moler, A. Pnueli, G. Seegmüller, J. Stoer, N. Wirth, and Nachum Dershowitz, editors, Rewriting Techniques and Applications, volume 355, pages 263–277. Springer Berlin Heidelberg, Berlin, Heidelberg, 1989. URL: http://link.springer.com/10.1007/3-540-51081-8_113 (visited on 2021-09-14), doi:10.1007/3-540-51081-8_113.
Matthew Might, David Darais, and Daniel Spiewak. Parsing with derivatives: a functional pearl. ACM SIGPLAN Notices, 46(9):189–195, September 2011. URL: https://doi.org/10.1145/2034574.2034801 (visited on 2023-05-18), doi:10.1145/2034574.2034801.
Dale Miller. An overview of linear logic programming. In Thomas Ehrhard, Jean-Yves Girard, Paul Ruet, and Philip Scott, editors, Linear Logic in Computer Science, pages 119–150. Cambridge University Press, 1 edition, November 2004. URL: https://www.cambridge.org/core/product/identifier/CBO9780511550850A013/type/book_part (visited on 2021-04-02), doi:10.1017/CBO9780511550850.004.
Andrey Mokhov, Neil Mitchell, and Simon Peyton Jones. Build systems à la carte: theory and practice. Journal of Functional Programming, 30:e11, 2020. URL: https://ndmitchell.com/downloads/paper-build_systems_a_la_carte_theory_and_practice-21_apr_2020.pdf (visited on 2020-06-11), doi:10.1017/S0956796820000088.
Martin Monperrus. Explainable software bot contributions: case study of automated bug fixes. In 2019 IEEE/ACM 1st International Workshop on Bots in Software Engineering (BotSE), 12–15. May 2019. URL: http://arxiv.org/abs/1905.02597 (visited on 2023-06-19), arXiv:1905.02597, doi:10.1109/BotSE.2019.00010.
J. Gregory Morrisett. Refining first-class stores. In Proceedings of the ACM SIGPLAN Workshop on State in Programming Languages, 73–87. Citeseer, 1993.
Mayur Naik and Jens Palsberg. A type system equivalent to a model checker. ACM Transactions on Programming Languages and Systems, 30(5):1–24, August 2008. URL: https://dl.acm.org/doi/10.1145/1387673.1387678 (visited on 2021-07-15), doi:10.1145/1387673.1387678.
Armin Najafi, Peter C. Rigby, and Weiyi Shang. Bisecting commits and modeling commit risk during testing. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2019, 279–289. Tallinn, Estonia, 2019. ACM Press. URL: https://users.encs.concordia.ca/~shang/pubs/Armin_FSE_2019.pdf (visited on 2020-07-06), doi:10.1145/3338906.3338944.
Vivek Nigam and Dale Miller. Algorithmic specifications in linear logic with subexponentials. In Proceedings of the 11th ACM SIGPLAN Conference on Principles and Practice of Declarative Programming - PPDP '09, 129. Coimbra, Portugal, 2009. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=1599410.1599427 (visited on 2021-03-26), doi:10.1145/1599410.1599427.
Gor Nishanov. Fibers under the magnifying glass. November 2018. URL: http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1364r0.pdf (visited on 2021-11-04).
Donald A. Norman. Living with Complexity. Mit Pr, Cambridge, Mass., January 2010. ISBN 978-0-262-01486-1.
missing journal in norvigDesignPatternsDynamic1996
Kristen Nygaard and Ole-Johan Dahl. The development of the SIMULA languages. In History of Programming Languages, pages 439–480. Association for Computing Machinery, New York, NY, USA, June 1978. URL: https://doi.org/10.1145/800025.1198392 (visited on 2022-12-20).
Larry O'Brien. Design patterns 15 years later: an interview. URL: https://www.informit.com/articles/article.aspx?p=1404056 (visited on 2023-07-26).
Mike O'Docherty. Object-Oriented Analysis and Design: Understanding System Development with UML 2.0. Wiley, Chichester, England ; Hoboken, NJ, 2005. ISBN 978-0-470-09240-8.
Martin Odersky, Philip Wadler, and Martin Wehr. A second look at overloading. In Proceedings of the Seventh International Conference on Functional Programming Languages and Computer Architecture - FPCA '95, 135–146. La Jolla, California, United States, 1995. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=224164.224195 (visited on 2022-06-07), doi:10.1145/224164.224195.
Chris Okasaki. Purely Functional Data Structures. Cambridge University Press, Cambridge, U.K. ; New York, 1998. ISBN 978-0-521-63124-2.
Chris Okasaki, Peter Lee, and David Tarditi. Call-by-need and continuation-passing style. LISP and Symbolic Computation, 7(1):57–81, January 1994. URL: https://www.researchgate.net/profile/Peter-Lee-88/publication/220606923_Call-by-Need_and_Continuation-Passing_Style/links/55633a2108ae8c0cab3509ba/Call-by-Need-and-Continuation-Passing-Style.pdf (visited on 2023-05-02), doi:10.1007/BF01019945.
missing institution in palaimoComparisonRADCNASA1982
Victor Pankratius, Felix Schmidt, and Gilda Garreton. Combining functional and imperative programming for multicore software: An empirical study evaluating Scala and Java. In 2012 34th International Conference on Software Engineering (ICSE), 123–133. Zurich, June 2012. IEEE. URL: https://web.archive.org/web/20120704064618id_/http://www.rz.uni-karlsruhe.de/~kb95/papers/pankratius-Scala-ICSE12-preprint.pdf (visited on 2022-11-10), doi:10.1109/ICSE.2012.6227200.
David Parkes and Lirong Xia. A complexity-of-strategic-behavior comparison between Schulze's rule and ranked pairs. Proceedings of the AAAI Conference on Artificial Intelligence, 26(1):1429–1435, September 2021. URL: https://ojs.aaai.org/index.php/AAAI/article/view/8258 (visited on 2024-01-07), doi:10.1609/aaai.v26i1.8258.
D. L. Parnas, John E. Shore, and David Weiss. Abstract types defined as classes of variables. In Proceedings of the 1976 Conference on Data : Abstraction, Definition and Structure, 149–154. New York, NY, USA, March 1976. Association for Computing Machinery. URL: https://dl.acm.org/doi/10.1145/800237.807133 (visited on 2023-08-29), doi:10.1145/800237.807133.
missing journal in parreauxUltimateConditionalSyntax
Simon Peyton Jones and Simon Marlow. Secrets of the Glasgow Haskell Compiler inliner. Journal of Functional Programming, 12(4):393–434, July 2002. URL: https://www.microsoft.com/en-us/research/wp-content/uploads/2002/07/inline.pdf (visited on 2020-07-01), doi:10.1017/S0956796802004331.
Simon Peyton Jones, Alastair Reid, Fergus Henderson, Tony Hoare, and Simon Marlow. A semantics for imprecise exceptions. ACM SIGPLAN Notices, 34(5):25–36, May 1999. URL: https://doi.org/10.1145/301631.301637 (visited on 2022-07-25), doi:10.1145/301631.301637.
Frank Pfenning. Church and Curry: combining intrinsic and extrinsic typing. In Christoph Benzmüller, Chad E. Brown, Jörg Siekmann, and Richard Statman, editors, Reasoning in Simple Type Theory: Festschrift in Honour of Peter B. Andrews on His 70th Birthday, volume 17 of Studies in Logic: Mathematical Logic and Foundations, pages 288–323. College Publications, London, December 2008. URL: https://www.cs.cmu.edu/~fp/papers/andrews08.pdf.
Nicholas Pippenger. Pure versus impure Lisp. ACM Transactions on Programming Languages and Systems, 19(2):223–238, March 1997. URL: https://dl.acm.org/doi/10.1145/244795.244798 (visited on 2022-01-06), doi:10.1145/244795.244798.
Michael Pradel and Koushik Sen. The good, the bad, and the ugly: an empirical study of implicit type conversions in JavaScript. In John Tang Boyland, editor, 29th European Conference on Object-Oriented Programming (ECOOP 2015), volume 37 of Leibniz International Proceedings in Informatics (LIPIcs), 519–541. Dagstuhl, Germany, 2015. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik. \subsection Other Most popular programming languages support situations where a value of one type is converted into a value of another type without any explicit cast. Such implicit type conversions, or type coercions, are a highly controversial language feature. Proponents argue that type coercions enable writing concise code. Opponents argue that type coercions are error-prone and that they reduce the understandability of programs. This paper studies the use of type coercions in JavaScript, a language notorious for its widespread use of coercions. We dynamically analyze hundreds of programs, including real-world web applications and popular benchmark programs. We find that coercions are widely used (in 80.42% of all function executions) and that most coercions are likely to be harmless (98.85%). Furthermore, we identify a set of rarely occurring and potentially harmful coercions that safer subsets of JavaScript or future language designs may want to disallow. Our results suggest that type coercions are significantly less evil than commonly assumed and that analyses targeted at real-world JavaScript programs must consider coercions. URL: http://drops.dagstuhl.de/opus/volltexte/2015/5236 (visited on 2022-07-25), doi:10.4230/LIPIcs.ECOOP.2015.519.
missing journal in precheltEmpiricalComparisonJava2000
Lutz Prechelt. Plat_Forms: the web development platform comparison — evaluation and results. Technical Report B-07-10, Institut für Informatik, Freie Universität Berlin, June 2007.
Raphaël L Proust. ASAP: As Static As Possible memory management. Technical Report UCAM-CL-TR-908, University of Cambridge Computer Laboratory, July 2017. URL: https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-908.pdf.
Christopher Pulte, Shaked Flur, Will Deacon, Jon French, Susmit Sarkar, and Peter Sewell. Simplifying ARM concurrency: multicopy-atomic axiomatic and operational models for ARMv8. Proceedings of the ACM on Programming Languages, 2(POPL):19:1–19:29, December 2017. URL: https://doi.org/10.1145/3158107 (visited on 2021-07-19), doi:10.1145/3158107.
Paul Quincey. Reply to comment on `Angles in the SI: a detailed proposal for solving the problem'. Metrologia, 59(3):038002, May 2022. URL: https://doi.org/10.1088/1681-7575/ac5434 (visited on 2022-05-21), doi:10.1088/1681-7575/ac5434.
Paul Quincey and Richard J. C. Brown. Implications of adopting plane angle as a base quantity in the SI. Metrologia, 53(3):998–1002, June 2016. Comment: 9 pages; accepted by Metrologia. URL: http://arxiv.org/abs/1604.02373 (visited on 2022-04-08), arXiv:1604.02373, doi:10.1088/0026-1394/53/3/998.
Pedro Ramalhete, Andreia Correia, and Pascal Felber. Efficient algorithms for persistent transactional memory. In Proceedings of the 26th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, PPoPP '21, 1–15. New York, NY, USA, February 2021. Association for Computing Machinery. URL: https://doi.org/10.1145/3437801.3441586 (visited on 2021-11-11), doi:10.1145/3437801.3441586.
Exequiel Rivas and Mauro Jaskelioff. Notions of computation as monoids. Journal of Functional Programming, May 2014. URL: https://www.cambridge.org/core/journals/journal-of-functional-programming/article/notions-of-computation-as-monoids/70019FC0F2384270E9F41B9719042528 (visited on 2022-06-08), doi:10.1017/S0956796817000132.
Amr Sabry and Matthias Felleisen. Reasoning about programs in continuation-passing style. In Proceedings of the 1992 ACM Conference on LISP and Functional Programming, LFP '92, 288–298. New York, NY, USA, January 1992. Association for Computing Machinery. URL: https://dl.acm.org/doi/10.1145/141471.141563 (visited on 2023-04-21), doi:10.1145/141471.141563.
Jean E Sammet. Why Ada is not just another programming language. Communications of the ACM, 1986.
Elizabeth Scott. SPPF-Style parsing from Earley recognisers. Electronic Notes in Theoretical Computer Science, 203(2):53–67, April 2008. URL: https://linkinghub.elsevier.com/retrieve/pii/S1571066108001497 (visited on 2020-06-15), doi:10.1016/j.entcs.2008.03.044.
Paula Severi and Fer-Jan de Vries. Decomposing the lattice of meaningless sets in the infinitary lambda calculus. In Lev D. Beklemishev and Ruy de Queiroz, editors, Logic, Language, Information and Computation, Lecture Notes in Computer Science, 210–227. Berlin, Heidelberg, 2011. Springer. doi:10.1007/978-3-642-20920-8_22.
Peter Sewell, Susmit Sarkar, Scott Owens, Francesco Zappa Nardelli, and Magnus O. Myreen. X86-TSO: a rigorous and usable programmer's model for x86 multiprocessors. Communications of the ACM, 53(7):89–97, July 2010. URL: https://dl.acm.org/doi/10.1145/1785414.1785443 (visited on 2021-07-09), doi:10.1145/1785414.1785443.
Mike Shal. Build system rules and algorithms. 2009. URL: http://gittup.org/tup/build_system_rules_and_algorithms.pdf (visited on 2021-01-22).
Adi Shamir. The Fixedpoints of Recursive Definitions. PhD thesis, Weizmann Institute of Science, Rehovot, October 1976. URL: https://weizmann.primo.exlibrisgroup.com/permalink/972WIS_INST/1d4esio/alma990002185270203596.
Yunhe Shi, David Gregg, Andrew Beatty, and M. Anton Ertl. Virtual machine showdown: stack versus registers. In Proceedings of the 1st ACM/USENIX International Conference on Virtual Execution Environments, VEE '05, 153–163. New York, NY, USA, June 2005. Association for Computing Machinery. URL: https://dl.acm.org/doi/10.1145/1328195.1328197 (visited on 2021-06-29), doi:10.1145/1064979.1065001.
Masaru Shirahata. Linear Set Theory. PhD thesis, Stanford University, February 1994. URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.29.7077&rep=rep1&type=pdf.
Masaru Shirahata. A linear conservative extension of Zermelo-Fraenkel set theory. Studia Logica, 56(3):361–392, May 1996. URL: http://link.springer.com/10.1007/BF00372772 (visited on 2021-03-06), doi:10.1007/BF00372772.
Masaru Shirahata. Linear set theory with strict comprehension. In Proceedings of the Sixth Asian Logic Conference, 223–245. Beijing, China, April 1998. WORLD SCIENTIFIC / S'PORE UNIV PRESS (PTE) LTD. URL: http://www.worldscientific.com/doi/abs/10.1142/9789812812940_0013 (visited on 2021-03-06), doi:10.1142/9789812812940_0013.
Olin Shivers and Mitchell Wand. Bottom-up β-reduction: uplinks and λ-DAGs (extended version). Technical Report, Citeseer, 2004.
Michael Shulman. Linear logic for constructive mathematics. arXiv:1805.07518 [math], May 2018. Comment: 39 pages. URL: http://arxiv.org/abs/1805.07518 (visited on 2021-03-04), arXiv:1805.07518.
John N Shutt. Fexprs as the Basis of Lisp Function Application or \$vau : The Ultimate Abstraction. PhD thesis, WORCESTER POLYTECHNIC INSTITUTE, August 2010. URL: https://web.wpi.edu/Pubs/ETD/Available/etd-090110-124904/.
Janet Siegmund, Christian Kästner, Jörg Liebig, Sven Apel, and Stefan Hanenberg. Measuring and modeling programming experience. Empirical Software Engineering, 19(5):1299–1334, October 2014. URL: https://doi.org/10.1007/s10664-013-9286-4 (visited on 2023-02-13), doi:10.1007/s10664-013-9286-4.
Jakob Grue Simonsen. Weak convergence and uniform normalization in infinitary rewriting. In Christopher Lynch, editor, Proceedings of the 21st International Conference on Rewriting Techniques and Applications, volume 6 of Leibniz International Proceedings in Informatics (LIPIcs), 311–324. Dagstuhl, Germany, 2010. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik. \subsection Other We study infinitary term rewriting systems containing finitely many rules. For these, we show that if a weakly convergent reduction is not strongly convergent, it contains a term that reduces to itself in one step (but the step itself need not be part of the reduction). Using this result, we prove the starkly surprising result that for any orthogonal system with finitely many rules, the system is weakly normalizing under weak convergence if\f\ it is strongly normalizing under weak convergence if\f\ it is weakly normalizing under strong convergence if\f\ it is strongly normalizing under strong convergence. As further corollaries, we derive a number of new results for weakly convergent rewriting: Systems with finitely many rules enjoy unique normal forms, and acyclic orthogonal systems are confluent. Our results suggest that it may be possible to recover some of the positive results for strongly convergent rewriting in the setting of weak convergence, if systems with finitely many rules are considered. Finally, we give a number of counterexamples showing failure of most of the results when infinite sets of rules are allowed. URL: http://drops.dagstuhl.de/opus/volltexte/2010/2660 (visited on 2022-07-25), doi:10.4230/LIPIcs.RTA.2010.311.
Jeremy Singer and Blair Archibald. Functional baby talk: analysis of code fragments from novice Haskell programmers. Electronic Proceedings in Theoretical Computer Science, 270:37–51, May 2018. URL: http://arxiv.org/abs/1805.05126v1 (visited on 2022-05-23), doi:10.4204/EPTCS.270.3.
David Snowdon, Godfrey Van Der Linden, Stefan Petters, and Gernot Heiser. Accurate run-time prediction of performance degradation under frequency scaling. In 2007 Workshop on Operating System Platforms for Embedded Real-Time Applications. NICTA, 2007. URL: http://hdl.handle.net/1959.4/39905 (visited on 2023-08-07), doi:10.26190/unsworks/517.
Alan Snyder. Encapsulation and inheritance in object-oriented programming languages. ACM SIGPLAN Notices, 21(11):38–45, November 1986. URL: https://dl.acm.org/doi/10.1145/960112.28702 (visited on 2022-12-26), doi:10.1145/960112.28702.
Z A Sparks and Amr Sabry. Superstructural reversible logic. In 3rd International Workshop on Linearity. 2014. URL: http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.720.5692&rep=rep1&type=pdf.
Michael Sperber and Peter Thiemann. Generation of LR parsers by partial evaluation. ACM Transactions on Programming Languages and Systems (TOPLAS), 22(2):224–264, March 2000. URL: http://dl.acm.org/doi/10.1145/349214.349219 (visited on 2020-06-15), doi:10.1145/349214.349219.
Mark Staples, Rafal Kolanski, Gerwin Klein, Corey Lewis, June Andronick, Toby Murray, Ross Jeffery, and Len Bass. Formal specifications better than function points for code sizing. In 2013 35th International Conference on Software Engineering (ICSE), 1257–1260. San Francisco, CA, USA, May 2013. IEEE. URL: http://ieeexplore.ieee.org/document/6606692/ (visited on 2023-12-27), doi:10.1109/ICSE.2013.6606692.
Andreas Stefik and Susanna Siebert. An empirical investigation into programming language syntax. ACM Transactions on Computing Education, 13(4):1–40, November 2013. URL: https://dl.acm.org/doi/10.1145/2534973 (visited on 2021-02-13), doi:10.1145/2534973.
Andreas Stefik, Susanna Siebert, Melissa Stefik, and Kim Slattery. An empirical comparison of the accuracy rates of novices using the quorum, perl, and randomo programming languages. In Proceedings of the 3rd ACM SIGPLAN Workshop on Evaluation and Usability of Programming Languages and Tools - PLATEAU '11, 3. Portland, Oregon, USA, 2011. ACM Press. URL: http://dl.acm.org/citation.cfm?doid=2089155.2089159 (visited on 2022-06-18), doi:10.1145/2089155.2089159.
Amanda Stent, Ann Syrdal, and Taniya Mishra. On the intelligibility of fast synthesized speech for individuals with early-onset blindness. In The Proceedings of the 13th International ACM SIGACCESS Conference on Computers and Accessibility - ASSETS '11, 211. Dundee, Scotland, UK, 2011. ACM Press. URL: http://dl.acm.org/citation.cfm?doid=2049536.2049574 (visited on 2022-11-30), doi:10.1145/2049536.2049574.
Colin Stirling. Decidability of higher-order matching. Logical Methods in Computer Science, 5(3):2, July 2009. URL: https://lmcs.episciences.org/757 (visited on 2021-11-15), doi:10.2168/LMCS-5(3:2)2009.
Milan Straka. Functional Data Structures and Algorithms. PhD thesis, Computer Science Institute of Charles University, September 2013. URL: https://dspace.cuni.cz/handle/20.500.11956/52896 (visited on 2022-01-04).
Lutz STRAßBURGER. Deep inference and expansion trees for second-order multiplicative linear logic. Mathematical Structures in Computer Science, 29(8):1030–1060, September 2019. URL: https://www.cambridge.org/core/product/identifier/S0960129518000385/type/journal_article (visited on 2022-08-11), doi:10.1017/S0960129518000385.
Bjarne Stroustrup. Why C++ is not just an object-oriented programming language. In Addendum to the Proceedings of the 10th Annual Conference on Object-oriented Programming Systems, Languages, and Applications, OOPSLA '95, 1–13. New York, NY, USA, October 1995. Association for Computing Machinery. URL: https://www.stroustrup.com/oopsla.pdf (visited on 2023-07-22), doi:10.1145/260094.260207.
Young-Kyoon Suh, Richard T. Snodgrass, John D. Kececioglu, Peter J. Downey, Robert S. Maier, and Cheng Yi. EMP: execution time measurement protocol for compute-bound programs. Software: Practice and Experience, 47(4):559–597, 2017. URL: https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.2476 (visited on 2023-08-07), doi:10.1002/spe.2476.
Herb Sutter. The C family of languages. Java Report, July 2000. URL: http://www.gotw.ca/publications/c_family_interview.htm (visited on 2021-10-28).
S. Doaitse Swierstra. Combinator parsing: a short tutorial. In Ana Bove, Luís Soares Barbosa, Alberto Pardo, and Jorge Sousa Pinto, editors, Language Engineering and Rigorous Software Development: International LerNet ALFA Summer School 2008, Piriapolis, Uruguay, February 24 - March 1, 2008, Revised Tutorial Lectures, volume 5520 of Lecture Notes in Computer Science, pages 252–300. Springer, Berlin, Heidelberg, 2009. URL: http://www.cs.uu.nl/research/techreps/repo/CS-2008/2008-044.pdf (visited on 2023-05-18), doi:10.1007/978-3-642-03153-3_6.
Antero Taivalsaari. On the notion of inheritance. ACM Computing Surveys, 28(3):438–479, September 1996. URL: https://doi.org/10.1145/243439.243441 (visited on 2022-12-14), doi:10.1145/243439.243441.
Ewan Tempero, Hong Yul Yang, and James Noble. What programmers do with inheritance in Java. In David Hutchison, Takeo Kanade, Josef Kittler, Jon M. Kleinberg, Friedemann Mattern, John C. Mitchell, Moni Naor, Oscar Nierstrasz, C. Pandu Rangan, Bernhard Steffen, Madhu Sudan, Demetri Terzopoulos, Doug Tygar, Moshe Y. Vardi, Gerhard Weikum, and Giuseppe Castagna, editors, ECOOP 2013 – Object-Oriented Programming, volume 7920, pages 577–601. Springer Berlin Heidelberg, Berlin, Heidelberg, 2013. URL: http://link.springer.com/10.1007/978-3-642-39038-8_24 (visited on 2022-08-31), doi:10.1007/978-3-642-39038-8_24.
Gil Tene, Balaji Iyengar, and Michael Wolf. C4: the continuously concurrent compacting collector. ACM SIGPLAN Notices, 46(11):79–88, June 2011. URL: https://doi.org/10.1145/2076022.1993491 (visited on 2022-06-08), doi:10.1145/2076022.1993491.
Allison Elliott Tew and Mark Guzdial. Developing a validated assessment of fundamental CS1 concepts. In Proceedings of the 41st ACM Technical Symposium on Computer Science Education, 97–101. Milwaukee Wisconsin USA, March 2010. ACM. URL: https://dl.acm.org/doi/10.1145/1734263.1734297 (visited on 2023-02-13), doi:10.1145/1734263.1734297.
Allison Elliott Tew and Mark Guzdial. The FCS1: a language independent assessment of CS1 knowledge. In Proceedings of the 42nd ACM Technical Symposium on Computer Science Education, 111–116. Dallas TX USA, March 2011. ACM. URL: https://dl.acm.org/doi/10.1145/1953163.1953200 (visited on 2023-02-13), doi:10.1145/1953163.1953200.
Masaru Tomita. Efficient Parsing for Natural Language. Springer US, Boston, MA, 1986. ISBN 978-1-4419-5198-4 978-1-4757-1885-0. URL: http://link.springer.com/10.1007/978-1-4757-1885-0 (visited on 2020-06-15), doi:10.1007/978-1-4757-1885-0.
Jean-Paul Tremblay and Paul G. Sorenson. The Theory and Practice of Compiler Writing. McGraw-Hill College, New York, first edition edition, January 1985. ISBN 978-0-07-065161-6.
P. W. Trinder, K. Hammond, H.-W. Loidl, and Simon Peyton Jones. Algorithm + strategy = parallelism. Journal of Functional Programming, January 1998. URL: https://www.microsoft.com/en-us/research/publication/algorithm-strategy-parallelism/ (visited on 2020-08-02).
Tarmo Uustalu and Varmo Vene. Comonadic notions of computation. Electronic Notes in Theoretical Computer Science, 203(5):263–284, June 2008. URL: https://linkinghub.elsevier.com/retrieve/pii/S1571066108003435 (visited on 2023-01-17), doi:10.1016/j.entcs.2008.05.029.
Marissa Venturini Zilli. Reduction graphs in the lambda calculus. Theoretical Computer Science, 29(3):251–275, January 1984. URL: https://www.sciencedirect.com/science/article/pii/0304397584900021 (visited on 2022-06-08), doi:10.1016/0304-3975(84)90002-1.
Eelco Visser. Syntax Definition for Language Prototyping. University, Amsterdam, 1997. ISBN 978-90-74795-75-3. Zugl.: Amsterdam, Univ., Diss., 1997.
Janis Voigtländer. Asymptotic improvement of computations over free monads. In Philippe Audebaud and Christine Paulin-Mohring, editors, Mathematics of Program Construction, volume 5133, pages 388–403. Springer Berlin Heidelberg, Berlin, Heidelberg, 2008. URL: https://www.janis-voigtlaender.eu/papers/AsymptoticImprovementOfComputationsOverFreeMonads.pdf (visited on 2021-07-09), doi:10.1007/978-3-540-70594-9_20.
Petar Vukmirović, Alexander Bentkamp, and Visa Nummelin. Efficient full higher-order unification. Logical Methods in Computer Science, December 2021. URL: https://lmcs.episciences.org/8837/pdf (visited on 2022-06-14), doi:10.46298/lmcs-17(4:18)2021.
P. Wadler and S. Blott. How to make ad-hoc polymorphism less ad hoc. In Proceedings of the 16th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages - POPL '89, 60–76. Austin, Texas, United States, 1989. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=75277.75283 (visited on 2022-06-07), doi:10.1145/75277.75283.
Philip Wadler. The essence of functional programming. In Proceedings of the 19th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages - POPL '92, 1–14. Albuquerque, New Mexico, United States, 1992. ACM Press. URL: http://portal.acm.org/citation.cfm?doid=143165.143169 (visited on 2021-11-22), doi:10.1145/143165.143169.
Philip Wadler. Call-by-value is dual to call-by-name. In Proceedings of the Eighth ACM SIGPLAN International Conference on Functional Programming, ICFP '03, 189–201. Uppsala, Sweden, August 2003. Association for Computing Machinery. URL: http://homepages.inf.ed.ac.uk/wadler/papers/dual/dual.pdf (visited on 2020-06-17), doi:10.1145/944705.944723.
Peter Walker. Font tuning: A review and new experimental evidence. Visual Cognition, 16(8):1022–1058, November 2008. URL: http://www.tandfonline.com/doi/abs/10.1080/13506280701535924 (visited on 2023-01-13), doi:10.1080/13506280701535924.
C. E. Walston and C. P. Felix. A method of programming measurement and estimation. IBM Systems Journal, 16(1):54–73, 1977. URL: http://ieeexplore.ieee.org/document/5388069/ (visited on 2023-12-30), doi:10.1147/sj.161.0054.
Paul Wankadia. Redgrep: from regular expression derivatives to LLVM. March 2013. URL: https://www.youtube.com/watch?v=ZJOgDovsIsg (visited on 2021-02-09).
missing booktitle in warthWorldsControllingScope2011
W.P. Weijland. Semantics for logic programs without occur check. Theoretical Computer Science, 71(1):155–174, March 1990. URL: https://linkinghub.elsevier.com/retrieve/pii/030439759090194M (visited on 2022-07-15), doi:10.1016/0304-3975(90)90194-M.
Aaron Weiss, Daniel Patterson, Nicholas D. Matsakis, and Amal Ahmed. Oxide: the essence of Rust. arXiv:1903.00982 [cs], March 2019. Comment: In submission. URL: http://arxiv.org/abs/1903.00982 (visited on 2020-05-17), arXiv:1903.00982.
David A. Wheeler. Fully countering trusting trust through diverse double-compiling. arXiv:1004.5534 [cs], April 2010. Comment: PhD dissertation. Accepted by George Mason University, Fairfax, Virginia, USA's Volgenau School of Information Technology and Engineering in 2009. 199 single-side printed pages. URL: http://arxiv.org/abs/1004.5534 (visited on 2020-09-13), arXiv:1004.5534.
Zhaomo Yang, Brian Johannesmeyer, Anders Trier Olesen, Sorin Lerner, and Kirill Levchenko. Dead store elimination (still) considered harmful. In 26th USENIX Security Symposium. Vancouver, BC, Canada, August 2017.
Victor Yodaiken. How ISO C became unusable for operating systems development. In Proceedings of the 11th Workshop on Programming Languages and Operating Systems, 84–90. October 2021. Comment: PLOS '21: Proceedings of the 11th Workshop on Programming Languages and Operating Systems October 2021. URL: http://arxiv.org/abs/2201.07845 (visited on 2022-10-06), arXiv:2201.07845, doi:10.1145/3477113.3487274.
Stephen F. Zeigler. Comparing development costs of C and Ada. March 1995. URL: http://archive.adaic.com/intro/ada-vs-c/cada_art.html (visited on 2023-12-29).
Noam Zeilberger. The Logical Basis of Evaluation Order and Pattern-Matching. PhD thesis, Carnegie Mellon University, Pittsburgh, PA, April 2009. URL: https://software.imdea.org/~noam.zeilberger/thesis.pdf.
Celal Ziftci and Jim Reardon. Who broke the build? Automatically identifying changes that induce test failures in continuous integration at Google scale. In 2017 IEEE/ACM 39th International Conference on Software Engineering: Software Engineering in Practice Track (ICSE-SEIP), 113–122. Buenos Aires, May 2017. IEEE. URL: https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45794.pdf (visited on 2020-07-06), doi:10.1109/ICSE-SEIP.2017.13.
Amir M. Ben-amram. Notes on Pippenger's comparison of pure and impure LISP. 1996. URL: citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.55.3024&rep=rep1&type=pdf.
Rodrigo Magalhães dos Santos and Marco Aurélio Gerosa. Impacts of coding practices on readability. In Proceedings of the 26th Conference on Program Comprehension, 277–285. Gothenburg Sweden, May 2018. ACM. URL: https://dl.acm.org/doi/10.1145/3196321.3196342 (visited on 2022-05-18), doi:10.1145/3196321.3196342.
V. van Oostrom. Confluence for Abstract and Higher-Order Rewriting. PhD thesis, Vrije Universiteit Amsterdam, 1994.
Wikipedia. Forward–backward algorithm. Wikipedia, July 2020. URL: https://en.wikipedia.org/w/index.php?title=Forward%E2%80%93backward_algorithm&oldid=966683884 (visited on 2020-07-08).
Wikipedia. Logit. Wikipedia, June 2020. URL: https://en.wikipedia.org/w/index.php?title=Logit&oldid=964387041 (visited on 2020-07-07).
Yaofei Chen, R. Dios, A. Mili, Lan Wu, and Kefei Wang. An empirical study of programming language trends. IEEE Software, 22(3):72–78, May 2005. URL: http://ieeexplore.ieee.org/document/1438333/ (visited on 2023-06-17), doi:10.1109/MS.2005.55.