Last week, In The Pocket was present at the yearly Techorama conference, this time hosted in the Kinepolis Antwerp. It was a very inspiring event, where we all learned a lot and gained a lot of ideas to work upon in the future. We'll be getting into some of the most remarkable talks we visited.
From left to right: Tim Kerger (Solution Architect), Yves Delcoigne (Xamarin Competence Lead), Kristof Colpaert (Mobile Developer)
Opening keynote: Scott Hanselman
No introduction is needed for Scott, who has been a symbol in the .NET world for years. He once again proved why!
Scott elaborated on the problems he and other people with diabetes type 1 are confronted with on a day-to-day basis. He talked about how the community got together to solve these problems, starting with crude solutions like a wooden-carved insulin pump, to IoT devices that are able to send your sugar level to a REST API that can be integrated into all kinds of applications.
This talk was very inspiring because it is simply amazing to see how a community, brought together by the same problem (controlling and maintaining a stable sugar level), can accomplish so many things.
In the afternoon we saw Scott again when we saw some of the developer tools that are currently being implemented, but not yet stable. One of the most impressive features was the new version of the Linux on Windows tool. Whereas the current version is currently very slow, and only a mapping that still executes Windows commands underlyingly, the new version of Windows will actually include a Linux kernel. This means that the performance will be near-native, and will be just like any other Linux machine. These environments can also be combined! You can deploy a website on the Linux kernel, have an instance of Visual Studio code running on the Windows part, and be able to debug the website. This really opens up new possibilities for developers that prefer Windows development, but don't use it because of lacking developer tools.
The next state of C#
A couple of talks were related to how the C# language has grown into its current state, and what is currently being added or will be added.
Filip Ekberg explained how, in the first versions of C#, many new features were added, but as time went by, fewer features were added with each new version. This was because it became very difficult to add new features to a 10-year old codebase. It's the reason why Microsoft decided to rebuild the C# compiler from scratch: the Roslyn compiler was born. With this new compiler, we can now expect more features.
Some of the features that were highlighted were already known to us, some of them were new. We for one did not know about the Span class yet, which takes a subset of a list in a memory-efficient way. This class can be used to manipulate lists without causing any overhead to the memory usage. Also interesting are the Ranges that will be introduced in C# 8.0. These allow us to take "slices" from a list in a more comprehensive way than currently available. Some examples:
- list[1..^5] to take all items except the first and the 5 last items;
- list[^1] to take the last item;
- list[1..4] takes items list through list. So note that the first index is inclusive, the last index is exclusive.
Some other highlights were the default method implementations in an interface, and record classes that may or may not be added in a later release. If you recognize these features from another language, you're correct: these are already available in Kotlin. The C# team is looking carefully at other language features to see what works and what doesn't work. Based on community feedback, these features are added in the C# language.
We can conclude that C# is a language that is still growing, and will keep growing for a long time.
Techorama was not a conference only focused on development. There were also some talks that were meant for managers, like the one from Jason Alba. His talk mostly focused on how to create and maintain innovative teams. There were no big surprises there (focus on personal growth), but it was interesting to make a comparison between the suggestions that Alba was proposing and what In The Pocket was doing. We can only conclude that we are doing a pretty good job!
Another talk that we attended, was the talk of Hannes Lowette. He went through the different mistakes developers made when deciding on implementing new technologies and frameworks. Some of these included checking if the team has the correct skills to use the framework, learning the internal workings of a framework, and fully finishing your old improvements before adding new frameworks. At the end of the talk, we had the possibility to take a quick test on the website, and if we succeeded, we could receive a certificate at the Axxes desk. Naturally, we couldn't leave this certificate just laying around.
Kevin Dockx, a freelance solution architect, talked about some of the pitfalls and optimizations regarding HttpClient. This was a healthy mix of things we already knew, and others that were new to me, but that we could immediately use the following day.
While it was obvious that using streams instead of reading a JSON response in a single string object is better for both memory and speed, it was interesting to see that using streams for writing operations could have a negative influence on performance. Changing the HttpCompletionMode was also a quick takeaway.
Finally, the explanation about the new HttpClientFactory introduced in .NET Core 2.1 was something I think everyone should know. This finally solves the problem of either re-using the HttpClient or recreating the client for each request. The HttpClientFactory will cache and dispose of HttpClient objects for you, while still being extensible enough to fit your needs.
Some talks were more of an introduction to a certain framework or tool. There was for instance a talk about AppCenter in which they discussed how to set up a new project, building and testing your apps, distributing your apps and connecting them to the different app stores. Our conclusion is that AppCenter can be handy for small projects. A build pipeline in AppCenter is set up in about 5 minutes, which is excellent for such projects. As soon as you'll need some more customization, you'll need to either migrate to Azure DevOps or choose another tool.
Another tool we discovered was Try .NET, for creating interactive documentation. This is pretty much a code editor that is usable in the browser, for C#. This should allow for library authors to let the user experiment with their library, without them having to include the library in a sample project.
Another introductory talk was for Unity. Johnny Hooyberghs created a game where multiple robots could compete against each other. The user is able to update the script which controls the actions of the robots. While this was not really a "new" thing, it was still interesting to see how fast you can create a basic game using Unity and .NET.
David Berry gave us an introduction to building enterprise-grade web APIs with .NET Core. While this technology isn't new, his hands-on approach taught us that ASP.NET is a really accessible platform for creating application backends. His awesome demonstration - he built an API to find nearby food trucks - inspired us to have a deeper look into the functionalities and possibilities of this framework within our Xamarin competence.
Some final words
There were many, many more talks that we didn't cover, especially about web technologies. Since only the Xamarin team was present, we followed the sessions that were the most relevant to us, but it's clear that the whole .NET landscape is changing on multiple fronts at once.
We can't wait what the future has in store, see you next year!