Session-typed languages building on the Curry-Howard isomorphism between linear logic and session-typed communication guarantee session fidelity and deadlock freedom. Unfortunately, these strong guarantees exclude many naturally occurring programming patterns pertaining to shared resources. In this paper, we introduce sharing into a session-typed language where types are stratified into linear and shared layers with modal operators connecting the layers. The resulting language retains session fidelity but not the absence of deadlocks, which can arise from contention for shared processes. We illustrate our language on various examples, such as the dining philosophers problem, and provide a translation of the untyped asynchronous π-calculus into our language.

Shared session types generalize the Curry-Howard correspondence between intuitionistic linear logic and the session-typed π-calculus with adjoint modalities that mediate between linear and shared session types, giving rise to a programming model where shared channels must be used according to a locking discipline of acquire-release. While this generalization greatly increases the range of programs that can be written, the gain in expressiveness comes at the cost of deadlock-freedom, a property which holds for many linear session type systems. In this paper, we develop a type system for logically-shared sessions in which types capture not only the interactive behavior of processes but also constrain the order of resources (i.e., shared processes) they may acquire. This typelevel information is then used to rule out cyclic dependencies among acquires and synchronization points, resulting in a system that ensures deadlock-free communication for well-typed processes in the presence of shared sessions, higher-order channel passing, and recursive processes. We illustrate our approach on a series of examples, showing that it rules out deadlocks in circular networks of both shared and linear recursive processes, while still being permissive enough to type concurrent implementations of shared imperative data structures as processes.

Although I am its author, this dissertation is really a joint e ort. First and foremost, I would like to thank my advisor Jan Ho mann for his unwavering support. Jan, thank you for your patience with me while I learned the basics of programming language theory. Your vision, not just about PL, but about success in research will always stay with me. And a special thanks for your constant guidance during my job application process. I also want to express my sincere gratitude to Frank Pfenning who, despite not being my o cial advisor, always treated me like his student. Frank, your vast experience and clarity of thought has taught me so much about PL research. I really enjoyed my collaborations and pair programming experiences with you; we have created some really impressive so ware together! Before anyone else, I would like to take this opportunity to thank my partner Dr. Shrimai Prabhumoye. Without you, I would not have been able to successfully complete my PhD. e life principles I have learned from you have made me, not just a be er researcher, but a be er person.I would also like to thank my commi ee members: Andrew Miller for introducing me to the world of security, privacy, and applied cryptography; Bryan Parno for providing amazing feedback on my application materials and dissertation; and especially Shaz Qadeer for enabling an awesome internship experience and teaching me how to become an independent researcher. I'd also like to thank all my collaborators:

No abstract

No abstract

No abstract

Reasoning about concurrent programs is challenging, especially if data is shared among threads. Program correctness can be violated by the presence of data races—whose prevention has been a topic of concern both in research and in practice. The Rust programming language is a prime example, putting the slogan fearless concurrency in practice by not only employing an ownership-based type system for memory management, but also using its type system to enforce mutual exclusion on shared data. Locking, unfortunately, not only comes at the price of deadlocks but shared access to data may also cause memory leaks . This paper develops a theory of deadlock and leak freedom for higher-order locks in a shared memory concurrent setting. Higher-order locks allow sharing not only of basic values but also of other locks and channels, and are themselves first-class citizens. The theory is based on the notion of a sharing topology , administrating who is permitted to access shared data at what point in the program. The paper first develops higher-order locks for acyclic sharing topologies, instantiated in a λ-calculus with higher-order locks and message-passing concurrency. The paper then extends the calculus to support circular dependencies with dynamic lock orders, which we illustrate with a dynamic version of Dijkstra’s dining philosophers problem. Well-typed programs in the resulting calculi are shown to be free of deadlocks and memory leaks, with proofs mechanized in the Coq proof assistant.

No abstract