Build Stuff 2015 – shared thoughts

{Build Stuff}15

After visting the TechDays in 2014, I’d was pleased that a good friend – and former colleague – tipped me about Build Stuff. Visiting the TechDays (formally known as the DevDays) felt more and more as watching a detergent commercial: Now with improved formula.

Wed 18 November 2016

Key Note – the future of programming

Uncle Bob (Robert Martin) had a nice story about the history of computers, software engineers, and software languages, starting with the famous Alan Turing. He ended addressing the issue that software development is becoming so important, that at some moment in time, a bad decision of a developer will kill many (say 10,000) people in one go. This will result in tons of regulations forced on us (developers), and he hoped that we as an industry can be a step ahead of this and come with this upfront. Food for thought.

Categories for the Working Programmer

I really felt clueless after leaving the room. The talk was about Haskell (a ‘hot’ functional language). The speaker showed some elegant math, to prove some generic ways of dealing with iterators/recursive functions within Haskell. But you might expect an answer to question why this is useful to a working programmer…

 Anti-Patterns in designing API’s

There is always a risk in telling people how to do things right by telling what they should NOT do. It was not the best talk ever (may be, because of that), but the examples that were given were nice. In short:

  1. Chauvinist Server: designing the API from server’s perspective failing to hide its complexity behind its API (API designed from the server’s perspective)
  2. Demanding client: client enforcing its special need onto the signature of the API (certain client’s limitation becomes server’s default behaviour)
  3. Transparent Server: server exposing its internal implementation to its clients (server’s underlying or private domain bleeds into the public API)
  4. Presumptuous Client: The client assuming the role of a server and engage in taking responsibilities that cannot guarantee
  5. Assuming Server: Server that assumes the responsibility of tailoring the response based on what it assumes client is (e.g. browser sniffing)

And yes, we as a company have violations of all in our codebase unfortunately.

Evil by Design – casino software

A nice follow up on the key note (I guess it was coincidence) was the talk by Jef Claes. He works for a company that builds and monitors an on-line casino. He started briefly be showing how an event based architecture allows them to monitor the usage in an anonymous way, and allows them to interact with cheaters or addicted users. Besides that, he shared his thoughts about the pro’s and cont’s of working in such a business, and if you should do that, or not. It reminded me about a time a worked on two applications providing consumer credit (for buying cars), something I would not easily do again. A lot of food for thought.

The Liberal Arts Programmer

A talk about learning from other disciplines. Basically, it was an encouragement to read books about things that are not (strictly) related to software (development). There were also some funny slides, including this one:

Company hierarchy: Sociopaths/clueless/losers Company hierarchy: Sociopaths/clueless/losers

Being Meta

A good talk. Code generation (CodeDom, T4), reflection, IL-optimisations, and tooling like PostSharp. The last thing is really something, I’d like to spend time on. If you are not familiar (yet) with the other topics, please do so yourself!

Thu 19 November 2016

Key Note – Coding vs. the Brain: Can’t We All Just Get Along?

Melvin Conway is a hero, but this talk was not his best ever (logically). He revitalised an idea he (and others) abandoned in the 90’s where code could be assembled by dragging controls on a designer canvas, and connect them with lines. His argument to pick this up again was that it could be useful when helping kids from primary school learning to write code. But hie was not convincing at all. Both because the lack of argumentation why this could help, of because of the examples he gave, and the design of the tool he showed. So 1993.

A board game night with geeks

The name of the topic is a bit misleading, as the talk was basically about boolean satisfiability problem solving (aka SAT solving). She showed a nice way of solving a problem that would take (proximally) 90 hours on a regular computer doing it the brute force way, but only a split second using SAT. On top of that she showed a nice way of combining the use of F# sharp for the functional stuff, and C# sharp for some proper plumbing. This all presented with flair, enthusiasm and slides from outstanding quality! (only that last part was already worth the talk)

From Power Chords to Power of Models: Insights from History of Rock Music via Machine Learning

A nice talk, from a not so gifted speaker. In short: he harvested a lot of data from Wikpedia about rock music, build a data model, filled it with the Wikipedia data, and did nice analysis on that. Some nice outcomes where presented with music of the bands, including some nice results, some of which were to be expected (Jimi Hendrix or Bob Dylan was the most influencing musician in the area, based on the analysing method) and some more surprising ones, like Jony Mitchell was the most visionary musician (meaning she was hardly influenced by others, but influenced a lot of them). A nice recently new method of data minding (tokenizing text, by converting words into vectors, with distances to other words in a sentence) looks very promising and could be applied in a a lot of areas!

 Unsafe at any Speed – Successful high performance low latency systems in C#

As you may (or may not) know, in C# (in contrast to VB.NET, and others) can be unsafe. This means that, if using the unsafe keyword, the garbage collector can be bypassed, and direct access to pointers is available. If you know think: Wait a minute, but that is what .NET is about, providing safe code, WITH garbage collection. That is true, but in some scenario’s, speed is key (in this case, real time analysis on video stream made by a camera for medical purposes). The basic idea presented at this talk was how to use this powerful option ONLY for those things that really need all speed you can get, and combine that with the other things that should NOT use be unsafe and handled by the good old garbage collector.

Artificial Intelligence that plays Atari video games: How did DeepMind do it?

A funny talk, about machine learning, only based on the visual output of Atari video games. Not really practical, but who cares?

Lies, Damn Lies and Consulting Lies – The Path to World Domination through Microservices

Worst talk by far. Period!

 Fry 20 November 2015

Mind Mining

This talk was an unpleasant surprise. The original topic of this talk was “Property Based Testing: Shrinking the Risk in Your Code”, but there was a last minute change. The nearby rooms were overloaded, so I stayed. So what was it about? Some USA mining village with a lot of unemployed (former) miners, where educated as programmers. Nice initiative, but not worth 55 minutes of my time.

Mutate your code and reveal you true test coverage

There is always the dilemma of choosing a talk with a talented speaker, and a talk with a interesting subject. The first will always result in a nice session, the second… Well, sometimes you learn something new. Mutation testing is an approach where your use some (sophisticated) tooling to mutate function logic (boolean and/or arithmetical operators mostly) to find unit tests that have no useful assertions. The idea itself is simply awesome, but the achievability is poor. I’d like to get some experience with it, but I would not be surprised (understatement) if it turns out that is just not worth the effort.

Programming with GUTs

Definitely the best talk of the week. Kevlin Henney has all properties a good speakers needs: knowledge,  storytelling, clarifying examples, humour, and a nice voice. The talk was about writing Good Unit Tests. The bottom-line: don’t blindly follow the procedure, but keep thinking. This sounds obvious but it is not. He used testing leap year logic, to make his point. The descriptiveness of the method names, the importance of the refactoring step in the TDD cycle, etcetera.

Goodhart’s law: Once a metric becomes a target, it loses its meaning as a measure.

Goodhart’s law: Once a metric becomes a target, it loses its meaning as a measure.

Are smart systems making us stupid?

The answer is – according to Dylan Beattie – no (as in all headlines with a yes/no question mark). It was more a philosophical, than a software talk, but nevertheless quite entertaining. One of the nice thoughts: Although we make smart systems, we should never make them arrogant, and should be extremely humble when the fail.

Programming For The Criminally Insane

Mark Rendle made a brilliant and hilarious show of the last talk of the conference. His talk had only one purpose: entertainment. He succeeded! I can not remember being a room of software engineers where there was half as much laughing as during this talk. Mark showed some insane languages who where only designed to be fun. Languages such as Brainfuck (only .,<>+-[]), Whitespace (like brainfuck but only with space, tab, linefeed), Shakespeare (reads as a Shakespeare play), INTERCAL (with keywords like PLEASE, COME FROM, GIVE UP) and others. I guess that if you are not a programmer, you would not have any clue…

Sat/Sun 21/22 November

Workshops machine learning with F#

During the weekend there where some nice workshops. Together with Ad and Wilko, I followed the workshop about machine learning. The first day, a lot of struggled with F# as most of us (including me) lacked experience with a functional programming languages in general and F# in particular. It was a nice course, with some classics to work on: OCR, user behaviour prediction, a spam-filter, and an AI using a simple neural network.

Conclusions

Although not all talks reached my expectations, in general it was a great week. The workshop I followed was fantastic, and the congress as a hole was way better than the DevDays (my only reference). The software community is adapting Micro services, and using functional languages (such as Haskell and F#) to write smarter (self learning) systems. Test driven development is adopted widely by the industry (which is good), but there are still a lot difficulties to master. I hope, to be able to get hands on experience with most of the topics, and look forward to evangelise some of these ideas and approaches at Exact!

Leave a Reply