Don't let compilation set the length of your coffee break

The bigger the codebase, the more coffee you can drink while your code is being compiled. In large enterprise corporations, the company pays you to play table football while CI processes your commit. Or do they?

What if I told you your build times don’t have to take hours, and you can run nightly E2E tests every night? What if the size of your repository can work in your favor?

We'll focus on how you can use monorepos to structure your projects so that our build tools can intelligently optimize the work that goes through your pipelines, reducing it from hours to minutes. Join us to learn how affected graph, caching, and distributed agents are the tools you were missing this whole time.

Protecting the friends and family

Enforcing module boundaries was always considered a core Nx functionality, but being powered by ESLint meant you can not use it for non-JS projects. There were other limitations that we didn’t like either.

We decided to make it truly core feature - the one that doesn’t depend on ESLint, that cannot be easily skipped over and one that integrates into the very soul of the Nx.

Join me to learn more!

How to cook with RxJS

The trickiest part of learning ReactiveX is switching your mindset to reactive. With so many operators out there learning Rx on your own is often overwhelming. And no, marbles don't actually help.

But we are living in a reactive world and we can find examples everywhere around us.

In this talk, we will break down the ReactiveX to the basic ingredients and equip you with the approach that will make learning even the hardest operator a child's play.

Writing a reactive code, after all, is no more than telling a story.

The talk provides an introduction to RxJS tailored in a way that even non-technical people can understand. By using metaphors from the world of cooking (or rather eating) and avoiding the buzzwords, I will explain the complex concepts in simple life situations everyone can relate to.

We will then use these basics to live code game logic driven by RxJS.

Some more insights are available via blog post:
bit.ly/cooking-with-rx
or via talk recording at ArmadaJS conference:
https://www.youtube.com/watch?v=jYuSwn5voNM

The age of monorepos

The web has gone through several evolutionary development leaps. Each made our applications more powerful, faster, and smaller but often at the developer's expense.

We are now entering the next stage that has been carefully prepared in the past few years. Let me invite you to the world of modern monorepo solutions and share the benefits you will reap by using them in every project size and setup. It's time you automate those boilerplate tasks and reduce the bottlenecks so you can focus on what truly matters.

Get ready for the next leap! Welcome to the age of monorepos!

In this talk, we’ll talk about the challenges of building software today and what monorepos can do to mitigate them. We will follow the path of web development and how each step was a consequence of the existing limitations. We'll go over the benefits of monorepos that are a direct consequence of today's development struggles.

Here’s the talk outline:
• The brief history of the web
• Challenges that led us to modern solutions
• Monorepos the naive-way and Lerna fatigue
• The modern monorepo solutions
• Modern features: Remote caching, dependency graph, distributed task execution, generators, code boundaries
• Short demo showcase

The Dark Art of Code Optimization

Performance topic is very trendy right now. Chance is you already heard it - use lazy loading, prefetch everything with partially hydrated server-side rendered static islands. Ship zero bytes of JavaScript! But what if your code is not running in the browser or your performance is bad at runtime?

This talk will share several (un)conventional tricks you can apply to speed up the application when the size of your data grows. I will show you how to measure performance and squeeze out those last excessive milliseconds.

Learn how usual "bad practices" can become your ally when battling performance.

This talk shows a contrast to typical time-to-interactive performance talks. It focuses on the performance of the code rather than ways of shipping fewer bytes over HTTP and making the application faster to interact. In the intro, I explain what the talk is not about by listing all the techniques commonly used.

The talk focuses on the following flow:
- What is big O, and how to count the number of loops
- How mutating is faster than using immutable code, and when to use it
- Why is implicit code faster than explicit, and when can we omit it
- Performance comparison between arrays and objects, and where each excels
- Maps vs. Objects (hashmaps) performance
- Why higher-order functions are usually too slow
- Finally, how to benchmark and performance time our code

Each of the topics is explained with a small code snippet that links to benchmarking results, followed by real-life situations where this was applied.

Vanquishing Deployment Dragons with Nx wizardry

A tale about a brave peasant who is set on a journey to vanquish the deployment dragon that has been tormenting the poor kingdom who just want to push their apps on (but not over) the edge and become the deployment master.

This talk will take us on an epic journey through architecture and the powerful Nx wizardry to show us how good tooling eventually defeats even the scariest of dev ops monsters.

This presentation is leading audience through an actual fairy tale where each step of the way the hero is using smart architecture decisions and Nx tooling to optimize their applications and achieve faster and more stable deployments.

Part of the talk will be a mini theatre, where several "actors" are playing out the play of the tale.