Bart Jacobs is an Associate Professor at the Faculty of Engineering Science , KU Leuven , affiliated with the Department of Computer Science and the Distributed and Secure Software (DistriNet) unit. His research focuses on computer program verification , programming languages , and formal methods for ensuring software safety and liveness properties. Key Research Areas: Modular formal verification of concurrent programs Memory safety in Rust with unsafe blocks Completeness thresholds for critical software Gradual typing and state threads Relational reasoning for advanced type systems Recent Publications highlight his work on verifying fine-grained concurrent modules, unsafe Rust code, and array-traversing programs. His projects span formal verification of safety/liveness properties (2018–2027) and model-driven engineering for adaptive SaaS systems. Awards & Memberships: Secretary of POC Informatica Member of Faculty of Engineering Science Council Doctoral Commission member at KU Leuven Teaching Responsibilities include courses on object-oriented programming, software design, and secure software engineering, reflecting his expertise in foundational and advanced programming concepts.
Shriram Krishnamurthi is a Professor in the Department of Computer Science at Brown University, specializing in programming languages, formal methods, and software education. His research focuses on language design, type systems, and pedagogical approaches to programming concepts. Recent publications highlight his work in areas such as Rust trait error debugging formal methods teaching tools automated type error telemetry document calculus design logic misconceptions in education His contributions also include program committee roles at major conferences like SPLASH, ICFP, and SIGCSE.
Ben Greenman is an Assistant Professor at the University of Utah's Department of Computer Science. He has affiliations with institutions including Cornell University (BS, M.Eng), Northeastern University (PhD), and Brown University (CIFellows 2020). His work spans programming language design, type systems, formal methods, and human factors in software development. His research focuses on Gradual typing and type soundness Language design with emphasis on usability Formal methods education tools Empirical studies of type system usage Recent work analyzes temporal logic misconceptions, privacy-respecting telemetry for type errors, and macro systems without traditional syntax barriers. His publications reveal trends in Gradual type migration Runtime monitoring and profiling Visual formal methods Developer-centric language design He has received the CIFellows 2020 award and serves on program committees for SPLASH, Scheme, and other conferences. His work addresses both theoretical and practical aspects of programming language design.
Ronald Garcia is an Associate Professor in the Department of Computer Science at the University of British Columbia, affiliated with the Faculty of Science and the Software Practices Lab. His research focuses on programming language theory, emphasizing gradual typing, type systems, and end-user programming. He teaches courses such as Programming Language Principles (CPSC 509) and Compiler Construction (CPSC 411). Education details are not explicitly stated in the provided texts, but his extensive academic contributions span over two decades. Research interests include formal semantics of programming languages, typestate systems, dependent types, and improving software practices for end-users. He has advised numerous Ph.D. and Master's students, contributing to over 30 academic publications. Recent work explores hybrid programming environments for end-users, runtime type slicing for debugging, and foundational frameworks for gradual dependent types. Garcia actively participates in academic conferences as a PC member and keynote speaker, notably in PLDI, POPL, and ICFP. His lab and collaborations focus on advancing theoretical foundations while addressing practical challenges in software development and education.
Benjamin Lee Greenman is an Assistant Professor at the Kahlert School of Computing , part of the John and Maria Price College of Engineering at the University of Utah. His research focuses on programming languages, gradual/migratory type systems, formal methods, and human factors in software development. He holds a Ph.D. from Northeastern University (2020), a CIFellows postdoc at Brown University (2020–2022), and degrees from Cornell University (B.S. in ILR, M.Eng. in CS). Key projects include: Forge: A tool for teaching formal methods with lightweight model finding. FlowFPX: Tools for debugging floating-point exceptions in scientific computing. LTL Tutor: An adaptive learning system addressing temporal logic misconceptions. Gradual Typing Benchmarks: Evaluating performance and guarantees of type systems. His work emphasizes rigorous methods for language design, including empirical studies, performance evaluation, and human-centered approaches. Recent contributions include exploring misconceptions in LTL education and advancing type system interoperability between typed and untyped code. Teaching roles include courses on compilers, software verification, and programming languages. He advocates for practical tools like Rhombus (Python-like syntax with Lisp macros) and Static Python ’s sound gradual typing system.
Josh Sunshine is an Associate Professor in the Software and Societal Systems Department (S3D) at Carnegie Mellon University's School of Computer Science, with a courtesy appointment in the Human-Computer Interaction Institute. He directs the NSF-funded REUSE program (Research Experiences for Undergraduates in interdisciplinary Software Engineering), providing summer research opportunities for diverse undergraduates across computer science domains including human-computer interaction, programming languages, and software security. His educational background includes a PhD in Software Engineering from Carnegie Mellon University (2013) under Jonathan Aldrich, and a BS from Brandeis University (2004) followed by four years as a software engineer. Prior academic training informs his industry-relevant research approach. Professor Sunshine's research spans programming languages, software engineering, and human-computer interaction with concentrated focus on usability of reusable software components. He investigates how developers interact with libraries, APIs, and testing tools, seeking to bridge formal methods with practical usability through human-centered design. Recent work develops tools that make verification and testing more accessible without sacrificing rigor. Analysis of his 15 most recent publications reveals strong emphasis on human-in-the-loop systems: 60% address software testing/tooling (e.g., TerzoN, Nanofuzz), 25% focus on visualization/education (e.g., Edgeworth), and 15% explore programming language safety (e.g., Rust studies). The work consistently combines empirical user studies with technical innovation, targeting real-world developer pain points. Scientific recognition includes: NSF CAREER Award (2024) for "Scientist-in-the-loop software testing" Best Paper Nominee at ACM Conference on Learning @ Scale (2024) for Edgeworth research Through the REUSE program, Professor Sunshine mentors 15-20 undergraduates annually in collaborative research with faculty including Charlie Garrod and Claire Le Goues. His grant portfolio centers on two major NSF awards: the REUSE site ($1.2M) and CAREER grant ($500k), supporting both research and educational outreach. Current projects integrate testing automation with human judgment and develop scalable tools for visual thinking in STEM education. As a core S3D faculty member, he contributes to CMU's interdisciplinary mission through the Human-Computer Interaction Institute collaboration. His REUSE program specifically builds inclusive research pathways, with 40% participation from underrepresented groups in computing. Future work focuses on expanding the "scientist-in-the-loop" paradigm across software engineering tasks.
Shriram Krishnamurthi serves as a Professor of Computer Science at Brown University, where he teaches core courses including Programming Languages (CSCI 1730), Topics in Programming Languages and Systems (CSCI 2950X), and specialized courses in Computer Science Education Research (CSCI 2952B) and Human Factors (EMCS 2410/2430). His academic journey began with a BA from Ohio Wesleyan University (1993), followed by a PhD from Rice University (2001). His research centers on bridging programming language theory with education, with pioneering work on notional machines for teaching language semantics and misconceptions in formal methods. He develops educational tools like Forge for formal methods instruction and Porpoise for LLM-assisted programming practice, while investigating how students learn complex concepts in Rust, linear temporal logic, and type systems. His work extends to K-12 curriculum design through projects like Bootstrap. Analysis of his 2023-2025 publications reveals three dominant trends: (1) adaptive tutors targeting specific misconceptions in formal logic, (2) debugging and visualization tools for complex language features (e.g., Rust traits), and (3) AI-integrated educational environments using LLMs. These efforts consistently focus on making advanced programming concepts accessible through grounded pedagogical design. No scientific awards were documented in the provided materials. While his graduate course instruction implies student advising, specific advisee names and grant details remain unreported in the source text. His collaborative network appears extensive through co-authored publications and Dagstuhl seminar participation, though formal lab structures aren't explicitly described.
McKenna McCall is an Assistant Professor at the Department of Computer Science, Colorado State University, specializing in formal methods and usable security. Her research bridges the gap between technical security systems and non-expert users, focusing on policy writing and theoretical guarantees of formal systems. PhD from Carnegie Mellon University's Electrical & Computer Engineering department (2023) Postdoctoral Researcher at Carnegie Mellon's Software and Societal Systems Department Her work includes Trusted Execution Environments (TEE) usability , Information Flow Control (IFC) for reactive systems, and security tools for trigger-action programs. She has contributed to conferences such as CCS, SOUPS, Euro S&P, and CSF. IEEE Euro S&P 2022 Outstanding Presentation Award CyLab Presidential Fellowship (2020) McKenna actively participates in academic service, including program committees for USENIX Security, CSF, and PriSC, and guest lectures at Carnegie Mellon University.
Amal Ahmed is a Professor and Associate Dean for Graduate Programs at Khoury College of Computer Sciences, Northeastern University, where she leads research in programming languages and secure compilation. She received her PhD in Computer Science from Princeton University and has established herself as a leading researcher in compiler correctness, language interoperability, and type systems. Her research focuses on correct and secure compilation across the software-hardware stack and safe language interoperability, including design of sound foreign-function interfaces (FFIs) and richly typed compiler intermediate languages. She makes extensive use of semantics and type systems for reasoning about imperative and probabilistic programming languages, multi-language systems, security, concurrency, and provenance. Her work has significantly advanced the understanding of gradual typing, compiler verification, and compositional language interoperability. Dr. Ahmed's publications reveal a research trajectory focused on building solid semantic foundations for language interoperability and secure compilation. Her recent work spans topics from probabilistic separation logic to WebAssembly interoperability, with consistent emphasis on formal verification and semantic techniques. She has developed frameworks for reasoning about multi-language systems that preserve security properties across language boundaries. NSF CAREER Award recipient Editorial Board: Journal of Functional Programming (2017–present) Editorial Board: Mathematical Structures in Computer Science (2016–present) Member: IFIP Working Group 2.8 (Functional Programming, 2014–present) As an educator and mentor, Dr. Ahmed has advised numerous PhD students, postdocs, and undergraduates, many of whom have gone on to successful academic and industry careers. She has organized the Programming Languages Mentoring Workshop and regularly teaches advanced courses in programming languages. She serves on the steering committees of major conferences including POPL, SPLASH, and PLMW, and has chaired program committees for ESOP and POPL.
Jeremy G. Siek is a Professor at Indiana University Bloomington in the School of Informatics and Computing. His research spans programming language design, type systems, gradual typing, mechanized theorem proving, and optimizing compilers. Gradual typing integration in functional languages Co-inventor of the Boost Graph Library Former NSF CAREER award recipient Active in programming language foundations research Jeremy's research focuses on reconciling static and dynamic type checking through gradual typing, with current work on parametricity in polymorphic blame calculus, combining gradual typing with dependent types, and formal criteria for gradual type systems. He investigates high-performance implementations of gradual typing and its application to security enforcement. His recent publications examine verified nanopass compilers, gradual security guarantees, and parameterized cast calculi. He has received multiple distinguished visiting fellowships and maintains the Deduce proof assistant for educational use. NSF CAREER Award (2009) Distinguished Visiting Fellowships (2010, 2015) Jeremy leads the Center for Programming Systems at IU and advises Ph.D. students Tianyu Chen (gradual security) and Darshal Shetty (gradual dependent types). He teaches courses in compilers, data structures, and programming language foundations.
