• Downen P. (2024). Call-by-Unboxed-Value. Proceedings of the ACM on Programming Languages. 8:ICFP. (845-879). Online publication date: 15-Aug-2024.

    https://doi.org/10.1145/3674654

  • Mason D. Threaded Execution as a Dual to Native Code. Companion Proceedings of the 7th International Conference on the Art, Science, and Engineering of Programming. (7-11).

    https://doi.org/10.1145/3594671.3594673

  • Shishkin E and Kislitsyn E. (2021). SafeComp: Protocol for Certifying Cloud Computations Integrity. Programming and Computer Software. 10.1134/S0361768821080053. 47:8. (871-881). Online publication date: 1-Dec-2021.

    https://link.springer.com/10.1134/S0361768821080053

  • Farvardin K and Reppy J. A New Backend for Standard ML of New Jersey. Proceedings of the 32nd Symposium on Implementation and Application of Functional Languages. (55-66).

    https://doi.org/10.1145/3462172.3462191

  • MacQueen D, Harper R and Reppy J. (2020). The history of Standard ML. Proceedings of the ACM on Programming Languages. 4:HOPL. (1-100). Online publication date: 14-Jun-2020.

    https://doi.org/10.1145/3386336

  • Farvardin K and Reppy J. From folklore to fact: comparing implementations of stacks and continuations. Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation. (75-90).

    https://doi.org/10.1145/3385412.3385994

  • Paraskevopoulou Z and Appel A. (2019). Closure conversion is safe for space. Proceedings of the ACM on Programming Languages. 3:ICFP. (1-29). Online publication date: 26-Jul-2019.

    https://doi.org/10.1145/3341687

  • Heller T, Lelbach B, Huck K, Biddiscombe J, Grubel P, Koniges A, Kretz M, Marcello D, Pfander D, Serio A, Frank J, Clayton G, Pflüger D, Eder D and Kaiser H. (2019). Harnessing billions of tasks for a scalable portable hydrodynamic simulation of the merger of two stars. The International Journal of High Performance Computing Applications. 10.1177/1094342018819744. (109434201881974).

    http://journals.sagepub.com/doi/10.1177/1094342018819744

  • Blelloch G, Gibbons P, Gu Y, McGuffey C and Shun J. The Parallel Persistent Memory Model. Proceedings of the 30th on Symposium on Parallelism in Algorithms and Architectures. (247-258).

    https://doi.org/10.1145/3210377.3210381

  • Zhai E, Piskac R, Gu R, Lao X and Wang X. (2017). An auditing language for preventing correlated failures in the cloud. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-28). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133921

  • Maeng K, Colin A and Lucia B. (2017). Alpaca: intermittent execution without checkpoints. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-30). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133920

  • Santolucito M, Zhai E, Dhodapkar R, Shim A and Piskac R. (2017). Synthesizing configuration file specifications with association rule learning. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-20). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133888

  • Yaghmazadeh N, Wang Y, Dillig I and Dillig T. (2017). SQLizer: query synthesis from natural language. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-26). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133887

  • Srinivasan V, Vartanian A and Reps T. (2017). Model-assisted machine-code synthesis. Proceedings of the ACM on Programming Languages. 1:OOPSLA. (1-26). Online publication date: 12-Oct-2017.

    https://doi.org/10.1145/3133885

  • Leger P and Fukuda H. Sync/CC. Proceedings of the Symposium on Applied Computing. (1245-1250).

    https://doi.org/10.1145/3019612.3019783

  • Tolpin D, van de Meent J, Yang H and Wood F. Design and Implementation of Probabilistic Programming Language Anglican. Proceedings of the 28th Symposium on the Implementation and Application of Functional Programming Languages. (1-12).

    https://doi.org/10.1145/3064899.3064910

  • Bouraqadi N and Mason D. Mocks, Proxies, and Transpilation as Development Strategies for Web Development. Proceedings of the 11th edition of the International Workshop on Smalltalk Technologies. (1-6).

    https://doi.org/10.1145/2991041.2991051

  • Nikolic M, Dashti M and Koch C. How to Win a Hot Dog Eating Contest. Proceedings of the 2016 International Conference on Management of Data. (511-526).

    https://doi.org/10.1145/2882903.2915246

  • Leger P and Fukuda H. Using continuations and aspects to tame asynchronous programming on the web. Companion Proceedings of the 15th International Conference on Modularity. (79-82).

    https://doi.org/10.1145/2892664.2892675

  • Fiore M and Staton S. Substitution, jumps, and algebraic effects. Proceedings of the Joint Meeting of the Twenty-Third EACSL Annual Conference on Computer Science Logic (CSL) and the Twenty-Ninth Annual ACM/IEEE Symposium on Logic in Computer Science (LICS). (1-10).

    https://doi.org/10.1145/2603088.2603163

  • (2014). System level synthesis of many-core architectures using parallel stream rewriting 2014 Electronic System Level Synthesis Conference (ESLsyn). 10.1109/ESLsyn.2014.6850388. 979-10-92279-03-0. (1-6).

    http://ieeexplore.ieee.org/document/6850388/

  • Haubelt C, Ludwig F, Middendorf L and Zebelein C. (2013). Using stream rewriting for mapping and scheduling data flow graphs onto many-core architectures 2013 Asilomar Conference on Signals, Systems and Computers. 10.1109/ACSSC.2013.6810532. 978-1-4799-2390-8. (1431-1435).

    http://ieeexplore.ieee.org/document/6810532/

  • Delgado J. (2013). Architectural Styles for Distributed Interoperability. Information Resources Management Journal. 26:4. (40-65). Online publication date: 1-Oct-2013.

    https://doi.org/10.4018/irmj.2013100103

  • Morazán M. Beautiful Imperative Code. Essays Dedicated to Rinus Plasmeijer on the Occasion of His 61st Birthday on The Beauty of Functional Code - Volume 8106. (273-284).

    https://doi.org/10.1007/978-3-642-40355-2_19

  • Keller G, Chakravarty M, Leshchinskiy R, Lippmeier B and Peyton Jones S. (2012). Vectorisation avoidance. ACM SIGPLAN Notices. 47:12. (37-48). Online publication date: 17-Jan-2013.

    https://doi.org/10.1145/2430532.2364512

  • Delgado J. Bridging the SOA and REST Architectural Styles. Migrating Legacy Applications. 10.4018/978-1-4666-2488-7.ch012. (276-302).

    http://services.igi-global.com/resolvedoi/resolve.aspx?doi=10.4018/978-1-4666-2488-7.ch012

  • St-Amour V, Tobin-Hochstadt S and Felleisen M. (2012). Optimization coaching. ACM SIGPLAN Notices. 47:10. (163-178). Online publication date: 15-Nov-2012.

    https://doi.org/10.1145/2398857.2384629

  • St-Amour V, Tobin-Hochstadt S and Felleisen M. Optimization coaching. Proceedings of the ACM international conference on Object oriented programming systems languages and applications. (163-178).

    https://doi.org/10.1145/2384616.2384629

  • Keller G, Chakravarty M, Leshchinskiy R, Lippmeier B and Peyton Jones S. Vectorisation avoidance. Proceedings of the 2012 Haskell Symposium. (37-48).

    https://doi.org/10.1145/2364506.2364512

  • Dekate C, Anderson M, Brodowicz M, Kaiser H, Adelstein-Lelbach B and Sterling T. (2012). Improving the scalability of parallel N -body applications with an event-driven constraint-based execution model . The International Journal of High Performance Computing Applications. 10.1177/1094342012440585. 26:3. (319-332). Online publication date: 1-Aug-2012.

    http://journals.sagepub.com/doi/10.1177/1094342012440585

  • Kick R. (2012). Computer science principles at Newbury Park High School. ACM Inroads. 3:2. (75-77). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2189835.2189859

  • Simon B and Cutts Q. (2012). How to implement a peer instruction-designed CS principles course. ACM Inroads. 3:2. (72-74). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2189835.2189858

  • Hawthorne E. (2012). Infusing software assurance in computing curricula. ACM Inroads. 3:2. (18-20). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2189835.2189844

  • Clear T. (2012). The hermeneutics of program comprehension. ACM Inroads. 3:2. (6-7). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2189835.2189837

  • Midtgaard J. (2012). Control-flow analysis of functional programs. ACM Computing Surveys. 44:3. (1-33). Online publication date: 1-Jun-2012.

    https://doi.org/10.1145/2187671.2187672

  • Brinke S, Bockisch C and Bergmans L. Reuse of continuation-based control-flow abstractions. Proceedings of the 2nd workshop on Free composition @ onward! 2011. (13-18).

    https://doi.org/10.1145/2089172.2089176

  • Zhao X and Jamali N. Supporting Deadline Constrained Distributed Computations on Grids. Proceedings of the 2011 IEEE/ACM 12th International Conference on Grid Computing. (165-172).

    https://doi.org/10.1109/Grid.2011.29

  • McCreight A, Chevalier T and Tolmach A. (2010). A certified framework for compiling and executing garbage-collected languages. ACM SIGPLAN Notices. 45:9. (273-284). Online publication date: 27-Sep-2010.

    https://doi.org/10.1145/1932681.1863584

  • McCreight A, Chevalier T and Tolmach A. A certified framework for compiling and executing garbage-collected languages. Proceedings of the 15th ACM SIGPLAN international conference on Functional programming. (273-284).

    https://doi.org/10.1145/1863543.1863584

  • Rompf T, Maier I and Odersky M. (2009). Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform. ACM SIGPLAN Notices. 44:9. (317-328). Online publication date: 31-Aug-2009.

    https://doi.org/10.1145/1631687.1596596

  • Rompf T, Maier I and Odersky M. Implementing first-class polymorphic delimited continuations by a type-directed selective CPS-transform. Proceedings of the 14th ACM SIGPLAN international conference on Functional programming. (317-328).

    https://doi.org/10.1145/1596550.1596596

  • Van bakel S and Lescanne P. (2008). Computation with classical sequents. Mathematical Structures in Computer Science. 18:3. (555-609). Online publication date: 1-Jun-2008.

    https://doi.org/10.1017/S0960129508006762

  • deLorimier M, Kapre N, Mehta N, Rizzo D, Eslick I, Rubin R, E. Uribe T, Knight T and DeHon A. GraphStep. Proceedings of the 14th Annual IEEE Symposium on Field-Programmable Custom Computing Machines. (143-151).

    https://doi.org/10.1109/FCCM.2006.45

  • van Bakel S, Lengrand S and Lescanne P. The language X. Proceedings of the 9th Italian conference on Theoretical Computer Science. (81-96).

    https://doi.org/10.1007/11560586_8

  • Bergeron E, Saint-Mleux X, Feeley M and David J. High Level Synthesis for Data-Driven Applications. Proceedings of the 16th IEEE International Workshop on Rapid System Prototyping. (54-60).

    https://doi.org/10.1109/RSP.2005.26

  • Amtoft T and Muller R. (2003). Inferring annotated types for inter-procedural register allocation with constructor flattening. ACM SIGPLAN Notices. 38:3. (86-97). Online publication date: 18-Mar-2003.

    https://doi.org/10.1145/640136.604186

  • Amtoft T and Muller R. Inferring annotated types for inter-procedural register allocation with constructor flattening. Proceedings of the 2003 ACM SIGPLAN international workshop on Types in languages design and implementation. (86-97).

    https://doi.org/10.1145/604174.604186

  • Danvy O and Schultz U. (2002). Lambda-Lifting in Quadratic Time. Functional and Logic Programming. 10.1007/3-540-45788-7_8. (134-151).

    http://link.springer.com/10.1007/3-540-45788-7_8

  • Danvy O and Nielsen L. Defunctionalization at work. Proceedings of the 3rd ACM SIGPLAN international conference on Principles and practice of declarative programming. (162-174).

    https://doi.org/10.1145/773184.773202

  • Shao Z and Appel A. (2000). Efficient and safe-for-space closure conversion. ACM Transactions on Programming Languages and Systems. 22:1. (129-161). Online publication date: 1-Jan-2000.

    https://doi.org/10.1145/345099.345125

  • Schweimeier R and Jeffrey A. (1999). A Categorical and Graphical Treatment of Closure Conversion. Electronic Notes in Theoretical Computer Science. 10.1016/S1571-0661(04)80090-2. 20. (481-511).

    https://linkinghub.elsevier.com/retrieve/pii/S1571066104800902

  • Morrisett G, Walker D, Crary K and Glew N. From system F to typed assembly language. Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (85-97).

    https://doi.org/10.1145/268946.268954

  • Thiemann P. (1998). Formalizing resource allocation in a compiler. Types in Compilation. 10.1007/BFb0055518. (178-193).

    http://link.springer.com/10.1007/BFb0055518

  • Morrisett G, Crary K, Glew N and Walker D. (1998). Stack-based Typed Assembly Language. Types in Compilation. 10.1007/BFb0055511. (28-52).

    http://link.springer.com/10.1007/BFb0055511

  • Appel A and Jim T. (1997). Shrinking lambda expressions in linear time. Journal of Functional Programming. 7:5. (515-540). Online publication date: 1-Sep-1997.

    https://doi.org/10.1017/S0956796897002839

  • Elliott C and Hudak P. (1997). Functional reactive animation. ACM SIGPLAN Notices. 32:8. (263-273). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258973

  • Claessen K, Vullinghs T and Meijer E. (1997). Structuring graphical paradigms in TkGofer. ACM SIGPLAN Notices. 32:8. (251-262). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258972

  • Hu Z, Iwasaki H, Takeichi M and Takano A. (1997). Tupling calculation eliminates multiple data traversals. ACM SIGPLAN Notices. 32:8. (164-175). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258964

  • Marlow S and Wadler P. (1997). A practical subtyping system for Erlang. ACM SIGPLAN Notices. 32:8. (136-149). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258962

  • Shao Z. (1997). Flexible representation analysis. ACM SIGPLAN Notices. 32:8. (85-98). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258958

  • Erwig M. (1997). Functional programming with graphs. ACM SIGPLAN Notices. 32:8. (52-65). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258955

  • Bell J, Bellegarde F and Hook J. (1997). Type-driven defunctionalization. ACM SIGPLAN Notices. 32:8. (25-37). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258953

  • Dimock A, Muller R, Turbak F and Wells J. (1997). Strongly typed flow-directed representation transformations (extended abstract). ACM SIGPLAN Notices. 32:8. (11-24). Online publication date: 1-Aug-1997.

    https://doi.org/10.1145/258949.258952

  • Dimock A, Muller R, Turbak F and Wells J. Strongly typed flow-directed representation transformations (extended abstract). Proceedings of the second ACM SIGPLAN international conference on Functional programming. (11-24).

    https://doi.org/10.1145/258948.258952

  • Boquist U and Johnsson T. (1997). The GRIN project: A highly optimising back end for lazy functional languages. Implementation of Functional Languages. 10.1007/3-540-63237-9_19. (58-84).

    http://link.springer.com/10.1007/3-540-63237-9_19

  • Sperber M and Thiemann P. (1996). Realistic compilation by partial evaluation. ACM SIGPLAN Notices. 31:5. (206-214). Online publication date: 1-May-1996.

    https://doi.org/10.1145/249069.231419

  • Sperber M and Thiemann P. Realistic compilation by partial evaluation. Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation. (206-214).

    https://doi.org/10.1145/231379.231419

  • Sperber M, Glück R and Thiemann P. Bootstrapping higher-order program transformers from interpreters. Proceedings of the 1996 ACM symposium on Applied Computing. (408-413).

    https://doi.org/10.1145/331119.331417

  • Minamide Y, Morrisett G and Harper R. Typed closure conversion. Proceedings of the 23rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (271-283).

    https://doi.org/10.1145/237721.237791

  • Appel A and Shao Z. (2008). Empirical and analytic study of stack versus heap cost for languages with closures. Journal of Functional Programming. 10.1017/S095679680000157X. 6:01. (47-74). Online publication date: 1-Jan-1996.

    http://www.journals.cambridge.org/abstract_S095679680000157X

  • Liang S and Hudak P. (1996). Modular denotational semantics for compiler construction. Programming Languages and Systems — ESOP '96. 10.1007/3-540-61055-3_39. (219-234).

    http://link.springer.com/10.1007/3-540-61055-3_39

  • Kishon A and Hudak P. (2008). Semantics directed program execution monitoring. Journal of Functional Programming. 10.1017/S0956796800001465. 5:4. (501-547). Online publication date: 1-Oct-1995.

    https://www.cambridge.org/core/product/identifier/S0956796800001465/type/journal_article

  • Shao Z and Appel A. (1995). A type-based compiler for standard ML. ACM SIGPLAN Notices. 30:6. (116-129). Online publication date: 1-Jun-1995.

    https://doi.org/10.1145/223428.207123

  • Liang S, Hudak P and Jones M. Monad transformers and modular interpreters. Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (333-343).

    https://doi.org/10.1145/199448.199528

  • Jones S and Santos A. (1995). Compilation by Transformation in the Glasgow Haskell Compiler. Functional Programming, Glasgow 1994. 10.1007/978-1-4471-3573-9_13. (184-204).

    http://link.springer.com/10.1007/978-1-4471-3573-9_13

  • Henglein F and Mairson H. (2008). The complexity of type inference for higher-order typed lambda calculi. Journal of Functional Programming. 10.1017/S0956796800001143. 4:04. (435-477). Online publication date: 1-Oct-1994.

    http://www.journals.cambridge.org/abstract_S0956796800001143

  • Greenberg A, Lubachevsky B, Nicol D and Wright P. (1994). Efficient massively parallel simulation of dynamic channel assignment schemes for wireless cellular communications. ACM SIGSIM Simulation Digest. 24:1. (187-197). Online publication date: 1-Jul-1994.

    https://doi.org/10.1145/195291.182589

  • Shao Z and Appel A. (1994). Space-efficient closure representations. ACM SIGPLAN Lisp Pointers. VII:3. (150-161). Online publication date: 1-Jul-1994.

    https://doi.org/10.1145/182590.156783

  • Wand M and Steckler P. Selective and lightweight closure conversion. Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (435-445).

    https://doi.org/10.1145/174675.178044

  • Diwan A, Tarditi D and Moss E. Memory subsystem performance of programs using copying garbage collection. Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (1-14).

    https://doi.org/10.1145/174675.174710

  • Okasaki C, Lee P and Tarditi D. (1994). Call-by-need and continuation-passing style. Lisp and Symbolic Computation. 7:1. (57-82). Online publication date: 1-Jan-1994.

    https://doi.org/10.1007/BF01019945

  • Pettersson M. (1994). RML — A new language and implementation for Natural Semantics. Programming Language Implementation and Logic Programming. 10.1007/3-540-58402-1_10. (117-131).

    http://link.springer.com/10.1007/3-540-58402-1_10

  • Sabry A and Felleisen M. (1993). Reasoning about programs in continuation-passing style. Lisp and Symbolic Computation. 6:3-4. (289-360). Online publication date: 1-Nov-1993.

    https://doi.org/10.1007/BF01019462

  • Nishizaki S. (1993). Programs with continuations and linear logic. Science of Computer Programming. 21:2. (165-190). Online publication date: 1-Oct-1993.

    https://doi.org/10.1016/0167-6423(93)90005-A

  • Harper R and Lillibridge M. Explicit polymorphism and CPS conversion. Proceedings of the 20th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (206-219).

    https://doi.org/10.1145/158511.158630

  • Giorgi J and Métayer D. (2009). Continuation-based compilation of functional languages for parallel machines. Mathematical Structures in Computer Science. 10.1017/S0960129500001547. 2:04. (393). Online publication date: 1-Dec-1992.

    http://www.journals.cambridge.org/abstract_S0960129500001547

  • Filinski A. Linear continuations. Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (27-38).

    https://doi.org/10.1145/143165.143174

  • Wadler P. The essence of functional programming. Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (1-14).

    https://doi.org/10.1145/143165.143169

  • Sabry A and Felleisen M. Reasoning about programs in continuation-passing style.. Proceedings of the 1992 ACM conference on LISP and functional programming. (288-298).

    https://doi.org/10.1145/141471.141563

  • MacLachlan R. The Python compiler for CMU Common Lisp. Proceedings of the 1992 ACM conference on LISP and functional programming. (235-246).

    https://doi.org/10.1145/141471.141558

  • Sabry A and Felleisen M. (1992). Reasoning about programs in continuation-passing style.. ACM SIGPLAN Lisp Pointers. V:1. (288-298). Online publication date: 1-Jan-1992.

    https://doi.org/10.1145/141478.141563

  • MacLachlan R. (1992). The Python compiler for CMU Common Lisp. ACM SIGPLAN Lisp Pointers. V:1. (235-246). Online publication date: 1-Jan-1992.

    https://doi.org/10.1145/141478.141558

  • Pettersson M. (1992). A term pattern-match compiler inspired by finite automata theory. Compiler Construction. 10.1007/3-540-55984-1_24. (258-270).

    http://link.springer.com/10.1007/3-540-55984-1_24

  • Moreau L. (1992). An operational semantics for a parallel functional language with continuations. PARLE '92 Parallel Architectures and Languages Europe. 10.1007/3-540-55599-4_102. (413-430).

    http://link.springer.com/10.1007/3-540-55599-4_102

  • Wand M. (1992). Correctness of procedure representations in higher-order assembly language. Mathematical Foundations of Programming Semantics. 10.1007/3-540-55511-0_15. (294-311).

    http://link.springer.com/10.1007/3-540-55511-0_15

  • Shivers O. (1991). The semantics of Scheme control-flow analysis. ACM SIGPLAN Notices. 26:9. (190-198). Online publication date: 1-Sep-1991.

    https://doi.org/10.1145/115866.115884

  • Reppy J. (1991). CML. ACM SIGPLAN Notices. 26:6. (293-305). Online publication date: 1-Jun-1991.

    https://doi.org/10.1145/113446.113470

  • Shivers O. The semantics of Scheme control-flow analysis. Proceedings of the 1991 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation. (190-198).

    https://doi.org/10.1145/115865.115884

  • Reppy J. CML. Proceedings of the ACM SIGPLAN 1991 conference on Programming language design and implementation. (293-305).

    https://doi.org/10.1145/113445.113470

  • Wegman M and Zadeck F. (1991). Constant propagation with conditional branches. ACM Transactions on Programming Languages and Systems. 13:2. (181-210). Online publication date: 1-Apr-1991.

    https://doi.org/10.1145/103135.103136

  • Duba B, Harper R and MacQueen D. Typing first-class continuations in ML. Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages. (163-173).

    https://doi.org/10.1145/99583.99608

  • Consel C and Danvy O. (1991). For a better support of static data flow. Functional Programming Languages and Computer Architecture. 10.1007/3540543961_24. (496-519).

    http://link.springer.com/10.1007/3540543961_24

  • Appel A and MacQueen D. (1991). Standard ML of New Jersey. Programming Language Implementation and Logic Programming. 10.1007/3-540-54444-5_83. (1-13).

    http://link.springer.com/10.1007/3-540-54444-5_83

  • Appel A. (1990). A runtime system. Lisp and Symbolic Computation. 3:4. (343-380). Online publication date: 1-Oct-1990.

    https://doi.org/10.1007/BF01807697

  • Giorgi J and Le Métayer D. Continuation-based parallel implementation of functional programming languages. Proceedings of the 1990 ACM conference on LISP and functional programming. (209-217).

    https://doi.org/10.1145/91556.91648

  • Danvy O and Filinski A. Abstracting control. Proceedings of the 1990 ACM conference on LISP and functional programming. (151-160).

    https://doi.org/10.1145/91556.91622

  • Tolmach A and Appel A. Debugging standard ML without reverse engineering. Proceedings of the 1990 ACM conference on LISP and functional programming. (1-12).

    https://doi.org/10.1145/91556.91564

  • Wand M and Wang Z. Conditional lambda-theories and the verification of static properties of programs Fifth Annual IEEE Symposium on Logic in Computer Science. 10.1109/LICS.1990.113758. 0-8186-2073-0. (321-332).

    http://ieeexplore.ieee.org/document/113758/

  • Quillian M. (1961). Simulation of human understanding of language. Communications of the ACM. 4:9. (406). Online publication date: 1-Sep-1961.

    https://doi.org/10.1145/366696.366784

  • Laing R. (1961). Automata theory. Communications of the ACM. 4:9. (406). Online publication date: 1-Sep-1961.

    https://doi.org/10.1145/366696.366783