Speaker

Lucas Santos

Lucas Santos

Senior Software Engineer at Klarna

Stockholm, Sweden

Lucas is a Brazilian dev who works as Senior Software Engineer at Klarna. Technology lover and, since 2011, works with Web applications and JavaScript. He's also a Google Developer Expert, Microsoft MVP, and Docker Captain who has been talking about technology for over 6 years both nationally and internationally. Member & Contributor to Node.js, TC39 Outreach, KEDA Project, and the TypeScript language.

Awards

Area of Expertise

  • Information & Communications Technology

Topics

  • JavaScript
  • NodeJS
  • mongodb
  • Kubernetes
  • Infrastructure as Code
  • Infrastructure as a Service
  • Cloud & Infrastructure
  • Software Architecture
  • Cloud Architecture
  • Solution Architecture
  • TypeScript

Using dependency injection containers with Typescript

Dependency injection can be a real life saviour. Most layered architectures take advantage of this popular pattern to transform a complex codebase into a perfectly testable one. In this talk we'll be seeing what is and how we can perform dependency injection using Typescript and how we can transform this process using dependency injection containers like TSRynge.

Best Performance Practices with Messaging Patterns

Messaging can be a really important part of your infrastructure. Its possibilities are endless, however, if it's not done the right way, it can also be a performance bottleneck. In this session we'll discuss the best practices for implementing messaging frameworks and patterns in your service mesh in order to increase scalability and efficiency. Attendees will understand real life problems and what they might cause, along with solutions to these problems. We'll introduce common messaging patterns and how to leverage them for a specific usage.

What is next for JavaScript?

JavaScript is in constant evolution, how nice would it be if that amazing feature you always dreamt of ended up in the language you love the most?

Well, you might be lucky! In this session, we'll explore some of the most exciting proposals that may end in the future versions of the language for the next years to come and decipher what can we expect from this amazing technology in the upcoming years according to their technical committee.

So fasten your seatbelt and let's take a journey for all that JavaScript could be!

The Mysterious Powers of JavaScript Generators

Generators have been around since the early days of ES2015, but how many times have you used them? Most devs don't see an actual use case for this incredible tool.

However, little do they know that generators are the base for several core functionalities of JS like our beloved async/await, and they are extensively used not only in async programming, but also for other common tasks like iterations, ranges, and much more.

It's time to dive deep into what generators are, how they work, what they are used for, and why they are so important!

The ultimate guide to JS security

Security is a crucial aspect of any user-facing application, and as a Node.js developer, it's important to stay ahead of the curve and learn the latest best practices for securing your code. In this talk, we'll cover the essential techniques for protecting your Node.js and JavaScript projects and your users from potential threats.

Let's dive into the crypto API, understand why you are storing your tokens wrong, and even how you can leverage the Web itself to protect not only your application but the whole chain.

Mysterious Forces are Sabotaging Your App! A Guide to Mastering JS Performance

Did you know it is possible that your app is slow because you write long functions?

We believe that the V8 JS engine would solve all of our problems with insane optimization, but in some cases, we can be tricked into falling into nasty problems and not even being aware of them, this can bring serious issues to production applications and it's extremely hard to debug! Maybe you're already having some of those right now!

Let me show you how to avoid V8's hidden rules so you never write slow JavaScript code again!

Promises under the hood

One of the greatest doubts in Javascript programming, both for beginners and older programmers, is the async data flux.

In this talk, we'll deep dive into Promises and learn not only how they work by understanding the very building blocks that make it possible, but we'll also understand why sometimes Promises can also be the evil twin and make your application even slower than it should be and, of course, how we can prevent that from happening.

Are you ready to understand all the good, the bad, and the ugly about promises and the async flow under the hood?

It's time to talk about Deno

In the realm of JS runtimes, we've been struck by Node. However, one specific contender is rising. Deno has been seen as a viable alternative to Node for years, but it never got the attention it deserved. With its latest developments and better integration with Node's current ecosystem, it's now time to have that long overdue talk about Deno and how it can change our way of coding, and if it will eventually replace our beloved Node.js.

Let's explore what Deno is, how it works, its differences, pros, and cons, and how can you use it now!

A type trip into TypeScript's types

TypeScript is widely known and widely loved for the possibility of adding a functional type system to JavaScript. While most of us will only see and use the most common types, what if I told you there's a whole other side to TypeScript that allows you to do other incredible things?

In this session, we'll explore this far side of TypeScript's types, let's understand inference, recursion, and even how it can be used to build another app!

So, what do you say of taking this trip to the type world and seeing things differently?

Connecting Containers with JavaScript Through gRPC

Docker has become an increasingly important subject when we talk about containers. However, it's made to be used by humans. What if we needed containers to be controlled by other applications? Is it possible to do it by using JavaScript?

In this talk, we'll build a container control application that will communicate with a container runtime through gRPC and will manage all our containers. Welcome to the new era of container management!

Understanding V8's Performance Pitfalls

V8 can save your code using its optimisation techniques, dramatically improving NodeJS and Javascript performance in order to create a more efficient application and compilation. However, those performance techniques are not well known to programmers since they're made on compiling time. In this session we'll understand the main performance pitfalls for V8 and how we can take advantage of those optimisations to create a highly scalable application.

Lightspeed Communication with gRPC

HTTP and JSON have been and still are widely used in micro-service-based architectures as one of the most efficient means of communication, but is it really true? Currently, with our scalability and speed demand, the ReST model is lagging behind! Let's get to know the technology that will make the ReST completely obsolete, welcome to the era of gRPC.

How Typescript and architecture saved my project from failing

Architecture is a not very well debated theme in the community. Many believe this topic does not actually change the final outcome of your project, however let's explore a real case where the adoption of Typescript along with event sourcing pattern was the difference between saving the project and losing the customer.

Design Patterns With JavaScript and Node.js - Yes, it is possible

Design patterns existed for ages, they are extremely useful and extremely hard to grasp in totality. For a long time we thought design patterns were only destined to be used in statically-typed languages, but JavaScript came to prove this is not true! Let's dive deep into some of the design patterns we can use to transform our coding style with JavaScript and Node.js.

Infinite scaling with Kubernetes and serverless architecture

Serverless is a buzzword often related to infinite scalability, but using cloud provided serverless services might prove a bit expensive or a bit vendor-attached experience. In order to solve this, why can't we use our own pre-existing underlying Kubernetes infrastructure to take advantage of the serverless perks without the costs?

Dissecting Node.js - How it works under the hood

Node.js has grown a lot since when it was created. This enormous growth has led to people using this awesome runtime without even knowing what it is! In this talk we'll dissect NodeJS bit by bit and explain how does this runtime lives and works under the hood.

You'll learn a lot about Bytecodes, the V8 engine, implementation details and how this so-called event-loop works after all.

Javascript as you've never seen before

Javascript is a part of our everyday lives and we're always either using or developing some application which is built upon it. Since this is so present in our community, we already have some default solutions and patterns for common problems. The thing you don't know is there's a whole new side to Javascript which is not seen so much, but can be very useful.

Your architecture can save your project

Have you thought about controlling every aspect of your application? Being able to go back in time and undo what was done without any problem? Fix bugs and problems in the blink of an eye? This session will tell you how we can do that using event sourcing and Typescript!

The complete guide to the best performance using NodeJS

Have you ever experienced slowness in your production applications? Well, this is not always related to your hardware, sometimes the problem is right under our nose and we just can't see it! In this talk you'll learn how to identify and monitor the most common bottlenecks in NodeJS applications, extract informations and graphs which will make your system as fast as it can get!

Lucas Santos

Senior Software Engineer at Klarna

Stockholm, Sweden