This talk explains reactive programming in its simplest form, explores the various places we see reactive programming paradigms appear in our every day code, and discusses the future of reactive primitives in TC39 and WHATWG.We'll walk through code samples using RxJS, a push based primitive and domain specific language that sits on top of JavaScript and you'll see just how easy it is to create a more composable application architecture and use reactive programming paradigms to essentially future proof your code from common JavaScript fatigue. You'll see how concepts and paradigms/code remain consistent from framework to framework and how easy it becomes to copy paste 90% of our code from framework to framework and what you can accomplish with the arsenal of lego bricks RxJS provides with its declarative syntax and intrinsic portability.

Progressive Web Apps! We're constantly hearing about PWAs and why we should care about them. 

‍

But when it comes to making one, we're often left to build out all the core features of a PWA, by hand. Thankfully, we have Angular, and have the right tools to help us out. We'll looks at patterns you can take in your Angular app to start to make it an Progressive Web App, and what tools are available to make sure our app is ready to be a PWA.

The main use-case for using dynamic components is when we can decide only in run-time which component is loaded. They’re also the only solution when we want to embed Angular components in non-Angular ones. In many cases, replacing in-template components with dynamic ones is beneficial to performance and code quality. In this talk we’ll learn how to create and use dynamic components, and discuss several types of usages. 

Do you have a web app, but you also need a mobile app?Would you like to be able to build both with a single project?Would you like to reuse your existing code and also share it with a mobile app project?Come and see how you can use the Angular CLI to extend your existing web application with mobile applications for Android and iOS.

Recursion and iteration are two alternative paradigms for solving problems by breaking them down into smaller chunks; this talk is a deep dive into how these paradigms work, and how JS supports them both. There's a fundamental tradeoff between the two: the stateful repetition of iteration is often more performant as it's closer to the way our machines "think", whereas many programmers find the self-referential abstraction of recursion easier to read & write. In JS prior to ES6, neither paradigm was especially easy to work with: iterative loops were laborious to read and write (not human-efficient), and recursion was limited by the fact that subsequent recursive calls to a function require additional frames added to the stack, potentially leading to stack overflow (not machine-efficient). Eventually, however, all three - recursion, iteration, and JS - were finally brought closer together. In this talk we'll dive into the nature of the two paradigms, examine what an Iterable and a tail-recursive function are, and learn how Tail Call Optimization unites the two paradigms, allowing us to write code recursively and run it iteratively.

When we talk about UI tests, the first thing that comes to mind is  probably Selenium. No wonder, it’s the most widely used testing  framework for web applications. It was originally developed in 2004 and  now, after 14 years, it still takes a dedicated team of QA engineers to  implement it correctly. Tests are often flaky, painful to debug, and the  overall developer experience is rather poor. But for many years there  wasn’t another choice, until Cypress was born. Cypress tries to solve  the biggest testing challenges, e.g. painless setup, easy to write  tests, support for async testing, performance, and a good understanding  of why  tests fail. Cypress is made from scratch focusing on developer  experience, debuggability and consistency.  In this talk, we’ll look at how to get started with Cypress and dive  into some basic tests. We’ll also see how to work with http requests and  explore the debugging capabilities of Cypress.

You're building a large data-driven app? Lots of form fields, selects, autocompletes,...validation? You're tired of typing all the HTML inputs? Maybe Angular wasn't the right choice for this after all? Stop it!
In this talk we're going to level up our skills and uncover the true power of Angular forms. We'll dive deep into fully configuration based, model driven, dynamic forms that will supercharge every Angular app. We will see how to create an abstraction layer around our forms that facilitate high reusability and allows us to create new forms in minutes.

Will speak together with Shahrzad (Sherry) Aziminia.

In this talk, we are going to look at what web components are, why we need them and how we can construct them according to best practices. In order to do this we will see several examples, and each example will be tackled with its own approach. Through these examples we will be able to see the pros and cons of different ways of structuring web components.

Then we will take a look at how we can construct these with Angular and Angular Elements. Thanks to the Angular team and their latest release (version 6) we can create Angular Elements more efficiently. In our code examples will with use version 6 because of this and show the best approach to creating Angular Elements.

One of the hardest things in our industry is looking back at a legacy platform and trying to figure out how to upgrade it.  Sometimes we have the luxury of being able to stop the world and do a rewrite from scratch. Sometimes that works, other times it doesn't.  Most times though we end up creating a new and shiny platform that makes our old platform look like its ancient.  In this talk Zack is going to share a few ways to upgrade your legacy platform to bring it into visual alignment with the new application while also sharing some ideas around merging the two.

2018 is an existing year for the Angular platform. Join me in this session where we will cover this year's roadmap of the upcoming features of the Angular platform. We will discuss the new build system, the Material CDK, Observables, the new rendering engine and many other great features. Get ready!

Will speak together with Ana Cidre.

In this talk, we are going to look at what web components are, why we need them and how we can construct them according to best practices. In order to do this we will see several examples, and each example will be tackled with its own approach. Through these examples we will be able to see the pros and cons of different ways of structuring web components.

Then we will take a look at how we can construct these with Angular and Angular Elements. Thanks to the Angular team and their latest release (version 6) we can create Angular Elements more efficiently. In our code examples will with use version 6 because of this and show the best approach to creating Angular Elements.

The comparisons between frameworks and libraries are numerous, but what should you really compare?  What do you need? What can the framework provide?  If you have any hesitation about using Angular you need to see this talk.  Dima will alleviate your concerns, and maybe create some new ones :D

What is the execution context of an observable? You might think you know it, most ppl don't. In this talk I will introduce you into the world of schedulers, it's secrets and advantages. I will show you how to use them in basic cases, as well as advanced scenario's. After this session you will master smooth animations, solving complex timing errors and controlling execution context like an expert.

It is not a secret that robots are better at tedious, repetitive tasks than humans. Angular CLI took care about code scaffold and significantly improve DX (developer experience) for Angular. Tooling used behind it was exposed as the separate package. It gave us the ability to create new generators collections like NgRx. You can and should create your schematics to reduce copy-paste development style. During this talk, I am gonna to show how to implement custom schematics and make machines work for us.

Some developers believe that Angular has different types of modules like shared, feature or routing module. They’d be surprised to learn that Angular has none. Using a simple application, this talk will demonstrate how Angular uses a compiler to merge all modules into a single injector. We’ll learn where lazy loaded modules fit into this picture and why modules hierarchy and encapsulation simply don’t exist at runtime. By the end of the talk, you’ll have enough knowledge to avoid unexpected results and will be able to link, load or compile modules like a pro.

Selectors aren’t just some helpful functions to select from the Store any longer. They've become the essential part of the Store API; they keep track of the typing and help reduce the number of triggered state changes (through memoization). In this talk we’ll also look into the lesser known createSelectorFactory function to override default memoization.

Single page applications in their pure form have one conceptual problem: the JavaScript code runs in one single "empty" HTML page.Search engines like the Google Bot ignore JavaScript code and see nothing but a blank page. Search engine optimization (SEO) becomes impossible!What is more, the user experience suffers because of this: Before the user can interact with our app, the code must be downloaded and rendered. This extends loading time and makes users frustrated.Luckily, there are some strategies to master these challenges:- Pre-rendering with headless browser- Server side rendering (SSR)- Static pre-renderingIn this talk, the Angular expert and book author Ferdinand Malcher will introduce you to the concepts and ideas of server side rendering with Angular.We will talk about possible solutions and go through specific examples with Angular. The extensive tooling around "Angular Universal" greatly helps us on our way. You will learn how the Angular server platform works and how you can set up a server-rendered application on your own.

RxJS is the single greatest thing in Angular in my opinion. But using it properly is a whole other thing. The learning curve is steep and the paradigm shift is big. And even if you get all of that, we still have to be careful with memory leaks. We need to clean up our resources. In this talk we will define what a memory leak is, how we can find them and why they can occur in our RxJS powered applications. We will learn how and when we need to unsubscribe (is it needed in a service or for an http observable?) and learn some unsubscription strategies. We will do this by refactoring an application with some real life examples and remove all the different types of memory leaks! By the end you should be able to identify and tackle the same problems in your own apps!

State management is a very important topic that brings a lot of new concepts and complexity in an application's architecture. Instead of focusing only on implementation details of a specific lib, this talk will explain several beneficial principles of state management at a high level.Based on this knowledge you will not only be able to understand patterns like FLUX and REDUX but also get the knowledge to compare specific libraries like ngRx, ngxs, akita, redux-observable.