Publications

Matthew Fluet

Articles in Refereed Journals

Lars Bergstrom, Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Lazy Tree Splitting. The Journal of Functional Programming, 22(4—5):pages 382—483. Cambridge University Press, September 2012. doi:10.1017/S0956796812000172. [Published online: 15 August 2012; a preliminary version of this paper appeared at ICFP’10: The Fifteenth ACM SIGPLAN International Conference on Functional Programming; solicited as a Selected Paper of ICFP’10.] [ bib ]

Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Implicitly-threaded Parallelism in Manticore. The Journal of Functional Programming, 20(5—6):pages 537—576. Cambridge University Press, November 2010. doi:10.1017/S0956796810000201. [Published online: 27 January 2011; a preliminary version of this paper appeared at ICFP’08: The Thirteenth ACM SIGPLAN International Conference on Functional Programming; solicited as a Selected Paper of ICFP’08.] [ bib ]

Kevin Donnelly and Matthew Fluet. Transactional Events. The Journal of Functional Programming, 18(5—6):pages 649—706. Cambridge University Press, September 2008. doi:10.1017/S0956796808006916. [Published online: 30 October 2008; a preliminary version of this paper appeared at ICFP’06: The Eleventh ACM SIGPLAN International Conference on Functional Programming; solicited as a Selected Paper of ICFP’06.] [ bib ]

Amal Ahmed, Matthew Fluet, and Greg Morrisett. L3: A Linear Language with Locations. Fundamenta Informaticae, 77(4):pages 397—449. IOS Press, June 2007. http://iospress.metapress.com/content/M581QJ0326367104. [A preliminary version of this paper appeared at TLCA’04: The Seventh International Conference on Typed Lambda Calculi and Applications; solicited as a Selected Paper of TLCA’04.] [ bib ]

Matthew Fluet and Riccardo Pucella. Phantom Types and Subtyping. The Journal of Functional Programming, 16(6):pages 751—791. Cambridge University Press, November 2006. doi:10.1017/S0956796806006046. [Published online: 09 June 2006; a preliminary version of this paper appeared at TCS’02: The Second IFIP International Conference on Theoretical Computer Science.] [ bib ]

Matthew Fluet and Greg Morrisett. Monadic Regions. The Journal of Functional Programming, 16(4—5):pages 485—545. Cambridge University Press, July 2006. doi:10.1017/S095679680600596X. [Published online: 10 August 2006; a preliminary version of this paper appeared at ICFP’04: The Ninth ACM SIGPLAN International Conference on Functional Programming; solicited as a Selected Paper of ICFP’04.] [ bib ]

Arthur T. Benjamin and Matthew T. Fluet. What’s Best? The American Mathematical Monthly, 107(6):pages 560—562. June-July 2000. doi:10.2307/2589353. [ bib ]

Papers in Refereed Conference and Workshop Proceedings

Umut Acar, Matthew Fluet, Adrien Guatto, Ram Raghunathan, and Sam Westrick. Hierarchical Memory Management for Mutable State. In PPoPP’18: Proceedings of the 23rd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming. ACM Press, February 2018. [20% acceptance rate.] [ bib ]

Matthew Le, Ryan Yates, and Matthew Fluet. Revisiting Software Transactional Memory in Haskell. In Haskell’16: Proceedings of the 9th International Symposium on Haskell, pages 105—113. ACM Press, September 2016. doi:10.1145/2976002.2976020. [29% acceptance rate.] [ bib ]

Matthew Le and Matthew Fluet. Partial Aborts for Transactions via First-Class Continuations. In ICFP’15: Proceedings of the 20th ACM SIGPLAN International Conference on Functional Programming, pages 230—242. ACM Press, September 2015. doi:10.1145/2784731.2784736. [29% acceptance rate.] [ bib ]

Umut A. Acar, Guy Blelloch, Matthew Fluet, Stefan K. Muller, and Ram Raghunathan. Coupling Memory and Computation for Locality Management. In SNAPL’15: First Summit on Advances in Programming Languages, volume 32 of Leibniz International Proceedings in Informatics (LIPIcs), pages 1—14. Schloss Dagstuhl—Leibniz-Zentrum fuer Informatik, May 2015. doi:10.4230/LIPIcs.SNAPL.2015.1. [ bib ]

Connor Adsit and Matthew Fluet. An Efficient Type- and Control-Flow Analysis for System F. In IFL’14: Proceedings of the 26th International Symposium on Implementation and Application of Functional Languages, pages 3:1—3:14. ACM Press, October 2014. doi:10.1145/2746325.2746327. [ bib ]

Matthew Le and Matthew Fluet. Combining Shared State with Speculative Parallelism in a Functional Language. In IFL’14: Proceedings of the 26th International Symposium on Implementation and Application of Functional Languages, pages 2:1—2:10. ACM Press, October 2014. doi:10.1145/2746325.2746328. [ bib ]

Lars Bergstrom, Matthew Fluet, Matthew Le, John Reppy, and Nora Sandler. Practical and Effective Higher-Order Optimizations. In ICFP’14: Proceedings of the Ninteenth ACM SIGPLAN International Conference on Functional Programming, pages 81—93. ACM Press, September 2014. doi:10.1145/2628136.2628153. [33% acceptance rate.] [ bib ]

Matthew Fluet. A Type- and Control-Flow Analysis for System F. In IFL’12: Revised Selected Papers of the 24th Symposium on Implementation and Application of Functional Languages, volume 8241 of Lecture Notes in Computer Science, pages 122—139. Springer-Verlag, September 2013. doi:10.1007/978-3-642-41582-1_8. [ bib ]

Lars Bergstrom, Matthew Fluet, Mike Rainey, John Reppy, Stephen Rosen, and Adam Shaw. Data-Only Flattening for Nested Data Parallelism. In PPoPP’13: Proceedings of the 18th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, pages 81—92. ACM Press, February 2013. doi:10.1145/2442516.2442525. [18% acceptance rate.] [ bib ]

Edward Amsden and Matthew Fluet. Fairness for Transactional Events. In IFL’11: Revised Selected Papers of the 23rd Symposium on Implementation and Application of Functional Languages, volume 7257 of Lecture Notes in Computer Science, pages 17—34. Springer-Verlag, August 2012. doi:10.1007/978-3-642-34407-7_2. [ bib ]

Sven Auhagen, Lars Bergstrom, Matthew Fluet, and John Reppy. Garbage Collection for Multicore NUMA Machines. In MSPC’11: Proceedings of the 2011 ACM SIGPLAN Workshop on Memory Systems Performance and Correctness, pages 51—57. ACM Press, June 2011. doi:10.1145/1988915.1988929. [33% acceptance rate.] [ bib ]

Lars Bergstrom, Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Lazy Tree Splitting. In ICFP’10: Proceedings of the Fifteenth ACM SIGPLAN International Conference on Functional Programming, pages 93—104. ACM Press, September 2010. doi:10.1145/1863543.1863558. [33% acceptance rate; solicited for a special issue of Journal of Functional Programming: Selected Papers of ICFP’10.] [ bib ]

Ruy Ley-Wild, Umut Acar, and Matthew Fluet. A Cost Semantics for Self-Adjusting Computation. In POPL’09: Proceedings of the 36th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, pages 186—199. ACM Press, January 2009. doi:10.1145/1480881.1480907. [23% acceptance rate.] [ bib ]

Lukasz Ziarek, Suresh Jagannathan, Matthew Fluet, and Umut Acar. Speculative N-Way Barriers. In DAMP’09: Proceedings of the Workshop on Declarative Aspects of Multicore Programming, pages 1—12. ACM Press, January 2009. doi:10.1145/1481839.1481841. [ bib ]

Matthew Fluet, Mike Rainey, and John Reppy. A Scheduling Framework for General-purpose Parallel Languages. In ICFP’08: Proceedings of the Thirteenth ACM SIGPLAN International Conference on Functional Programming, pages 241—252. ACM Press, September 2008. doi:10.1145/1411204.1411239. [33% acceptance rate.] [ bib ]

Matthew Fluet, Mike Rainey, John Reppy, and Adam Shaw. Implicitly-threaded Parallelism in Manticore. In ICFP’08: Proceedings of the Thirteenth ACM SIGPLAN International Conference on Functional Programming, pages 119—130. ACM Press, September 2008. doi:10.1145/1411204.1411224. [33% acceptance rate; solicited for a special issue of Journal of Functional Programming: Selected Papers of ICFP’08.] [ bib ]

Ruy Ley-Wild, Matthew Fluet, and Umut Acar. Compiling Self-Adjusting Programs with Continuations. In ICFP’08: Proceedings of the Thirteenth ACM SIGPLAN International Conference on Functional Programming, pages 321—334. ACM Press, September 2008. doi:10.1145/1411204.1411249. [33% acceptance rate.] [ bib ]

Matthew Fluet, Nic Ford, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. Status Report: The Manticore Project. In ML’07: Proceedings of the ACM SIGPLAN Workshop on ML, pages 15—24. ACM Press, October 2007. doi:10.1145/1292535.1292539. [ bib ]

Matthew Fluet, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. Manticore: A Heterogeneous Parallel Language. In DAMP’07: Proceedings of the Workshop on Declarative Aspects of Multicore Programming, pages 37—44. ACM Press, January 2007. doi:10.1145/1248648.1248656. [ bib ]

Kevin Donnelly and Matthew Fluet. Transactional Events. In ICFP’06: Proceedings of the Eleventh ACM SIGPLAN International Conference on Functional Programming, pages 124—135. ACM Press, September 2006. doi:10.1145/1159803.1159821. [32% acceptance rate; solicited for a special issue of Journal of Functional Programming: Selected Papers of ICFP’06.] [ bib ]

Matthew Fluet, Greg Morrisett, and Amal Ahmed. Linear Regions Are All You Need. In ESOP’06: Proceedings of the Fifteenth European Symposium on Programming, volume 3924 of Lecture Notes in Computer Science, pages 7—21. Springer-Verlag, March 2006. doi:10.1007/11693024_2. [24% acceptance rate.] [ bib ]

Matthew Fluet and Riccardo Pucella. Practical Datatype Specializations with Phantom Types and Recursion Schemes. In ML’05: Proceedings of the ACM SIGPLAN Workshop on ML, pages 203—228. Elsevier, March 2006. doi:10.1016/j.entcs.2005.11.046. [ bib ]

Amal Ahmed, Matthew Fluet, and Greg Morrisett. A Step-Indexed Model of Substructural State. In ICFP’05: Proceedings of the Tenth ACM SIGPLAN International Conference on Functional Programming, pages 78—91. ACM Press, September 2005. doi:10.1145/1086365.1086376. [30% acceptance rate.] [ bib ]

Greg Morrisett, Amal Ahmed, and Matthew Fluet. L3: A Linear Language with Locations. In TLCA’04: Proceedings of the Seventh International Conference on Typed Lambda Calculi and Applications, volume 3461 of Lecture Notes in Computer Science, pages 293—307. Springer-Verlag, April 2005. doi:10.1007/11417170_22. [Solicited for a special issue of Fundamenta Informaticae: Selected Papers of TLCA’05] [ bib ]

Matthew Fluet and Greg Morrisett. Monadic Regions. In ICFP’04: Proceedings of the Ninth ACM SIGPLAN International Conference on Functional Programming, pages 103—114. ACM Press, September 2004. doi:10.1145/1016850.1016867. [26% acceptance rate; solicited for a special issue of Journal of Functional Programming: Selected Papers of ICFP’04.] [ bib ]

Matthew Fluet and Riccardo Pucella. Phantom Types and Subtyping. In TCS’02: Proceedings of the Second IFIP International Conference on Theoretical Computer Science, pages 442—460. Kluwer Academic Press, August 2002. doi:10.1007/978-0-387-35608-2_37. [ bib ]

Matthew Fluet and Stephen Weeks. Contification Using Dominators. In ICFP’01: Proceedings of the Sixth ACM SIGPLAN International Conference on Functional Programming, pages 2—13. ACM Press, September 2001. doi:10.1145/507635.507639. [35% acceptance rate.] [ bib ]

Articles in Collections / Chapters in Books

Matthew Fluet, Lars Bergstrom, Nic Ford, Mike Rainey, John Reppy, Adam Shaw, and Yingqi Xiao. Programming in Manticore, a Heterogenous Parallel Functional Language. In Zoltán Horváth, Rinus Plasmeijer, and Viktória Zsók, editors, CEFP’09: Revised Selected Lectures of the Third Central European Functional Programming Summer School, volume 6299 of Lecture Notes in Computer Science, pages 94—145. Springer-Verlag, December 2010. doi:10.1007/978-3-642-17685-2_4. [ bib ]

Theses, Technical Reports, and Lightly or Unrefereed Publications

Matthew Fluet. The Manticore Project. In FHPC’13: Proceedings of the 2nd ACM SIGPLAN Workshop on Functional High-Performance Computing, pages 1—2. ACM Press, September 2013. doi:10.1145/2502323.2508150. [Unrefereed; invited talk abstract.] [ bib ]

Matthew Fluet. A Type- and Control-Flow Analysis for System F. Technical Report 1850/15920, Rochester Institute of Technology, February 2013. hdl:1850/15920. [ bib ]

Edward Amsden and Matthew Fluet. Fairness for Transactional Events. Technical Report 1850/14852, Rochester Institute of Technology, March 2012. hdl:1850/14852. [ bib ]

Jim Allen, Zena Ariola, Pierre-Louis Curien, Matthew Fluet, Jeff Foster, Dan Grossman, Robert Harper, Hugo Herbelin, Yannis Smaragdakis, David Walker, and Steve Zdancewic. An Overview of the Oregon Programming Languages Summer School. SIGPLAN Notices, 44(11):pages 1—3. ACM Press, June 2010. doi:10.1145/1816027.1816029. [Unrefereed.] [ bib ]

Ruy Ley-Wild, Umut Acar, and Matthew Fluet. A Cost Semantics for Self-Adjusting Computation. Technical Report CMU-CS-08-141, Carnegie Mellon University, July 2008. http://reports-archive.adm.cs.cmu.edu/anon/2008/CMU-CS-08-141.pdf. [ bib ]

Matthew Fluet. Monadic and Substructural Type Systems for Region-Based Memory Management. Ph.d. dissertation (computer science), Cornell University, November 2006. hdl:1813/3773. [ bib | pdf (double) | pdf (single) ]

Amal Ahmed, Matthew Fluet, and Greg Morrisett. A Step-Indexed Model of Substructural State. Technical Report TR-16-05, Harvard University, July 2005. ftp://ftp.deas.harvard.edu/techreports/tr-16-05.pdf. [ bib ]

Henry Cejtin, Matthew Fluet, Suresh Jagannathan, and Stephen Weeks. Formal Specification of the ML Basis System, January 2005. http://mlton.org/MLBasis.attachments/mlb-formal.pdf. [Unrefereed.] [ bib ]

Amal Ahmed, Matthew Fluet, and Greg Morrisett. L3: A Linear Language with Locations. Technical Report TR-24-04, Harvard University, July 2004. ftp://ftp.deas.harvard.edu/techreports/tr-24-04.pdf. [ bib ]

Matthew Fluet. Monadic Regions: Formal Type Soundness and Correctness. Technical Report TR2004-1936, Cornell University, April 2004. hdl:1813/5647. [ bib ]

Stuart Allen, Bob Constable, and Matthew Fluet. Expressing and Implementing the Computational Content Implicit in Smullyan’s Account of Boolean Valuations. Technical Report TR2004-1933, Cornell University, March 2004. hdl:1813/5644. [ bib ]

Matthew Fluet. Monadic Regions. In SPACE’04: Informal Proceedings of the Second ACM SIGPLAN Workshop on Semantics, Program Analysis, and Computing Environments for Memory Management. January 2004. http://www.diku.dk/topps/space2004/space_final/fluet.pdf. [Lightly refereed.] [ bib ]

Matthew Fluet and Dan Wang. Implementation and Performance Evaluation of a Safe Runtime System in Cyclone. In SPACE’04: Informal Proceedings of the Second ACM SIGPLAN Workshop on Semantics, Program Analysis, and Computing Environments for Memory Management. January 2004. http://www.diku.dk/topps/space2004/space_final/fluet-wang.pdf. [Lightly refereed.] [ bib ]

Arthur T. Benjamin, Matthew T. Fluet, and Mark L. Huber. Optimal Token Allocations in Solitaire Knock ’m Down. The Electronic Journal of Combinatorics, 8(2):page #R2. August 2001. http://www.combinatorics.org/ojs/index.php/eljc/article/view/v8i2r2. [Lightly refereed.] [ bib ]

Arthur T. Benjamin and Matthew T. Fluet. A Rational Solution to Cootie. The College Mathematics Journal, 31(2):pages 124—125. March 2000. doi:10.2307/2687584. [Lightly refereed.] [ bib ]

Dominic Mazzoni, Matthew Fluet, and Joel Miller. Deep Impact. The UMAP Journal, 20(3):pages 211—224. Fall 1999. http://www.comap.com/product/?idx=459. [Lightly refereed.] [ bib ]

Matthew T. Fluet. Searching for Optimal Strategies in Knock ’m Down. B.s. senior thesis (mathematics, Harvey Mudd College, May 1999. [ bib | pdf ]

Arthur T. Benjamin and Matthew T. Fluet. The Best Way to Knock ’m Down. The UMAP Journal, 20(1):pages 11—20. Spring 1999. http://www.comap.com/product/?idx=687. [Lightly refereed.] [ bib ]

Arthur T. Benjamin and Matthew T. Fluet. Bounds on a Bug. The UMAP Journal, 20(1):pages 5—9. Spring 1999. http://www.comap.com/product/?idx=656. [Lightly refereed.] [ bib ]