Why using types? When are they useful? Why we should care about types? What are types? These are the questions [this series of posts]/en/types/ give some answers to.
Here is a simple experiment: take a fair dice (or a coin) and roll it until every
side of the dice has been observed at least once. Write down the number of
rolls and repeat the operation several times.
On average, how many rolls does it take to observe every side of the dice at
least once?
This is precisely the question we are about to answer together.
Solving Maths puzzle is fun. Solving them using the shiniest features of
Scala 3 is even amazingly funnier! If you do not have
Scala 3 installed yet:
Soyez les bienvenu·e·s! Cette session a le dessein de vous présenter
un outil de programmation très puissant. Alors que la plupart des
introductions sur le sujet commencent par une présentation de ses
fondements théoriques d’une manière très formelle, nous avons choisi
de vous le présenter à travers de courts exemples et des cas
d’utilisation concrets.
Cet atelier est composé de trois parties. La dernière présente trois
des cas d’utilisation des plus utiles. Ils forment les usages majeurs
en pratique. Mais ne vous y aventurez pas sans préparation! Cette partie
est la dernière pour une bonne raison: elle s’appuie massivement sur
les leçons des parties précédentes.
Commencez par Premier Contact, elle vous exposera,
via les plus simples exemples, les idées clefs. Son but est
d’ouvrir votre esprit à des manières d’utiliser les types et données
que vous n’avez vraisemblablement jamais soupçonnées.
Arpentez ensuite
Cas d’utilisation simples et utiles: relations sur les types,
pour un premier défi devant un usage pratique.
Après cela seulement vous serez prêt·e pour
Cas d’Utilisation Plus Avancés.
Welcome. This session will introduce you to a very powerful tool in
programming. Whereas most introduction start by presenting its
theoretical foundations in a very formal way, we chose to present
it via short examples and practical use cases.
This workshop is made of three parts. The last one presents three
of the most valuable use cases. They are the real big powerful use cases.
But do not go there unprepared! This is the last part for a reason:
they rely massively on lessons you will learn in the previous parts.
Start by First Contact, it will show
you, via the simplest examples, the core ideas. Its goal is to open your
mind to ways of using types and data you may have never imagined possible.
Then go to
Easy Useful Use Cases: Relations on Types,
for the first real-life challenge.
Then, you are ready for More Advanced Use Cases.
Today we will explore the Curry–Howard correspondence. Our mission
is writing, in Scala’s type system, the property
on natural number of being prime. Wikipedia defines it by:
A natural number (1, 2, 3, 4, 5, 6, etc.) is called a prime number (or a prime) if it is greater than 1 and cannot be written as a product of two natural numbers that are both smaller than it.
Recursion schemes are said to be a tough subject. Articles and presentations often
flood the audience with lots of names such as Algebra, CoAlgebra, catamorphisms,
anamorhpisms, hylomorphism, etc. Is knowing all these concepts required to understand
recursion schemes? I have good news for you: it isn’t! All you need, to see what recursion
schemes are and why there are useful, can be presented with just a single basic function,
often taught as an introduction to programming: factorial. I’m glad to welcome you to
to the high-school introduction to recursion scheme 😉.
Generalized Algebraic Data Types (GADT) is certainly one of the most feared concept in programming nowadays. Very few mainstream languages support GADTs. The only ones i know which does are Haskell, Scala, OCaml and Haxe. The idea is actually very simple but often presented in complicated ways. In fact, if you’re familiar to both basic Object-Oriented-with-Generics and basic functional programming, then you most probably are already familiar with GADTs without even knowing you are. But if GADTs are so simple, why so many people feel terrified by them? Well GADTs rely on two fundamental ideas, one of them is known by every Object-Oriented-with-Generics programmer while the other is known by every functional programmer. The problem is most people make the huge mistake of opposing them even though they are complementary. So before diving into GADTs, let me remind you of these elementary notions from Object-Oriented and functional programming.
I will present how to develop a web application in Scala.js. This talk is for Scala developers having a penchant for web development but rebuffed by JavaScript. It goes from ScalaJS basics to the implementation of a naive virtual DOM written in Scala. It presents:
It happens regularly in software development that we have to connect systems speaking different languages. JSON is nowadays ubiquitous in service communication, especially in web development but XML still has its fair amount of bastions. Imagine you need to pass information provided by a JSON API through an XML layer, you need a converter.