On October 21, 2019 I had the pleasure to participate in the Silesian edition of the 4DEVELOPERS conference in Katowice, which is the Silesian edition of the largest technology festival for programmers in Poland. The conference was addressed mainly to programmers who are familiar with Microsoft technologies. There were 32 lectures given by 32 speakers, and around 400 participants attended the entire event.
The event was divided into 4 thematic paths:
- – NET
- – Application Architecture
- – Cloud Computing
- – JavaScript
I was mainly interested in the .Net and Application Architecture paths.
Build your software on solid foundations (Application Architecture) – Marcin Bałda
Comparison of the process of building a house to creating software. The lecture was mainly devoted to discussing SOLID principles that allow for production of high-quality software. The author focused on the importance of the application skeleton design and building solid foundations for future functionalities. The lecture was based only on theoretical issues.
Useful links:
Lecture description – in Polish
https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design
REST Services with AWS Lambda and .Net Core (.NET) – Marcin Bałda
Presentation of the capabilities of the AWS Lambda platform in .NET projects. The speaker showed that .NET also works well with cloud services other than Microsoft Azure. He built a small application connecting to the AWS cloud and introduced its basic functions, such as recognizing objects in images and categorizing them using artificial intelligence.
Useful links:
https://aws.amazon.com/blogs/compute/developing-net-core-aws-lambda-functions/
Ports and Adapters (Application Architecture) – Dominik Przybysz
A very interesting lecture on ports and adapters architecture and a comparison with the layered architecture, which is currently the most widely used. Thanks to ports and adapters, we can freely change the operation of the application, and also easily scale its individual elements. This architecture also allows us to freely divide a monolithic application into microservices, as well as cooperate with various data suppliers/recipients. During the lecture, Domain Driven Design concepts and suggestions on how to model the application using the DDD approach were also addressed.
Useful links:
https://github.com/alien11689/ports-and-adapters-example
https://en.wikipedia.org/wiki/Domain-driven_design
https://herbertograca.com/2017/09/14/ports-adapters-architecture/
Secure Domain (Application Architecture) – Dominik Przybysz
The lecture was about the most common mistakes programmers make when writing code. The author presented various situations where the programmer, knowing the assumptions of e.g. Clean Architecture, misinterpreted them so that the application was built on weak foundations and thus difficult to expand in the future. The speaker also presented tools that help create better code and better define application domains.
Useful links:
Video from the conference – in Polish
History of Asynchronous in .NET – Marcin Tyborowski
During the lecture, the author presented the history of asynchronous programming in .NET and discussed the pros and cons of different approaches.
- – Thread and Threadpool – the first approach to multithreading in .NET: creating threads is very expensive and without proper control we can easily cause memory leaks
- – APM – a very non-intuitive approach, because of which multi-threaded applications have become illegible to programmers without a solid understanding of multithreading; it does not work in .NET Core
- – Event-based asynchronous pattern – a much easier approach than APM, but still the code is very different from the synchronous code
- – Task Parallel Library – thread creation is fast, adding lambda expressions has greatly increased the readability of the code, but the code is still different from the synchronous code
- – Async / await – the final version of multithreading in .NET – easy, understandable and fast
Useful links:
https://tyborowski.it/history-of-asynchronous-in-net/
https://github.com/tbr09/Multithreading
Make your applications intelligent – short tutorial how you can add artificial intelligence to your apps (.NET) – Michał Jankowski
Overview of how you can quickly turn a simple application into an application that uses artificial intelligence, based on the example of creating a photo storage program. Thanks to the Cognitive Service, the cloud automatically recognizes unauthorized photos, such as pornographic material with approximately 99% efficiency. This significantly reduces the amount of work needed to check all photos. Cognitive Services also allows you to describe photos and thus categorize them. During the presentation the lecturer created a program connecting to Cognitive Services.
Useful links:
https://www.youtube.com/watch?v=IBCqHy27ndE
https://azure.microsoft.com/en-us/services/cognitive-services/
Clean Domain Model: Domain-Driven Design tactically and practically (.NET) – Kamil Grzybek
During the presentation, the lecturer discussed how to practically implement a clean domain model using DDD and C#. The author showed many examples of how to conduct a conversation about the proper domain of the application. During the presentation it was also shown how to avoid primitive types in the program and how to write unit tests correctly for code written in this way. During the presentation, a modular monolith created with the DDD principles was presented as a counterweight to currently very popular microservices, which are also used where they do not make sense.
Useful links:
Lecture slides – in Polish
https://github.com/kgrzybek/modular-monolith-with-ddd
