Last week I went to my second tech conference of this fall, .NET DeveloperDays in Warsaw. It was an event of a smaller scale than TechDays or NDC, but still one of the biggest in Eastern Europe. The list of notable speakers included Michele Leroux Bustamante, Dino Esposito, and Sasha Goldshtein, the majority of others being representatives of local software development companies. Frankly, some organizational aspects left to be desired (over-crowded space, a lot of ambient noise during the sessions, too much attention to sponsors sometimes), but there was still some very good content. Also, I got the ticket for free by winning it in a lottery, so, as Dutch people would say, een gegeven paard moet men niet in de bek kijken…
In no particular order, here are some things I learned.
Daniel Marbach impressed the audience with lots of examples of concurrent and/or asynchronous code in .NET, demonstrating various patterns and explaining both internals and gotchas of certain approaches. Like,
Task.Run() should be used in the majority of scenarios, since it already has reasonable default settings; but if you need to provide a custom implementation of
Task.Factory.StartNew() can be used instead. He also gave some advice when not to use
async/await pattern to avoid extra memory allocations and complexity because of async state machine that compiler generates in this case; sometimes just returning the task without awaiting it provides less overhead and better overall performance (imagine making these async calls in a loop). Daniel also reminded us about the recently introduced
ValueTask type, a struct that generalizes the return type of async methods which might return quickly and synchronously in some cases. All the samples used for this talk are available on github.
I finally got to see Dino Esposito on stage (didn’t we all learn ASP.NET from his books at some point?), where he, in his famous expressive Italian manner, shared various ways of implementing change history functionality in .NET applications.
To me it was a surprise to learn that the ANSI SQL standard version of 2011 introduced support for temporal databases, with one of the main applications of it being historical data management with system-versioned tables. And this standard is actually implemented in Microsoft SQL Server 2016, meaning that in many cases software developers using SQL Server can leverage this functionality to implement audit trail features with very low effort. It’s not a silver bullet, of course, but definitely is a viable option.
When it comes to application performance optimization, Sasha Goldshtein is the expert you want to listen to. I attended two of his talks, where he shared some real-world stories and also which methodologies/tools can be used to investigate performance issues. USE (Utilization, Saturation, Errors) is apparently a well-known model of approaching these kind of problems, and it helps with deciding what to measure and how to interpret the results. The second talk was almost entirely about debugging and memory dump analysis tools. I learned that CLRMD provides a .NET API for process and dump introspection (something that wasn’t easy to do from .NET code in the past). It literally allows to attach to a running process and query objects in its managed heap! It is still only a library, however, so turning it into a usable tool takes some effort. And that is what Sasha did, creating his own open-source command-line WinDbg-style debugging tool called msos (stands for “managed SOS”, where SOS is a debugging library SOS.dll and is a part of the .NET Framework toolset on Windows). Not something for everyday use, but I am planning to practice using this tool to be well-prepared for a rainy day.
One of the talks by Neal Ford was about evolutionary architecture, a term coined by him and his ThoughtWork colleagues. I have mixed feelings about this one… It certainly did show software architecture from a slightly new angle, focussing on embracing and supporting change instead of fighting or denying it. But it also felt a lot like advertising the book with the same name that has just been published. I am still hesitating to buy it and waiting for more reviews to appear online: only 190 pages for such a fundamental topic somehow doesn’t feel enough. What I did like in the talk was a rundown of various architectural patterns and a clear trade-off analysis (what each of them makes easier/cheaper to achieve and what becomes harder instead).
That is it (some other talks just didn’t leave a huge impression). I am sure .NET DeveloperDays will keep getting better and better with each year and will attract more top-level speakers. And my next step is SDD Deep Dive in London, where I hope to learn everything about IdentityServer from Dominick Baier himself. Really looking forward to it!