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 2021

  • Thursday 2021-01-21 1515-1600, Zoom

    Benjamin Chetioui (BLDL, University of Bergen)
    Composable Transformations of Python Programs with JAX

    Abstract: JAX is a research project that leverages the NumPy interface and the XLA compiler to produce high-performance code that runs seamlessly on CPU, GPU, and TPU while conserving the ease of prototyping provided by Python. JAX is at the core of many higher-level machine learning libraries, many of which power DeepMind’s research. This talk will focus on one of the key components that give JAX its power, namely its composable function transformations.

    Short bio: Benjamin Chetioui is a PhD candidate in the PUT group at UiB. He was a part of the JAX core team during the second half of 2020, and remains a contributor to the project.

  • Thursday 2021-02-04 1515-1600, Zoom

    Semyon Atamas (JetBrains)
    Fortran for IntelliJ: pitfalls of supporting old language in a modern IDE

    Fortran is a 64-year old language but is still used in some areas, mostly related to hard computations. Working with such a technology stack is hard and when your favorite IDE can’t help you it’s even harder. That’s why I decided to create a Fortran plugin for the IntelliJ platform. In this talk, I’ll give an overview of the general concepts of language plugins for the IntelliJ platform, tell what problems we faced with our plugin for the Fortran language, and share some statistics about plugin users.

    Short bio: Semyon Atamas is a Tech Lead of the Plugins Marketplace Team in JetBrains. He has a M.Sc. degree in software engineering from the Academic University in St. Petersburg and a B.Sc. in physics from St. Petersburg Polytechnical University. Prior to joining JetBrains, Semyon worked at Intel Research. He is the creator and maintainer of JetBrains's IntelliJ plugin for Fortran.

  • Friday 2021-04-09 1215-1400, Zoom

    Yulia Startsev (Mozilla, DE)
    Developing JavaScript in the SpiderMonkey engine

    If you have programmed a bit, in any language, You might be curious about how the language evolves; what it takes for an idea to go from –something we talk about– to a functioning part of a run time. Something that you, as a developer, might use in your work. In this talk, we will answer that question for the JavaScript Language. This talk will also dive a bit into the research that we do at TC39, the standardizing body responsible for it.

    By walking in the footsteps of a proposal (Nullish Coalescing) we will see the steps every proposal must go through to be accepted by Ecma's TC39 committee and finally become published by the specification body each spring. Along the way, we will learn a little about how to read specifications. As the last leg of this journey, we will implement the feature together in Firefox's SpiderMonkey Engine, understanding each part of the engine that we touch and what it means for something to be a "Standard". You will come away from this talk knowing about the process from start to finish, and hopefully inspired to take a deeper look.

    Short bio: Yulia Startsev is a programmer at Mozilla on the SpiderMonkey Team. She represents Mozilla at ECMA TC39, the standardizing body for JavaScript (officially Ecmascript).

  • Thursday 2021-04-29 1415-1600, Zoom

    John Reid (JKR Associates and Rutherford Appleton Laboratory, UK)
    History of Coarrays and SPMD Parallelism in Fortran

    The coarray programming model is an expression of the Single-Program-Multiple-Data (SPMD) programming model through the simple device of adding a codimension to the Fortran language. A data object declared with a codimension is a coarray object. Codimensions express the idea that some objects are located in local memory while others are located in remote memory. Coarray syntax obeys most of the same rules for normal array syntax. It is familiar to the Fortran programmer so the use of coarray syntax is natural and intuitive. Although the basic idea is quite simple, inserting it into the language definition turned out to be difficult.

    In addition, the process was complicated by rapidly changing hardware and heated arguments over whether parallelism should be supported best as an interface to language-independent libraries, as a set of directives superimposed on languages, or as a set of specific extensions to existing languages.

    In this paper, we review both the early history of coarrays and also their development into a part of Fortran 2008 and eventually into a larger part of Fortran 2018. Coarrays have been used, for example, in weather forecasting and in neural networks and deep learning.

    Short bio: John Reid spent most of his career performing research in the Numerical Analysis Group that began at Harwell and moved to the Rutherford Appleton Laboratory (RAL) in 1990. He is currently an Honorary Scientist at RAL. Much of this work resulted in Fortran codes in HSL (formerly Harwell Subroutine Library). He has been actively involved in Fortran standardization since 1983 and was Convenor (chair) from 2000 to 2017 for ISO/IEC JTC1/SC22/WG5. He was the main author of a series of OUP books giving informal descriptions of the successive Fortran standards, all with explanations. For the last ten years, his main Fortran interest has been in the standardization of coarrays.

  • Wednesday 2021-05-05 1415-1600, Zoom

    Bjarne Stroustrup (Morgan Stanley and Columbia University, USA)
    Thriving in a crowded and changing world: C++ 2006-2020

    By 2006, C++ had been in widespread industrial use for 20 years. It contained parts that had survived unchanged since introduced into C in the early 1970s as well as features that were novel in the early 2000s. From 2006 to 2020, the C++ developer community grew from about 3 million to about 4.5 million. It was a period where new programming models emerged, hardware architectures evolved, new application domains gained massive importance, and quite a few well-financed and professionally-marketed languages fought for dominance. How did C++ – an older language without serious commercial backing – manage to thrive in the face of all that? This talk focuses on the major language changes to the ISO C++ standard for the 2011 and 2020 revisions.

    Themes include efforts to preserve the essence of C++ through evolutionary changes, to simplify its use, to achieve complete type-and-resource safety, to improve support for generic programming, to better support compile-time programming, to extend support for concurrency and parallel programming, and to maintain stable support for decades’ old code.

    The ISO C++ standard evolves through a consensus process. We try (not always successfully) to mitigate the effects of design by committee, bureaucratic paralysis, and excessive enthusiasm for a variety of language fashions.

    Short bio: Bjarne Stroustrup is the designer and original implementer of C++. Dr. Stroustrup is a Technical Fellow and a Managing Director in the technology division of Morgan Stanley in New York City and a Visiting Professor in Computer Science at Columbia University. His research interests include distributed systems, design, programming techniques, software development tools, and programming languages.

    Bjarne Stroustrup's personal website.

  • Thursday 2021-05-20 1415-1600, Zoom

    Peter Van Roy (Université catholique de Louvain, BE)
    A History of the Oz Multiparadigm Language

    Oz is a programming language designed to support multiple programming paradigms in a clean factored way that is easy to program despite its broad coverage. It started in 1991 as a collaborative effort by the DFKI (Germany) and SICS (Sweden) and led to an influential system, Mozart, that was released in 1999 and widely used in the 2000s for practical applications and education.

    We give the history of Oz as it developed from its origins in logic programming, starting with Prolog, followed by concurrent logic programming and constraint logic programming, and leading to its two direct precursors: the concurrent constraint model and the Andorra Kernel Language (AKL).

    We give the lessons learned from the Oz effort including successes and failures and we explain the principles underlying the Oz design. Oz is defined through a kernel language, which is a formal model similar to a foundational calculus, but that is designed to be directly useful to the programmer. The kernel language is organized in a layered structure, which makes it straightforward to write programs that use different paradigms in different parts.

    Oz is a key enabler for the book Concepts, Techniques, and Models of Computer Programming (MIT Press, 2004). Based on the book and the implementation, Oz has been used successfully in university-level programming courses starting from 2001 to the present day.

Previous years