Progressive .NET Tutorials 2019
I attended the Progressive .NET Tutorials at Skillsmatter in London.
Keynote: We are the guardians of our future
Tess argued that we cannot be isolated from the ethical impacts of our decisions. It is easy for us to say that we are just doing mathematics, that we are just applying an algorithm, that it is someone else's job to think about the impacts of what we are doing. Even in the world of A.I., as she said "if the source data is biased, the model is biased".
She talked us through a number of examples where the ethical implications of our actions can impact people but also how we can improve our processes.
- Build better guidelines.
- Provide datasheets for datasets explaining the expected use cases. Just as materials come with tolerances, so do datasets, explaining the nature of the training data.
- Detect, don't predict.
- Keep humans in the loop.
Here are my sketchnotes:
Beyond HTTP in ASP.NET Core 3.0 with gRPC
by Steve Gordon
Steve talked us through the current changes that are happening in .NET Core 3.0 to support gRPC, a high-performance, cross-platform RPC framework. The primary ability to communicate between platforms relies on an interface specification in a .proto file that allows for code-generation of the client and server and allows the message contents to be pure data because the metadata is in the contract in that file.
Here are my sketchnotes:
Go Channels in .NET - concurrency made easy
Riccardo introduced us to CSP - Communicating sequential processes and how to use the System.Threading.Channels package in .NET while comparing this with the Akka .NET framework.
Quantum Computing 101
Johnny gave us a brief introduction to the principles behind Quantum Computing, how this is different to the classic computation that we are used to. He introduced us to the concepts of superposition where in the Quantum world a Qubit can hold all possible values at the same time, only when observed will the value collapse. Along with superposition, Quantum Entanglement is a key concept in the Quantum Computing world where two particles are linked so that when one changes value, the other instantly changes.
He introduced us to Q# by Microsoft, which is their simulation of a Quantum Programming Language that simulates the Quantum Computer and IBM's Q Experience which is a more graphical representation that includes the ability to run on a real quantum computer or a simulation of one.
Surviving Microservices
Michele gave us an awesome, high-content, keynote about surviving the transitions to microservices, especially for the medium to large sized organisations that have old-legacy code-bases. She explained to us that we need to understand why we wanted to do the transformation, that in order to prove the value we have to talk in the strategic value rather than in terms of the tactical value that we see from our technical perspectives.
She went on to talk about the different decisions that we must make along the way, that this is a long process that can take a lot of thought and effort, that we have to balance design, to re-architect to understant eventual consistency and the problems of going through the production in a system of complex microservices.
Here are my sketchnotes:
Authentication for serverless
by Robin Minto
Robin started by explaining how security has changed over the past few decades, how moving from a monolith where the identity boundary was the edges of the application through to microservices where the identity boundary was distributed (or at least multiple identity boundaries) and then onto serverless where you don't even have control of where the code is running.
Here are my sketchnotes:
Pipeline driven organisations
by Roy Osherove
Roy talked us through how traditional organisations are partially implementing pipelines, individual silos within the organisation (dev, test, security, etc), but the pipelines are not connected and require humans to be the decision makers.
He argues that in the ideal world we code delegates in a universal pipeline, where we allow the pipeline to make the decisions according to the rules that we encode.
To have trust in the pipeline we need to be disciplined, we need to "skill up" and we need to train the pipeline, when something goes wrong (i.e. when the pipeline fails to block something) we have to correct the delegates, or add new ones. Each discipline, each silo, needs to continue to produce their own delegates and trust the others to produce theirs.
Here are my sketchnotes:
