Jonathan Aldrich

• Home
• Publications
• Teaching
• Talks

See also a list of papers by others that I think are fundamental to my research area. Also a list of case study papers.

Book Chapters

• Checking Concurrent Typestate with Access Permissions in Plural: A Retrospective. Kevin Bierhoff, Nels E. Beckman and Jonathan Aldrich. In Peri L. Tarr and Alexander L. Wolf, editors, Engineering of Software: The Continuing Contributions of Leon J. Osterweil, pages 35-48. Springer, 2011.
• Practical Exception Specifications. Donna Malayeri and Jonathan Aldrich. In Christophe Dony, Jørgen Lindskov Knudsen, Alexander B. Romanovsky, and Anand Tripathi, editors, Advanced Topics in Exception Handling Techniques, volume 4119 of Lecture Notes in Computer Science, pages 200-220. Springer, 2006.

Refereed Journal Publications

• Sound Gradual Verification with Symbolic Execution. Conrad Zimmerman, Jenna DiVincenzo, and Jonathan Aldrich. Proc. ACM Program. Lang. 8, POPL, Article 85, January 2024.
• Plan B - Design Methodology for Cyber-Physical Systems Robust to Timing Failures. Mohammad Khayatian, Mohammadreza Mehrabian, Edward Andert, Reese Grimsley, Kyle Liang, Yi Hu, Ian McCormack, Carlee Joe-Wong, Jonathan Aldrich, Bob Iannucci, and Aviral Shrivastava. Transactions on Cyber-Physical Systems, Volume 6 Issue 3, July 2022.
• Bounded Abstract Effects. Darya Melicher, Anlun Xu, Valerie Zhao, Alex Potanin, and Jonathan Aldrich. ACM Trans. Program. Lang. Syst. (TOPLAS) 44, 1, Article 5, March 2022
• PLIERS: A Process that Integrates User-Centered Methods into Programming Language Design. Michael Coblenz, Gauri Kambhatla, Paulette Koronkevich, Jenna L. Wise, Celeste Barnaby, Joshua Sunshine, Jonathan Aldrich, and Brad A. Myers. ACM Transactions on Computer-Human Interaction, 2021.
• Obsidian: Typestate and Assets for Safer Blockchain Programming. Michael Coblenz, Reed Oei, Tyler Etzel, Paulette Koronkevich, Yannick Bloem, Brad A. Myers, Joshua S. Sunshine, and Jonathan Aldrich. ACM Trans. Program. Lang. Syst. (TOPLAS) 42, 3, Article 14, December 2020.
• Gradual verification of recursive heap data structures. Jenna Wise, Johannes Bader, Cameron Wong, Jonathan Aldrich, Éric Tanter, and Joshua Sunshine. Proc. ACM Program. Lang. 4, OOPSLA, Article 228, November 2020
• Can advanced type systems be usable? An empirical study of ownership, assets, and typestate in Obsidian. Michael Coblenz, Jonathan Aldrich, Joshua Sunshine, and Brad A. Myers. Proc. ACM Program. Lang. 4, OOPSLA, Article 132, November 2020
• Penrose: from mathematical notation to beautiful diagrams. Katherine Ye, Wode Ni, Max Krieger, Dor Ma'ayan, Jenna Wise, Jonathan Aldrich, Joshua Sunshine, and Keenan Crane. ACM Trans. Graph., Vol. 39, No. 4, Article 144, 2020.
• Decidable Subtyping for Path Dependent Types. Julian MacKay, Alex Potanin, Jonathan Aldrich, and Lindsay Groves. Proc. ACM Program. Lang. 4(POPL):66, 2020.
• Model-Based Adaptation for Robotics Software. Jonathan Aldrich, David Garlan, Christian Kästner, Claire Le Goues, Anahita Mohseni-Kabir, Ivan Ruchkin, Selva Samuel, Bradley R. Schmerl, Christopher Steven Timperley, Manuela Veloso, Ian Voysey, Joydeep Biswas, Arjun Guha, Jarrett Holtz, Javier Camara, Pooyan Jamshidi. IEEE Software 36.2 (83-90), 2019.
• Reasonable Programmable Literal Notation. Cyrus Omar and Jonathan Aldrich. Proc. ACM Program. Lang. 2(ICFP):106, 2018.
• Foundations of Typestate-Oriented Programming. Ronald Garcia, Éric Tanter, Roger Wolff, and Jonathan Aldrich. Transactions on Programming Languages and Systems 36(4) article 12, 2014.
• AEminium: A Permission Based Concurrent-by-Default Programming Language Approach. Sven Stork, Karl Naden, Joshua Sunshine, Manuel Mohr, Alcides Fonseca, Paulo Marques, and Jonathan Aldrich. Transactions on Programming Languages and Systems 36(1) article 2, 2014.
• A Case Study on the Lightweight Verification of a Multi-Task Threaded Task Server. Nestor Catano, Ijaz Ahmed, Radu Siminiceanu, and Jonathan Aldrich. Science of Computer Programming 80(A):169-187, 2014.
• Differencing and Merging of Architectural Views. Marwan Abi-Antoun, Jonathan Aldrich, Nagi Nahas, Bradley Schmerl, and David Garlan. Automated Software Engineering Journal 15(1):35-74, 2008.
• A Case Study in Re-engineering to Enforce Architectural Control Flow and Data Sharing. Marwan Abi-Antoun, Jonathan Aldrich, and Wesley Coelho. Journal of Systems and Software 80(2):240-264, February 2007.
• Discovering Architectures from Running Systems. Bradley Schmerl, Jonathan Aldrich, David Garlan, Rick Kazman, and Hong Yan. IEEE Transactions on Software Engineering 32(7):454-466, July 2006.
• Comprehensive Synchronization Elimination for Java. Jonathan Aldrich, Emin Gun Sirer, Craig Chambers, and Susan Eggers. Science of Computer Programming 47(2-3):91-120, May-June 2003.

Refereed Conference Publications

1. Derivations with Holes for Concept-Based Program Synthesis. João Costa Seco, Jonathan Aldrich, Luís Carvalho, Bernardo Toninho, and Carla Ferreira. Proc. Onward!, 2022.
2. Gradual Program Analysis for Null Pointers. Sam Estep, Jenna Wise, Jonathan Aldrich, Éric Tanter, Johannes Bader, and Joshua Sunshine. Proc. European Conference on Object-Oriented Programming (ECOOP), 2021.
3. Facilitating Connector Evolution With Architecture-Centric Development. Selva Samuel and Jonathan Aldrich. Short Technical Track Paper, Proc. International Conference on Software Architecture (ICSA), March 2021.
4. A Case Study in Language-Based Security: Building an I/O Library for Wyvern. Jennifer Fish, Darya Melicher, and Jonathan Aldrich. Onward! 2020.
5. Syntactically Restricting Bounded Polymorphism for Decidable Subtyping. Julian MacKay, Alex Potanin, Jonathan Aldrich, and Lindsay Groves. Asian Symposium on Programming Languages and Systems (APLAS), 2020.
6. Interdisciplinary Programming Language Design. Michael Coblenz, Jonathan Aldrich, Brad A. Myers, and Joshua Sunshine. In Onward! Essays, 2018.
7. Capabilities: Effects for Free. Aaron Craig, Alex Potanin, Lindsay Groves, and Jonathan Aldrich. Proc. International Conference on Formal Engineering Methods (ICFEM), 2018.
8. Gradual Program Verification. Johannes Bader, Jonathan Aldrich, and Éric Tanter. Proc. VMCAI, January 2018.
9. The Implementation of Object Propositions: the Oprop Verification Tool. Ligia Nistor and Jonathan Aldrich. Proc. Formal Aspects of Component Software (FACS), 2017.
10. A Capability-Based Module System for Authority Control. Darya Melicher, Yangqingwei Shi, Alex Potanin, and Jonathan Aldrich. Proc. European Conference on Object-Oriented Programming (ECOOP), June 2017.
11. Glacier: Transitive Class Immutability for Java. Michael Coblenz, Whitney Nelson, Jonathan Aldrich, Brad Myers and Joshua Sunshine. Proc. International Conference on Software Engineering (ICSE), Buenos Aires, Argentina, May 20-28, 2017.
12. Toward Semantic Foundations for Program Editors. Cyrus Omar, Ian Voysey, Michael Hilton, Joshua Sunshine, Claire Le Goues, Jonathan Aldrich and Matthew A. Hammer. Proc. Summit on Advances in Programming Languages (SNAPL), May 2017.
13. Hazelnut: A Bidirectionally Typed Structure Editor Calculus. Cyrus Omar, Ian Voysey, Michael Hilton, Jonathan Aldrich, and Matthew A. Hammer. Proc. Principles of Programming Languages (POPL), 2017.
14. Programmable Semantic Fragments: The Design and Implementation of typy. Cyrus Omar and Jonathan Aldrich. Proc. Generative Programming: Concepts & Experiences (GPCE), 2016.
15. Software Development Practices, Barriers in the Field and the Relationship to Software Quality. Beth Yost, Michael Coblenz, Brad Myers, Joshua Sunshine, Jonathan Aldrich, Sam Weber, Forrest Shull, Matthew Patron, Melissa Heeren, Shelley Krueger, and Mark Pfaff. Proc. Empirical Software Engineering and Measurement (ESEM), 2016.
16. Composing Interfering Abstract Protocols. Filipe Militão, Jonathan Aldrich, and Luís Caires. Proc. European Conference on Object-Oriented Programming, 2016.
17. Exploring Language Support for Immutability. Michael Coblenz, Joshua Sunshine, Jonathan Aldrich, Brad Myers, Sam Weber, and Forrest Shull. Proc. International Conference on Software Engineering (ICSE), 2016.
18. Inter-app Communication in Android: Developer Challenges. Waqar Ahmad, Christian Kästner, Joshua Sunshine, and Jonathan Aldrich. Proc. Mining Software Repositories (MSR), 2016.
19. Cooperative Exceptions for Concurrent Objects. Bruno Cabral, Alcides Fonseca, Paulo Marques, and Jonathan Aldrich. Proc. 21st IEEE Pacific Rim International Symposium on Dependable Computing (PRDC), 2015.
20. A Course-Based Usability Analysis of Cilk Plus and OpenMP. Michael Coblenz, Robert Seacord, Brad Myers, Joshua Sunshine, and Jonathan Aldrich. Visual Languages and Human-Centric Computing (VL/HCC), 2015.
21. A Theory of Tagged Objects. Joseph Lee, Jonathan Aldrich, Troy Shaw, and Alex Potanin. Proc. European Conference on Object-Oriented Programming (ECOOP), 2015.
22. Composable and Hygienic Typed Syntax Macros. Cyrus Omar, Chenglong Wang, and Jonathan Aldrich. Proc. Symposium on Applied Computing (SAC), 2015.
23. Searching the State Space: A Qualitative Study of API Protocol Usability. Joshua Sunshine, James Herbsleb and Jonathan Aldrich. Proc. International Conference on Program Comprehension (ICPC), 2015.
24. Collaborative Infrastructure for Test-Driven Scientific Model Validation. Cyrus Omar, Jonathan Aldrich, and Richard Gerkin. Proc. International Conference on Software Engineering, New Ideas and Results track (ICSE NIER), 2014.
25. Structuring Documentation to Support State Search: A Laboratory Experiment about Protocol Programming. Joshua Sunshine, James Herbsleb, and Jonathan Aldrich. Proc. European Conference on Object-Oriented Programming, 2014.
26. Rely-Guarantee Protocols. Filipe Militão, Jonathan Aldrich, and Luís Caires. Proc. European Conference on Object-Oriented Programming, 2014.
27. Safely Composable Type-Specific Languages. Cyrus Omar, Darya Kurilova, Ligia Nistor, Benjamin Chung, Alex Potanin, and Jonathan Aldrich. Proc. European Conference on Object-Oriented Programming, 2014.
28. In-Nimbo Sandboxing. Michael Maass, Jonathan Aldrich, and William Scherlis. Proc. Science of Security (HotSOS), 2014.
29. Object Propositions. Ligia Nistor, Jonathan Aldrich, Stephanie Balzer and Hannes Mehnert. In Formal Methods, 2014.
30. The Power of Interoperability: Why Objects Are Inevitable. Jonathan Aldrich. In Onward! Essays, 2013. Presentation available in PDF, PPTX.
31. Introducing Tool-Supported Architecture Review into Software Design Education. Yuanfang Cai, Rick Kazman, Ciera Jaspan, and Jonathan Aldrich. In Proceedings of the Conference on Software Engineering Education and Training (CSEE&T), 2013.
32. Statically Checking API Protocol Conformance with Mined Multi-Object Specifications. Michael Pradel, Ciera Jaspan, Jonathan Aldrich, and Thomas Gross. In Proceedings of the International Conference on Software Engineering (ICSE '12), 2012.
33. Verification of Snapshotable Trees using Access Permissions and Typestate. Hannes Mehnert and Jonathan Aldrich. In Proceedings of TOOLS, 2012.
34. A Type System for Borrowing Permissions. Karl Naden, Robert Bocchino, Kevin Bierhoff, Jonathan Aldrich. In Proceedings of Principles of Programming Languages (POPL '12), 2012. The full proofs (and fixes to errata) are in CMU CS technical report CMU-CS-11-142.
35. First-Class State Change in Plaid. Joshua Sunshine, Karl Naden, Sven Stork, Jonathan Aldrich, and Éric Tanter. In Proceedings of Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA '11), 2011. errata.
36. Gradual Typestate. Roger Wolff, Ronald Garcia, Éric Tanter, and Jonathan Aldrich. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '11), 2011.
37. An Empirical Study of Object Protocols in the Wild. Nels E. Beckman, Duri Kim, and Jonathan Aldrich. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '11), 2011.
38. Permission-Based Programming Languages (NIER Track). Jonathan Aldrich, Ronald Garcia, Mark Hahnenberg, Manuel Mohr, Karl Naden, Darpan Saini, Sven Stork, Joshua Sunshine, Éric Tanter, and Roger Wolff. In Proceedings of the International Conference on Software Engineering (ICSE '11), New Ideas and Emerging Results Track, 2011.
39. Static Extraction and Conformance Analysis of Hierarchical Runtime Architectural Structure using Annotations. Marwan Abi-Antoun and Jonathan Aldrich. In Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA '09), 2009.
40. CZ: Multiple Inheritance without Diamonds. Donna Malayeri and Jonathan Aldrich. In Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA '09), 2009.
41. Typestate-Oriented Programming. Jonathan Aldrich, Joshua Sunshine, Darpan Saini, and Zachary Sparks. In Proceedings of Onward!, 2009. (presentation)
42. Concurrency by Default: Using Permissions to Express Dataflow in Stateful Programs. Sven Stork, Paulo Marques, and Jonathan Aldrich. In Proceedings of Onward!, 2009.
43. Checking Framework Interactions with Relationships. Ciera Jaspan and Jonathan Aldrich. In Proceedings of the European Conference on Object Oriented Programming (ECOOP '09), July 2009.
44. Practical API Protocol Checking with Access Permissions. Kevin Bierhoff, Nels E. Beckman, and Jonathan Aldrich. In Proceedings of the European Conference on Object Oriented Programming (ECOOP '09), July 2009.
45. Is Structural Subtyping Useful? An Empirical Study. Donna Malayeri and Jonathan Aldrich. In Proceedings of the European Symposium on Programming (ESOP '09), March 2009.
46. Verifying Correct Usage of Atomic Blocks and Typestate. Nels Beckman, Kevin Bierhoff, and Jonathan Aldrich. In Proceedings of the Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA '08), Nashville, TN, USA, October 2008.
47. Error Reporting Logic. Ciera Jaspan, Trisha Quan, and Jonathan Aldrich. In Proceedings of the International Conference on Automated Software Engineering, September 2008.
48. Integrating Nominal and Structural Subtyping. Donna Malayeri and Jonathan Aldrich. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '08), July 2008.
49. Checking Semantic Usage of Frameworks. Ciera Jaspan and Jonathan Aldrich. In Library Centric Software Design Symposium, 2007.
50. Using Types to Enforce Architectural Structure. Jonathan Aldrich. In Working International Conference on Software Architecture (WICSA '08), February 2008.
51. Modular Typestate Checking of Aliased Objects. Kevin Bierhoff and Jonathan Aldrich. In Object-Oriented Programming Systems, Languages, and Applications (OOPSLA '07), October 2007.
52. Differencing and Merging of Architectural Views. Marwan Abi-Antoun, Jonathan Aldrich, Nagi Nahas, Bradley Schmerl, and David Garlan. In Proceedings of the International conference on Automated Software Engineering, September 2006.
53. Lightweight Object Specification with Typestates. Kevin Bierhoff and Jonathan Aldrich. In Proceedings of Foundations of Software Engineering (FSE '05), September 2005.
54. Permission-Based Ownership: Encapsulating State in Higher-Order Typed Languages. Neel Krishnaswami and Jonathan Aldrich. In Proceedings of Programming Language Design and Implementation (PLDI '05), June 2005.
55. Open Modules: Modular Reasoning about Advice. Jonathan Aldrich. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '05), July 2005.
    • Important Note: The ABC compiler includes a module system inspired by my Open Modules proposal (Ongkingco et al., AOSD '06). However, this implementation does not enforce the critical property of Open Modules: that clients will not be affected by semantics-preserving changes to the implementation of a module. In order to obtain this property, it is important that clients of a module only advise exposed join points through named pointcuts in the module interface. External aspects must never refer to internal join points except through those names. I mention this here because the difference has led to some to think that Open Modules does not enforce this property.
56. Prototypes with Multiple Dispatch: An Expressive and Dynamic Object Model. Lee Salzman and Jonathan Aldrich. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '05), July 2005.
57. Ownership Domains: Separating Aliasing Policy from Mechanism. Jonathan Aldrich and Craig Chambers. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '04), June 2004.
58. DiscoTect: A System for Discovering Architectures from Running Systems. Hong Yan, David Garlan, Bradley Schmerl, Jonathan Aldrich, and Rick Kazman. In Proceedings of International Conference on Software Engineering (ICSE '04), May 2004.
59. Language Support for Connector Abstractions. Jonathan Aldrich, Vibha Sazawal, Craig Chambers, and David Notkin. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '03), July 2003.
60. Alias Annotations for Program Understanding. Jonathan Aldrich, Valentin Kostadinov, and Craig Chambers. In Proceedings of Object-Oriented Programming Systems, Languages, and Applications (OOPSLA '02), November 2002.
61. Architectural Reasoning in ArchJava. Jonathan Aldrich, Craig Chambers, and David Notkin. In Proceedings of the European Conference on Object-Oriented Programming (ECOOP '2), June 2002.
62. ArchJava: Connecting Software Architecture to Implementation. Jonathan Aldrich, Craig Chambers, and David Notkin. In Proceedings of the International Conference on Software Engineering (ICSE '02), May 2002.
63. Static Analyses for Eliminating Unnecessary Synchronization from Java Programs. Jonathan Aldrich, Craig Chambers, Emin Gun Sirer, and Susan Eggers. In Proceedings of the Sixth International Static Analysis Symposium (SAS '99), September 1999.

Workshop Papers, Demonstrations, and Technical Reports

1. A Study of Undefined Behavior Across Foreign Function Boundaries in Rust Libraries. Ian McCormack, Joshua Sunshine, and Jonathan Aldrich. arXiv:2404.11671, 2024.
2. "Against the Void": An Interview and Survey Study on How Rust Developers Use Unsafe Code. Ian McCormack, Tomas Dougan, Sam Estep, Hanan Hibshi, Jonathan Aldrich, Joshua Sunshine. arXiv:2404.02230, 2024.
3. Gradual Verification for Smart Contracts. Haojia Sun, Kunal Singh, Jan-Paul Ramos-Dála, Jonathan Aldrich, and Jenna DiVincenzo. In Workshop on Principles of Secure Compilation (PriSC), arXiv:2311.13351, 2023.
4. Latte: Lightweight Aliasing Tracking for Java. Conrad Zimmerman, Catarina Gamboa, Alcides Fonseca, and Jonathan Aldrich. Presented at International workshop on Aliasing, Capabilities and Ownership (IWACO) International Workshop on Human Aspects of Types and Reasoning Assistants, arXiv:2309.05637, 2023
5. Static Information Flow Control Made Simpler. Hemant Gouni and Jonathan Aldrich. In Human Aspects of Types and Reasoning Assistants (HATRA), arXiv:2210.12996, 2022.
6. Gradual C0: Symbolic Execution for Efficient Gradual Verification. Jenna DiVincenzo, Ian McCormack, Hemant Gouni, Jacob Gorenburg, Mona Zhang, Conrad Zimmerman, Joshua Sunshine, Éric Tanter, and Jonathan Aldrich. arXiv:2210.02428, 2022.
7. An Empirical Study of Protocols in Smart Contracts. Timothy Mou, Michael Coblenz, and Jonathan Aldrich. In Human Aspects of Types and Reasoning Assistants (HATRA) arXiv:2110.08983, 2021.
8. Psamathe: A DSL with Flows for Safe Blockchain Assets. Reed Oei, Michael Coblenz, and Jonathan Aldrich. In Practical Aspects of Declarative Languages (PADL), extended version as arXiv:2010.04800, 2021.
9. User-Centered Programming Language Design: A Course-Based Case Study. Michael Coblenz, Ariel Davis, Megan Hofmann, Vivian Huang, Siyue Jin, Max Krieger, Kyle Liang, Brian Wei, Mengchen Same Yong, and Jonathan Aldrich. In Human Aspects of Types and Reasoning Assistants (HATRA) arXiv:2011.07565, 2020.
10. Gradual Program Analysis. Sam Estep, Jenna Wise, Jonathan Aldrich, Éric Tanter, Johannes Bader, and Joshua Sunshine. In Workshop on Gradual Typing (WGT'20), 2020.
11. Gradual Verification of Recursive Heap Data Structures. Jenna Wise, Johannes Bader, Jonathan Aldrich, Éric Tanter, and Joshua Sunshine. In Workshop on Gradual Typing (WGT'20), 2020.
12. Smarter Smart Contract Development Tools. Michael Coblenz, Joshua Sunshine, Jonathan Aldrich, and Brad A. Myers. Proc WETSEB, 2019.
13. User-Centered Design of Permissions, Typestate, and Ownership in the Obsidian Blockchain Language. Michael Coblenz, Jonathan Aldrich, Joshua Sunshine, and Brad A. Myers. Proc. HCI for Blockchain: Studying, Designing, Critiquing and Envisioning Distributed Ledger Technologies Workshop at CHI'2018, 2018.
14. A User Study to Inform the Design of the Obsidian Blockchain DSL. Celeste Barnaby, Michael Coblenz, Tyler Etzel, Eliezer Kanal, Joshua Sunshine, Brad Myers, and Jonathan Aldrich. Proc. Workshop on Evaluation and Usability of Programming Languages and Tools (PLATEAU'2017), 2017.
15. Empirical Studies on the Security and Usability Impact of Immutability. Sam Weber, Michael Coblenz, Brad Myers, Jonathan Aldrich, and Joshua Sunshine. Proc. IEEE Cybersecurity Development Conference, 2017.
16. Substance and Style: domain-specific languages for mathematical diagrams. Wode Ni*, Katherine Ye*, Joshua Sunshine, Jonathan Aldrich, and Keenan Crane. Proc. Domain-Specific Language Design and Implementation (DSLDI), 2017.
*indicates equal contribution.
17. Designing extensible, domain-specific languages for mathematical diagrams. Katherine Ye, Keenan Crane, Jonathan Aldrich, and Joshua Sunshine. In Off the Beaten Track (OBT), 2017.
18. Capability Safe Reflection for the Wyvern Language. Esther Wang and Jonathan Aldrich. In Proceedings of the Workshop on Meta-Programming Techniques and Reflection (META), 2016.
19. Naturally Embedded DSLs. Jonathan Aldrich and Alex Potanin. In Proceedings of the Workshop on Domain-Specific Language Design and Implementation (DSLDI), 2016.
20. Delegation Revisited: Reuse Mechanisms in a Statically Typed, Expression-Oriented Language. Jonathan Aldrich and Alex Potanin. In Proceedings of the Workshop on New Object-Oriented Languages (NOOL), 2016.
21. Delegation vs. Inheritance for Typestate Analysis. Du Li, Alex Potanin, and Jonathan Aldrich. In Proceedings of Formal Techniques for Java Like Programs (FTfJP), 2015.
22. Statically Typed String Sanitation Inside a Python. Nathan Fulton, Cyrus Omar, and Jonathan Aldrich. Proc. Privacy and Security in Programming (PSP), 2014. Best Paper Award.
23. Usability Hypotheses in the Design of Plaid. Jonathan Aldrich and Joshua Sunshine. In Evaluation and Usability of Programming Languages and Tools (PLATEAU), 2014.
24. Wyvern: Impacting Software Security via Programming Language Design. Darya Kurilova, Alex Potanin, and Jonathan Aldrich. Proc. Evaluation and Usability of Programming Languages and Tools (PLATEAU), 2014.
25. Considering Productivity Effects of Explicit Type Declarations. Michael Coblenz, Jonathan Aldrich, Brad Myers, and Joshua Sunshine. In Evaluation and Usability of Programming Languages and Tools (PLATEAU), 2014.
26. Language-Based Architectural Control. Jonathan Aldrich, Cyrus Omar, Alex Potanin, and Du Li. In International Workshop on Aliasing, Capabilities, and Ownership (IWACO '14), 2014.
27. Using Machine Learning in the Automatic Translation of Object Propositions. Ligia Nistor and Jonathan Aldrich. Proc. AI4FM, 2014.
28. Substructural Typestates. Filipe Militão, Jonathan Aldrich, and Luís Caires. In Programming Languages meets Program Verification, 2014.
29. Wyvern: A Simple, Typed, and Pure Object-Oriented Language. Ligia Nistor, Darya Kurilova, Stephanie Balzer, Benjamin Chung, Alex Potanin, and Jonathan Aldrich. In Mechanisms for Specialization, Generalization, and Inheritance (MASPEGHI), 2013.
30. Type-Directed, Whitespace-Delimited Parsing for Embedded DSLs. Cyrus Omar, Benjamin Chung, Darya Kurilova, Alex Potanin, and Jonathan Aldrich. In Globalization of Domain Specific Languages (GlobalDSL), 2013.
31. High-Level Abstractions for Safe Parallelism. Robert L. Bocchino, Hannes Mehnert, and Jonathan Aldrich. In Workshop on Determinism and Correctness in Parallel Programming, 2013.
32. Are Object Protocols Burdensome? Ciera Jaspan and Jonathan Aldrich. In Evaluation and Usability of Programming Languages and Tools Workshop (PLATEAU), 2011.
33. Verifying Object-Oriented Code Using Object Propositions. Ligia Nistor and Jonathan Aldrich. International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO), 2011.
34. Featherweight Typestate. Ronald Garcia, Roger Wolff, Éric Tanter, and Jonathan Aldrich. Technical Report CMU-ISR-10-110, July 2010.
35. Gradual Featherweight Typestate. Roger Wolff, Ronald Garcia, Éric Tanter, and Jonathan Aldrich. Technical Report CMU-ISR-10-116R, July 2010 (revised December 2010).
36. Aliasing Control with View-Based Typestate. Filipe Militão, Jonathan Aldrich, and Luís Caires. In Proceedings of Formal Techniques for Java Like Programs (FTfJP), 2010.
37. A Theory of Typestate-Oriented Programming. Darpan Saini, Joshua Sunshine, and Jonathan Aldrich. In Proceedings of Formal Techniques for Java Like Programs (FTfJP), 2010.
38. DynXML: Safely Programming the Dynamic Web. Joshua Sunshine and Jonathan Aldrich. In Proceedings of Analysis and Programming Languages for Web Applications and Cloud Applications (APLWACA), 2010.
39. Modular Composition and State Update in Plaid. Jonathan Aldrich, Karl Naden, and Éric Tanter. In Proceedings of the Workshop on Mechanisms for Specialization, Generalization, and Inheritance (MASPEGHI), 2010.
40. Resource-Based Programming in Plaid. Jonathan Aldrich. Unpublished manuscript presented at the Fun and Innovative Thoughts (FIT) session at PLDI, 2010. Also available at the PLDI FIT session page.
41. A Language-based Approach to Specification and Enforcement of Architectural Protocols. Kevin Bierhoff, Darpan Saini, Matthew Kehrt, Majid Al-Meshari, Sangjin Han, and Jonathan Aldrich. Technical Report CMU-ISR-10-110, March 2010.
42. Verifying Event-Driven Programs using Ramified Frame Properties. Neelakantan R. Krishnaswami, Jonathan Aldrich, and Lars Birkedal. In Proceedings of Types in Language Design and Implementation (TLDI), 2010.
43. Typestate Protocol Specification in JML. Taekgoo Kim, Kevin Bierhoff, Jonathan Aldrich, and Sungwon Kang. In Proceedings of the Workshop on Specification and Verification of Component-Based Systems (SAVCBS '09), August 2009.
44. Reducing STM Overhead with Access Permissions. Nels E. Beckman, Yoon Phil Kim, Sven Stork, and Jonathan Aldrich. In Proceedings of the International Workshop on Aliasing, Confinement and Ownership 2009 (IWACO '09), July 2009.
45. Language support for Distributed Proxies. Darpan Saini, Joshua Sunshine, and Jonathan Aldrich. Proc. Distributed Objects for the 21st Century, 2009.
46. Static Extraction of Sound Hierarchical Runtime Object Graphs. Marwan Abi-Antoun and Jonathan Aldrich. In Proceedings of Types in Language Design and Implementation, January 2009.
47. Design Patterns in Separation Logic. Neelakantan R. Krishnaswami, Jonathan Aldrich, Lars Birkedal, Kasper Svendsen, and Alexandre Buisse. In Proceedings of Types in Language Design and Implementation, January 2009.
48. A Field Study in Static Extraction of Runtime Architectures. Marwan Abi-Antoun and Jonathan Aldrich. In Proceedings of the Workshop on Program Analysis for Software Tools and Engineering (PASTE'08), November 2008.
49. Permissions to Specify the Composite Design Pattern. Kevin Bierhoff and Jonathan Aldrich. In proceedings of the FSE 2008 Workshop on Specification and Verification of Component-Based Systems (SAVCBS '08), November 2008.
50. Verifying Correct Usage of Atomic Blocks and Typestate: Technical Companion. Nels Beckman and Jonathan Aldrich. Carnegie Mellon University Technical Report CMU-ISR-08-126, 2008.
51. SASyLF: An Educational Proof Assistant for Language Theory. Jonathan Aldrich, Robert J. Simmons, and Key Shin. In Proceedings of Functional and Declarative Programming in Education (FDPE '08), 2008.
52. A Theory of Linear Objects. Matthew Kehrt and Jonathan Aldrich. In 2008 International Workshop on Foundations of Object-Oriented Languages (FOOL '08), San Francisco, California, January 2008.
53. Checking and Measuring the Architectural Structural Conformance of Object-Oriented Systems. Marwan Abi-Antoun and Jonathan Aldrich. Carnegie Mellon University Technical Report CMU-ISRI-07-119, December 2007.
54. Modular Verification of the Subject-Observer Pattern via Higher-Order Separation Logic. Neelakantan R. Krishnaswami, Lars Birkedal, and Jonathan Aldrich. In ECOOP 2007 Workshop on Formal Techniques for Java Like Programs, July 2007.
55. Ownership Domains in the Real World. Marwan Abi-Antoun and Jonathan Aldrich. In International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO), in conjunction with the European Conference on Object-Oriented Programming (ECOOP), 2007.
56. Compile-Time Views of Execution Structure Based on Ownership. Marwan Abi-Antoun and Jonathan Aldrich. In International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO), in conjunction with the European Conference on Object-Oriented Programming (ECOOP), 2007.
57. Eclipse Plug-ins for Statically Checking and Visualizing Ownership Domain Annotations. Marwan Abi-Antoun and Jonathan Aldrich. Research Demonstration, European Conference on Object-Oriented Programming (ECOOP), 2007.
58. A Programming Model for Failure-Prone, Collaborative Robots. Nels Beckman and Jonathan Aldrich. In the 2nd International Workshop on Software Development and Integration in Robotics (SDIR), Rome, Italy, April 2007.
59. Combining Structural Subtyping and External Dispatch. Donna Malayeri and Jonathan Aldrich. In 2007 International Workshop on Foundations and Development of Object-Oriented Languages (FOOL/WOOD'07), Nice, France, January 2007.
60. JavaD: Bringing Ownership Domains to Mainstream Java. Marwan Abi-Antoun and Jonathan Aldrich. Carnegie Mellon University Technical Report CMU-ISRI-06-110, May 2006.
61. A Language-based Approach to Specification and Enforcement of Architectural Protocols. Kevin Bierhoff, Jonathan Aldrich, and Sangjin Han. Technical Report CMU-ISRI-06-121, April 2006.
62. Ego: Controlling the Power of Simplicity. Andi Bejleri, Jonathan Aldrich, and Kevin Bierhoff. In proceedings of the POPL '06 Workshop on Foundations of Object-Oriented Languages (FOOL '06), January 2006.
63. Improving System Dependability by Enforcing Architectural Intent. Marwan Abi-Antoun, Jonathan Aldrich, David Garlan, Bradley Schmerl, Nagi Nahas, and Tony Tseng. In proceedings of the ICSE 2005 Workshop on Architecting Dependable Systems (WADS '05), May 2005.
64. Modeling and Implementing Software Architecture with Acme and ArchJava. Marwan Abi-Antoun, Jonathan Aldrich, David Garlan, Bradley Schmerl, Nagi Nahas, and Tony Tseng. Demonstration, in proceedings of the International Conference on Software Engineering (ICSE '05), May 2005.
65. Selective Open Recursion: Modular Reasoning about Components and Inheritance. Jonathan Aldrich and Kevin Donnelly. In proceedings of the FSE 2004 Workshop on Specification and Verification of Component-Based Systems (SAVCBS '04), November 2004.
66. Open Modules: Reconciling Extensibility and Modularity. Jonathan Aldrich. In Proceedings of the Workshop on Software Engineering Properties of Languages for Aspect Technologies (SPLAT '04), March 2004.
67. Statically-Scoped Exceptions: a Typed Foundation for Aspect-Oriented Error Handling. Neel Krishnaswami and Jonathan Aldrich. Carnegie Mellon Technical Report CMU-ISRI-05-102, published on web January 2004, TR version January 2005.
68. Using Types to Enforce Architectural Structure. Jonathan Aldrich. University of Washington Ph.D. Dissertation, August 2003.
69. Architecture-Centric Programming for Adaptive Systems. Jonathan Aldrich, Vibha Sazawal, Craig Chambers, and David Notkin. In Proceedings of the Workshop on Self-Healing Systems (WOSS '02), November 2002.
70. Architecture-Centric Programming for Context-Aware Configuration. Vibha Sazawal and Jonathan Aldrich. In Proceedings of the OOPSLA '02 Workshop on Engineering Context-Aware Object-Oriented Systems and Environments (ECOOSE '02), November 2002.
71. Challenge Problems for Separation of Concerns. Jonathan Aldrich. In Proceedings of the OOPSLA 2000 Workshop on Advanced Separation of Concerns, October 2000.
72. Evaluating Module Systems for Crosscutting Concerns. Jonathan Aldrich. University of Washington PhD Generals Examination Report, September 2000.
73. Providing Easier Access to Remote Objects in Client Server Systems. Jonathan Aldrich, James Dooley, Scott Mandelsohn, and Adam Rifkin. In Thirty-first Hawaii International Conference on System Sciences (HICSS-31), January 1998. Additional details available in California Institute of Technology Computer Science Technical Report 97-20, 1997. The implementation and documentation are available at the JEDI home page, http://www.cs.cmu.edu/~aldrich/jedi/