This week I went to NCRAFTS 2015 in Paris. NCRAFTS is a conference focusing on the craftsmanship of software development.
Subjects presented varies from Domain Driven Design, Continuous Delivery to Functional Programming and F#.
In other words, exactly my favorite subjects.

There was only two tracks at this conference, but since the quality of talks was so high I was glad there wasn't more tracks as it was already really hard to choose which talk to go to.

Fortunately the staff promised us that the videos will be out very soon so we will all be able to watch recordings.

The remainder of this post is a summary of what I thought about the sessions that I attended. You may of course not agree with me, this is just what I thought about each of the sessions I attended.
I hope it may be of help to some to decide if they want to spend time on watching the videos.

Day 1
Keynote: The Joy Of Debugging Ourselves

Laurent Bossavit

Kicks the conference off to a great start. Not the most technical talk, but lots of food for thought.
The talk revolves around why we as humans behave and think like we do. Understanding how our mind work may lead us to be more aware of possible pitfalls when developing software?

Continuous delivery - the missing parts

Paul Stack

Mr. Stack is a great speaker and gave a very entertaining talk about Continuous Delivery. But I personally missed exactly what Stack thinks are the missing parts. A very good overview of continuous delivery though.

Functional Programming in C#

Tomasz Jaskula

The meat of the talk was how we can take two techniques used in functional programming and implement them in C#.

  • dependency injection through method arguments and partial application
  • Railway oriented programming / error handling functional style

The ideas presented was interesting and I certainly want to study the C# code in the repository, but unfortunately Jaskula seemed very nervous and uncomfortable presenting.
He probably needs more practice at doing demoing of code on stage as he didn't handle that part very well. It was hard to follow when he walked us through the code.
I mean, I have watched Scott Wlaschin material on railway oriented programming which is the same concept, and I have experimented with it in F# so I think I already know the ROP quite well.
I consider myself an expert in C#.
So I think I came really well prepared, still I had a hard time following the code presented.
But if you decide to watch the recording, don't dismiss his ideas because of the somewhat lacking presentation. At least go to the source code on github and study that before you make up your mind, I really think he has some good ideas.

Hands On: Suave, Fake

Tomas Petricek

Suave is a web server implemented in F# and this Hands On session was lead by no less than the great Tomas Petricek. This was topped when also Wlaschin joined us in the room. I have to admit I felt a bit star struck sitting in a such a small room with these great minds.
Tomas gave an intro to Suave and the we started coding.
I had not tried coding using the Suave library before this, but we got quickly got going and I recommend anyone to have a look at Suave.
The hands on was of course not recorded so you will not be able to watch this session, but both Hanselmans recent post and the Suave website are good places to start if you want to have a look at this. Petrecek has published the code we used as a starting point here.

I missed "The Silver Bullet Syndrome" among others because of the Suave session. There was quite a lot of talk about it so I suppose it must have been pretty good. Definitely a talk to watch when available.

FAKE - A DSL for build tasks

Steffen Forkman

Yet another great talk. Fake is a F# based build automation system. It provides functionality much like Make and Rake and Forkman gave a very good introduction to it during this talk. He even did a live, on stage release of a new version of the tool and a visual studio extension for it.
He even briefly demonstrated another F# based tool called Canopy, similar to Selenium, which also looks very interesting.

The Kata In The Hat

Jonathan Perret

Emmanuel Gaillot

Code kata in something that I think was Haskell (I don't know Haskell, but the extension of the files was .hs and it definitely was a functional language so I think it must have been Haskell).
The twist was that the audience gave them challenges like singing, dancing, not using 'e' etc that they
did their best to complete.
Still, watching someone write code that I could not understand while they sang and danced, well, not my cup of tea...
In my opinion, an otherwise great day, ended a bit meh, but hey it was late in the day.

Day 2
Towards Modelling Processes

Mathias Verraes

A great talk on touching on and expanding on Domain Driven Design. When he referred back to "Introducing EventStorming" that Alberto Brandolini from day 1 he made me wish I could have split myself so I could have watched that without missing the FAKE talk that I attended. I definitely are going to watch it when the videoes are published.

Type Driven Development

Mark Seeman

Yet another great talk, this conference was simply filled with them.
Starts out showing how easily we can use F# to model our domain. Main take-away for me was how elegantly we can develop in a pseudo-code style when programming in F#.
This is done by detailing the steps in a top down manner which I think Seeman explains very well in this talk which I highly recommend you to watch when available.

Enterprise Tic-Tac-Toe

Scott Wlaschin

Very often I get a feeling that demoes and samples showing F# are to simple and doesn't feel relevant for real world problems that I need to solve when I am developing typical enterprise applications.
Wlaschin attempts to remedy this in this talk and walks us through how to implement features that are typically needed in an enterprise application.
Of course things has to be simplified to fit into a conference talk, but he succeeds pretty well I think and also gives some ideas on how to design API's which aren't just F# specific and some of the ideas presented may be used regardless of which programming language you may happen to use.
Absolutely a recommended watch.

Functional Library Design

Tomas Petricek

Petricek argues that you should rather make libraries than frameworks and explains why in this talk.
He has also written about this on his blog here:
But if you prefer to watch the video I highly recommend this talk

Layers Considered Harmful

Christian Horsdal

Horsdal argues that we often create way to many layers that doesn't do us any good. They often just adds friction and complexity to our applications. He propose that the solution is to create vertical slices instead with different layering depending on the actual need.
Watch it when you can.

When DDD meets Documentation

Cyrille Martraire

I had never heard about Martraire before this talk, but I was very happy to see that he is a very good speaker. He is very energetic and his ideas are interesting.
He actually doesn't talk that much about writing documentation in this talk. He talks a lot about how and when you may choose not to actually write any documentation. He may give you some clues
that may help you see that there may be alternatives that are better.
I recommend that you watch this talk and find out.

The T in TDD : tests, types, tales

Mathias Brandewinder

Unfortunately Brandewinders had some troubles with his PC just before the talk and was forced to loan a computer that had a very different keyboard layout from what he was used to.
This caused quite a lot of troubles in this talk that was intended to contain a lot of live coding.
Still I think he got away quite well from the presentation and I would still recommend to watch the session. He shows us how F# scripting sometimes can be a good alternatives to your regular unit test.
All in all a very interesting end to a great conference.