Just 8 days after Scala.io in Lyon, I was attending yet another conference, in my home town, the DevFestToulouse. I was there last year, remember ? It is a generalist conference, with talks on a large panel of subjects, ranging from methods & tools, to DevOps, hitting Languages, paradigms, Web,... The theme this year was retro-gaming. Here are some notes about this day and my opinions about it.

About the event

The DevFest is one of the major event related to IT in Toulouse, the other one being Capitole du Libre and at a lesser degree the THSF. So it is a good place to meet old teammates & future ones. For this third edition, the venue was close to the city center, in the largest place possible (imho) to receive a conference in the city. The concept remained the same as last year : an opening and an ending keynote, conferences split in 4 tracks in between. Conferences were either on a 40 minutes (without questions) or 15 minutes format. To answer questions, the speakers were available at a special booth, after their talks.

Opening keynote

After an introduction with Maxime Pawlak as MC, he left the floor to Laurent Victorino, a developer in the game industry. Well fitted in the retro-gaming theme of the day. Laurent gave a fun keynote, mainly revealing tricks used in past video games: bugs which became features, tricks to boost the ego of the player,... It was really entertaining and the presentation was built up like a game. Including a twist at the end.

Morning sessions

I was a bit disappointed with the schedule because all the sessions I wanted to attend were in the afternoon, and sometimes scheduled at the same time. I also forgot a last minute change, where a talk called was swapped with Fabien Tregan's Old Man Glitch which I would have gone to see. I overheard it was awesome. Instead I went to see Céline Louvet again, just for the pleasure of hearing some Haskell and getting an extra dose of motivation to learn this language once and for all.

After that, I went to see Guillaume Membré for a talk on radio, and DIY. In his talk, Guillaume introduced pretty well the concepts of Software Defined Radio (SDR), and things you can do with it. As I work at Sigfox, well, this wasn't new to me, but I think his talk was well built for beginners. He then explained how to track planes using these techniques. Nice one.

For my last morning session, I had to choose between a session on CAP theorem and Kafka by Sébastien Guilloux and one on web application development in Rust by Sylvain Wallez. I went for the latter. Sylvain, as always was a good speaker and his talk was based on his need to develop a comments system for his blog.
After expressing his frustrations with Go (the language), he explained his motivations in trying Rust. Then, with examples, he showed us the power of the languages, with libraries like serde. He insisted on the quality of the artifacts available on Crates, the maven central of Rust. Then he showed how to write simple web APIs with Actix. After this talk, I still find Rust is some kind of an UFO: the focus on performance is everywhere in this ecosystem, yet, some paradigms, inspirations come from Haskell, or FP languages, where the beauty of the design comes from the very high level of abstraction (we are far from the machine) which is sometimes contradictory with performance. Nevertheless, Sylvain, with his talk invited me to try, at least for the strong typing, the traits which are close to typeclasses and the macro system.

It was then time to have lunch, and reconnect with old mates.

Afternoon

The afternoon started with a quickie brilliantly done by Arnaud Bos on Architecture Decision Records (ADR), and a technique to keep track of the architectural choices. More importantly, he focused on the why, explaining that some resulting code is written the way it is because of unwritten things and the "why" section of an ADR is here to explicitly describe this context. Then he explained how the ADR may be seen as a log of the architecture evolution, and a documentation which maximizes the ROI on it (it does not consume too much time to write ADR, yet the information in them hold high value). He finally reminded us, that every team has to find a balance in the granularity of the description put in the ADR.

My next stop was at François Teychene talk about systemd. There is a lot in his talk. As always, François was a great speaker allying style & content perfectly. After a short story (like he said, it's hype to start with a story in a talk, nowadays) on why it is important for developers to know systemd in the DevOps trend, he introduced the basic concepts. In a few words, systemd is a generalization of the scripts we wrote for the venerable System V init system. It offers configuration over scripting, letting the cumbersome writing of shell scripts to the past. After some explanations on how to write a basic unit file, he introduced the main command to interact with systemd : systemctl. He did a little digression on logs which are accessible with journald and the journalctl command. He then explained how systemd nonetheless applies to services, but also to paths, sockets,... There is also a systemd deamon for the user ! François spoke also about CGroups, and how to use systemd to manage them. The talk ended up with a galaxy of tools gravitating around systemd. A must see to start taking the maximum of automation in your Linux.

Then, it was time to see Victor Kropp talking about Multiplatform Projects in Kotlin. Well, his talk showed more than that! Again, this talk started with a story. The one of a simple webform which asked for a date of birth. But with a mismatch between day and month between the frontend side & backend side, leading to either a client side validation error or a server side error (when fixing by hand the Javascript). This example let Victor introduce the concept behind multiplatform kotlin: write once, reuse everywhere. He then showed how to provide interfaces to mark boundaries with parts which may call a specific feature of a platform. The keyword to use for such interface (well it is a class, but to me, it looks much more like an interface) is expect class. The implementation being done platform by platform with an actual class. This allows to share a function like :

fun validateDate(day: Int, month: Int, year: Int): Boolean = new Date(day, month, year).isValid()

// With the expected class :
expect class Date(day: Int, month: Int, year: Int) {
  fun isValid(): Boolean
}

Then all we have to do is to provide an actual interpretation. But does it solve the problem of the day/month mismatch ? Well, not really, so Victor, introduces the experimental support for inline classes :

inline class Month(val m: Int)
inline class Day(val d: Int)
inline class Year(val y: Int)

// Allowing to rewrite:
fun validateDate(day: Day, month: Month, year: Year): Boolean = //...

As a Kotliner, this talk was interesting, and as a functional programmer, it was nice to see that the language is going to add more things at compile time.

One of the best, if not the best, talk of the day was done by Frédéric Cabestre about Functional Programming. With a slice of history to begin with, he introduces the concept of Referential Transparency very simply and stated its benefits:

• modularity & composition
• local reasoning & equational reasoning
• easy to test, easy to refactor

Then, he illustrated these properties with a representation of natural integers using functions and lambda calculus and using this representation in an addition. He also showed an example based on functional sets. After a small digression on type systems where he stated that the goal of typing is to maximize correctness, or at least, proof of correctness. He did this without dismissing functional developers who don't like static typing and that was nice. Then, it was time for some live coding. Frédéric showed a simple program, written in imperative style Scala. Then, step by step, he transformed this imperative program into a functional program, introducing some well known structures, like Either and some combinators, like flatMapor map, without naming them. At the end of the talk, he said that the abstractions he had introduced during the live session are, somehow the design patterns of functional programming.

It was a really good talk, showing how the hardest part is to keep aside the bottom-up (we have built abstractions, based on how the machine works) reasoning, inherited from years of dominant imperative programming, to switch to a top-down reasoning, where we start from the tool our brain uses: Mathematics. To go further, check the code and the slides.

In the line of Frédéric's talk, I ended up with Alexandre Delattre and Guillaume Andrieu for a talk about Functional Programing in Kotlin. They did a great job at explaining how to do FP in Kotlin. The talk was centered on the concept of typeclasses and ad-hoc polymorphism. Through a live coding session, they illustrated ad-hoc polymorphism with the example of natural multiplication. To make their point, Alexandre & Guillaume defined the natural multiplication as adding n times an object to itself. We then saw how Int, Doubleand String are "addable". But what about a Pair? We could also define a natural multiplication of Pair by the operation leading to the pair made by the natural multiplication on both elements of the pair. We then saw how this "Addable" property is encoded as a typeclass which provides an extension to the types for which an implementation exists. In Kotlin, this pattern is encoded with interfaces and extension functions, and they introduced Λrrow which provides the Semigroup typeclass which is in fact what they had called Addable in their sample code. Before ending the talk, they demonstrated how KEEP-87 would improve the encoding of typeclasses and instances in Kotlin.
As a Kotliner and a user of Λrrow it was nice to see a room full of developers not really familiar with Λrrow, getting ready to use it. Alexandre & Guillaume did a great job at showing enough to get hooked. The thing with these talks on Functional Programming is that they do not "sell" a solution, but invite to think differently. And in this regard, Frédéric's talk and Alexandre & Guillaume's one have done well.

Ending keynote

The ending keynote was delivered by Quentin Adam from Clever Cloud. In his talk, he tackled several topics, starting with "the marketing of shame". Conferences like DevFestToulouse make the developers who attend want to investigate further the interesting things discovered through a day of conference, but when they'll go back to the office the next day, they will feel the shame of not using these techniques, frameworks, learned the day before. And Adam states it clearly: at this stage we compare our inside with someone else's outside (in this case, the technologies showcased in a talk by a speaker). Quentin tied all this to some economic reasoning: a piece of software is not a piece of art, it has to deliver value. In that regard, he invites us to do the job we are bound to do as engineers: find solutions which match the balance for a project. We, as technical people must be able to make decision rationally. But we, as humans, are subject to emotional decisions. Hence the marketing of shame made by some big, well known names in our industry.
This keynote was a good way to end the day, with some thoughts on Economics, Software and maybe life in general.

Up to you, DevFestToulouse 2019

I remember filling the CFP for DevFestToulouse and I also remember feeling unsure about what to submit. The DevFest is a generalist conference with a high number of attendees. What to say then in 15 or 40 minutes to a that vast audience ? I did not find the answer, but the selected speakers did and they did it well. Sure, I did not get my brain exploded because of advanced talks (like at Scala.io) but I think the value in this kind of conference is to see, hear, about things we don't do every day, to broaden the spectrum of knowledge instead of drilling it down. I sometimes regret the unnecessary emphasis on goodies, contests and so on, but I think an event with this (pleasant) venue, with food, and so on, is costly, and I understand that the sponsors need their return on investment (a pile of CV and applicants...). So, it is a fair game. Anyway, a thing remains: organizing such a conference cannot be done without an amazing team, and as such, the organizers did succeed. They did a great job and volonteering. So, kudos to them and to the speakers (because focusing on such an heterogeneous audience is not easy at all) ! DevFestToulouse was great thanks to them, and I hope, that next year, they will improve again (some risky choices made did pay off, some did not, imho) for another good edition.

Edit on November 12th: Fixing typos (thanks Arnaud Bos)