In this talk, Luciano will demonstrate how evil magicians can cast a JWT brute force spell to take control of poorly constructed JWT tokens. From the books of dark magic, you are going to read rhymes of Node.js, ZeroMQ and parallel computing to make this evil plan happen and by doing so you are going to make fool of all those noobs magicians who don't know yet how to safely use JWT tokens!

It’s about the things that he wishes he knew since the beginning, his “ah-ah that’s how it works! moments that guided him to write code in a more expressive and declarative way.

It's a love letter for this powerful language, in the form of a talk that bounces between the technical and the personal perspectives.

Cirpo's hope is that everyone in the room, even experienced developers, will learn a bit more about writing more idiomatic and consistent JavaScript code, learning from the mistakes he made and that he still witness every time he sees other developers start using it.

Dian will share with you the theoretical and practical sides of Massive.js, a Postgres-exclusive data mapper for Node, and how Node applications can get the most out of their data by moving past the conventional wisdom of object-oriented and object-relational approaches to leverage Postgres to the fullest possible extent.

From an API for your coffee machine to a porg that screams every time your webpack build fails to playing games with hundreds of people at the same time, the only limit is your imagination. You might not leave this talk with a degree in Electrical Engineering*, but you'll learn useful basics to let you enter the wonderful world of hardware. You'll look at different ways to combine JavaScript and hardware, from APIs all the way to JS enabled microcontrollers.

In this talk you will discover why more advanced compilers are at the core of the next evolution of web performance.

Probably the most common question you get asked as you get to know an organisation is “What framework should I use?” No matter what some people would have you believe there is no straightforward answer. The answer though is founded in our typical response of “What are you trying to do?

In this talk, you will explore a deep dive into the technology behind those everyday experiences, and demystify the algorithms and abstractions that make our digital world go round. You will discover everything from network addressing algorithms, frequency-hopping cellular data networks and shortest path optimisation, to wavelet compression, fingerprint recognition and media encoding schemes. Whether you’re a programmer, a product owner or just somebody who loves using the latest tech, after watching this talk you’ll never look at your phone quite the same way again.

Bonus: Time and connection permitting, you’ll have a chance to help (or hurt) Brian as he live streams a game of Clone Drone in the Danger Zone by launching your own laser-sword-wielding robots via the React interface.

Check out the links to the Game and the Extension

Supplement :

Jennifer's talk includes three QA horror stories: Manual testing, Mystery tests, and "It works on my machine". She addresses these by showcasing automating testing tools (and doing a live demo of Cypress), proposing an updated workflow (TDD, with devs and QA working together), and using Docker to ensure consistency across environments (more live demo).

The code that she will demo can be found here

This talk is for people who don't have a solid understanding of how Blockchain works and are also struggling to find a use case for it, outside of cryptocurrency.

Unlike state changes which can be instantaneous, animations inherently take time to complete. They may be stopped, queued or interrupted but they must always, always maintain coherency for the user.

In this talk Opher will discuss the theory of managing state-based animation, orchestrating animations across different components and animation UX using JS and CSS.

In this talk Artur will explore the various ways to manage state and side effects in React applications. Today you have multiple libraries doing very similar things and I will be comparing thunks, sagas and epics. You start by having a look at how Redux middleware works and how you can use it to wait for third party API calls.

After that let's have a look at how to manage atomicity requirements using sagas, throttling and debouncing requests to prevent APIstressing and gaining fine grained control over your HTTP requests. You will walk away with knowledge of how to manage the state in your client app in a modular way and having more control over your applications data.

In this talk he will provide a comparative view of the most popular JavaScript GraphQL clients (i.e. Relay and Apollo), focusing on their API, their biggest selling point, and how they are used in the wild. Additionally he will share the story behind the move from Relay to Apollo at Hudl, focusing on the motivation and lessons learned from this decision.

To explain that, Luca will share a simple example that will cover the key areas of MobX State Tree, showing how simple can be structuring a Reactive application with this state management system

In this talk Matteo and David will share with you a new and straightforward way to identify bottlenecks in Node.js and beyond.

You are still at the point where there is no complete consensus on what a reactive application is; you will explore how this consensus is evolving and what problems it brings.

You are going to learn about the past, present and possible futures of reactive programming and how you can survive it all.

Sebastian doesn't believe so. Thanks to your modern, sophisticated toolchain you have many metrics at hand that Mr. McCabe & Mr. Halstead could only dream of. In this talk, Sebastian will share with you how the combination can give you much better & "more human" advice about the flaws of your codebase - not as abstract numbers, but as concrete pointers to the parts of your code that really need your love & attention.

In this presentation AMahdy will discuss the basics of implementing the APIs, the available gateways, and show some demos and how they resonate in the era of PWA.We will also discuss the current limitations, and how the future will look like towards standardizing those APIs.

Anna will demystify the rendering process and look into possible optimisations in order to achieve the best experience after the initial page load.

You will learn about different tests, how to make sure your tests aren’t flaky, and how to troubleshoot test failures.

Finally Matt will explain the advantages and disadvantages of this setup and compare Puppeteer to WebDriver.

Modern JavaScript conventions, browser APIs, AI services and IoT hardware provide a unique platform for creating art. In this talk you will learn about this type of creative, interactive application development and look at the libraries, APIs, services, hardware and approaches to creating expressive works with JavaScript — audio, visual and otherwise.

Sam will share with you the basics of the web-audio API. You will learn how to load and play sound files. How to create and compose sounds with the web-audio API. Sam will explain some of the audio nodes available in within the web-audio API and how to combine them to create some of the most used audio effect. As a cherry on top you’ll apply these effects on the sound of an electric guitar live on stage.

You're writing code every day as part of our jobs. You do not always have to use those skills to create something useful, but can also do some fun experiments with it. Playing with the web-audio API is a perfect way to improve your programming skills, and have fun at the same time.

In this Keynote, Sarah will share with you some key use cases for these functions within a Vue.js application: you’ll accept payments with stripe, you'll create your own Serverless API, you’ll gather geolocation data from Google Maps, and more!

You’ll make it all work with Vue and Nuxt seamlessly, simplifying how to leverage this paradigm to be a workhorse for your application.

If this sounds familiar to you, then this talk is for you! There is an innovative way to migrate from the old technology, to change the applications step by step and to implement all new things that the cool kids are using. Ivan will share with you the story of Micro Frontends, a microservice approach to the modern web, the story that will change the way you look and develop your apps!

The problem is, JavaScript isn't a very good compilation target, because it simply wasn't designed to be one. Born out of asm.js, a somewhat crazy concept dreamt up by Mozilla, WebAssembly was designed from the ground-up as an efficient compilation target for the web. It promises smaller payloads, rapid parsing and validation and consistent performance... and it's ready to use, right now! During this talk you will learn about what's wrong with the way you are using JavaScript today and why you need WebAssembly. It will delve into the internals, giving a quick tour of the WebAssembly instruction set, memory and security model, before moving on to the more practical aspects of using it with Rust, C++ and JavaScript. Finally you'll do some crystal-ball gazing and see what the future of this rapidly evolving technology might hold.

After this journey, you will be ready to level up your existing web apps, create new offline-first web apps, and ...eventually... wave goodbye to native.

In this talk, Lance will share with you a deep dive into the circuit breaker pattern, how it works and how you can use it to make your JavaScript applications shine. You will learn how to build resilient web applications that gracefully handle failure. Using JavaScript in the browser, and Node.js on the server, you will build microservices that respond to failure with features like fallback functions and request throttling. With circuit breakers, you don't just fail, you fail fast and do it with style.

During this Talk you will explore Jackie's and her Team's journey over the years, from how they choose which technologies to implement, how they piecemeal large rewrites while maintaining developer sanity and website integrity (and how to cut corners gracefully), how they manage technical debt, and finally, how to be at peace with the reality of a fragmented codebase.

Jackie's goal with this talk is to shed light on the notion that a perfectly organized codebase following every best practice is unrealistic, especially for long-lived projects.

It will be explained how Javascript can both make well-designed websites more accessible, as well as make well-designed websites inaccessible. This will initially look at vanilla JavaScript. This will latterly involve the new issues introduced by frameworks such as the frameworks such AngularJS. In both cases, best practices and common gotchas will be explained. The talk will be lighthearted, simple, and focus on skills that any web developer can use.

In this talk Mate will use the Stranger Things analogy to tell the story of a video engineer who wants to craft a 360/VR html5 player from scratch using some handcrafted DASH/HLS stream. The purpose of sharing this adventure is to talk about this universe, give a detailed walk-through of the implementation and it’s challenges and to point out that everyone has the power in their browser to write such a cool thing and it’s an amazing adventure.

Sempiler is different fundamentally because it models the semantics and symbols of the target platform in a source language of your choice. Using this approach it can transpile your source code to truly native, zero overhead emissions that maintain a clear (almost 1:1) parity between the source and emitted artefacts.

Further, one can optimise the code to the semantics of the target platform without having to waste time (re)learning foreign syntax or fighting with black boxes between their code and the machine.

More details on the project can be found here.

Behaviour-Driven Architecture builds on ideas from BDD, UCD and DDD and works particularly well in complex domains as it encourages strong domain modelling, clean code, clean architecture and drastically speeds up automated acceptance testing.

WebAssembly allows you to compile and run C/C++ and other statically-typed applications in the browser, and hence enables code reusability between native and Web. Moreover, due to being a typed and low-level language, its performance comes very close to native.

In this talk Boyan will examine WebAssembly and discuss what its future is in relation to JavaScript and some of the most popular Web frameworks.

In today's workplaces, there are still huge issues with inclusivity. Whilst you may not notice it in your workplace, underrepresented groups are faced with difficulties and feelings that those with privilege are likely to have never encountered. But this doesn't and shouldn't, have to be the way - being an ally allows you to amplify the voices of the underrepresented and make change happen.

In this talk, Joe would like to share with you some of his what he has learnt around how you can be better allies for inclusivity and make improvements not only in our place of work, but in our every day lives.

Guillaume will introduce practices and offer strategies that teams can use to improve their effectiveness with rolling out code changes to a live environment using Continuous Delivery (CD).

He will also demonstrate how teams can achieve CD for their applications, services or libraries by giving the team control over its Build Pipeline via a robust, repeatable and programmatic way to bootstrap, evolve and restore a CD pipeline. As part of the demonstration, he will introduce how to use the latest capability of Jenkins Pipeline DSL when designing a CD pipeline and how to use Docker containers for running the CD pipeline.

A sample implementation can be found here. Nathan will share the reasons for moving the project from JS to C++ with code samples for all relevant concepts presented in JS.

It had to be:

• modular

• blazingly fast

• fully testable

• customizable

During this talk you will learn about the challenges of migrating this old stack to a brand new and modular platform. Jean-Yves will explore how they overcame all their challenges:

• How Angular and web components enabled them to share code across applications

• How moving to restful services could enable multi device bookings: start on your browser and continue on your PC.

• How embracing the power of open source, and the latest web technologies speeds up development, and makes writing tests and debugging easier

• How the transformation is beneficial to the developer, to the company, to the airline, and to the end user.

This talk provides a brief overview of Reason, explaining its origins and why it’s so useful. The talk will walk through some simple code snippets, and demonstrate how Reason can be compiled to JavaScript to integrate with existing codebases, including React.

Finally, you’ll be introduced some interesting open source projects and libraries in the Reason ecosystem. Although it's a very new technology, there's already a lot of excitement about it in the JavaScript community, and core contributors include some of the team behind React JS. Reason was created in order to take advantage of OCaml’s strengths whilst keeping the syntax familiar for JS developers.

The workshop is extremely interactive. You make sure that each participant solves several performance issues in a given HTTP application. Your methods and tools include 0x for flamegraph generation, autocannon for HTTP/1.1 benchmarking, v8 trace analysis, and bytecode interpretation all within a structured analysis workflow.

Requirements: Participation requires a recent version of either Linux or macOs, or otherwise a VM running a recent Linux version. They will need root/admin access, and the ability to build native node modules. Follow these instructions.

First, you will go over what React is and how to build components, containers and how you can create a clean, modular application. You will then add in Redux and cover what actions, reducers, and a store are. The project does include an API request and you will implement it by using GraphQL and discuss how it fits into the architecture. There will be a little unit testing and linting examples involved as well. The end goal for this segment is to have a working React application.

Next, Rizchel will share with you how containerize the application with Docker. There will be discussion around what is docker, why is it important, etc. The end goal for this segment is to have a containerized application.

You will then get our application deployed to Kubernetes. There will be an overview of IBM Cloud, getting set up with the Kubernetes service and on Kubernetes specifically. We will go through the commands to deploy the application. I will also go through alternative ways to deploy an application using yaml files, load balancers, etc. The end goal for this segment is to have a deploy a containerized application. If time permits, Riozchel will introduce Istio. There are many features that Istio provides but specifically, you will build how to a/b test an application using Istio. The end goal for this segment is to provide an a/b test for the application.

By the end of this workshop, you have learnt how to build an application using React, Redux, and GraphQL. With that application, you will know how to dockerize and deploy it. Additionally, you will be able to implement Istio and a/b test their applications.

Topics - Blockchain technology and decentralized applications - How Ethereum Works- Smart Contracts - Using web3.js and Solidity - How to create Ethereum wallets - How to create a Smart Contract Deployment Platform - Enterprise Level Smart Contracts - Consortium Blockchain

The workshop will be hands-on, you will build multiple applications.

Workshop Requirements

• Google Chrome
• Metamask Plugin (for Chrome)
• A free infura.io account
• NodeJS 8.11.3 or 10.6
• Code Editor, e.g Visual Studio Code

Workshop Requirements

• Follow this instructions to install NativeScript and Android dependencies.

• If you have an Android Device you can use it during development (remember to bring a cable!) - this is the simplest option.

• If you don't have an Android Device install Android Studio and set up an AVD - Guy recommends using the Nexus 5 and the latest SDK.

• Once your Android device is connected / AVD running run "tns device" to verify Nativescript has access to the device.

• If you are using an Android device you need to enable developer mode + enable usb debugging - you can follow these instructions.

• Finally you can verify everything is running by running "tns create test" which creates an empty Nativescript app. then "cd test" and "tns run android" will load the simple app into your phone / emulator

In this talk, Felix will share with you a "veteran's introduction" to Electron, explaining both the up- and downsides of building desktop apps with JavaScript as well as discussing concerns around performance. You will discover:

• An understanding beyond the hype, peeling back the myths and rumors about Electron, how it's built, and what it enables.
• How Electron enables any Angular developer to add "Desktop Software" to the list of things they can offer.
• How Electron educates on the ability to combine JavaScript with native code (C++, Objective-C, Rust), taking web apps beyond the browser.

In the first few minutes, you will learn what Electron is. Then, you'll spend about 15 minutes live-coding an editor that'll look a lot like Visual Studio Code, explaining the thinking behind building Visual Studio Code in the first place. Felix will finish by discussing what fast Electron apps (like the Visual Studio 2017 installer or Skype) do well, why some apps became famous for being slow, and how we (the Electron contributors) think about the future of Electron.

In this talk, you’ll learn what is re-usable and what isn’t, the intricacies of shared code bases, and cross-team communication when building React and React Native apps at the same time. With real-life examples, code snippets, and memes, you will learn everything you need to know to get started on your native journey.

Come if you’re interested to see the day-to-day life of React developers forced by fate to work with Angular.

Come if you want to know why it is not that bad! At last, you will learn the answer to the big question: Which framework should I choose for my next frontend application?

During this talk you will learn how to maximize your time with everything from how to come up with project ideas, how to avoid getting frustrated, and actually create work that you’re proud of - all while learning specific, relevant skills.

Augustine will share with you about his current stream of work, which involves creating an event-driven write pipeline that generates materialised views of tagging metadata corresponding to the various read profiles thus improving the overall performance and scalability of the system. The new architecture comprises of small, single-purpose Javascript-based services, lambda functions, event stores, queues, streams and a number of specialised data stores.

Building a majority of the components in Javascript, you will discover how they:

• Built simple components that are easy and quick to deploy.
• Used Typescript for static type-checking.
• Adopted Functional Javascript techniques.
• Adopted input validation libraries like joi.
• Used docker-compose to orchestrate dependencies for acceptance testing.
• Took advantage of other tools and libraries like Bluebird, nsp, testdouble, etc.

Then this talk is for you! Nicholas will show you how to get started in building your own IoT 'thing', components parts and of course the iotjs.net or ZJS framework built for IoT.

The talk will have an interactive 'thing' that can be controlled by the audience and will seek to use a Mozilla 'Web of Things' gateway in part of the demo.

First, you'll discuss the fundamentals of how graphics are drawn and then step by step you will discuss each part that is needed to be assembled to draw your image. And finally, you will explore shaders and some basics of GLSL the programming language from opengl.

Thanks to AWS Lambda and S3 a Serverless Build system was created and tuned up for your needs. How many Lambdas is Max using? What is his queue system? Why is this approach helping new developers? Are you paying for lambda or are you still in the free tier? If you want to know the answer to these questions, then you know what you have to do!

Aleksandr's talk will open the window to the world of those who are enthused by what they do and will show the right way to the big games' development in browser. Personal experience of war with performance and searching for the right way, solving pressing problems and incredible discoveries in the JS world. In this talk you can find useful game developer cases: techniques for efficient data storing, drawing UI on Canvas, and ways to approach parsing binary files

Web Bluetooth allows developers to create web applications which can monitor and control Bluetooth devices. In this session, Martin will share with you the key Bluetooth concepts and capabilities and the Web Bluetooth APIs which let you exploit them.

There may even be demos!

In web dev, sometimes the sheer volume of things to learn can be overwhelming. Pair this with anxiety and a tendency to procrastinate and you’ve got the perfect recipe for doing absolutely nothing. More choice doesn’t mean more creativity. When you work within constraints you have to look for unconventional ways around a problem, exploring things you would otherwise pass by.

Cassandra will share with you her experience when, either for external or self imposed reasons, she had to use just CSS and HTML for a project, and the funny outcomes!

During the workshop, you will discover the benefits of the reactive and functional paradigms, in particular, you are going to build the following examples:

• Analysis of a simple maps application with MobX
• Building a similar application but with MobX State Tree

Workshop Requirements

Please make sure to bring your laptop and install node.js, npm and your favourite IDE or editor.

Workshop Requirements

Please make sure to have both Node.js and Docker installed in your machine before you attend the workshop. A basic knowledge of JavaScript and Node.js is required as well.

During this hands-on session, you will learn about what are the main causes of web page performance, and how you can solve it using webpack's code splitting capability. By the time you walk away from this workshop, you will be able to jump on any website, profile it, and know exactly what and how to code split your application so that you can make page spees and performance a first class citizen in your applications.

Dylan, Anthony and Matt will share with you the opportunity to evaluate an open source framework, ask questions and discover what TypeScript and Dojo 2 have to offer your next project.