The Epic Battle of Kotlin and C#

The decision between C# and Kotlin is often dictated by a company's prevailing platform (CLR or JVM). However, this limitation may not apply to greenfield projects.

Finding a modern and powerful enterprise language like Kotlin is a challenge. Likewise, discovering an innovative enterprise language such as C# is equally daunting. In this epic showdown, you, the attendee, will help us determine which language to choose for a new project. We trust in your impartiality! We will present facts and points to aid your judgment, striving to be unbiased.

We’ll cover platform independence, language features, and ecosystems. Join our session and become our judge! You'll see a series of topics with solutions in both Kotlin and C#, and you will vote for a winner in each category. Your insights might even guide your future projects.

This is an interactive talk. The audience will use a voting system available via scanning a QR code with their mobile device to decide the outcome of the battle.

Stay with C# or switch to F#? Let's fight! Let's vote!

We are two developers with a long experience in OOP, and in the .NET world it means C#. Both of us later discovered functional programming, and in the .NET world it means F#. One of us was convinced to make a switch to F# with its immutable data and terse syntax and never looked back. The other one was convinced that the evolution of C# and adoption of FP elements make it a solid language to take advantages of both paradigms. Perhaps both of us are right in our choices but what would YOU do?

Come to our session, and you will become our judge. You will be presented a series of small tasks with solutions in both languages, and you will vote for a winner in each category. Perhaps yo can make a choice for your own future?

Beyond LINQ: Using Expression Trees in .NET

You've probably worked with LINQ or lambda expressions in .NET, but you might not realize that when you do, you're actually using a really powerful feature of the .NET platform called expression trees. And once you learn a bit about how this technology works 'under the hood', you'll discover you can use expression trees to do all sorts of advanced things - from metaprogramming and code generation, to automating tests and even transpiling .NET code to JavaScript.

In this talk, Max will show you how he and his team started out using expression trees to avoid duplicating code in LINQ statements and ended up with a solution for automatic scaffolding of all sorts of data grids (including complex filters and sortings) and web forms (including dropdowns, dependent fields, and input validation) from just C# DTOs, to React and Angular components with integration tests attached. This approach helps his team deliver new features to clients faster and write less code than before.

He'll explain how to use the expression tree API directly, and talk you through the pitfalls and problems they encountered and how to work around them. As a result, you will learn how to start writing significantly less boring boilerplate code and increase your efficiency in daily tasks. As a bonus, you’ll get an idea of how to dramatically improve Reflection performance without using ‘black art’ like Reflection.Emit - and you’ll even learn how to write a library like AutoMapper, Simple Injector, LinqKit or Moq yourself, as all of these benefit from using expression trees internally.

Federations Strike Back

Micro-services and micro-frontends have been with us for a while. At first glance, it looks that these architectural styles are just implementations of the same idea on the backend and on the frontend correspondingly. However, sometimes the whole is more than just a sum of its parts.

GraphQL Schema Federation is a powerful, open architecture for creating a supergraph that combines multiple GraphQL APIs. Webpack Module Federation is a way of organizing each JS build as a container that also consumes other builds as containers. This way each build is able to access any other exposed module by loading it from its container.

In this talk, we will see how GraphQL Schema Federation and Webpack Module Federation together synergize with each other for building modularized language/framework-agnostic distributed applications. The approach can help architects to establish common ground across multiple teams with different languages/frameworks of choice and improve code reusability.

In this session, you'll know how to:
- Make React, Angular, Vue, and/or good old Vanilla JS work together in the same application
- Provide your frontend team with a robust API gateway using GraphQL Schema Federation
- Bundle backend and frontend to make them easily pluggable

Are Anemic Domain Models really considered harmful?

In his book Patterns of Enterprise Application Architecture, Martin Fowler describes the "Domain Model" as a complex approach to organizing business logic. The method consists of the consciousness of classes corresponding to domain model objects in data structure and behavior. At the same time, technical aspects such as data storage, authentication, authorization, and transaction management are removed from the business logic.

The pattern is implemented in two ways: 1) Rich model — data and behavior are encapsulated inside domain objects. 2) Anemic model — only data is encapsulated in the objects of the domain model, and the behavior is transferred to a separate layer of services.

Fowler and Evans consider the anemic model to be an antipattern. However, many codebases the speaker has worked with are implemented in the "anemic" model style. Many teams reported that they had a hard time implementing the “rich model” and have never succeeded. Is it just a lack of expertise or something related to the pattern? This talk is dedicated to comparing the firm and weak sides of both approaches and non-obvious details of each domain model implementation in the OOP paradigm and the functional programming style.

The code examples are in C, F#, Java, and Kotlin.

Web Application Factory Or Real HTTP Client - Take Two

In software testing, the decision between using mock services and real services can greatly impact the outcome and effectiveness of your tests. This talk will delve into this issue with a particular focus on .NET applications, and explore the trade-offs between isolation and accuracy in testing.

The talk will demonstrate a practical example, showing how we can reuse code to perform integration tests with both real and mocked services. This approach allows us to verify that our controller methods function properly under real-world conditions, without having to sacrifice the speed and convenience of local, isolated testing.

We will also explore the role of Continuous Integration/Continuous Delivery (CI/CD) and Test Management systems in this testing paradigm. We'll delve into how the dual-pronged approach of using both Web Application Factory and Real HTTP Calls can be seamlessly integrated into your CI/CD pipeline to enhance test efficiency and accuracy. Furthermore, we will discuss how to synchronize these testing strategies with various Test Management systems, ensuring effective tracking, documentation, and overall management of your test cases.

Attendees will leave with a more nuanced understanding of the .NET testing landscape and a set of powerful, reusable code examples to apply in their projects.

Technical details are available here: https://dev.to/maxarshinov/web-application-factory-vs-real-http-calls-take-two-2a1k. However, there is much more content in the talk than in the article.

Decoding Distributed Applications Deployment Dilemmas

As the landscape of cloud deployment options continues to expand, developers are often left with pressing questions: "Should I choose Kubernetes or managed container services?", "When does a serverless architecture make sense?", "How can I best automate my infrastructure deployment?", "Which tools align with my application requirements and organizational constraints?". The plethora of options can often lead to decision paralysis or ill-suited choices.

This talk aims to address these questions by delving into a comparative analysis of popular deployment platforms - AWS Elastic Container Service (ECS), Amazon Elastic Kubernetes Service (EKS), Azure Kubernetes Service (AKS), AWS Lambda, Azure Functions - and infrastructure automation tools - AWS Cloud Development Kit (CDK), Azure Bicep, and HashiCorp's Terraform.

We'll explore the unique strengths, weaknesses, and application scenarios of each offering, aiding developers, architects, and DevOps professionals in making informed, strategic decisions. We'll also examine the interplay between infrastructure automation tools and deployment platforms, discussing how they can be leveraged for more efficient and robust deployment pipelines.

This talk will shed light on key considerations such as cost-effectiveness, scalability, resilience, and ease of management when deploying distributed applications. Empower yourself with the knowledge and confidence to make optimal decisions on this illuminating journey as we decode the deployment dilemmas.

The Team Lead's Cookbook

The role of a team lead can be likened to a master chef who orchestrates the symphony of flavors in a five-course meal. Each course, from project management to business analysis, software architecture, test management, and DevOps, must be prepared and presented with meticulous care and proficiency. More often than not, seasoned developers are asked to don the chef's hat, not because they have trained extensively in this culinary art, but due to their exceptional skill in one particular dish. The challenge lies in not just acclimating to the kitchen but in preparing the entire feast to perfection.

Drawing from over 15 years of experience in the industry, this talk will provide a robust "cookbook" for aspiring and newly minted leads. I'll share the tried-and-true recipes for success I've refined over the years, offering valuable insights and best practices to manage the many facets of tech leadership.

- Our journey begins with project management. I will introduce a set of proven indicators, enabling you to proactively manage risks and ensure the success of your team's work.
- Moving forward, I will show why having a separate system for requirement management is a good idea and how analysts can benefit from using Git.
- Next, we turn our attention to software architecture. We'll step away from the traditional view, instead focusing on the modern "architecture-as-code" approach using C4, ADR, and arc42.
- We'll then venture into the vital realm of test management, specifically looking at test automation and the valuable technique of Spec by Example.
- Finally, we'll explore the world of DevOps, a critical domain that interweaves all the other aspects.

Whether you're just stepping into the team lead role or are a seasoned lead aiming to refine your skills, this talk offers a well-rounded guide for mastering the complex responsibilities of a team lead.