[FOSDEM] FOSDEM 2018 - Ada Developer Room - Sat 3 Feb 2018 - Brussels

[Dirk Craeynest]

-----------------------------------------------------------------------

         Ada-Belgium is pleased to announce the program for its

                 8th Ada Developer Room at FOSDEM 2018

                      on Saturday 3 February 2018

   Université Libre de Bruxelles (ULB), Solbosch Campus, Room AW1.125
     Avenue Franklin D. Roosevelt Laan 50, B-1050 Brussels, Belgium

                Organized in cooperation with Ada-Europe

<http://www.cs.kuleuven.be/~dirk/ada-belgium/events/18/180203-fosdem.html>
              <http://fosdem.org/2018/schedule/track/ada/>

-----------------------------------------------------------------------

FOSDEM, the Free and Open source Software Developers' European Meeting,
is a non-commercial two-day weekend event organized early each year in
Brussels, Belgium.  It is highly developer-oriented and brings together
8000+ participants from all over the world.  The goal is to provide
open source developers and communities a place to meet with other
developers and projects, to be informed about the latest developments
in the open source world, to attend interesting talks and presentations
on various topics by open source project leaders and committers, and
to promote the development and the benefits of open source solutions.
The 2018 edition takes place on Saturday 3 and Sunday 4 February.  It
is free to attend and no registration is necessary.

In this edition, Ada-Belgium organizes once more a series of
presentations related to the Ada Programming Language and Free or
Open Software in a s.c. Developer Room.  The "Ada DevRoom" at FOSDEM
2018 is held on the first day of the event, Saturday 3 February 2018.

---------------------------------------
Ada Programming Language and Technology
---------------------------------------

Ada is a general-purpose programming language originally designed
for safety- and mission-critical software engineering.  It is used
extensively in air traffic control, rail transportation, aerospace,
nuclear, financial services, medical devices, etc.  It is also perfectly
suited for open source development.

Awareness of safety and security issues in software systems is
increasing.  Multi-core platforms are now abundant.  These are some
of the reasons that the Ada programming language and technology
attracts more and more attention, among others due to Ada's support
for programming by contract and for multi-core targets.  The Ada 2012
language definition was approved and published by ISO in December 2012,
updated early 2016, and work on new features for the next revision
is ongoing.  As with the prior Ada 1995 and Ada 2005 standards,
the first full implementation of the Ada 2012 standard was made
available in gcc - the GNU Compiler Collection (GNAT).  More and more
tools are available, many are open source, including for small and
recent platforms.  Interest keeps increasing, also in the open source
community, and many exciting projects started.

The Ada DevRoom aims to present the facilities offered by the
Ada language (such as for object-oriented, multicore, or embedded
programming) as well as some of the many exciting tools and projects
using Ada.

--------------------------------
Ada Developer Room Presentations (room: AW1.125, 76 seats)
--------------------------------

The presentations in the Ada DevRoom start after the opening FOSDEM
keynote.  The program runs from 10:30 to 19:00, and consists of 7.5
hours with 9 talks by 9 presenters from 5 different countries, plus
2 half-hour sessions with informal discussions.

10:30-11:00 - Arrival & Informal Discussions

  Feel free to arrive early, to start the day with some informal
  discussions while the set-up of the DevRoom is finished.

11:00-11:05 - Welcome
              by Dirk Craeynest - Ada-Belgium

  Welcome to the Ada Developer Room at FOSDEM 2018, which is organized
  by Ada-Belgium in cooperation with Ada-Europe.  Ada-Belgium and
  Ada-Europe are non-profit organizations set up to promote the
  use of the Ada programming language and related technology,
  and to disseminate knowledge and experience into academia,
  research and industry in Belgium and Europe, resp. Ada-Europe has
  member-organizations, such as Ada-Belgium, in various countries,
  and direct members in many other countries.  More information on this
  DevRoom is available on the Ada-Belgium web-site (see URL above).

11:05-11:50 - An Introduction to Ada for Beginning and Experienced Programmers
              by Jean-Pierre Rosen - Adalog

  An overview of the main features of the Ada language, with special
  emphasis on those features that make it especially attractive for
  free software development.  Ada is a feature-rich language, but what
  really makes Ada stand-out is that the features are nicely integrated
  towards serving the goals of software engineering.  If you prefer
  to spend your time on designing elegant solutions rather than on
  low-level debugging, if you think that software should not fail,
  if you like to build programs from readily available components
  that you can trust, you should really consider Ada!

12:00-12:50 - Making the Ada_Drivers_Library: Embedded Programming with Ada
              by Fabien Chouteau - AdaCore

  The Ada programming language was designed for embedded programming
  and it is well known in the aerospace domains and in general every
  domain where failure is not an option.  Unfortunately it is not
  used a lot in the embedded FOSS community.  In the past two years,
  AdaCore worked to promote the use of Ada in the FOSS community,
  in particular for embedded programming with the "Make with Ada"
  blog post series, my interview for the Embedded.fm podcase, blog
  posts on "ARM Community" or the "Make with Ada" competition.

  In this 45 minutes lecture I will:
  + give a short introduction of Ada for embedded and how its features
    (programing by contract, strong typing, representation clauses
    (hardware mapping), OOP, static compiler checks and optional
    run-time checks) can help improving the development time,
    maintenance and quality of FOSS embedded projects;
  + present the Ada_Drivers_Library project, where we put all those
    features in practice to develop micro-controller device drivers
    in Ada;
  + make a quick getting started demo;
  + present some of the best projects from the "Make with Ada"
    competition.

13:00-13:20 - Shared Memory Parallelism in Ada: Load Balancing by Work Stealing
              by Jan Verschelde - University of Illinois at Chicago

  Tasking in Ada provides an effective tool for shared memory
  parallelism.  For coarse grained regular parallelism, load balancing
  works with one single job queue.  For finer grained and irregular
  parallelism, work stealing balances the load with multiple job
  queues.  The programming concepts will be illustrated with examples
  of algorithms in polyhedral geometry.  The demonstrated code belongs
  to the free and open source PHCpack.

13:30-13:50 - Ada, or How to Enforce Safety Rules at Compile Time
              by Jean-Pierre Rosen - Adalog

  This is a real life story of a mixed criticality system, where a
  proper usage of Ada's features for controlling visibility allowed
  a provable enforcement of the segregation rules at compile time:
  any violation would simply not compile.

14:00-14:50 - Contract-based Programming: a Route to Finding Bugs Earlier
              by Jacob Sparre Andersen - JSA Research & Innovation

  Contract-based programming is a software development technique,
  where you include assertions of program properties as a part of the
  compiled source text.  In the strict form, the assertions are checked
  at compile-time, but in this presentation I will focus on the more
  common, less strict, form, where at least some of the assertions
  aren't checked until run-time.  Ada gives us a lot of help, so we
  can write the our assertions about the program properties once, and
  then have the compiler insert actual run-time checks wherever there
  is a possibility that the assertion is violated.

  This presentation will focus on how we can write these contracts in
  Ada in a way that make them effective at ensuring that our source
  text does what we intend it to and allow the compiler to generate
  efficient checks of the assertions.  The intended audience is anybody
  with enough programming experience to know concepts like types,
  encapsulation and packages.  Having tried to write Ada before will
  be a benefit, but it isn't a requirement.

15:00-15:50 - SPARK Language: Historical Perspective & FOSS Development
              by Yannick Moy - AdaCore

  SPARK started in 1987 as a restricted subset of Ada 83, defined by
  its own grammar rules.  The overhaul of the language and toolset
  starting in 2010 increased greatly the language subset, dropping in
  effect the need for separate grammar rules.  Since then, SPARK has
  progressively adopted most of the Ada features, to a point where the
  last remaining non-SPARK significant Ada feature today is pointers.
  We have started work on including safe pointers in SPARK, borrowing
  the ideas of pointer ownership from Rust.  So one can legitimately
  wonder what difference remains between SPARK and Ada.

  In the first part of this talk, I will lay out the principles that
  have guided us through the inclusion of language features in SPARK
  since 2010.  I will describe in particular the trade-offs that
  we considered for support of important features like recursion,
  types with non-static constraints, generics, object orientation,
  concurrency.  I will give a preview of the support envisioned
  for pointers in SPARK.  So that the distinction between Ada and
  SPARK appears clearly: it's not about quantity, it's about safety
  and security.

  In the second part of this talk, I will give a tour of FOSS projects
  which are using SPARK today: Aida, Certyflie, Muen, PolyORB-HI,
  Pulsar, StratoX, Tokeneer.  For each one, I will describe at
  which level of assurance SPARK is used, with how much efforts and
  for which benefits.  Then I will focus on the largest one, Muen,
  an x86/64 separation kernel for high assurance.  Finally, we will
  look at the resources which are available to the community for FOSS
  development in SPARK.

16:00-16:50 - Writing REST APIs with OpenAPI and Swagger Ada
              by Stephane Carrez - Bouygues Telecom

  The OpenAPI specification is an emerging specification to describe
  RESTful web services.  The Swagger suite is a collection of tools
  to write such API descriptions and have the code generated in more
  than 29 languages, including Ada.  The presentation will describe
  how to write a REST operation with OpenAPI, generate the Ada client
  with Swagger Codegen and use the generated code to interact with
  the server.  We will also describe the generated Ada server code
  and how to implement the server side and run a complete REST server.

17:00-17:50 - Browser-as-GUI and Web Applications with Gnoga
              by Jeffrey R. Carter - Atos Belgium

  Gnoga is an all-Ada library that uses the features of modern web
  browsers as a portable GUI.  The program may run on the same computer
  as the browser, or on a server over the internet.  Participants will
  be introduced to using Gnoga to create such programs.

  A singleton version of the Random_Int demo program will be used to
  demonstrate the use of Gnoga as the GUI for a program running on the
  same computer as the browser.  Random_Int is a very simple program
  that generates (pseudo)random integers in a user-specified range.
  The Chattanooga demo is a text-chat server program allowing people
  to chat on line.  It demonstrates the use of Gnoga to create web
  applications.  A secure version of Chattanooga can sometimes be
  accessed at https://chat.gnoga.com/.  (The certificate for this site
  has expired, but can still be used to ensure encrypted communication
  with the site.)

  After installing Gnoga, the demos are available in the demo
  directory.  More information about Gnoga may be found at gnoga.com,
  especially the Tools page.

18:00-18:20 - Easy Ada Tooling with Libadalang
              by Raphaël Amiard and Pierre-Marie De Rodat - AdaCore

  A lot of developers consider that a language is only as good as the
  tooling that accompanies it.  Ada has been conceived as a language
  pretty well amenable to tooling, yet the tooling offer besides
  AdaCore's is not very extensive, at least when compared to other
  languages like Java, despite the existence of the ASIS project
  (Ada Semantic Interface Specification).

  One of Libadalang's aims is to help solve that by providing an
  easy way to build new Ada-aware tools.  Libadalang is a library
  that allows the user to query information about Ada code, including:
  + Syntactic information.  Query the token stream, the syntax tree,
    find syntax patterns, etc.
  + Semantic information, such as which declaration an identifier
    references, the type of expressions, all references to a
    declaration, etc.
  In addition, one of the aims is to allow the users to modify the
  trees, and propagate the changes to the source.

  This talk will go over what Libadalang can already do today, how
  it differs from ASIS, future plans for the library, and potential
  exciting use cases.

18:30-19:00 - Informal Discussions & Closing

  Informal discussion on ideas and proposals for future events.

-------------------------------
More information on Ada DevRoom 
-------------------------------

Speakers bios, pointers to relevant information, links to the FOSDEM
site, etc., are available on the Ada-Belgium site at
<http://www.cs.kuleuven.be/~dirk/ada-belgium/events/18/180203-fosdem.html>

We invite you to attend some or all of the presentations: they will
be given in English.  Everybody interested can attend FOSDEM 2018;
no registration is necessary.

We hope to see many of you there!

Dirk Craeynest, FOSDEM Ada DevRoom coordinator
Dirk.Craeynest at cs.kuleuven.be (for Ada-Belgium/Ada-Europe/SIGAda/WG9)