Bergen Language Design Laboratory (BLDL)

BLDL has an internal meeting series. Some of these have a content which may be of interest to a larger audience. The program of these are announced here.

Contact Magne Haveraaen for more information.

Seminars 2018

  • Monday 2018-10-29 1215-1400, 405O2 (the aquarium), Høyteknologisenteret

    Markus Roggenbach (Computer Science, Swansea University, Wales, UK):
    Syntactic Theory Functors

    Developing specifications for practical problems turns out to hit issues that are immaterial to foundational specification theory. One issue may be that it is awkward specifying a simple idea, e.g., writing axioms in first order logic expressing that it is required for a remote control to have at least 13 distinct buttons. Another issue may be that several specifications are conceptually the same, with minor differences in declarations causing them to be duplicated. Though immaterial to foundational theory, lack of support causes lengthy writing of boilerplate code or repeated adaptation from one context to another.

    We propose a framework for creating institution specific structuring mechanisms, syntactic theory functors (STFs). STFs subsume the standard institution independent structuring mechanisms, and open up new ways of reusing existing and structuring new specifications. This allows building a rich institution incrementally from a simple institution and appropriate STFs.

    This talk reports on work undertaken in a research collaboration with Magne Haveraaen.

  • Wednesday 2018-10-31 1015-1200, Aud 4, realfagbygget

    Markus Roggenbach (Computer Science, Swansea University, Wales, UK):
    Software Model Checking for Mobile Security – Collusion Detection in K

    Mobile devices pose a particular security risk because they hold personal details and have capabilities potentially exploitable for eavesdropping. The Android operating system is designed with a number of built-in security features such as application sandboxing and permission- based access control. Unfortunately, these restrictions can be bypassed, without the user noticing, by colluding apps whose combined permissions allow them to carry out attacks that neither app is able to execute by itself. In this talk, we report upon a software model-checking approach within the K-framework that is capable to detect collusion. This involves giving an abstract, formal semantics to Android applications and proving that the applied abstraction principles lead to a finite state space.

    This talk reports on work undertaken in a research collaboration with Irina Asavoae and Hoang Nga Nguyen.

  • Wednesday 2018-10-31 1230-1330, 405O2 (the aquarium), Høyteknologisenteret

    Uwe Wolter (Institutt for informatikk, Universitetet i Bergen, Norge)
    Graph Algebras and Software Engineering

    The latest trend in software engineering regards models as first-class entities of the software development process. This trend has led to a branch of software engineering, often called Model-Driven Engineering (MDE), which promotes modelling as the main activity of software development and pursues the shift of paradigm from code-centric to model-centric.

    The different kinds of models, exploited in Software Engineering and, especially, in MDE, appear often as graph-based structures. Generalized Sketches are a universal and flexible mathematical specification formalism for those graph-based structures. Starting from generalized sketches, we developed in Bergen, during the last decade, the so-called Diagram Predicate Framework (DPF) to describe different kinds of graph-based structures and their semantics in a uniform way, thus providing a formal ground to relate, extend and integrate different diagrammatic modelling techniques and to define and implement meta-modelling, version control and model transformations.

    Operations on graph-based structures are omnipresent in Software Engineering and, especially, in MDE. However, a proper and adequate formalization of those operations has been missing until lately. As a first essential step towards such a formalization, we introduced the concept of graph algebra that generalizes the traditional concept of algebra.

    Graph algebras are not ”algebras of graphs”. ”Algebras of graphs” are special traditional algebras where the carrier is a set of (finite) graphs. In contrast, the carrier of a graph algebra is one single graph that will be often infinite in applications. Graph operations, i.e., operations in a graph algebra, describe how certain finite parts of the carrier graph can be ”computed” based on other finite parts of the carrier graph. In traditional algebra the arity of an operation is described by a finite set of ”input positions”, while the input and output arity, respectively, of a graph operation is described by a finite graph.

  • Domain Specific Language (DSL) month September 2018
    • Thursday 2018-09-06 1415-1500, 405O2 (the aquarium), Høyteknologisenteret

      Sandra Macia (Barcelona Supercomputing Centre (BSC), Spain):
      Saiph: Towards a DSL for High-Performance Computational Fluid Dynamics

      Saiph is a Domain Specific Language developed at the Barcelona Supercomputing Center (BSC) for simulating physical phenomena modeled by Partial Differential Equations systems designed for users that are not experts in numerical methods neither programming for supercomputers.

      This DSL expects to ease the development of scientist applications by allowing domain experts to transcribe their equations into Saiph code and then generating HPC-ready code that efficiently exploits the computational resources of modern heterogeneous supercomputers while dealing with all the specific aspects of solving partial differential equations systems.

      To achieve that, Saiph provides a high-level syntax that directly maps with concepts of the domain, hiding from the user all the complexities related to the numerical methods. Users only have to translate their equations to Saiph language and set the desired parameters of the simulation. Later, the equation's system is solved in parallel by a supercomputer, distributing the work across several nodes (using MPI) and applying intra-node tecniques (using OpenMP/OmpSs) to achieve a high performance.

    • Thursday 2018-09-13 1415-1500, 405O2 (the aquarium), Høyteknologisenteret

      Magne Haveraaen (Institutt for informatikk, Universitetet i Bergen, Norway):
      The API is the DSL

      The formal structure of library application programmer interface (API) declarations is similar to formal grammars. Here we show how to use this to generate domain specific language (DSL) tools from library interfaces. This includes an interpreter, the use of classical transformation rules for code optimisation, and a verification strategy for (possibly hand) transformed code.

    • Mini course Thursday 2018-09-20 and Friday 2018-09-21 both days 1015-1200, 405O2 (the aquarium), Høyteknologisenteret

      Mikhail Barash (Turku Centre for Computer Science (TUCS), Finland):
      Extend your Java: language composition with JetBrains MPS

      JetBrains Meta Programming System MPS is a powerful language workbench that allows defining domain-specific languages and IDEs for them. It features a projectional editor that allows for non-textual notations in code: tabular and graphical (mathematical symbols, diagrams, etc.). Because of this, language definition in MPS does not require implementing a parser, and languages can have syntactic ambiguities. This makes possible composition of several languages with "conflicting" syntaxes.

      In this short course, I will introduce JetBrains MPS and show how to define a simple language using MPS.

      JetBrains MPS has a built-in language, called baseLanguage, which is a projectional implementation of Java. We will extend this language with several custom constructs (for example, operator "@x" that returns name of identifier, similar to C#'s nameof(); lazy variables; custom if's; and others). We will define a code generator that will "transpile" these custom constructs to ordinary Java code.


      • Knowledge about object-oriented programming.
      • Understanding (informal is enough) how a compiler works. Example video introduction.
      • Students are expected to bring laptops to follow the tutorial and have JetBrains MPS installed.

    • Thursday 2018-09-20 1415-1600, 405O2 (the aquarium), Høyteknologisenteret

      Mikhail Barash (Turku Centre for Computer Science (TUCS), Finland):
      Introducing Language Wheel

      I will present my ideas on a language workbench that would allow non-language-engineers to define new programming languages using a wizard-like interface.

      The highlight of the proposed approach is to focus on language constructs (concepts) that constitute a language in a holistic way. Similar to other language workbenches (for example, JetBrains MPS), each concept encapsulates several aspects: abstract and concrete syntax, type system rules, code generation, etc. Finding a way to let a user to specify all these aspects in a convenient/intuitive way is the goal of this research. A solution introduced in Language Wheel is so-called illustrative language definition, where "var x;" serves as THE definition of concept Variable Declaration, rather than more usual definition along the lines of "var":keyword identifier:string ";":keyword.

      I will talk about current web-based prototype implementation of the system.

      Language Wheel homepage
      Some slides on Language Wheel

  • Thursday 2018-08-23 1400-1600, Vilvite auditorium

    Bjarne Stroustrup (Managing Director, Technology Division, Morgan Stanley, NYC, NY, USA):
    The Continuing Evolution of C++

    The development of C++ started in 1979. Since then, it has grown to be one of the most widely used programming languages ever, with an emphasis on demanding industrial uses. It was released commercially in 1985 and evolved through one informal standard (“the ARM”) and several ISO standards: C++98, C++11, C++14, and C++17. How could an underfinanced language without a corporate owner succeed like that? What are the key ideas and design principles? How did the original ideas survive almost 40 years of development and 30 years of attention from a 100+ member standards committee?

    What is the current state of C++ and what is likely to happen over the next few years? What are the problems we are trying to address through language evolution?

    Short bio: Bjarne Stroustrup is the designer and original implementer of C++ as well as the author of The C++ Programming Language (Fourth Edition), A Tour of C++, Programming: Principles and Practice using C++ (Second Edition), and many popular and academic publications. Dr. Stroustrup is a Managing Director in the technology division of Morgan Stanley in New York City as well as a visiting professor at Columbia University. He is a member of the US National Academy of Engineering, and an IEEE, ACM, and CHM fellow. He received the 2018 Charles Stark Draper Prize, the IEEE Computer Society's 2018 Computer Pioneer Award, and the 2017 IET Faraday Medal. His research interests include distributed systems, design, programming techniques, software development tools, and programming languages. He is actively involved in the ISO standardization of C++. He holds a masters in Mathematics from Aarhus University, where he is an honorary professor, and a PhD in Computer Science from Cambridge University, where he is an honorary fellow of Churchill College.

    Bjarne Stroustrup's personal website.

VilVite auditorium is in VilVite, Thormøhlensgt 51.
Conference room D is in VilVite, Thormøhlensgt 51.
Lille auditorium is in Datablokken, Høyteknologisenteret, Thormøhlensgt 55.
Stort auditorium is in Datablokken, Høyteknologisenteret, Thormøhlensgt 55.

VilVite, Thormøhlensgt 51

Previous years