The conference unites library authors and core teams with fresh ideas, great people, and a summer Amsterdam in the background. 

We recognize JavaScript development as an art of engineering, and that's why the conference offers both a JS-driven art exhibition and audiovisual performances during the afterparty. 

First dedicated JavaScript conference in Amsterdam.

Taking our biggest and longest-running JavaScript community forward, we're adding a new event to our family - a full-day conference covering the latest and greatest news and insights from the global JavaScript network.

Join us and a group of internationally known JavaScript enthusiasts to share inspiration and spend a great, summer day in one of the most unique Amsterdam locations.

JSNation

The largest and the oldest JavaScript community in Amsterdam kicked-off the first edition of a full-day conference having Amsterdam Zoo as a location.

AmsterdamJS Conference 2017 Aftermovie

The JavaScript language gets ever more powerful, but more complex to implement and deliver good performance. Learn about V8's new compiler pipeline.

The JavaScript language gets ever more powerful, but more complex to implement and deliver good performance. V8 has a new compiler pipeline and a unified approach to collecting feedback about your application. 

I’ll explain how we do it and present some problems. For example, in complex systems, facile "solutions" often distort the environment in unexpected ways. Welcome to the jungle *__*.

V8 and How It Listens to You

Security might seem like a difficult and intimidating area to approach, that's only backend-related. 

Let's talk about security. We can all agree it is very important, however the general feeling about it is that it's a difficult and intimidating area to approach. 

Furthermore, is very often seen as something only backend-related, however front-end plays an important role as well.

The Art of Keeping Your Application Safe

Let's talk about why reactive programming is awesome and how it can help with managing complexity, data and scaling your applications. 

Managing state in large application applications is hard. Managing async behavior is even harder. 

Let's talk about why reactive programming is awesome and how it can help with managing complexity, data and scaling your applications. 

Also, remember the callback hell?! Well, we once have been PROMISED that all will be good. And guess what, we OBSERVED we can do better. Let's deep dive into how observables are much better than promises.

RxJS All Things

WebGL is not so scary and difficult as many people think.

WebGL is not so scary and difficult as many people think. Let`s have a quick tour over WebGL nature and ecosystem.

WebGL Practical Application

Makepad is an experimental livecoding environment, which compiles JS to run on the GPU and renders every UI pixel using webGL. 

This talk is about makepad (http://makepad.github.io), an experimental livecoding environment which renders every UI pixel using webGL and runs multithreaded. 

Makepad compiles JS to run on the GPU which opens up many powerful angles to styling and data visualisation.

In this talk i will showcase the editor, rendering architecture and goals of Makepad: find the fun of programming.

Makepad: Rethinking Web UI's with WebGL

Typescript was warmly welcomed with all our developers from C++, Java and C# background. So it was only a question of time for our public JavaScript SDK to be completely rewritten in TS, from scratch. 

Typescript was warmly welcomed with all our developers from C++, Java and C# background. So it was only a question of time for our public JavaScript SDK to be completely rewritten in Typescript from scratch. 

In my talk I will focus on good and bad things that we experienced during development, and will tell how our initial thoughts played out.

Porting Web SDK from JS into TS

What is Serverless, how it works and why are people talking about it? But most important of all, how and why Serverless can be important for you?

What is Serverless, how it works and why are people talking about it? How many servers are there in Serverless computing? 

But most important of all, how and why Serverless can be important for you?
Don’t panic! This talk will take you to the journey through the Serverless Galaxy with Node.js.

The Hitchhiker's Guide to the Serverless Galaxy

Refactoring or changing an API of a lib you maintain might not be a fun task. But, sometimes it is required.

Refactoring or changing an API of a lib you maintain might not be a fun task. But sometimes it is required. If you are going to do it anyway, you don't want to do this manually anyway. So with the power of ASTs & codemods you can automate this & have confidence in the result

Automating Front-End Refactoring

Creating a stable and reproducible development environment can be a hassle. Docker comes to the rescue with lightweight containers that isolate each application component with minimal overhead.

Creating a stable and reproducible development environment can be a hassle. The more components you have the less feasible it becomes to run them all together on your laptop. 

Using Vagrant helps with reproducibility and isolation but putting all components on a single VM is very different from the way they will run in production. 

Docker comes to the rescue with lightweight containers that isolate each application component with minimal overhead.

Why You Should Care About Docker

The new kid on the block in browser land is WebAssembly. It allows precompiled code to run at native speed, connected via JavaScript to your browser. 

The new kid on the block in browser land is WebAssembly. It allows precompiled code to run at native speed, connected via JavaScript to your browser. 

But how does it work? What are the (dis)advantages? Can we optimise our SPA with it? With many examples, I will talk you through the setup, pitfalls and rough edges.

WebAssembly: the Final Frontier

Assuming everyone uses the web with a 10 Mbps connection and a Macbook Pro is rather utopian. 

Assuming everyone uses the web with a 10 Mbps connection and a Macbook Pro it's rather utopian. 

At Udacity we have a daily traffic of millions of page views from people all around the globe and we always aim to serve the best experience possible even if you're browsing the sites with an old Android with a 3G connection. 

We'll see what critical steps we follow to make sure we are making our sites as fast as possible.

The Road to Web Performance in 3 Critical Steps

This talk presents the results of the first empirical investigation on PWAs, showing that the PWA and service workers technology is promising in terms of energy efficiency.

Mobile web apps represent a large share of the Internet today. However, they still lag behind native apps in terms of user experience. 

Progressive Web Apps (PWAs) are a new technology introduced by Google that aims at bridging this gap, with a set of APIs known as service workers at its core. 

In this talk Ivano presents an empirical study that evaluates the impact of service workers on the energy efficiency of PWAs, when operating in different network conditions on two different generations of mobile devices. 

This talk presents the results of the first empirical investigation on PWAs, showing that the PWA and service workers technology is promising in terms of energy efficiency.

Are Service Workers Draining My Battery?

As a guitar player, I usually use some effect-pedals to change the sound of my guitar. I started wondering: “What if, it would be possible to recreate these pedals using the web-audio-api?”

Changing Live Audio with the Web-Audio-Api

Virtual DOM is generally considered to give the best performance for web applications. How can this be given it is such an inefficient algorithm?

Virtual DOM is generally considered to give the best performance for web applications. How can this be given it is such an inefficient algorithm? 

I will give an overview of popular Virtual DOM implementations and I will introduce our Virtual DOM library, MaquetteJS. 

I will also show how Virtual DOM makes unit testing easy. I will demonstrate how we achieve 100% code coverage on all our visual components using fast-running NodeJS unit tests.

Benefits of Virtual DOM

A deep dive on how Uber leverages javascript, across its engineering orgs.

Join this session for a deep dive on how Uber leverages javascript across its engineering orgs. From building frontend properties with a full javascript stack using express and react to the tools and infrastructure we use to automate best practices.

Javascript @ Uber

2017

Amsterdam JSNation is a 2-day event focusing exclusively on JavaScript development. 

At our conference, inspiring talks meet fresh ideas and good people - you’ll hear all you need to know about the latest trends in JS tech, see stellar speakers, meet new friends and colleagues, and connect with key people in the industry. 

Plus, all of that in one of Europe's top destinations.

Summary of our hot, summer gathering with great JavaScript crowd and international speakers.

Amsterdam JSNation Conference 2018 Aftermovie

The Power of the Paradigm

Go beyond reactive programming (Promises, Observables, etc) and take a fresh look at plain old callbacks.

Programming with callbacks has been every JavaScript programmer's struggle since always. "Callback hell" is the reason why we have created Promises, Observables, reactive programming libraries, and other smart tools to help us avoid using callbacks directly. 

In this talk, we'll go beyond reactive programming and take a fresh look at callbacks. We will discover an incredible pattern among simple callbacks, that allows us to do everything that Observables or Promises or Iterables can do, and through familiar functional APIs. That pattern is fondly named "Callbags".

Callback Heaven

If you are building an SPA, you can take advantage of optimizations that give you epic scalability, with super low latencies at a fraction of the cost.

I'm going to tell you a secret. If you are building an SPA, you can take advantage of optimisations that give you epic scalability, with super low latencies at a fraction of the cost. 

To understand the secret, I'll need to teach you a few things such as the actors involved in transferring data from your server to the browser; and about the ancient technology called 'serverless' which you might be surprised to learn is something you've already been using for years. 

By the end, you'll know the secret of how to architect an SPA for scale without breaking the bank.

How to scale an SPA? - Asim Hussain

First annual JavaScript Awards Ceremony recording http://osaward.com

Streamed from Amsterdam JSNation Conference http://amsterdamjs.com

JavaScript Open Source Awards 2018

With WebBluetooth the browser can take control of all kinds of physical devices in the real world like lightbulbs, robots, and even drones.

Time for JavaScript to get physical. With WebBluetooth the browser can actually take control of all kinds of physical devices in the real world like lightbulbs, robots and even drones. And nowadays you can even run JavaScript straight on microcontrollers and even little Bluetooth beacons. 

This talk will teach you the basics that you need to get started and give a peek at some more advanced topics like building your own Bluetooth devices using just JavaScript

Fun with Bluetooth

An anthology of QA horror stories from the past, and how to avoid such situations with TDD. 

An anthology of QA horror stories from the past, and how to avoid such situations with TDD. 

When tests are built in from the beginning and not tacked on after features are built, fewer defects are created and development moves faster. 

JavaScript has all the tools required to cover your automated testing needs, and writing tests in the same language as your app is a no brainer. 

We'll cover the tools available today and the logistics of merging your QA and dev teams.

Tales from the QA crypt

Understand the challenges that we're facing today, and see how a smart 'Smart Home' experience could look like in the near future.

Advertisements suggest that we are at the zenith of mankind's scientific knowledge and technological power, but when it comes to IoT and the so-called 'Smart Home', we are clearly not. In fact, we are in the middle of the dark age. 

I'll explain the challenges that we're facing today (from an implementors perspective), what's 'wrong' with our current products & show you how a smart 'Smart Home' experience could look like in the near future.

The dark ages of IoT

Get your Computer Science hat on and explore sorting algorithms currently implemented by JS engines. Learning how they work, will help you create more performant and consistent applications!

No matter your experience in JS, you have probably came across the Array#sort method at some point. 

Do you remember the first time you tried sorting numbers? You were probably astonished that the sort method does not sort things out quite as we might expect. Believe it or not, there is actually much more going on than meets the eye! 

Let’s get our computer science hat on and explore some useful sorting algorithms currently implemented by JS engines used by Node such as Chrome's V8 and Microsoft's Chakra. 

As a developer, learning how these algorithms work, why and when to use them will help you create more performant and consistent applications!

How to Sort Your Socks Using JavaScript

See why typed JavaScript, especially in large code-bases, is worth the added effort.

Some tools are so useful that once you've used them in one project, it is hard to work on other projects without them. 

React was certainly that way for me when I first started, and now TypeScript has become the same way. 

This talk will cover why typed JavaScript, especially in large codebases, is worth the added effort. 

I will discuss my personal experiences - the good, the bad, and the ugly - and talk about why I can't seem to start a project without `npm install typescript`.

TypeScript Ruined My Life (In a Good Way)

Since last year, all major browsers support ECMAScript modules, and Node.js is looking to support them as well. Join me for a tour! 

Since last year, all major browsers support ECMAScript modules, and Node.js is looking to support them as well. Join me for a tour! 

I will tell you about the history behind the feature, compare it to other JS module systems, explain the new syntax forms and their meaning, discuss some of the pitfalls, and give an overview of proposed extensions.

ECMAScript Modules: Past, Present, and Future

See a simple structure for sharing state between server and browser, in isomorphic apps.

Isomorphic (also known as Universal) JavaScript apps have been described as the "Holy Grail" of web development. 

Developers don't have to write redundant code on the server and the client. Users get the best experience, with both fast initial load and even faster subsequent page views. 

Googlebot is happy, too, not having to execute client side JS to crawl your site. And with React, Vue and Angular all supporting server side rendering on Node.js, this is more achievable than ever. 

In this talk, I'll talk about a simple structure for sharing state between server and browser that we at BCGDV Berlin have successfully used in four products we launched in the last 18 months.

Persistence Cycle: A Successful Structure for Isomorphic Apps

What if you could log your brain to the developer console, typing with your brain signals?

What if you could log your brain to the developer console, typing with your brain signals? 

This talk is a demonstration of an open-source Brain-Computer Interface that is completely developed with JavaScript, from the ground up, using neural networks and signal processing. 

Armagan hits the stage with a wireless EEG headset, shows how to read signals from the brain in JavaScript using native C++ Node.js modules over USB, and the implementation in Electron, Node.js and Vue.js.

console.log(brain)

At GitLab we use Vue JS in production more than a year. I refactored old parts of GitLab with Vue and created many new features using the framework. 

We are really impressed how Vue is simple yet powerful. 

First 10 mins of the talk are an introduction for new comers, then deep dive into the best techniques, like state management, reactivity, tooling and also the experiences about new feature development and migrating a legacy featue to Vue.

VueJS Best Practices

Challenges, technologies, and best practices, from building the new mobile version of Pinterest.

We rebuilt the whole Pinterest mobile web experience for authenticated users. It looks and feels just like our native apps while maintaining the fast load times expected of mobile web. 

We used cutting edge technologies which led to a 40% increase in each of our core engagement metrics and up to 30% in time spent. But it was not all sunshine and rainbows! 

In this talk I will share challenges, technologies and best practices that we used for the new Mobile Website.

Bringing Mobile Web back to Life

Tips and best practices on WebVR User Experience.

The main points of the presentation will be focused on tips and best practices regarding WebXR UX. I will have a several VR devices ready to show how an experience can be adapted to run independently of the hardware that's available to the user. Main point is to teach developers how can they make their content truly accessible with as little as possible.

Look ma! No hands!

Problems developers face when building HTML5 applications.

Introduction: Problems developers face when building HTML5 applications. The bonuses of skeletal animation. Optimising existing assets Using shaders for UI element development and optimisation Shader SFX development. The use of video format as a way of optimising resources. Possible problems of the listed approaches. Project examples.

Optimizing Assets for Graphics Heavy Web Apps

A walk through in the depths of microservices powering a plethora of Angular applications at bol.com, the biggest webshop in the Netherlands and Belgium.

An online retail website is just the tip of the iceberg hiding a mountain of complexity. Let me walk you through the depths of microservices powering a plethora of Angular applications at bol.com, the biggest webshop in the Netherlands and Belgium - BOL.COM

In the Ocean of Angular Web Applications

Learn about the super powers ClojureScript can add to the view layer, and the benefits of functional programming.

Clojure came along into our lives in 2007 as one of the most concise and powerful Lisps, and since them it's been widely adopted by members of the community. 

Recently, Clojure got a new friend called ClojureScript, which allows us to use Clojure to build robust and reliable front ends. 

Ever wanted to use a rich data structure set, macros and take advantage of the great performance optimizations present on the JVM? You got it! In this talk I'll go through the super powers ClojureScript can add to the view layer and the benefits of functional programming.

Building functional Front-ends with ClojureScript

Angular apps are getting more performant with each new version of the framework - thanks to the huge number of internal optimizations.

Angular apps are getting more performant with each new version of the framework - thanks to the huge number of internal optimizations. 

But the main responsibility for the eventual app performance is on us, developers. 

Let's go through the main points on how we could help the framework to build and the browser to perform our app better.

Optimized Angular apps: smaller, faster, better

How we can do awesome things with Webassembly? What does it offer? How easy it is to kickstart WebAssembly in your application?

How we can do awesome things with Webassembly? What does it offer? How easy it is to kick start WebAssembly in your application? We can compare the performance difference between WASM and native JS.

Do Things Faster and Better With WebAssembly

Combine the power of RxJS with your preferred components library (React or Vue).

Embrace Reactive Programming in React and Vue with RxJS

See how it is easy implementing a client-side mocking solution with connect-api-mocker library.

When you are developing an application that uses remote REST API endpoints, it will be hard to implement a new feature that has not an API implementation yet. 

Also always you need to have a running API server to continue development. Then, you probably will have some troubles to test some very exceptional issues because it's hard to reproduce that kind of issues. 

All of these problems can be managed with a very simple client-side mocking approach. At this talk, we will talk about that approach and and how it is easy implementing a client-side mocking solution with connect-api-mocker library.

Mock to start

Do you remember Dart? See what happened with the “JavaScript killer”, and why you need to try it right now.

Do you remember anything about the Dart programming language? Time have changed, and the second coming is near. I'll show you what happened with “JavaScript killer”, and why do you need to try it right now.

Dart: the Return

OneUp.company builds a lot of MVPs based on Ethereum smart contracts and Vue. To accelerate this process, they have been using Node and Docker to automate the manual steps. 

At oneUp.company we build a lot of MVPs based on Ethereum smart contracts and Vue. To accelerate this process, we have been using Node.js and Docker to automate the manual steps. 

The boilerplate code for this is now made available on Github, making the creation of Ethereum dApps smoother for everyone. During this presentation we present this boilerplate code and give pointers on how to best use Node.js and Docker for Ethereum smart contracts.

Accelerating Ethereum Development with Node.js and Docker

2018

JavaScript is #1 on demand programming language in the world with 25 millions of developers behind it. Meet the ones who shape out the now and the future of the prospering nation. June 5-7, 2019.

Amsterdam JSNation is a 2-day event focusing exclusively on JavaScript development. At our conference, inspiring talks meet fresh ideas and good people with summer Amsterdam in the background. 

We recognize JavaScript development as an art of engineering that is why the conference happens in a former church Rembrand attended. Which is located in the most center of the city next to the best places Amsterdam has to offer.

A look at how JS got to where it is today, as well as where it’s headed. Will that future direction continue to be a good one, or not?

A look at how JS got to where it is today as well as where it’s headed, but asking the critical questions of if that future direction will continue to be a good one or not?

Keep Betting on JavaScript

Learn how Google’s security team has achieved a high-level of safety against XSS, and related problems, by integrating tools to make it easier for developers to produce secure software.

18 years have passed since Cross-Site Scripting (XSS) became the single most common security problem in web applications. Since then, numerous efforts have been proposed to detect, fix or mitigate it, but these piecemeal efforts have not combined to make it easy to produce XSS-free code.

This talk explains how Google’s security team has achieved a high-level of safety against XSS and related problems by integrating tools to make it easier for developers to easier to produce secure software than vulnerable, and to bound the portion of a codebase that could contribute to a vulnerability.

We will show how this works in practice and end with advice on how to achieve the same results on widely-used, open-source stacks and new browser mechanisms that will make it much easier to achieve high levels​ of security with good developer experience.

Securing the DOM from the Bottom Up

Tools that supercharge unit, integration, and end-to-end tests, with a focus on Cypress.

Day to day I work on Cypress.io, an open source end-to-end test runner. And I love it - but there are other tools that help me write better tests and better code. 

In this presentation, I will show some of my favorite tools that complement, extend and supercharge my unit, integration and end-to-end tests.

Testing Tools and Their Friends

The reasoning behind some of the breaking changes in the next webpack version. 

A changelog only tells half of the story. In this talk I want to talk about the reasoning behind some of the breaking changes in the next webpack version. 

I try to convince you that doing these breaking changes is worth it and we are not randomly trying to make migration harder.

Webpack 5 - Why Breaking Change? What is next?

Short and easy introduction to lenses, profunctor optics, and how to use them for state management.

Functional lenses for contemporary frameworks

We use the term open source to mean a lot of things: it's difficult to discuss the struggles of simply being a maintainer whether you are a volunteer or working on it at a company.

We use the term open source to mean a lot of things: it's difficult to discuss the struggles of simply being a maintainer whether you are a volunteer or working on it at a company. 

We lack clarity in what sustainability looks like because there are so many different goals: diversity in participation and work, community building, building a business. 

I'll be going through some of my experiences in going from onlooker to contributor to full time maintainer and how we may want to broaden what maintenance looks like and where we can look to for guidance.

Open Source: Charity or Business?

PWAs load quickly, even on flaky networks, have an icon on the home screen, can re-engage with users by sending push notifications, and load as top-level, full-screen experiences. 

Progressive Web Apps combine the best of the web and the best of apps. They load quickly, even on flaky networks, have an icon on the home screen, can re-engage with users by sending push notifications, and load as top-level, full-screen experiences. 

In this talk Jamie Maria Schouren explains the what, why, and how of Progressive Web Apps, her own quest in search for "app-iness" and with code examples and real-life​ use cases, shows why PWA’s are the future of the web!

The search for App-iness

We'll take a brief tour of our Accessibility Checklist and talk about how our development team deals with the practical implications of implementing accessibility on our React frontend.

Inclusivity is important to us. As a company that builds web applications for Universities and Research Institutes we need to ensure that everyone can successfully use our Web sites and applications regardless of their physical or cognitive ability. 

We'll take a brief tour of our Accessibility Checklist and talk about how our development team deals with the practical implications of implementing accessibility on our React frontend.

A11Y and React

This talk is for people curious about GraphQL, Gatsby, and JAMStack generally, as well as those people interested in speeding up the development and deploy process for their teams.

This past year my team at PayPal began looking at how we could radically improve our developer experience and deliver high-quality applications faster. 

We landed on an approach we call “static apps” that removes our heavy node layer and replaces it with static markup and JS on a CDN. All of the dynamic content is served over GraphQL APIs. This approach to using JavaScript, APIs and Markup is sometimes referred to as the JAMStack. 

This talk will walk through some of the challenges we faced with our node.js application servers and how we are trying to solve them by moving to this new model. Performance, stability, security and developer experience concerns will all be highlighted. 

This talk is for people curious about graphql, gatsbyJS and JAMStack generally as well as those people interested in speeding up the development and deploy process for their teams.

An Introduction to Static Web Apps with JAMStack

Learn how to leverage functional programming techniques to reduce complexity and write safer JavaScript in a real-world scenario.

With the rise of software-based innovation, the business rules and flow controls are getting more complex. Software engineers do not only have to handle increasingly complicated problems, but they also carry greater responsibility for ensuring the quality of their code. 

It’s clear that our tools and methods should evolve to build robust software. In this talk, we’ll explore how to leverage functional programming techniques to reduce the complexity and write safer JavaScript in a real-world scenario. Come to see what’s exciting about static analysis, pure functions, composition and immutability; and how these principles are a powerful tool to optimize your code for correctness.

Stop the Software Apocalypse with Functional Programming

Explore many of Angular features and improvements in the pipeline that allow anyone to build and deploy performant apps with very little overhead.

Angular grew significantly in the past few years from both a tooling and developer experience standpoint. This talk will explore many of the features and newer improvements in the pipeline that allow anyone to build and deploy performant apps with very little overhead.

Through real demos and examples, we’ll cover Ivy, bundle budgeting, differential loading, automatic code-splitting, and progressive rehydration of SSR elements. In the second part of the talk, we’ll focus on how to efficiently prefetch and preload different modules and components.

Building Fast Angular Applications from End-to-End

JavaScript Proxies are fun and powerful, but you should probably never use them! Learn why. Plus, see how Immer makes working with immutability easy, 

Immer is a tiny package that allows you to work with immutable data structures with unprecedented ease. It doesn't require learning new data structures or update APIs, but instead creates a temporarily draft tree which can be modified using the standard JavaScript APIs. 

Immer makes all the ceremony that is needed to perform deep updates in immutable objects obsolete.

Brace yourself; for example your Redux reducers will become twice as short without giving up on any of the semantic constraints.

Immer (optionally) uses proxies under the hood. Proxies are an exotic JavaScript feature that is nowadays available in all modern browsers. What are they, how do they work and why should you (not) use them? How did they make Immer possible?

Join this talk to learn how you can finally use immutability in JavaScript without fighting the language. Or just to get an idea about the powerful patterns that are possible nowadays in JavaScript, by using proxies.

Immer, Immutability and the Wonderful World of Proxies

Learn the alternative ways of presenting 2D content in the browser (CSS, Canvas, WebGL), along with the pros and cons of each one.

This talk is about looking at alternatives to traditional ways of presenting 2D content in the browser. We will look at the different methods along with the pros and cons of each one. 

I will take a slightly deeper dive and show examples of how WebGL can be used to render incredibly fast 2D graphics and also do some pretty interesting effects.

Turbo charging 2D on the web

Explore the most important performance metrics and ways you can easily set up performance tests using WebDriver, as part of your CI/CD pipeline.

The performance of a web application is the most crucial non-functional aspect that is often ignored and not tested. Their implications are difficult to understand, hard to predict and in most cases connected with bad user experience and revenue loss.

With Lighthouse, WebPageTest and other tools you are already able to capture tons of performance metrics of your application. However understanding and testing them often feels difficult and painful.

In this talk, Christian will present you the most important performance metrics and ways how you can easily set up performance tests using WebDriver as part of your CI/CD pipeline.

Automated Performance Testing With WebDriver

Build a cross-platform game using an adaptive gameplay. This will allow the same web app to be played on touch screens, using a mouse or pen on desktops, up to the ultimate immersive experience with WebVR!

We’ll see how to build a cross-platform game using an adaptive gameplay. This will allow the same web app to be played on touch screens, using a mouse or pen on desktops, up to the ultimate immersive experience thanks to WebVR! By using PWA, it will run totally offline, can be pinned on your mobile home screen or even be pushed to the Microsoft Store. 

We'll see how to build the 3D scene using glTF, create the loading screen using the latest CSS features, manage the gameplay and finally how to use a service worker in the best way possible in collaboration with IndexedDB. I'll share what I've learned while creating the game. Fun topic but serious learnings. 

I'll demo the game on desktop, mobile and on a VR headset which provides a very cool gameplay via the VR controllers! :)

Using WebGL and PWA to build an adaptive game for touch, mouse and VR devices

Post-Mortem debugging is a powerful technique that allows you to take a memory dump, when an issue occurs in your application, and later analyze it offline.

Post-Mortem debugging is a really powerful technique that allows you, through the use of several tools, to take a memory dump when an issue occurs in your application and later analyze it offline.

The talk will primarily focus on llnode and how you can use this tool to better understand why a Node.js process is behaving odd or is crashing.

Post mortem NodeJS debugging

A journey into the asynchronous debugging horrors, how to avoid them and what patterns can be used to ease the life of each developer debugging applications. 

A journey into the asynchronous debugging horrors, how to avoid them and what patterns can be used to ease the life of each developer debugging applications. 

We all have run into issues debugging JavaScript. Knowing what went wrong due to missing stack traces in asynchronous contexts and finding the actual issue takes way too long. 

Following best practices in error handling reduces debugging time and improves the code base a lot!

Error handling: doing it right!

See how you can control multiple drones using JavaScript and Node.

We're pretty used to drones flying around us by now. Until now most of these drones were still controlled by a human operator. But what if we could control them solely using our code? 

In this talk I will show how to control multiple drones using JavaScript. 

With the help of Node.js we'll send commands to the drones and read back their telemetry. I will talk about the difficulties of flying and keeping control of a drone completely without human interference. 

In the second part we will actually send the drones flying and I'll ask two audience members to participate in a small 'drone' game.

Controlling a swarm of drones with NodeJS

Learn what it means to ‘load test’ your application, and how to get started with writing your first script.

The key to finding the optimal solution to a problem is to threefold: maximise the number of tools in your ‘personal tool box’; know all their capabilities and uses; and to know which tool is best suited to fix the particular problem in front of you. 

This talk will enable you to grow all three aspects around load testing. 

It will look at what it means to ‘load test’ your application, how to get started with writing your first script and provide you with a case study and an insight as to the tools and techniques that we use here at the FT to help identify such performance issues.

Ready, Steady, Crash!

In this talk we're going to rewrite RxJS from scratch, seeing behind the curtains which are the core components and the ideas of the library. 

RxJS has become almost a standard in the emerging reactive Front-End world. If you're not using it right now, you probably played with a few operators. 

In the talk we're going to rewrite RxJS from scratch, seeing behind the curtains which are the core components and the ideas of the library. 

You'll see how to build Observables, Subscriptions and Operator, then we'll introduce Schedulers and how they're used in RxJS. If you fancy Reactive Programming or simply you want to learn something new then... this talk is for you!

Reinventing RxJS

Top #10 things I've learned while putting JavaScript on the top of server-side benchmarks.

This presentation is about server performance, which means that no time in the world would be enough to cover it all. Hopefully, I can share with you the top #10 things I've learned while putting JavaScript on the top of the server side benchmarks.

You will learn about runtimes and engines, how some are more capable than others, and sometimes the obvious choice is not always the right one...

This talk is about thinking outside of the box, being creative and don't take anything for granted. We will debunk myths about native code vs. script or RAM usage; it's going to be fast! I promise!

10 thing I learned making the fastest JS server runtime in the world

We moved our application from the cluster module to PM2 & RabbitMQ. This talk will cover the Why/What/How we made this migration.

As Node.js is single threaded. This is why you can’t take full advantage of multiple core machines unless you use the cluster module or a process manager like PM2.

We moved our application from the cluster module to PM2 & RabbitMQ. This talk will cover the Why/What/How we made this migration.

RabbitMQ and PM2 in Node for managing Multiple Processes

How to build a really large application? How to think about architectural layers? What is wrong with the majority of JS frameworks? How does GraphQL influence my architecture?

I've seen a lot of NodeJs applications. I see a lot of misunderstandings around architectural patterns. 99% of NodeJS tutorials do not cover this topic and limited to "hello world" apps. 

How to build a really large application? How to think about architectural layers? What is wrong with the majority of JS frameworks? How does GraphQL influence my architecture? 

I will answer all of these questions.

The working Architecture of Node Applications

Zero Knowledge Architecture is a pattern that allow to build applications where all data is stored and exchanged in an encrypted way. 

Zero Knowledge Architecture is a pattern that allow to build applications where all data is stored and exchanged in an encrypted way. It enforces end-to-end encryption and client-side operations only. 

Let's see how to build a Zero Knowledge backend, involved in data transfer and keys-echange system, with a JS client-side lib. No more excuses not to secure your applications design.

Building Zero-Knowledge Backend

The ownership of the npm package 'event-stream' changed hands, late 2018, and found its way into the hands of an attacker, targeting a Bitcoin wallet.

The ownership of the npm package event-stream changed hands late 2018 and found its way into the hands of an attacker targeting a specific mobile application. How did an attacker go from an npm package to a mobile application? How was this exploit found? What purpose did each of the three payloads have?

This session will dive into the three payloads of the attack, how they worked, how they were obfuscated, and what their goal ultimately was.

There's no reason to assume this is an isolated event and understanding how this occurred and what it did is an important part of staying secure going forward.

Analysis of an exploited npm package

When thinking of backend languages, JavaScript is not the first thing that comes to mind. But why not? 

When thinking of backend languages, JavaScript is not the first thing that comes to mind. But why not? 

Why not write a backend in JavaScript? Or even a whole microservices infrastructure!

In this talk we will discuss exactly what a microservice can look like in Javascript with the addition of frameworks like Socket.IO or NestJS and how several microservices would communicate with each other. 

There is no prior knowledge of JavaScript required. Everything we show will be explained.

What's your backend written with? JavaScript?!

Intro on building a server-side rendered website with Quasar, by using Vue and Nodejs. 

Razvan does an intro on building a server-side rendered website with Quasar by using Vue and Nodejs. Sections: What is SSR, Writing Universal Code, Configuring and building SSR, Client-side hydration, SSR with PWA, Deploying.