WSPS III

Invitation to WSPS 3

The Section of Mathematical and Information Sciences of the Association of Hungarian PhD and DLA Students and the PhD Students’ Union of the Széchenyi István University anticipates Your attendance at the 3rd Winter School of PhD Students in Informatics and Mathematics, which will be held between 15th-17th January, 2016 at the Széchenyi István University, Győr, Hungary.

The aim of our winter school is dual:

  • improve the multidisciplinary scientific network of PhD students by inviting them to present their work in poster sessions and;
  • improve professional skills in an intensive course.

Each year, the intensive course has a theme relevant for a wide audience. Internationally renowned scientists will give a number of in-depth lectures; these will be accompanied by seminar sessions where attendees will be able to explore topics in an interactive, hands-on way. This year’s topic is functional programming, and the intensive course is taught professors from the Eötvös Loránd University, Faculty of Informatics (ELTE IK).

Are you familiar with functional programming or a novice in it? Be aware that there is no required knowledge prior to applying to the winter school, as sufficient curriculum will be provided beforehand the workshop to learn the basics. We will also start off with a warmup session on the first day to make sure nobody is left behind before we start the journey!


Poster section and publication

All participants are invited to present their work in the form of posters, be it relevant to the topic of the intensive course or to some other area of Informatics or Mathematics. Each presented poster participates in the competition for the best poster award.
Posters should be submitted via email to the contact address (mito [at] dosz [dot] hu) after registration. It is good to know that you don’t have to bother with the printing, as we will take care of it!

All poster abstracts will be published in the conference proceedings. Articles related to the posters are welcomed to be submitted after the winter school and selected papers will be published afterwards in the Acta Technica Jaurinensis.


Registration

The registration fee is 22 000 HUF, which also covers the expenses of the meals and the printing of the submitted posters.
Accommodation in the university’s dormitory is available for 7000 HUF for the 2 nights which should be transferred together with the registration fee. Should you have special requests regarding accommodation, please contact the organizers directly; we are flexible on the details.
A special allowance of 9 000 HUF is available for the full members of the Section of Mathematical and Information Sciences of the Association of Hungarian PhD and DLA Students.

The deadline for the registration is the 5th of January, 2016.
Extended deadline for the registration is the 7th of January, 2016.

Poster submission deadline is the 10th of January, 2016.

Registration form

Registration is complete when the registration fee (and the accommodation fee) is transferred to the bank account of the Association of Hungarian PhD and DLA Students.
Bank account: 11600006-00000000-62169239
International bank account: HU50 1160 0006 0000 0000 6216 9239
The transfer remark should contain the keyword “MITO” and your name.


Planned Program

Day 1 – Friday, January 15, 2016

11:00 – 12:30 Registration and occupying accommodation
13:00 – 14:30 Warmup
                            Gábor Páli, PhD
14:30 – 15:00 Coffee break
15:00 – 15:15 Welcome and opening
                            Péter Baranyi, DSc
15:15 – 16:00 Writing Scalable and Fault-Tolerant Systems in Erlang
                            Csaba Hoch – Erlang Solutions
16:00 – 17:30 Let’s Party! PaRTE! – How to use the ParaPhrase technology?
                            Tamás Kozsik, PhD
17:30 – 18:00 Coffee break
18:00 – 19:00 Poster session
19:00 – 20:00 Dinner

Day 2 – Saturday, January 16, 2016

08:00 – 09:00 Breakfast
09:30 – 11:00 Programming in Haskell Lecture
                            Gábor Páli, PhD
11:00 – 11:30 Coffee break
11:30 – 13:00 Programming in Haskell Practice
                            Gábor Páli, PhD
                            Artúr Poór
13:00 – 14:00 Lunch
14:00 – 15:30 Programming in Haskell Lecture
                            Gábor Páli, PhD
15:30 – 16:00 Coffee break
16:00 – 17:30 Programming in Haskell Practice
                            Gábor Páli, PhD
                            Artúr Poór
17:30 – 19:00 Poster session
19:00 – 20:00 Gala Dinner

Day 3 – Sunday, January 17, 2016

08:00 – 09:00 Breakfast
09:30 – 11:00 Dependent types – Agda
                            Gábor Páli, PhD
11:00 – 11:30 Closing ceremony
12:00 – 13:00 Lunch


Topics

Functional programming is a programming paradigm based on the concept of expressing the behaviour of a program as a mathematical functional model rather than as explicit sequences of instructions to a processor, which is the primary concept in imperative programming. Functional languages treat computation as the evaluation of mathematical functions and avoid changing-state and mutable data, thus being either completely side-effect-free or carefully partition off those facilities for doing computations that may have side effects. Functional programming is known to provide better support for structured programming than imperative programming, meanwhile functional programs are often shorter and easier to understand than their imperative counterparts.

Writing Scalable and Fault-Tolerant Systems in Erlang
Why does of the most popular NoSQL databases use Erlang?

Erlang is a functional programming language with a strong support for concurrency and distribution. Its features together with the BEAM (the virtual machine running Erlang code) and the OTP library (a library of basic components, patterns and principles) makes it easier to build scalable and reliable systems. Riak is a distributed key-value store written mainly in Erlang, with a high level of scalability, availability and fault-tolerance. In this presentation, I will show the features of Erlang that make it a good fit for writing systems such as Riak, and explain how Riak’s key features are supported by Erlang’s key features.

Let’s Party! PaRTE!
Refactoring code to parallel patterns

Parallel programming is hard. Can we make it fun? Functional programming may be the best way to achieve success. This paradigm focuses on composition, and fosters the construction of programs from side-effect free components. In this lecture we investigate how parallel programming patterns allow us to compose scalable, easy-to-maintain parallel programs, and how such patterns can be introduced into programs by refactoring. In the talk we shall work with the Erlang language, and present PaRTE, the ParaPhrase Refactoring Tool for Erlang.

Programming in Haskell
From Higher-Order Functions to Higher-Order Types

In these lectures, we are going to take a purely fictional journey to the realm of purely functional programming, where it is possible, and as matter of fact, quite common to abstract over functions as well as over types. It is because functions are first-class citizens there, so functions may take functions as parameters, and functions may produce functions as results – such functions are called higher-order. In addition to that, we will also see that types can also be higher-order, which will eventually lead us to parametric polymorphism, a generic and convenient way of implementing programs. With the help of Haskell, we will take a sneak peek at those concepts, along with some cunning examples, and see, for example, how it is possible to use lists as containers and computations at the same time.

Dependent types – Agda
Types == Theorems

Programmers like to write programs, mathematicians like to prove theorems. However, it is not always known to either of them that they are tackling the same concepts – in a bit different form. The firm connection between their work is called the Curry-Howard correspondence, which claims that types can be taken as theorems, and programs of those types can be taken as proofs for the theorems that the types represent. Along this paradigm, a dependently-typed functional programming language and proof assistant, Agda was born – and that is going to be the language that we will use here to illustrate how to construct mathematical proofs via composing functional programs interactively by their types.


Lecturers

Tamás KozsikTamás Kozsik is associate professor at Eötvös Loránd University, Budapest, Hungary, where he is vice dean for projects and innovation at the Faculty of Informatics. He offers courses on concepts of programming languages, concurrency, formal methods in parallel programming, enterprise Java technologies, aspect-oriented programming, design-by-contract, functional programming, and teaches various programming languages (Ada, Eiffel, Haskell, Java, Scala).

He has led the research projects “Software technologies of distributed and manycore systems” and “Verified and Certified Software Components”, and he was principal investigator in “ParaPhrase: Parallel Patterns for Adaptive Heterogeneous Multicore Systems” (EU FP7).

Gábor PáliGábor Páli is an assistant professor at Eötvös Loránd University, Budapest, Hungary, where he teaches, studies, and uses functional programming – mostly Haskell – for real-world applications. Before returning to academia after earning his master’s degree, he worked on computer games such as Project Torque (aka. Level-R) at Invictus Games in Debrecen. Under the years of his doctorate studies, he was also a research intern both at Chalmers University of Technology in Gothenburg, Sweden, and at the Computer Laboratory in Cambridge, UK, where he participated in research projects that blended the field of functional programming and operating systems, Feldspar and Mirage. In parallel to that, he has been a long-time contributor to open source software, and he gained developer status for the FreeBSD and the Glasgow Haskell Compiler projects over the years. All those experiences enabled him to strike and maintain a balance between theory and practice in education as well as in research.

Csaba HochCsaba Hoch received his Computer Science degree from Eötvös Loránd University in 2009. He met the functional and concurrent programming language Erlang when he was exploring the test tool Erlang QuickCheck at the University of Sheffield, UK and when he worked in the RefactorErl project at Eötvös Loránd University developing an Erlang refactoring tool. He spent the next 4 years at Ericsson Hungary, where he participated in the development of NETSim, which is one of the largest Erlang programs ever written. Among other things, he developed and maintained NETSim’s build&test system and gave NETSim user trainings. At the beginning of 2013, he joined Erlang Solutions Hungary. He has been working on WombatOAM, a new tool for monitoring, administrating and deploying Erlang systems, and provided support for the Riak distributed database. He wrote the Erlang indentation for the Vim text editor, and contributed to other open source vim-erlang projects.


Map and transportation


Sponsors

logo_dosz                ntp-vertical                Ministry of Human CapacitiesMinistry of Human Capacities               Járműipari Kutatóközpont               Széchenyi István University               PhD Students's Union of the Széchenyi István University

 


Contact

mito [at] dosz [dot] hu


Fotógaléria


Documents