Talks

There are too many talks about how to develop good software. However, creating bad software requires discipline, perfectionism, and a high level of dedication and craftsmanship. In this talk you will learn to create code that, when modified, will break parts of the application that seemingly have no connection. You will introduce so much entropy into projects that your teammates will question why they chose programming as a career. Join this talk and let's create software together that would make a goat vomit!

Get ready for an amazing talk where we challenge the "hype" in the world of web development! Discover how to combine tRPC, ChatGPT, TailwindCSS, NextJS 13, and Zod to create web applications that are not only hype-worthy but also functional! We won't let ourselves be swayed by current trends, instead, we'll explore how these cutting-edge technologies can take your skills and projects to the next level. Join the hype and leave behind those who reject it!

Aren't you tired that they ask you to create clean code but no one has told you what it really is? Aren't you sick that in talks of good practices they don't show you how to address the refactors that will improve your application? If that's the case, this is your talk. We will "reform" a frontend application, where little by little we will make it more legible and mantainable in a very simple and practical way. Don't miss it!

TypeScript is a superset of JavaScript which adds a typing system to the language. It has gained more and more popularity due to the reliability that it provides for us in our applications, the living documentation it gives us and the numerous refactors it gives us. A static type system has become a very important part of the tools we use to increase our productivity. It being that important the TC39 committee has launched a proposal which would add tpye annotations to JavaScript with a very similar API to TypeScript. In this round table we'll talk about the pros and cons of TypeScript, the implications of the new proposal and mucho more!

The frontend has become complex. Very complex. We went from using JavaScript with jQuery to use frameworks that help us handle state, components and abstract us from having to deal with the DOM and so many more things. But... How do we handle the code that does not belong to the framework? Should we separate in different layers? Should we apply concepts of architecture in the frontend? In this talk we'll see different architectural patterns of Software and we'll debate how to apply them in the frontend in order to make our application more robust and solid while keeping them flexible.

The front moves very fast –or so they say–, so so fast that either you are constantly updated, or you miss the newest framework. Do you want to keep updated and learn what are these millennials doing on the web? Do you know technologies like ESModules, WebAssembly, Pika, Babel, Shadow DOM, WebComponents, Grid, Flexbox, Custom properties, PostCSS and many more? If you don't know them, don't worry, in this talk we'll review the whole frontend landscape and what makes it so awesome –or so they say–.

In this talk I'll share my most beloved tips and tricks to increase your productivity. We'll be using my favourite IDE: Webstorm. Follow me into this journey!

Deno is said to be by many the successor of Node, including the creator of both: Ryan Dahl, who using the knowledge obtained from Node's 10 year lifespan started this project in order to fix some of the errors, which he mentions in the talk where he introduced Deno to the world.

Node was very disruptive in the tech world, but back then JavaScript was not what it is today. Many things didn't exist then, like promises, ESModules, binary data and many other APIs that are standard now. So Node had to innovate in these areas. But now that there are many standard APIs that solve these problems Node has had problems adapting, as it would have meant that there would be very big breaking changes.

Moreover, Deno has native TypeScript support —which means that we don't need to compile a TypeScript file in order to run it—, a security model, a decentralized solution to distribute packages, a single executable and many more things.

How can we apply RxJS to incorporate it into a highly reactive application? In this talk we'll see the main pain points and general pitfalls while providing concrete examples to create a truly reactive architecture.

Are you sick of architecture talks where they show you nice graphs (📊) but no code? Talks where they teach you SOLID, layers and –for an unseemingly weird reason– onions but they don't go deeper? Want to know how to apply architecture to the crazy world of the frontend, but you don't know why? If that is the case, this is your talk. We'll review at a technical level what makes up a good architecture, good practices™️ and loads and loads go code with TypeScript and Vue. Batteries not included.

In this talk we'll see how to unit test our code. Although we'll be using Jest and JavaScript, the concepts we'll see you can apply to any other language or testing framework. We'll deepen our knowledge on how to make good tests, from the test definition to the strategies to follow to make our test more robust and long-lived. We'll see concepts like F.I.R.S.T, given when then, TDD, mocking and... Much more!

In the crazy world of the frontend it has been known by its volatile nature, however, we don't really put much effort to abstract ourselves from that nature. We should build robust and long-lived code. In this talk we'll see how to approach common problems using TypeScript, components and several design patterns. Moreover, we'll see how to make our code open to change without needing to try to guess the future. And of course we'll follow SOLID principles to make your application easy to change and test. Let's start this journey towards beautiful software!

Kotlin is a modern language. It's simplicity and benefits make you fall in love. So it is that Google has made it the official language of Android; but it does not stop with Android! In this talk we'll show you why Kotlin is a great language, and we'll show you a web application with the backend and frontend made with Kotlin.

Web layouts have evolved exponentially. Grid and flexbox are a main part of this evolution. This native CSS tools allows us to create layouts easily and fast. It is a passionate subject that interests me and I'm sure it will interest you.

Are you finding it challenging to stick to a routine? Do you often put off tasks indefinitely or procrastinate excessively? If so, you're not alone. Join us on a journey inspired by James Clear's "Atomic Habits" to cultivate positive habits and break free from negative ones.

Together, we'll embark on creating a Progressive Web App (PWA) using Next.js, Shadcn, and Tailwind CSS to seamlessly track our habits. By leveraging NFC tags, we'll effortlessly record our progress and hold ourselves accountable.

It's time to bid farewell to procrastination and welcome productivity with open arms!

When you tell people you code in JavaScript they usually look down on you. This talk will give you the tools to enlighten those heretics. We'll be entering the world of design patterns applied to JavaScript, looking through some of the cutting edge properties of ES6 such as Proxies and default function parameter expressions, dealing with objects and even some examples of functional programming. This talk is not allowed for cardiacs.