|
L1. Tim Steenvoorden, Rinus Plasmeijer (Radboud University, NL): Visual Prototyping using Task
Oriented Programming
In this course we
will create applications using a visual assistant for Task Oriented
Programming (TOP). TOP is a novel programming paradigm developers can use
to quickly prototype multi-user web applications. The central way of
modelling applications in TOP is by creating Tasks. Tasks represent pieces
of real world work that can be performed by people or by systems. Using a
handful of operations, they can be combined into bigger and more powerful
Tasks.
We will explore the
basic concepts of TOP by studying some example applications, while showing
how to model them using Tasks in a visual
development environment. The visual environment guides developers during
the modelling process. The tool only presents sane ways to create and expand
Tasks, and gives hints how to solve type and scoping errors. This results
in correct and compilable program code.
Students are
encouraged to extend the example applications in a hands
on session. Our visual approach does only require basic knowledge on
programming and data types. The introduction on TOP and its modelling
principles are a prerequisite on the course on mTasks..
L2. Mart Lubbers, Pieter Koopman,
Rinus Plasmeijer (Radboud University, NL): Task Oriented Programming for
the Internet of Things
The Internet of
Things (IoT) consists of devices that sense, act,
and communicate with other systems on the internet. Typical requirements
for IoT devices are that they must be cheap and
consume little energy. This is achieved by driving the IoT
devices by small microprocessors with tiny amounts of memory and processing
power. Most of these systems have no proper operating system and just run a
specific program to execute the intended task.
This makes
programming of the IoT very challenging. The
single program running on such a device must interleave all subtasks, like
monitoring inputs, controlling the peripherals and communication. Various
devices that cooperate have to agree on the protocol used and have to solve
the notorious concurrent programming problems.
In this lecture we
will give a hands-on introduction to Task Oriented Programming (TOP) for
the IoT. In our TOP approach the communication
between devices and their servers is handled transparently by the mTask system. The entire system is programmed in a
single high-level functional program. For each subtask of the system we
define a corresponding mTask. These subtasks can
be composed by task combinators to more powerful
tasks. These tasks can inspect intermediated values of other subtasks as
well as communicate with any other task in the system via Shared Data
Sources (SDS). Subtasks for an IoT device are
dynamically shipped to the device and interpreted there. The strong type
system prevents runtime type problems. This TOP approach greatly simplifies
the development of software for the IoT.
L3.1 João Paulo Fernandes (Univerity of Coimba, PT), Rui Pereira
(University of Minho & University of Beira Interior, PT): Paint your
Programs Green - On the Energy Efficiency of Data Structure Implementations
In this lecture we
analyse and compare the energy efficiency of different implementations for
concrete data abstractions such as Sequences, Sets or Associative
Collections. For each implementation, we inspect how operations such as
adding, deleting or searching for elements handle different workloads. The
subjects of our study are a functional programming language and an
object-oriented one. Our goal is to provide developers actionable
information that has already been integrated in supporting tools, and that
can steer green software construction.
L3.2 João Saraiva (University of Minho, PT): Green Software in an
Engineering Course
Sustainable
development has become an increasingly important theme not only in the
world politics, but also an increasingly central theme for the engineering
professions around the world.
Software engineers are no exception as shown in various recent
research studies. Despite the intensive research on green software, today’s
undergraduate computing education often fails to address our environmental
responsibility. We present a module on green software that we introduced as
part of an advanced course on software engineering. We introduce a
catalogue of energy smells and green refactorings,
which our preliminary results show that do help
students in reason and optimizing the energy consumption of software systems.
L3.3 Csaba Szabó (Technical University of Kosice, SK): Software
Application Energy Profiling for Java Projects
This tutorial
addresses the energy efficiency of software applications implemented in
Java programming language. The first part describes the current state of
the art in energy profiling as well as options for displaying energy
consumption of segments of the source code. Next, a custom code analysis
method for displaying information is presented addressing the processor,
operating memory, and hard disk. After this analysis, a short introduction
to the implemented Java application follows. In order to demonstrate the
practical use of the application, several test solutions are created, where
we measured the energy consumption. With each example, we put emphasis on
solving one problem with at least two solutions to determine which
implementation has lower energy intensity. The results of the examples are
also part of this tutorial.
L4. Štefan Korečko (Technical University of Kosice, SK):
Development of Correct Software with B-Method
One of the
well-recognized approaches to the development of correct software systems
is the utilization of formal methods (FM) for their specification and
verification. FM are rigorous mathematically based
techniques for the specification, analysis, development and verification of
software and hardware. Rigorous means that a formal method provides a
formal language with unambiguously defined syntax and semantics and
mathematically based means that some mathematical apparatus (formal logic,
set theory, etc.) is used to define the language.
One of the FM used
in industrial practice is B-Method, a state based, model-oriented formal
method intended for software development. B-Method is primarily used in the
railway sector, for the safety-critical software behind automated urban
metro subway systems (including the one in Budapest). The strength of
B-Method lies in a well-defined development process, which allows to
specify a software system as a collection of components called B-machines
and to refine such an abstract specification to a concrete one. The concrete
specification can be automatically translated to ADA, C or another
programming language. An internal consistency of the abstract specification
and correctness of each refinement step are verified by proving a set of
predicates called proof obligations (PObs). The
whole development process, including proving, is supported by an
industrial-strength software tool called Atelier B.
This tutorial
serves as a gentle, practical, introduction to B-Method. During the
tutorial, the participants will develop a simple software controller for a
railway scenario. They will be able to run the scenario with the controller
in a toolset containing corresponding simulation game.
L5. Nikola Domazet
(Ericsson Nikola Tesla, HR), Tihana Galinac Grbac (University of
Pula, HR): Programming of Advanced Management and Orchestration of
Virtualized Network Resources - Selection of Case Studies
New management and
orchestration (MANO) functions are standardized for use in distributed and
virtualised network environments. Their main role is to provide safe and
reliable operation of applications using network functions. Therefore, as
continuation of our previous lecture where we provide basic concepts, here
in this lecture we will provide a selection of case studies where these
functions are implemented and explain the advanced mechanisms behind and
simplicity of their application.
L6. Tibor Brunner, Máté Cserép, Anett Fekete, Mónika Mészáros, Zoltán Porkoláb (Eötvös Loránd University, HU): Code Comprehension with
Advanced Tool Support
In this tutorial we
will introduce the state of the art code comprehension tools to the students.
We will give a theoretical foundation for code comprehension, navigation
and code visualization methods and approaches to apply them in practical
software development. In the practice session we will demonstrate how to
set up a specific toolset: CodeCompass with
incremental parsing, Visual Studio Code as front-end tool and the usage of
the Language Server Protocol. We will parse an open source library and find
and fix a specific bug in it using the toolset.
L7. Clemens Grelck
(University of Amsterdam, NL): Functional Array Programming with Single
Assignment C: Opportunities and Challenges
SAC (Single
Assignment C) is in several aspects a functional programming language out
of the ordinary. As the name suggests, SAC combines a C-like syntax (with
lots of curly brackets) with a state-free, purely functional semantics.
Originally motivated to ease adoption by programmers with an imperative
background, the choice offers surprising insights into what constitutes a
"typical" functional or a "typical" imperative
programming language construct. Again on the exotic side for a functional
language, SAC emphasises multi-dimensional arrays, instead of lists and
trees. Array programming treats multi-dimensional arrays in a holistic way:
functions map potentially huge argument arrays to result arrays with a
call-by-value semantics, and new array operations are defined by
composition of existing ones. SAC is a high-productivity language for
application domains that deal with large collections of data in a
computationally intensive way.
At the same time
SAC also is a high performance language competing with low-level imperative
languages through compilation technology. The abstract view on arrays
combined with the functional semantics support far-reaching program
transformations. A highly optimised runtime system takes care of automatic
memory management with a focus on immediate memory reuse. Last not least,
the SAC compiler exploits the state-free semantics of SAC and the
data-parallel nature of SAC programs for fully compiler-directed
acceleration on a large variety of contemporary machine architectures, from
multi-core servers to GPGPU accelerators and clusters of workstations.
The lectures
motivate the language design of SAC and provide a hands-on introduction to
array programming as a paradigm. We look into all aspects from the
underlying array calculus to the concrete language design with
imperative-looking functional code, discuss a multitude of examples,
explore compilation challenges and eventually see some performance results
on various parallel computing architectures.
L8. Viktória Zsók, Li Jianhao, Yuri Kim (Eötvös Loránd University,
HU): Balanced Distributed Computation Patterns
The
state-of-the-art concurrent software development made extensive usage of
various methodologies and approaches to obtain high speed up. However,
parallelism remains one of the most difficult domains especially in the
case of pattern based programming approaches. The main purpose is to
explore parallel computation schemes in a new environment, to illustrate
the appropriateness and applicability in novel distributed computation
setups. The amount of parallelism is explored based on many factors such
as: applied computation pattern refined granularity, semantics of
distributed nodes, data streaming, and especially load balancing.
L9. JongWon Kim (Gwangju Institute of Science and Technology, KR):
Computer Systems for AI-inspired Cloud: Theory & Lab
In this lecture, an
overview-style introduction of modern computer systems will be made around
the definition, operating system virtualization & containers,
cloud-native computing, HPC/HPDA clustering, and cloud data centres. This
step-by-step introduction will help the audience to better understand the
recent development of computer systems for AI-inspired cloud. Also,
co-designed SmartX-mini Labs are introduced to
guide how to make hands-on-experience for selected computer system issues.
|
