5 research outputs found
Experimental Biological Protocols with Formal Semantics
Both experimental and computational biology is becoming increasingly
automated. Laboratory experiments are now performed automatically on
high-throughput machinery, while computational models are synthesized or
inferred automatically from data. However, integration between automated tasks
in the process of biological discovery is still lacking, largely due to
incompatible or missing formal representations. While theories are expressed
formally as computational models, existing languages for encoding and
automating experimental protocols often lack formal semantics. This makes it
challenging to extract novel understanding by identifying when theory and
experimental evidence disagree due to errors in the models or the protocols
used to validate them. To address this, we formalize the syntax of a core
protocol language, which provides a unified description for the models of
biochemical systems being experimented on, together with the discrete events
representing the liquid-handling steps of biological protocols. We present both
a deterministic and a stochastic semantics to this language, both defined in
terms of hybrid processes. In particular, the stochastic semantics captures
uncertainties in equipment tolerances, making it a suitable tool for both
experimental and computational biologists. We illustrate how the proposed
protocol language can be used for automated verification and synthesis of
laboratory experiments on case studies from the fields of chemistry and
molecular programming
On Multi-Language Semantics: Semantic Models, Equational Logic, and Abstract Interpretation of Multi-Language Code
Modern software development rarely takes place within a single programming language. Often, programmers appeal to cross-language interoperability. Benefits are two-fold: exploitation of novel features of one language within another, and cross-language code reuse. For instance, HTML, CSS, and JavaScript yield a form of interoperability, working in conjunction to render webpages. Some object oriented languages have interoperability via a virtual machine host (.NET CLI compliant languages in the Common Language Runtime, and JVM compliant languages in the Java Virtual Machine). A high-level language can interact with a lower level one (Apple's Swift and Objective-C). Whilst this approach enables developers to benefit from the strengths of each base language, it comes at the price of a lack of clarity of formal properties of the new multi-language, mainly semantic specifications. Developing such properties is a key focus of this thesis. Indeed, while there has been some research exploring the interoperability mechanisms, there is little development of theoretical foundations. In this thesis, we broaden the boundary functions-based approach à la Matthews and Findler to propose an algebraic framework that provides systematic and more general ways to define multi-languages, regardless of the inherent nature of the underlying languages. The aim of this strand of research is to overcome the lack of a formal model in which to design the combination of languages. Main contributions are an initial algebra semantics and a categorical semantics for multi-languages. We then give ways in which interoperability can be reasoned about using equations over the blended language. Formally, multi-language equational logic is defined, within which one may deduce valid equations starting from a collection of axioms that postulate properties of the combined language. Thus, we have the notion of a multi-language theory and part of the thesis is devoted to exploring the properties of these theories. This is accomplished by way of both universal algebra and category theory, giving us a very general and flexible semantics, and hence a wide collection of models. Classifying categories are constructed, and hence equational theories furnish each categorical model with an internal language. From this we establish soundness and completeness of the multi-language equational logic. As regards static analysis, the heterogeneity of the multi-language context opens up new and unexplored scenarios. In this thesis, we provide a general theory for the combination of abstract interpretations of existing languages in order to gain an abstract semantics of multi-language programs. As a part of this general theory, we show that formal properties of interest of multi-language abstractions (e.g., soundness and completeness) boil down to the features of the interoperability mechanism that binds the underlying languages together. We extend many of the standard concepts of abstract interpretation to the framework of multi-languages. Finally, a minor contribution of the thesis concerns language specification formalisms. We prove that longstanding syntactical transformations between context-free grammars and algebraic signatures give rise to adjoint equivalences that preserve the abstract syntax of the generated terms. Thus, we have methods to move from context-free languages to the algebraic signature formalisms employed in the thesis
Scala with Explicit Nulls
The Scala programming language unifies the object-oriented and functional styles of programming. One common source of errors in Scala programs is null references. In this dissertation, I present a modification to the Scala type system that makes nullability explicit in the types. This allows us to turn runtime errors into compile-time errors. I have implemented this design for explicit nulls as a fork of the Dotty (Scala 3) compiler. I evaluate the design by migrating a number of Scala libraries to use explicit nulls.
In the second part of the dissertation, I give a theoretical foundation for explicit nulls. I do this in two, independent ways. First, I give a denotational semantics for type nullification, a key part of the explicit nulls design. Separately, I present a core calculus for null interoperability that models how languages with explicit nulls (like Scala) interact with languages where null remains implicit (like Java). Using the concept of blame from gradual typing, I show that if a well-typed program fails with certain kinds of nullability errors, an implicitly-nullable subterm can always be blamed for the failure