Remix, is it more React hype?

Remix, aka remix.run, from the makers of React Router is gaining a lot of noise on social media, but is that transitioning into real value for the end user?

Well, let's take a look at building something with Remix, what's the dev experience like, how well does it solve our problems, and most importantly, is it worth the hype?

GraphQL over CosmosDB, where to start

The popularity of GraphQL can't be denied and it fits really nicely with a schemaless data model like we can achieve with GraphQL.

But how do we get started with it? What options do we have when it comes to running GraphQL in Azure? How can we get rich type safety between our GraphQL schema and CosmosDB models?

In this session we'll go from zero to hero and get you running your first GraphQL server underpinned with CosmosDB, ready for your next application.

Type-safe GraphQL with TypeScript

One of the nice things with GraphQL for API design is that it enforces type-safety in the schema that we define. But alas, these types are embedded as part of our schema and that type safety is lost for our resolvers, resolver variables, consuming clients and so on, requiring us to recreate the type system. It’d be so much easier if we could leverage our schema type system in our application.

This sounds like a job for type generation, but how do we do that? We’ll take a look at a tool that can generate you TypeScript type definitions, then implement our backend using them before looking at how they can plug into the front end with React (or Angular or Vue or Svelte or whatever is the framework of the month!).

We’ll cap off by learning how to model our storage platform effectively, using a separate type system for storage and combine them with the GraphQL schema types, producing a rich, strongly types, end-to-end development model.

Supercharging a Web Devs Toolbox

Being a web developer can be a complex job, whether it’s picking the right JavaScript framework, CSS framework, transpiling pipeline, bundler, linter, and this is before we even start talking about tooling.

But let’s talk about tooling, there’s been a lot of exciting innovations in the last few years with the tools that we can use to make a web developers live easier. From VS Code extensions to real-time remote collaboration, dev environment setup to build automation, let’s take a look at all of those.

In this session we’ll take a look at our toolbox and how we can make the most from it. We’ll start with VS Code and some extensions to make web dev easier. Next we’ll look at how to configure development environments for repeatability, so you spend less time installing software and more time building it. To cap it off we’ll look at how to build and deploy applications with a push of a commit.

End to end GraphQL

GraphQL is a powerful approach to creating APIs where the power in the hands of the client more than the server. This means we need to think differently to how we create GraphQL servers.

From creating a schema to represent the data contracts, implementing that schema against a data store and how to have a client work with the server, there's a lot of things to consider in the design.

So, let's get started! Over the course of this workshop, we'll learn the building blocks of the GraphQL language, create a server with TypeScript, work with data stores and create a web app to connect to it. With the basics done, it's time to expand with advanced GraphQL features such as real time through subscriptions, creating federated backends to integrate existing APIs and how to handle security.

Day 1
- Why GraphQL
- GraphQL fundamentals
- GraphQL clients and servers
- Building our first GraphQL server
- Connecting GraphQL servers with data stores

Day 2
- GraphQL on the client
- Hosting GraphQL in the cloud
- Real-time backends with subscriptions
- Federated backends with Apollo
- Security for GraphQL

Pre-requisites
- A laptop
- Git
- Text editor (VS Code is recommended)
- Node LTS + latest npm
- Familiarity with JavaScript/TypeScript

Nice to have
- Docker + VS Code Remote Containers extension
- Azure subscription
- GitHub account

GraphQL is just APIs for hipsters, right?

GraphQL, the API approach that's going to change the world... or at least, that's what those who advocate for it say. But is it just because it's "new and shiny" that people are so excited by it, or is there something more that makes GraphQL worth investing time in as you build your APIs?

I was a skeptic but now I'm an advocate for using GraphQL in building your apps, so what made me change my opinion of this technology?

Come on a journey where we'll look at what GraphQL is, why it's an interesting and relevant technology in building applications. We'll do a compare and contrast with REST, discuss the pros and cons that GraphQL represents and see how we can uplift existing APIs to be GraphQL without having to rewrite our entire codebase.

it'll be a session that's a mix of live demo and slides for theory.

Docker, FROM scratch

Docker's popularity has exploded over the last couple of years, especially in the DevOps space, but unless you've spent a lot of time in that area it can be a confusing technology to wrap your head around.

So let's step back and start looking at Docker from, well, FROM scratch (and we'll understand just what that means).

With minimal starting knowledge of Docker we'll look into what it is, cover off all the core concepts from images to containers, volumes to networks, and how we can compose environments. We'll also look at how to use Docker in Dev, not just DevOps and how containers can be useful tools without being something to run production infrastructure on.

The beauty of stupid ideas

We spend all our days striving to write the perfect code, code that is well thought out and will stand the test of time.

This is not a talk about that code. This is a talk about all that code you don't write because it's stupid, it doesn't solve a "real" problem or doesn't make any sense.

We'll explore some of my own stupid ideas, like writing my own number system in .NET or writing an IoC container in JavaScript, what I learnt from these stupid ideas and why exploring stupidity is important.

Redux, beyond React

Redux has grown in popularity within the React community as an alternative to Flux and a powerful way to manage within your application. From its focus on immutability, pure functions or time traveling, it's become a popular way to back your React applications.

But Redux is more than a React library, it's a powerful pattern for data management in any kind of application.

In this session we're going to dive deeply into how Redux works, look at why it's so popular with React, how it can work with any front-end framework and even beyond JavaScript.

Beyond console.log

Whether you're a Chrome, FireFox, Edge or Safari kind of person you've probably opened up the web developer tools at some point... but is your extent of usage writing console.log within your code and inspecting an element, or have you gone deep?

For this session we'll be diving into the tips and tricks that will make you a power user when it comes to your browser dev tools, explore the console beyond console.log, learn the differences between the different browser tooling and how to find that damn problem that's only happening on _insert any browser name here_!

WebAssembly, your browsers sandbox.

We've been doing web development for 30+ years and in all that time have you ever stopped to think, "This SPA needs more C++"? Well thanks to the power of WebAssembly you can finally bring C, C++, Rust, Go and other high level languages to the browser.

So does this mean that we can replace our JavaScript with these other languages? Probably not, so what is the role that WebAssembly can play in building web applications? And most importantly, what does it look like as a web developer to try and incorporate these platforms that have traditionally been on the server?

For this talk, we'll look at some of the fundamentals of WebAssembly, how to incorporate it into our development process and ultimately what it looks like to build an application that uses a mixed development stack.

This is intended to be an entry level talk to people who don't have any real experience with WebAssembly.

2 Day React Workshop

React is a JavaScript library for creating high-performing, maintainable JavaScript applications and brings a fresh approach to thinking into the JavaScript community.

Being a declarative user interface library that is un-opinionated about the rest of your application it is easy to reason about it is simpler to learn and master the basics than a full application framework like Angular. Also, thanks to the simple nature of React, the patterns and lessons you will learn are transferable to other libraries and frameworks.

Aaron started using React in its v0.8 days after having worked with several other web frameworks, and immediately liked what he saw. From its drive towards componentisation to data management it’s been a great tool for building application dashboards, public websites, and native applications. Aaron has introduced it to many projects across a variety of industries through his career.

### Day 1: React fundamentals

* Introducing React and the Virtual DOM
* Why React?
* React's Architecture
* Advantages
* Components
* Props
* State
* Lifecycle
* Styling
* Developer experience
* Dev Tools
* Hot Reload
* React with TypeScript
* Functional patterns and immutability
* State management patterns
* Container/Smart components
* Hooks
* Redux
* Error Handling
* Error Boundaries
* Routing and Single Page Applications (SPA’s)

### Day 2: Real world React

* Application/source control structure
* Automated testing
* Optimising app performance
* webpack
* Production configuration
* Bundling
* Code splitting/lazy loading
* Integrating with a web server

### Pre-requisites:
* Understanding of JavaScript fundamentals
* Participants need to bring a laptop
* [Latest Node LTS](http://npmjs.com/)
* [Git](https://git-scm.com/)
* [VSCode](https://code.visualstudio.com/) or other text editor

Unleash the Power of VS Code

VS Code is hot, there's no doubt about it being an utterly amazing editor, but I ask you, are you using it to its full potential? Let's go on a journey together and look to unlock the real power that you can get out of VS Code. Whether it's with shortcuts or extensions, environment standardisation and remote development, collaboration to integrations, there's so many things to uncover that can take you from a user to a pro in no time.

This session will leave you itching to get back into your editor and code up a storm on that next piece of work.

This will be a primarily hands-on, demo-heavy talk as we look at all the things you can do with VS Code. It doesn't need to be specific to a single platform/language but depending on the audience it will be tailored to best suite them with the extensions that are covered.