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.
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.
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.
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 memorization). In this talk we’ll also look into the lesser known createSelectorFactory function to override default memorization.
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!
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
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.
To place a speech here - Set number "1" in sessions collection to a Session. And choose 1 day.