Yannis Smaragdakis

Declarative Static Program Analysis: An Intelligent System over Programs

It's the dream of most every programmer: a smart system that "knows more about my code than I do". How do we go about building it? I will argue for the benefits of using logic-based declarative languages as a means to specify static program analysis algorithms. Every aspect of complex program behavior (e.g., regular language features, reflection, exceptions, code generation) is captured by separate logical rules that cooperate to produce a model of what the code does. The result is "holistic" analysis: although every sub-analysis has its own concerns, everything is connected. Concretely, the focus will be on the Doop framework for analysis of Java programs, and especially on its latest developments. Doop encodes multiple analysis algorithms for Java declaratively, using Datalog: a logic-based language for defining (recursive) relations. With an aggressive optimization methodology, Doop also achieves very high performance--often an order of magnitude faster than comparable frameworks.

Attach:smaragdakis.jpg Δ Yannis Smaragdakis (http://smaragd.org) is a Professor at the University of Athens. Prior to that he had a 10+ year faculty career in the US, most recently as an Associate Professor at the University of Massachusetts, Amherst. His interests include program analysis and testing (especially pointer analysis, static-dynamic analysis combinations, and invariant inference); declarative and extensible languages (especially program generators, generics/templates, and applications of the Datalog language); and languages and tools for systems (especially multi-threading, parallel and distributed computing, and program locality). Large parts of his FC++ project have been integrated into the Boost C++ libraries, and he continues to maintain strong ties to industrial development and open-source projects. His latest work includes the Doop framework for the analysis of Java bytecode, as well as other related projects for program analysis algorithms expressed declaratively, in the Datalog language. Smaragdakis serves as the academic liaison of LogicBlox Inc., producing an industrial Datalog engine. He also currently serves on the SIGPLAN Executive Committee and was the Program Chair of OOPSLA'16. He is a recipient of an NSF Career award, an ERC Starting/Consolidator grant, and several best/distinguished paper or artifact awards (OOPSLA'15, ISSTA'12, ASE'07, ISSTA'06, GPCE'04, USENIX'99).

Tomáš Petříček

Language Challenges of Targeting Multiple Runtimes

With JavaScript becoming an ubiquitous execution environment, many programming languages designed for other managed runtimes support JavaScript as an alternative additional target. The mismatch between the primary runtime for which the language was designed and the secondary runtime, here JavaScript, poses a number of interesting challenges for language and library designers.

In this talk, I will discuss some of the challenges based on my experience of contributing to F#-to-JavaScript compilers. For example, how can a statically-typed programming language access libraries created for a dynamically-typed runtime? How do we compile F# types so that they can be used by JavaScript clients? Or, how should we compile multi-threaded code if the target environment is single-threaded?

In addition to discussing the specific challenges from the F#-to-JavaScript perspective, I will give an overview of the range of approaches used by other compilers targeting JavaScript and I will conclude the talk with some ideas on what a programming language that will be a native citizen of multiple runtimes look like.

Attach:petricek.jpg Δ Tomas is a Visiting Researcher at the Alan Turing institute, working on tools for open data-driven storytelling. He is building tools that integrate with modern data sources (open government data, data published by citizen initiatives) and let users easily create analyses and visualizations that are linked to the original data source, making the analyses more transparent, reproducible, but also easy to adapt. His early work on the project can be found at http://thegamma.net.

Tomas' many other interests include open-source and functional programming (he is an active contributor to the F# ecosystem), programming language theory (his PhD thesis on "coeffects" develops a theory of context-aware programming language language), but also understanding programming through the perspective of philosophy of science (he wrote essays on the history and philosophy of "types" and errors in software).