C#, TypeScript, Go - It's all the same

Programming languages are living things, and they grow and change as time goes by. In evolutionary biology, convergent evolution is defined as the process whereby distantly related organisms independently evolve similar traits to adapt to similar necessities. Which basically means that if something is a great idea somewhere - it's likely it's a great idea elsewhere as well.

So, many features that appear in new versions of programming languages are actually features that are "inspired by" other languages - ideas that have been proven to work, and that make the programming experience richer and better.

In this presentation, we'll take a look at some of the new features that are coming in C# 13 and TypeScript 5/6 - and how they are inspired from each other, and from other programming languages and platforms as well.

Who are you? OIDC Authentication - the good, the bad and the ugly

Each and every application needs users - so it needs to verity the identity of those users. Increasingly, and with good reason, that functionality is out-sourced to a third party provider, with AWS Cognito being one of the most used ones. This talk will cover some of the most common patterns of authentications used with Cognito, and how you can actually manage modern authentication for your product.

How to mess up JWT's - a practitioner's guide

JSON Web Tokens are everywhere - you are using a bunch of them right now. It's such a common technology, yet, it's very easy to get them wrong. In this session, we get to the nitty gritty of JWT's - what they are, how they work, and how to make sure that we haven't made an app that just waits to be hacked.

The session's goal is to make developers aware of the pitfalls accompanying JWT's by telling some personal stories of cases where JWT's were used improperly. In my experience, such improper usage is extremely commonplace and JWT's are associated with magical thinking, i.e. "I'm using JWT's and I'm secure"
The key take-away of the talk should be that JWT's are a great took that should be used carefully, with full understanding of what it can and cannot do.

Make your own signals for fun and profit

Signals are cool - all the best frameworks have them, and very few people know what they actually are or what they actually do. In this talk we'll try to demistify them, by implementing a small signal-based application from scratch.

Asynchrony on the web

The web is asynchronous by design, and it has to be.
But, there is a bit of a problem in that asynchronous programming has a slight tendency to make people's heads explode. And people really don't like when their heads explode. To get out of the pickle, we need to handle the asynchrony somehow. This talk will explore the reasons for the design of the web, and will try to offer some solutions, from the worst possible to the current state of the art.

How to write bad code

There is so much bad code out there - which means that it must be in demand.
So, in this talk, let's try to analyze what makes a piece of code so bad it stinks, and how we can write such gems.

Decorators in TypeScript - Deep Dive

One of JavaScript's stronger sides always was the ability to modify itself at runtime, but this was coupled with very weak runtime code information - so we had to work somewhat in the dark. Decorators are a feature that enables us to inject and use cross-cutting concerns - and they have been used with great success in frameworks like Angular and Vue. This talk will inspect how this is implemented in the current TypeScript version, and how we can leverage it to our benefit.

Make you a Redux for fun and profit

Unidirectional data flow has been all the rage these past years - mostly thanks to libraries like React that use it heavily. But it is a bit of a counterintuitive pattern of work, so this presentation aims to demystify why and when it's actually needed and to explain all the strange words (dispatcher, reduced, store) that are used within it, by making a simple implementation in TypeScript from scratch.

Functional Programming for mere mortals

Functional programming combines the expressiveness and power of abstract mathematics with the intuitive clarity of abstract mathematics. If you start reading about it it's full of words like category theory, monad, functor, combinator, lambda calculus, currying and expressions like Y=λf.(λx.f(xx))(λx.f(xx)). Also, most of the people you meet talking about it are like they are in some kind of a cult, uniform and trying to convert you to the one true way. And you just want to write better code - not a doctoral thesis!

This talk is not like that. This talk focuses on how you can use functional programming techniques as additional tools in your toolbelt - tools that you can use when and if they are needed, where they are needed. Tools that you use in addition to, not instead of everything you've learned until now. Tools and techniques that will enable you to, sometimes, make your code more reliable, more predictable, more readable, and more maintainable,

May Contain Jargon. No Math Required.

How to write and run C# in the browser

So far JavaScript had a monopoly on web code - we could either write some form of JavaScript or not execute code on the web.
The WebAssembly standard changes that, by defining a binary code standard that could be directly executed by the browser. That binary code could be written in any language compilable to wasm - and that could mean C# as well.

In this session we'll take a look at Blazor, an engine that enables us to write C# code for the server, C# code for the client, run it, and, if we're lucky, it might even work.

Why test code?

Do we need to test code, and why? The most common lies we tell to ourselves and to our managers, and how to cut through all the buzz regarding modern software testing from a developer's perspective.

C#, C# Everywhere, nor any server in sight

This presentation focuses on two new and fun technologies - Client side C# (a.k.a. Blazor) and Serverless C# (a.k.a Azure Functions). The goal of this demo-based presentation is to build a fully functional web-site, using only C#, but without using any servers.
We will create an Azure Function, from scratch, using C#, that connects to the Cognitive API and Cosmos DB. When (and if) that is operational and deployed, we’ll continue with creating a frontend for our function using Blazor, and deploying it on Azure.

Dark secrets of the event loop

Knowing the event loop in JavaScript makes the difference between knowing what’s going on and praying that everything works. In this presentation we will try and cover the inner-works of JavaScript, how the one thread ( that did not sign up for this job ) in the browser handles execution of instructions, what happens if we try running things asynchronously and why the event loop is important in this delicate cycle.

Testing your tests with mutation testing

Do you write unit tests? Lots of people do. But are those unit tests actually good? Do they test the right things? Oftentimes, the answer to these questions is a null value. Nobody knows. So, how can we test that our tests are working fine?
Mutation testing inverts the testing process by using code-under-test modifications to determine the overall quality of the tests-under-code.