MSE Master of Science in Engineering

The Swiss engineering master's degree


Chaque module vaut 3 ECTS. Vous sélectionnez 10 modules/30 ECTS parmi les catégories suivantes:

  • 12-15 crédits ECTS en Modules technico-scientifiques (TSM)
    Les modules TSM vous transmettent une compétence technique spécifique à votre orientation et complètent les modules de spécialisation décentralisés.
  • 9-12 crédits ECTS en Bases théoriques élargies (FTP)
    Les modules FTP traitent de bases théoriques telles que les mathématiques élevées, la physique, la théorie de l’information, la chimie, etc., vous permettant d’étendre votre profondeur scientifique abstraite et de contribuer à créer le lien important entre l’abstraction et l’application dans le domaine de l’innovation.
  • 6-9 crédits ECTS en Modules contextuels (CM)
    Les modules CM vous transmettent des compétences supplémentaires dans des domaines tels que la gestion des technologies, la gestion d’entreprise, la communication, la gestion de projets, le droit des brevets et des contrats, etc.

Le descriptif de module (download pdf) contient le détail des langues pour chaque module selon les catégories suivantes:

  • leçons
  • documentation
  • examen 
Advanced Programming Paradigms (TSM_AdvPrPa)

A wealth of fascinating technologies exists alongside the ubiquitous object-oriented programming and the inadequate testing methods. This module introduces students to the most relevant of these emerging technologies from a general programming-language point of view.

Paradigms Besides object-orientation as today's mainstream programming paradigm, other quite different paradigms have been developed and brought to maturity during the last decades: in particular functional programming, but also logic and constraint programming. None of these paradigms is well suited to solving all the different kinds of problems but each has its own particular strengths in specific areas. Since modern software encompasses many such areas, simultaneous application of several paradigms seems appropriate, and consequently, their seamless integration into multi-paradigm languages.

Types Programming languages with a rich and consistent type system make it possible to detect certain errors at the time of compilation already. Using the type system, invariants can be declared in one's own data types, which are then checked by the compiler. Programming in and with a strong type system can be regarded as the first step in the direction of program verification. With even stronger type systems, it is possible to formulate complete program specifications. The compiler does then, however, generally require support for verification.

Correctness Choosing the right programming paradigm for a given problem simplifies its solution, but does not guarantee its correctness – the most important of all software qualities. Such a guarantee requires, in addition to the actual implementation (the "How?"), a specification (the "What?") and proof of correctness (the "Why?"). Continuous research right from the very outset of computing has now led to a verification technology that is entering industrial application. Since object-oriented programming is ubiquitous, its specification and verification is of particular importance.

This module will provide:

  • an overview of programming concepts, paradigms and languages;
  • a comprehensive introduction to functional programming (using Haskell or Scala);
  • an introduction to multi-paradigm programming, with special emphasis on types (using Scala, which is a combination of functional and object-oriented programming);
  • an introduction to the theory and practice of specification and verification of imperative programs (as a basis for the verification of object-oriented programs - example Dafny) and/or of functional programs (example Coq).

Compétences préalables

Good knowledge of object-oriented programming.

Objectifs d'apprentissage

Students will acquire an understanding of the emerging paradigms, practical skills in modern functional, multiparadigm and type-full programming, and a basic understanding of the increasingly important field of software specification and verification.

Catégorie de module

Functional programming (6 weeks)

  • Programming concepts, paradigms and languages.
  • Absence of state, referential transparency, reasoning about programs.
  • Eager versus lazy evaluation.
  • Types and type inference, higher-order functions, concrete data types and pattern matching.
  • Functors, applicative functors, monads.
  • An application: interpreter for a small imperative programming language (IML).

Multi-paradigm and strong typed programming (4 weeks)

  • Trait types (and Mixin composition as a variant on classical inheritance).
  • Generic types (co- and contravariance for type parameters).
  • Type classes and implicit parameters.
  • Type-secure DSLs (Domain Specific Languages).

Program verification (4 weeks)

  • Reliability via testing and verification.
  • Hoare logic and weakest preconditions.
  • Architecture of verification tools.
  • An application: verification condition generator.
  • A current verification tool: Dafny and/or Coq.

Méthodes d'enseignement et d'apprentissage

  • Ex-cathedra teaching.
  • Programming and verification exercises.

Bibliographie

  • Graham Hutton, Programming in Haskell, Second Edition, Cambridge, 2016.
  • Miran Lipovaca, Learn You a Haskell for Great Good!, No Starch Press, 2011.
  • Martin Odersky, Lex Spoon and Bill Venners, Programming in Scala, Artima, 2008.
  • David Gries, The Science of Programming, Springer, 1981 (a classical text).
  • José Bacelar Almeida et al., Rigorous Software Development, Springer, 2011.
  • Federico Biancuzzi und Shane Warden, Masterminds of Programming: Conversations with the Creators of Major Programming Languages, O'Reilly, 2009 (for recreation).

Télécharger le descriptif complet

Retour