Software You Can Love

“I’m going to attend this conference, is anyone else coming?” texted my friend Sandro in our group chat.
“What’s it called?” I replied.
Software You Can Love.”
“Sold! How could I miss it?”

Love and passion are what I pour daily into my job, and into the software I write. A few years ago I heard, for the first time, the expression, this code hadn’t received enough love, referring to a piece of code badly formatted and poorly implemented. The expression did resonate with me – the idea that quality code is like that because of personal and emotional involvement sounded so correct.

So the idea of a conference where the focus was on quality in terms of software that is relatable looked like an event I can’t miss.

The conference comes from the Zig community. I’m not that much into the Zig language and although I recognize the validity of the approach, I’m not completely sold on the idea of exposing all the gears. Anyway, Zig is promoted as a system programming language in the arena of successors to C and C++, so it is worth investigating and trying to get a hands-on feeling of what the language is.

The conference was defined as four days – the first two being for social tinkering and workshops, the last two for traditional conference speeches.

The ticket for all four days was 400€, a bit out of reach for my pockets since I had to sponsor my attendance myself. The full ticket included an electronic badge you can tinker with during the first two days. The talks part of the conference, the last two days, was down to a more manageable 100€. Not as cheap as the last Scala Italy or C++ It, but still doable with a little suffering.

So let’s start with my report using my, now well tried and true, template.


There were about 130-140 attending the conference. The age profile was quite mixed, there were quite some seasoned programmers like me and there also was a baby in his (or maybe her, I didn’t ask) pushchair (!)

Regretfully audience was predominantly male. This is something that is fading away in other conferences like Scala Italy, Lambda Days, and Codemotion. I am not sure what the community could do about this, since I’m sure there is no one intentionally scaring people away, on the other hand, an effort must be made to make the community more inclusive and welcoming.


No Stands. The conference had one sponsor, but they had no desk/display, so nowhere to grab swags or talk with companies using these technologies. To be fair, Zig is still very young, and using its ecosystem in production (in an industrial context) today needs a good amount of bravery. Also, the attendance is somewhat low to be of interest for a generic sponsorship. Anyway, given the growth, it will be possible to welcome some industry sponsors for future editions.

Food & Location

The conference offered no lunch or break snacks. On the first day, during the registration, they offered some focaccia and small pizzas, but this was (a very welcome) exception.

The location was CityLife in Milan, a very convenient place to reach with public transportation and a stunning visual – glass and steel skyscrapers contrasting with traditional Milan architecture. More precisely the talks happened in a movie theater. The audio was very good and the slides were projected on the movie screen providing an excellent overall quality. The air quality was sometimes a bit questionable, but it improved after a brief talk with the technician.

The stage had a stand for the speaker to talk and two chairs space, where the host and the speaker had a brief chat before and after each talk… sort of talk show format.

The screen shared the slide presentation and the output of a Twitch chat where remote attendees could leave comments, and ask questions. I have mixed feelings about this chat – from one side it was distracting and it happened a few times the speaker didn’t notice the question in the chat. On the other side, some lines were very fun and provided a way to feel connected with remotes. Maybe some human filtering before reaching the screen could have improved the experience.

Below the movie theater, many restaurants were available (and a bookstore) and many shops were located on a lower floor. When it comes to restaurants, cheap or expensive can be a very subjective matter. Close to my workplace, there are several places where you can eat a decent meal for 10€, so paying 25€ for a modest lunch (we are talking about mall restaurants) would make me label the place as expensive. To be fair, on the restaurant level there were many tables you could sit at without being required to order something, and, willing to do so, you could have your food from home. Possibly I was more sensitive to this part since I had no expense refund.


Talks were organized in a single track, lasted about 45′ leaving some time for Q&A, and interleaved with short 10′ breaks. The format was quite convenient and provided time for networking (and nature’s calls). The talks were very diverse – from those deep into technical details to those more general on the approach or very personal.

Hybrid-Level Programming

by Richard Feldman, link to the official talk description.

Richard introduces the concept of hybrid-level programming by presenting a case where a large number of dependencies makes it hard to find problems. Once you determine you are having a problem, you are now faced with countless places where things could have gone wrong.

Dependencies are seen as layers between your code and the actual platform. Hybrid-level programming is to get rid of intermediate levels and expose lower-layer abstractions to upper layers. This usually has performance benefits and improves the readability and understandability of the system.

The talk was interesting and thought-provoking. I’m not sold on the idea that removing layers is always good since layers are there to increase the abstraction level and offer domain concepts to the programmer. For sure there are cases where dependencies are mindlessly thrown into the application just to solve a very specific problem or generally provide an unneeded abstraction.

Data-Oriented Design Revisited: Type Safety in the Zig Compiler

by Matthew Lugg, link to the official talk description.

The data-oriented approach focuses on keeping related data close together to maximize cache efficiency. Generally speaking, things get better if you shift from “array of structs” to “struct of arrays”. In this talk, Matthew shows how to enforce strict typing on data-oriented structures to avoid misusing the objects contained.

The talk delved into zig AST representation showing how to apply DOD to syntax trees.

Linking can be fast (if you cheat): Roc’s Surgical Linker

by Brendan Hansknecht, link to the official talk description.

When looking at interpreted languages is hard to ignore how fast they are in the development loop, going from changing the code to trying it out is a negligible time. Can we do the same with compiled languages? Well, the main problem seems to be the linker taking a very long time.

Brendan goes into different standard linkers to check what are the best performances and finds that mold takes some 0.2s to perform its task on a demo code. The talk continues by checking what it means to link the code and how to improve the time.

By creating a sort of pre-linked binary of all the dependencies, and inserting with “surgical” precision the compiled binary, the time could be made negligible.

A Python command line parser You Can Love

by Anthon van der Neut, link to the official talk description

The talk is focused on describing the history of command line parsing libraries (starting from getopt) and proceeds on the ultimate command line parsing component for Python. This component has several advanced features such as a configuration file for default values, option callbacks, shell completion support, and type validation.

This talk turned out a bit hard to follow, because of the large amount of details and widescope. Possibly focusing on the design and implementation of a couple of component features would have improved the interest.

Nea: A webserver that never allocates

by Folkert de Vries, link to the official talk description

Nea is an experimental web server platform for Roc. Memory management for web applications may be an issue. For example, if you get an out-of-memory crash, it could be hard to determine which is the request that needed an insane amount of memory, possibly it is not the one that made the server crash.

Since the cloud memory is paid for, it makes sense to statically allocate all the memory at server startup and perform custom allocations. Each request is served with a memory arena where allocations are performed. If the arena is exhausted then you have found the guilty request and the server will abort the transaction without crashing.

The talk was interesting and detailed. I shared some doubts that also emerged in the Q&A time, about handling request abortion via setjmp/longjmp. These calls are an effective way to jump through the stack but they don’t deal with resource deallocation. If you have opened files or database connections or acquired a mutex or whatever, nothing will be relinquished when long-jumping back in the stack.

The author minimized the problem. By controlling the implementation language (Roc), it is possible to handle the resource properly in this case.

Defeating the Optimizer: How to Write (and Avoid) Unoptimizable Code

by Martin Wickham, link to the official talk description

This talk was one I liked most – technical, informative, and entertaining to follow, too. Martin showed how the compiler behaves and why by going through some example code snippets. More precisely how pointer/references interact with function calls, and what kind of optimization you can expect in such cases.

Biodigital Jazz!

by Joran Dirk Greef, link to the official talk description

This was quite a talk. Joran is the CEO of TigerBeetle and presented his view of software development with some unconventional stances:

  • software development should not be seen as an expense but as an asset
  • companies exist to serve people, making money is just a byproduct
  • It is easier to rewrite everything from scratch
  • Optimization is very important since it is time-saved for the user

The talk closed with a demo of the testing environment of TigerBeetle’s distributed DB system, implemented like a videogame.

I enjoyed the talk, but exceptional claims require exceptional proof, besides “I did it so it must be true for everyone”

My unanswered question was: if we leave engineers to refine and polish their code endlessly, when do they finish and pass to the next activity?

Abstract Factories, Zygomorphisms, and You: The Role of Social Interaction in Language Ecosystems

by Edoardo Vacchi, link to the official talk description

This was another entertaining talk, exploring the idea that programming languages constrain the way you look at programming problems. Missing constructs hampers the way you can think of the solution. Maybe it is not exactly like this, maybe this also depends on how the language is predominantly used, what were the common problems when the language was designed, and what kind of community the language attracted.

Edoardo swept through several languages presenting when and how they were designed and how they are used.

Step back, Dive deep: Finding Insight through Breadth and Depth

by Samarth Hattangady, link to the official talk description
Samarth is a videogame programmer (Konkan Coast Pirate Solutions) and he talked about optimizations.

He presented three examples – how to improve reading speed from disks, how to boost floating point inverse square root, and how to make efficient 3D animations.

Neat hacks as they are, they provide solutions to specific problems. Usually, this is the case for optimization, you take a specific case, giving up on a general one, to exploit what makes it so specific to your advantage. Looking at your problem from a different point of view may provide enough insights to attempt a different way.

I didn’t ask – whether it is possible from, say Linux or Windows, to instruct the OS to store data on the outer rim of the disk to take advantage of faster reading speed.

Types and other techniques as an accessibility tool for the ADHD brain

by Michael Newton, link to the official talk description

ADHD is a medical condition that causes distress in the executive function, i.e. the action that goes from knowing that something has to be done to doing it.

In the talk, Michael describes what ADHD is and what has been the impact on his life. What is interesting is that techniques and tools considered good programming habits, greatly help people affected by ADHD making it hard to forget or oversee things.

More precisely strong types, union types, property-based testing, dependent types, and linear types, build setups all provide a stronger environment that makes for a less distressful experience.

I did appreciate how the speaker talked about his medical condition, sharing his experience.

Maps and Yellow Pages

by Motiejus Jakštys, link to the official talk description

When browsing Google Maps, we get a sort of Yellow Pages map, i.e. something that lists all the companies, shops, and markets you may (or may not) be interested in buying something. This could be fine if this is what you are looking for, but what if you are looking for something that is not backed by business and profit? Let’s say a water fountain, a kid’s playground, or a bench.

Moreover, it is hard if not impossible to contribute to commercial maps.

In this talk, OpenStreetMap is presented and attendees are shown how to edit and contribute to maps in a similar way to how people contribute to Wikipedia.

Maintaining Your Love For Passion Projects

by Josh Wolfe, link to the official talk description

This was the last talk and a very moving one. Josh talked about his project yauzl – a zip archive library written in JavaScript, and how and why his enthusiasm and passion got drained away.

While the talk provided several insights into the zip format and its quirks, the best part was about how the emotional part, which we programmers often neglect, plays a pivotal role in how we work and in how much we commit to a project. We are not just Vulcanian logic, as sometimes we dream of, but we are deeply emotional beings (like everyone else), and neglecting emotions can be far more dangerous than we think.

Josh’s candid, personal, and transparent presentation left a mark on me. Best talk of the whole conference, one of the best talks ever.

Personal Thoughts

Software You Can Love has been an enjoyable and informative conference. I expected to attend more Zig content and surely didn’t expect to attend talks that rather than celebrating the hero’s perfect way to success, expose the weaknesses and the red flags to be aware of in our job and passions.

A big shout-out to Loris Cro, the organizer, presenter, and trouble-shooter who almost single-handedly drove the conference from start to end. Despite this huge workload, he found time to talk with every attendee sharing his contagious enthusiasm for software, Zig, and the community.

I’m eagerly looking forward to next year’s SYCL conference. It would be great to see sponsor booths offering swag and T-shirts while discussing their involvement with Zig, Roc, and other parts of the devsphere. A dedicated area for lunch and breaks would be a welcome addition, along with affordable workshop or social tinkering options for self-sponsored attendees. Nevertheless, I am confident that the quality agenda, welcoming atmosphere, and enthusiastic organization will once again make it a standout event.

(featured image from inpixelhouse on Pinterest)

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.