FortranCon 2020

Europe/Zurich
ZOOM (University of Zurich)

ZOOM

University of Zurich

Anna Hehn (University of Zurich), Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich), Vladimir Rybkin (University of Zurich)
Description

Synopsis

FortranCon 2020 is the first International Conference targeting the development for and with the Fortran programming language and will take place on July 2 - 4 in Zurich, Switzerland.

In recent years Fortran has seen a series of new standards, improving the language in regards to object-oriented, parallel and general-purpose programming. This has spurred the development of several new projects written in and for Fortran, helping the Fortran programmers - in particular, the scientific community - to modernize their code and make it more maintainable.

With this conference, we intend to bring together active Fortran project developers from all fields: library and tool developers as well as people using Fortran to develop scientific applications, to share their experience and exchange ideas.

Comments on the Covid-19 situation:

The conference will take place and will be held completely virtually.
Start times:

  • on Thursday: 15:00/3pm UTC+2/CEST
  • on Friday: 13:00/1pm UTC+2/CEST

Keynote

For the Keynote talk we are happy to welcome Mr. Steve Lionel, convener of the ISO Fortran Standards group, retired Intel employee and to many known as Doctor Fortran.

Conference Structure / Registration / Call for Abstracts

The FortranCon 2020 is organized in two full days with speaker presentations (2. and 3. July) and a half-day workshop (4. July) on a particular Fortran topic with lectures and hands-on sessions. Anyone interested is kindly requested to register for the event, specifying if she/he would like to participate in the conference and/or the tutorial. The registration is free of charge. Please register until June 1st, 2020 June 12th, 2020 (extended deadline). Participants can virtually attend the meeting (due to Covid-19 situation).

A Call-for-Abstract is also open for people who would like to present at the conference. The official language is English. We have 2 tracks: Selected Presentations (25 + 5 minutes discussion) and Junior Presentations (15 + 5 minutes discussion). The Junior presentations are principally intended for Junior researchers and will be directly decided on by the Local Committee while the Selected Presentations will be reviewed by a Scientific Committee.

The submission must consist of a title (max 10 words) and an abstract (max 200 words). Furthermore, it is required to specify if you apply for a 15 or 25 minutes presentation. Note that juniors have the priority for the 15 minutes slots. You should submit a talk about anything you think is worth sharing with the Fortran Community. However, we are happy to host talks on other topics that can inspire us. Speakers will be requested to describe their experience, the implemented techniques, and the eventual new developments.

Unless explicitly requested by the speaker, all presentations will be recorded and made available through SWITCHtube. If required, presentations can also be given remotely. Please leave a note during the abstract submission or contact the organizers if you want/have to give the presentation remotely.

The Scientific Committee members advise on the selection of the selected presentations by voting each presentation. Each vote is between 1 – 5 points per talk. Members who are also submitting for a talk will not be able to vote on their own presentation. Furthermore, a member will not be able to vote if there is a possibility of a conflict. Based on this advice, the final decision is made by the Local Committee members once the voting deadline has passed (usually 15 days after the deadline of submission). There will be multiple calls for selected presentations (see deadlines), up to the fulfillment of the slots (14 presentations). Junior presentations are only selected by the Local Committee members following the criteria of being related to Fortran and based on the first-come, first-served basis up to the fulfillment of the junior slots (6 presentations). The decision of acceptance of the junior presentations is sent about 15 days after the submission, with the final deadline for submission on June 1st, 2020 (see deadlines).

The last half-day is devoted to a tutorial on a selected Fortran topic. Registered participants will be presented with a set of topics from which they can choose during the registration. The top selected topic will be presented in the tutorial. Example of topics are:

  • New Fortran 2003/2008 features (including Object-Oriented) and outlook to the new standard 2018
  • Best practices for Fortran
  • Fortran parallelization
  • Fortran/C/Python interoperability
  • Unit-testing frameworks
  • Meta-programming tools
  • Source-code documentation tools

Pre-requisites for the tutorial are: be active in the development of an application written in Fortran (basic knowledge of Fortran), basic knowledge of C language, familiarity with object-oriented programming concepts and parallel programming techniques.

Deadlines

Registration (free of charge): June 1st, 2020 June 12th, 2020 (extended deadline).

First Selected Call-for-Abstract: May 1st, 2020 (decisions sent by May 15th, 2020).

Second Selected Call-for-Abstract: June 1st, 2020 (decisions sent by June 15th, 2020).

Junior Call-for-Abstract: running deadline up to June 1st, 2020 (decisions sent about 15 days after the submission, based on the first-come, first-served basis up to the fulfilment of the junior slots).

Local Committee Members

Local committee members are in charge of the final selection of the selected and junior presentations, organization of the event, and preparation of the tutorial.

  • Tiziano Müller, Dept. of Chemistry, UZH
  • Anna Hehn, Dept. of Chemistry, UZH
  • Vladimir Rybkin, Dept. of Chemistry, UZH
  • Johann Mattiat, Dept. of Chemistry, UZH

Scientific Committee Members

Scientific committee members advice on the selection of the expert presentations.

  • Alfio Lazzaro, HPE CH
  • Anton Shterenlikht, HPE UK
  • Arjen Markus, Deltares NL
  • Milan Curcic, University of Miami USA
  • Rob Neely, LLNL USA
  • Wadud Miah, NAG UK

Funding

We gratefully acknowledge the funding of this event by the UZH Graduate Campus via its GRC Grant, the NCCR MARVEL and the Swiss National Supercomputing Centre.

GRC Grants Logo
Marvel Logo SNF Logo

The National Centres of Competence in Research (NCCR) are a research instrument of the Swiss National Science Foundation.

CSCS Logo
 
 
 
 
Registration
Conference registration
    • 14:30 16:00
      Welcome & Keynote
      Convener: Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich)
      • 14:30
        Registration 30m
      • 15:00
      • 15:15
        Keynote: Fortran 2018...and Beyond 45m

        Steve Lionel, Convenor of the ISO/IEC Fortran Standard Committee, talks about how a Fortran standard is made and then gives an overview of what's new in Fortran 2018. Looking to the future, Steve then highlights features planned for the next revision of the standard, whose working title is Fortran 202X.

        Speaker: Mr Steve Lionel (Intel (ret.))
    • 16:00 16:10
      Short break 10m
    • 16:10 17:20
      Session A: Community Efforts
      Convener: Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich)
      • 16:10
        Toward a thriving open source Fortran community 25m

        A thriving community around a programming language is essential for onboarding
        new users and retaining existing ones. Besides a few discussion boards and mailing lists, Fortran has not had a healthy online community in the modern internet era, like many other programming languages have. Despite the developments of the language, its user base has been declining as a result. Many new software projects are being started in languages like C++, Python, or Julia, despite Fortran being better suited for the task at hand. In this talk, we will discuss the need for and the ongoing development of the new fortran-lang (https://fortran-lang.org) community and its suite of projects that currently include a standard library, package manager, and a website. Fortran-lang aims to provide a central place for Fortran users, beginning and expert alike, to find recommended tools, libraries, tutorials, and discussion venues that are inclusive and welcoming of newcomers. We believe that an organized community and a home of Fortran on the internet, in addition to the Standards Committee and compiler developers, are essential for the long-term thriving—and not just mere survival—of Fortran. Finally, we will discuss the next steps, the one-year vision, and the 10-year vision for going forward.

        Speaker: Milan Curcic (University of Miami)
      • 16:40
        Fortran Standard Library 15m

        The Fortran Standard, as published by the International Organization for Standardization (ISO), does not include a Standard Library. The language can be extended with new intrinsic procedures and modules, but these must be formally standardized and then implemented by compiler vendors before becoming available to users. Therefore, the goal of this project is to provide a community driven and agreed upon de facto "standard" library for Modern Fortran, called the Fortran Standard Library (stdlib; https://github.com/fortran-lang/stdlib). This library aims to provide to the community a set of procedures for science, engineering, and mathematics. The overall scope of the Fortran Standard Library is therefore similar to the one of SciPy or to the default built-in Matlab scientific environment. Currently the library includes procedures for catching and handling errors, handling optional arguments, facilitating I/O operations, linear algebra, numerical integration, and descriptive statistics. Started a few months ago, no less than 15 people already contributed to the development of the Fortran Standard Library and its documentation. Many other programmers are also involved in active discussions about its development through GitHub issues. The development of this library is part of the Fortran-lang project and aims to collaborate with the Fortran Standards Committee.

        Speaker: Jeremie Vandenplas (WUR)
      • 17:00
        Fortran Package Manager 15m

        While Fortran is the oldest high level language, it has done quite well in keeping up with the times in terms of features and capabilities of the language itself. However, modern practices and developers have become accustomed to tools and ecosystems which provide many conveniences in a programming environment. Unfortunately, Fortran has not kept pace with such tooling and ecosystems. One such tool which has become popular is a package manager. A package manger is a tool that manages the dependencies of a project on other libraries. This is accomplished by keeping track of the dependencies, with specifiable version constraints, and automating the process of fetching them - including transitive dependencies - for use in the compilation of the project. Often included are the facilities for compiling, running, and testing the project, as well as searching for available open source libraries, and generating a template for new projects. This paper describes the development of just such a tool for Fortran, aptly named the Fortran Package Manager (FPM).

        Speaker: Brad Richardson
    • 17:20 17:50
      Break 30m
    • 17:50 19:20
      Session B: Compiler Support
      • 17:50
        Front-end optimization in gfortran 25m

        The gfortran front end to gcc reads in the source code and converts it to an abstract syntax tree, which is then converted to an intermediate representation which gcc then further optimizes and converts into assembler. However, there are certain optimizations that require knowledge of Fortran semantics and which are better handled at the level of the abstract syntax tree because the rest of the compiler is language-agnostic. In other words, the compiler rewrites the source code representation to something that the user ought to have written.

        This presentation gives an overview of what transformations are currently done, how their effect can be controlled by the user and what future developments might be. On that last point, input from the community is highly welcome.

        Speaker: Dr Thomas König (Gnu Fortran maintainer)
      • 18:20
        Flang: The LLVM Fortran Front-End 25m

        We'll present the goals, current status and future plans for Flang, the LLVM Fortran front-end.

        Flang is the new LLVM-based Fortran front-end supporting full Fortran 2018. It is being written from scratch in modern C++ and will make extensive use of existing LLVM tools (MLIR, LLVM IR, utility libraries, and so on). We expect this to be the last Fortran front-end that will ever need to be written.

        The primary goals of Flang are
        - Build a robust Fortran compiler using modern compiler techniques (parser combinators, multi-level intermediate representations) that encompasses all of the Fortran 2018 standard.
        - Develop an active community of developers (now DOE, NVIDIA, Arm, AMD and others).
        - Provide support for Fortran tool development.
        - Provide support for Fortran language experimentation for features proposed for future Fortran standards.

        60,000+ lines of the compiler have been upstreamed to the flang/ directory of the LLVM monorepo. Its build integrates with the rest of LLVM (as an optional component). This covers parsing, semantic analysis and the start on lowering to an MLIR dialect called FIR.

        We will also briefly discuss the next steps for the project.

        Speaker: Gary Klimowicz (NVIDIA)
      • 18:50
        LFortran: Interactive LLVM-based Fortran Compiler for Modern Architectures 25m

        We are developing a modern open-source Fortran compiler called LFortran
        (https://lfortran.org/). This front-end compiler will enable the interactive
        execution of code in environments like Jupyter. This will allow exploratory work
        (much like Python, MATLAB or Julia) which is currently not feasible. The
        interactivity of our compiler does not impede compilation of binaries with the
        goal to run user's code on modern architectures such as multi-core CPUs and
        GPUs, which is an essential requirement for wider Fortran adoption that current
        Fortran compilers do not address well. A Live demo of the compiler with a
        Jupyter notebook will be shown. The compiler itself is written in C++ for
        robustness and speed with optional Python wrappers to improve inter-operability.
        It parses Fortran code to an Abstract Syntax Tree (AST) and transforms it to an
        Abstract Semantic Representation (ASR). LFortran has several backends that
        transform the ASR to machine code via LLVM, or to C++, or to provide automatic
        Python wrappers. More backends are planned. The compiler has been designed to be
        modular so that data can be extracted/inserted between the different stages,
        which is an important feature that would support an ecosystem of tools that
        otherwise would be hard with a monolithic compiler.

        Speaker: Dr Ondřej Čertík (Los Alamos National Laboratory)
    • 19:20 20:20
      Dinner/Lunch Break 1h
    • 20:20 22:10
      Session C: HPC Applications
      • 20:20
        Copernicus Spacecraft Trajectory Design and Optimization Program 15m

        Copernicus is a spacecraft trajectory design and optimization application developed at the NASA Johnson Space Center. Copernicus is written in Fortran and uses many features of the latest language standards. The tool is used for a wide range of projects at NASA, including the upcoming Artemis missions to flight test the Orion spacecraft and then return humans to the Moon. This presentation will give a brief overview of the software, its history, how it was designed, and how it is used.

        Speaker: Mr Jacob Williams (NASA Johnson Space Center)
      • 20:40
        Evolving Fortran for Emerging Architectures: Lessons from the ICON-GPU Atmospheric Model 25m

        For decades Fortran has been on the forefront of high performance computing. As new architectures emerged, the Fortran standard added constructs to exploit them, but not always with complete success. For example, F90 added array syntax to describe vectorization, yet vectorizing compilers found it easier to translate DO loops with appropriate directives. Co-arrays were added in F08 and extended in F18 to support distributed memory, but this is usually addressed by the Message-Passing Interface (MPI). Other libraries, e.g., BLAS, LAPACK or PLASMA cover optimized numerical calculations outside of the language.

        The advent of General Purpose Graphics Processing Units (GPGPUs) has created another conundrum. They can be programmed with an appropriate language (CUDA, CUDAFortran, or OpenCL) or with directives (e.g., OpenMP4.5 or OpenACC3.0), each with disadvantages. In this talk, we outline the lessons learned in porting the ICON atmospheric model to GPUs with OpenCL, CUDAFortran and, finally, OpenACC, with the latter now in production at the Swiss National Supercomputing Centre (CSCS). Now that we understand the programming challenges, it is possible to consider new extensions to the Fortran standard to address GPUs, which are clearly not going away any time soon. We attempt to give some future perspectives.

        Speaker: William Sawyer (Swiss National Supercomputing Centre)
      • 21:10
        EIS2 - A mathematically rich input file processor for HPC applications 25m

        Allowing users to control software using input control files has substantial benefits for ease of use, avoidance of error and reproducibility of results. Evaluation of mathematical expressions provides a powerful way of allowing user control of even the most complex codes while remaining natural and easy-to-learn for the end user. Derived from the input control system of the EPOCH particle-in-cell plasma code, EIS2 allows a developer to add rich text file based controls to a large scientific code. EIS2 combines a mechanism for reading structured, hierarchical text files with a mechanism for evaluting mathematical expressions while allowing the host code to provide contextual information as the expression is evaluated. This means that a text expression provided by a user such as (1+sin(x))*(1+cos(y)) can be easily evaluated over a range of x and y values and used to set values as required by the host code. By using an approach that is optimised for performance rather than generality evaluating these expressions is many times faster than a general purpose parser such as Python.

        EIS2 is written in standard Fortran 2003 (with optional 2008 extensions) and has a C interoperable interface for other languages (releasing soon).

        https://github.com/csbrady-warwick/EIS-2

        Speaker: Christopher Brady (University of Warwick)
      • 21:40
        Using R with High Performance Fortran on a Windows Laptop 25m

        We will discuss the integration of R with Fortran, using such tools as
        MPI, OpenACC and CUDA Fortran on a Windows laptop. We will consider how
        to create a package with all three of these tools. We will demonstrate the
        considerable speedup with ordinary kriging and other spatial functions. We
        can exploit the statistical functions by utilizing the NVIDIA graphics card
        in conjunction with the PGI Community Edition Fortran compiler. Our
        package can extend the current functions by extreme speedups.

        Speaker: Dr Erin Hodgess (Western Governors University)
    • 13:00 14:50
      Session D: Interfacing
      Convener: Anna Hehn (University of Zurich)
      • 13:00
        Connecting Fortran to the Internet of Things 25m

        At first glance, Fortran may not be easily associated with the emerging Internet of Things and its new networked services, data formats, and protocols. In fact, the language features of modern Fortran make it possible to inter-connect with existing third-party libraries, written in C, Lua, Python, and other languages. With the toolset given by the ISO C binding module, Fortran applications gain access to RESTful web services, NoSQL databases, ZeroMQ message queues, MQTT-based pub/sub middleware, or IoT sensor networks. The talk will give an overview of existing technologies and how to access them from Fortran.

        Speaker: Mr Philipp Engel
      • 13:30
        gtk-fortran: a GTK / Fortran binding 25m

        The gtk-fortran binding (https://github.com/vmagnin/gtk-fortran/wiki), developed since 2011, is based on the ISO_C_BINDING module, introduced in the Fortran 2003 standard, which is used to interface fortran programs with the functions of the GTK libraries (mainly written in C). gtk-fortran is multi-platform: Linux, FreeBSD, MacOS, Windows (via MSYS2), and even Raspberry Pi (ARM processor)...

        GTK being a collection of libraries (GTK, Pango, GDK, ATK, Cairo, GdkPixbuf, GLib...), a python script parses the hundreds of GTK header files and generates around 10000 Fortran / C interfaces. A supplementary High Level library can ease programming, and PLplot can also be used in gtk-fortran. The user can learn to create Graphical User Interfaces using its wiki documentation and the commented Fortran examples.

        We will finally speak of the new GTK 4 development branch, our objective being to be ready for the release of that next major version around the end of the year. We will also present some ideas for the future and a SWOT analysis of the project.

        Speaker: Vincent MAGNIN (Univ. Lille, CNRS, Centrale Lille, Yncréa ISEN, Univ. Polytechnique Hauts-de-France, UMR 8520 - IEMN, F-59000 Lille, France.)
      • 14:00
        Shroud: generate Fortran wrappers for C and C++ libraries 25m

        Fortran application often need to access libraries which are written
        in C or C++. The interoperability with C features introduced in
        Fortran 2003 standardized access to symbols and types. But to access
        all of the features of C++ libraries additional wrapper code must be
        written, often by the author of the C++ library who may not be
        familiar with modern Fortran features.
        Shroud is a tool to create an idiomatic Fortran interface for a C++
        library. The user creates a YAML file with the C/C++ declarations to
        be wrapped along with annotations to provide semantic information and
        code generation options.
        Many C++ features will map directly to Fortran such as classes,
        overloaded function, default arguments and template instantiation.
        Shroud has successfully been used by several projects over the past
        four years.
        Shroud is written in Python and available at github.com/llnl/shroud
        with a BSD license.

        Speaker: Lee Taylor (Lawrence Livermore National Laboratory)
      • 14:30
        Designing a Modern C++/Fortran Interface by Example 15m

        In the world of quantum chemistry programs, Fortran reigns supreme. While there are packages available that are purely written in C++ and Python, it has become increasingly common to combine different languages. Common combinations include C++/Fortran or Python/C++.

        Fortran 2003 introduced a standardized way to generate interoperable procedures and derived types with the C programming language, using the BIND(C) attribute. This was a necessary step, as interfaces from C to legacy Fortran code had compiler-specific problems which made portability a major issue. Following Fortran 2008 and 2018, more technical specifications were accepted that furthered interoperability.

        In this presentation, we will discuss the development of a C/C++ interface to a modern Fortran library called DBCSR (Distributed Block Compressed Sparse Row), designed for efficient sparse matrix-matrix multiplication, among other operations. This interface is currently being incorporated in a novel sparse-tensor quantum chemistry program written in C++. Several points about C/Fortran interoperability will be addressed, such as memory management, derived types, handling arrays, and problems encountered therein, as well as how preprocessors may be used to help design a modern C++ interface with Fortran at its roots.

        Speaker: Mr Maximilien Ambroise (Universität Heidelberg)
    • 14:50 15:20
      Coffee break 30m
    • 15:20 16:50
      Session E: Scripting, DSLs and Experimental Programming
      • 15:20
        Program flow control using scripting languages 15m

        Controlling program flow from scripting languages is a tractable extension which lowers barriers for extending functionality in lower level languages (such as fortran).

        In this presentation we show how a set of required features enables end-users to change and control the program flow using Lua scripts.
        The following features are necessary for minimal code in the hosting program:
        - dictionaries for seamless data exchange with little coding effort
        The dictionaries allows (pointers to) data to be referenced via characters and ensures
        no intermediate copying of data.
        - running a Lua interpreter
        - creating interaction points in program
        This is the most problematic part since you have to expose break points where the
        hosting program stops and calls Lua. Another approach would be to build your entire program
        around scripting.

        In our density functional theory program (Siesta) we expose Lua for users to implement their own molecular dynamics engines, change convergence criteria/properties based on self consistent cycles, and more.

        This coding effort revealed substantial insight on how to control and expose data structures for end users in scripting languages.
        We envision that other scripting languages are better suited since the communities are not experienced Lua coders/users, e.g. Python, nim.

        [aotus,flook,fdict]

        Speaker: Dr Nick Papior (DTU DCC)
      • 15:40
        The Futile project: an embedded DSL to simplify the treatment of low-level operation in large Fortran programs 15m

        While writing a FORTRAN code, the developer is often obliged to increase code smell (see https://en.wikipedia.org/wiki/Code_smell) due to the intrinsic characteristic of the programming language.
        This problem not only generate inaesthetically long code, but is also responsible of the great majority of side-effects and bugs.
        The FUTILE project is an attempt to simplify developer's life by taking care of some of these operations.
        By definition, this suite of modules is conceived for Fortran programmers. The Fortran standard used is F95, with only minor extensions to F2003 standard, in the aim of increase portability with older codes.
        In addition to that, FUTILE package might be also seen as a framework, which helps traditional Fortran developers to "think differently" and to write code subprograms which are similar to those of higher level, "object-oriented" programming.

        Speaker: Luigi Genovese (CEA Grenoble)
      • 16:00
        Generic Programming Techniques 15m

        Different strategies towards generic programming in Fortran are discussed. The Fypp preprocessor is presented as a versatile tool for condititional compilation and template metaprogramming.

        Speaker: Mr Patrick Seewald (University of Zurich)
      • 16:20
        Experimental Fortran Programming 25m

        While Fortran is usually used for serious work, number crunching for instance, it does not mean that that is the only way to use it. Far from it, the features offered by modern Fortran allow all manner of experimentation with other programming paradigms. Emulating, say, prototype-based object-oriented programming may not lead to an efficient implementation, but it offers the benefits of demonstrating what the possibilities are of such a paradigm. In this talk I would like to present three cases of extending the language beyond the obvious:

        • Using user-defined operators to stay close to the mathematical notation of differential equations
        • An alternative way of looking at object-oriented programming
        • Introducing "lambda expressions"or anonymous functions

        As stated, the implementation probably will not lead to very efficient programs, but thinking beyond the traditional will bring new possibilities to light.

        Speaker: Dr Arjen Markus (Deltares)
    • 16:50 17:20
      Break 30m
    • 17:20 19:00
      Session F: Interfacing & IDEs
      • 17:20
        Interfacing with OpenCL from Modern Fortran for Highly Parallel Workloads 15m

        OpenCL is a well-established and widely-supported standard for executing parallel workloads
        on accelerator devices such as conventional multicore CPUs as well as GPUs and FPGAs.

        In this presentation, detail is given on a modern Fortran library which wraps calls to the OpenCL API with a higher abstraction level aimed at scientists and engineers looking to execute highly-parallel OpenCL kernels from Fortran. Modern Fortran features, including derived types, generics, operator-overloading and the iso c binding, are exploited to bring the Fortran style to OpenCL by: abstracting away pointers; providing a level of type-safety for device memory; detecting and handling program errors in a user-friendly manner; and providing a concise but feature-rich interface.

        Device kernels are written in the OpenCL C dialect and the Fortran library provides routines to: initialize the accelerator, allocate device memory, enqueue kernels for execution, perform memory transfers and manage device synchronisation.

        Code extracts and results are presented for two fluid dynamics codes implementing a lattice Boltzmann method and a multigrid finite volume Euler solver. Background is given on the challenges and design choices for programming GPU hardware from a Fortran perspective, followed by discussion on the future of accelerator offloading from the Fortran language.

        Speaker: Laurence Kedward (University of Bristol, UK)
      • 17:40
        Applying context-free grammar to hierarchically organized and variably shaped arrays 15m

        In the community of environmental modelling, the advent of hyper-resolution Earth observations and datasets in conjuncture with growing computational resources lead to an increase in model resolution.
        The mathematical representations of biogeophysical processes need to be solved for billions of grid cells and thousands of time points.
        Each process requires parameters that cannot be easily and sensibly set fix nor calibrated.
        Instead they need to be inferred directly from the land surface properties through transfer functions.
        In a simple form, they follow a context free grammar which follows the Fortran language.
        The transferred effective parameters have a hierarchical interdependency forming a tree structure.
        Yet finally, the shape of the arrays containing the land surface properties does usually not conform with the shape of the array of process parameters of the model.
        This necessitates multiple array broadcasting, slicing and remapping steps.
        The scientific approach - the Multiscale Parameter Regionalization (MPR) concept - is now available as an object-oriented and flexible Fortran library (https://git.ufz.de/chs/MPR).

        In this presentation, we discuss the design of the MPR library, show implementation details and highlight major difficulties. We are strongly interested in community feedback on the implementation.

        Speaker: Mr Robert Schweppe (Helmholtz-Centre for Environmental Research Leipzig - UFZ)
      • 18:00
        A Fortran-Keras Deep Learning Bridge for Scientific Computing 25m

        Implementing artificial neural networks is commonly achieved via high-level programming languages like Python, and easy-to-use deep learning libraries like Keras. These software libraries come pre-loaded with a variety of network architectures, provide autodifferentiation, and support GPUs for fast and efficient computation. As a result, a deep learning practitioner will favor training a neural network model in Python where these tools are readily available. However, many large-scale scientific computation projects are written in Fortran, which makes them difficult to integrate with modern deep learning methods. To alleviate this problem, we introduce a software library, the Fortran-Keras Bridge (FKB). This two-way bridge connects environments where deep learning resources are plentiful, with those where they are scarce. The library a number of unique features offered by FKB, such as customizable layers, loss functions, and network ensembles. We apply FKB to address open questions about the robustness of an experimental approach to global climate simulation, in which subgrid physics are outsourced to deep neural network emulators. In this context, FKB enables a hyperparameter search of one hundred plus candidate models of subgrid cloud and radiation physics, initially implemented in Keras, to then be transferred and used in Fortran to assess their emergent behavior.

        Speaker: Mr Jordan Ott (UC Irvine)
      • 18:30
        Code::Blocks: open source, cross platform IDE for Fortran 25m

        While it is possible to write Fortran code with a simple text editor, many programmers prefer to use an IDE (Integrated Development Environment) for their work. In addition to simply highlighting text in many editors, Code::Blocks offers Fortran users a grouping of their code files into projects, compiling code with the selected compiler directly from the IDE, code navigation, code completion and debugging with GDB debugger and more. Code::Blocks IDE is an open source project that has been continuously developed in C ++ by many developers from different countries since 2004. The source code of the IDE is organized in the core and in many plugins. Most of the functions specific to Fortran are implemented in the FortranProject plugin. The presentation explains many features of this IDE that are useful for programming in Fortran. It shows how to create a project and how to add existing code to this project, how to navigate the code and how to debug it. Some new features and ongoing work are also shown.

        Speaker: Darius Markauskas (TU Berlin)
    • 19:00 20:00
      Lunch/Dinner break 1h
    • 20:00 21:50
      Session G: Parallelization and Modernization
      • 20:00
        F2PY: Bringing fast code into the future 15m

        F2PY is a tool (authored by Pearu Peterson in 1999) to generate custom CPython
        extension modules to interface high-performance Fortran or C libraries to high-level Python code. The F2PY tool, currently packaged with NumPy, is one of the most fundamental packages in the scientific Python ecosystem. On the other hand, F2PY has not kept up with modern Fortran standards, as evidenced by the lack of support for user-defined types or derived types, for example. Adding these new features will improve significantly the applicability range of F2PY to interfacing modern Fortran libraries to Python code. Since Fortran is often, but unfairly, considered a niche programming language, finding contributors and building a community around this package has proven difficult, in spite of its importance and relevance in modern scientific code.

        In this talk, we will discuss the current status of the F2PY project and possible ways forward. This will include a discussion on how to create extension modules and F2PY's approach to doing this, with concrete examples for those unfamiliar with the tool. In addition, we will discuss current efforts to modernize this tool to extend its capabilities and make sure that projects that depend on it are supported in the future.

        Speaker: Dr Melissa Weber Mendonça (Quansight)
      • 20:20
        Highly Parallel Fortran and OpenACC Directives 25m

        Fortran has long been the language of computational math and science and it has outlived many of the computer architectures on which it has been used. Modern Fortran must be able to run on modern, highly parallel, heterogeneous computer architectures. A significant number of Fortran programmers have had success programming for heterogeneous machines by pairing Fortran with the OpenACC language for directives-based parallel programming. This includes some of the most widely-used Fortran applications in the world, such as VASP and Gaussian. This presentation will discuss what makes OpenACC a good fit for Fortran programmers and what the OpenACC language is doing to promote the use of native language parallelism in Fortran, such as do concurrent and Co-arrays.

        Speaker: Mr Jeff Larkin (NVIDIA)
      • 20:50
        Parallelization of a Legacy Software through Fortran 2018 Standard 25m

        Anatem is a software developed by the Brazilian Electrical Energy Research Center (Cepel) that aims to evaluate electromechanical disturbances on large power systems, being the most used software in Brazil for that matter. Its development dates from the late '80s through today, being a legacy code mostly written in Fortran 77 standard and before object-oriented programming mindset even existed. In the face of a challenge to achieve real-time simulation, parallel techniques were deployed employing Fortran 2018 standard with Intel Fortran 2020 compiler, reaching desirable results in less than six months of work.

        This presentation discusses how coarrays and collective functions could be applied to obtain fast implementations, with less coding than alternatives like the MPI library, the upsides, and the downsides for the before-mentioned approach.

        Speaker: Mr Nicolas Netto (Electrical Energy Research Center (Cepel))
      • 21:20
        ParaMonte: Plain Powerful Parallel Monte Carlo Library 25m

        We present the ParaMonte library, a pure-modern-Fortran open-source software for serial and parallel stochastic sampling and integration of high-dimensional mathematical objective functions of arbitrary shapes and dimensions. The principal design goals of the ParaMonte library are: 1. full automation of the entire build process of the library as well as all Monte Carlo simulations, 2. interoperability of the core library with multiple programming languages, including C/C++/MATLAB/Python/..., via the C-interoperability features of the Fortran language, 3. high-performance 4. parallelizability and scalability of the simulations, 5. virtually zero-dependence on external libraries, 6. fully-deterministic reproducibility and continuation of all stochastic simulations, 7. automatic comprehensive-reporting and post-processing of the simulation results. The library is Fortran-2018 standard compliant and the parallelization of the code relies on the MPI and Coarray parallelism paradigms within the Fortran programming language. We discuss how these design goals can help the ParaMonte users readily and efficiently solve a variety of machine learning and scientific inference problems on a wide range of platforms, from Jupyter notebooks on personal laptops to supercomputers. We also discuss how the modern features of the Fortran language simplified software development and what new language features would be desired from the developer perspective.
        https://www.cdslab.org/paramonte/

        Speaker: Prof. Amir Shahmoradi (The University of Texas)
    • 21:50 22:00
      Closing notes 10m
      Speaker: Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich)
    • 14:00 16:00
      Workshop: Tutorial 1: Introduction to OOP
      Conveners: Arjen Markus (Deltares), Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich), Vladimir Rybkin (University of Zurich)
    • 16:00 17:00
      Break 1h
    • 17:00 19:00
      Workshop: Tutorial 2: Advanced topics in OOP
      Conveners: Arjen Markus (Deltares), Tiziano Müller (Theory & Computation, Dept. of Chemistry, University of Zurich), Vladimir Rybkin (University of Zurich)