In this talk, you will discover the Background Sync API and the APIs that it depends upon, you will explore what you might use it for and see it in action. Once that is all set, you can take a peek into the future and even more background tasks with a look at the Periodic Sync API.

The web platform has a lot to offer to the creation and distribution of generative music: With Web Audio and JavaScript, artists and developers can build their generative works on a universal runtime that will allow them to run on any platform and any device. And they can also easily distribute their works on the very same platform – something that has been out of reach for most generative musicians throughout history. On the web, all you need to do is share a link.

Join Tero for this talk as he explores some landmark generative music works spanning a wide historical time period up to the present day. You'll discover how the essential qualities of these systems can be reproduced using Web Audio and JavaScript. Tero hopes that studying and appreciating what has been done before may inspire new generative music tools and musical works unique to the web.

There's a lot of confusion about what are exactly the differences between all the tooling options. Beyond the clear divergences like npm script and gulp being task managers and webpack or browserify bundlers, there's a humongous question usually unanswered: When to use any of these utils?

There is no silver bullet in engineering. When facing singleton scripts npm is brilliant. When piping multiple complex scripts gulp shine like a diamond. If you need to bundle any ES6 project maybe babel is enough. Or brunch. Or for a lot of bult-in cool feature webpack is unbeatable.

Know the differences, master the tools.

What if Don told you that when Mozart composed his first violin concerto and when Joe Developer builds a CRUD app in Rails, they have to think about their craft in the same way? You would probably call him crazy, but rest assured it’s true. Musicians and developers do think alike. There are both horizontal and vertical axes to the thought process that goes into the architecture of a piece of music and a piece of software.

As someone with both 18 years as a web professional and a degree in music performance, Don Burks brings a lifetime of experience and a passion for understanding why we do things the way we do to this talk. After observing the significant fraction of developers he has met having musical backgrounds, some investigation was needed. The results of that investigation have informed this talk.

When we started talking about the Web of Things in 2007, no one believed that one day embedded devices would talk Web and Node.js natively! Fast forward 10 years, many new platforms support Node.js and offer HTTP/WS APIs but this is only the beginning as the Web has a lot more to offer.

In this talk Dom will explore some of the most interesting bits the Web and Node.js have to offer to the IoT, in particular:

• Connecting electronic actuators and sensors (GPIO) to a Raspberry Pi with Node libraries such as on/off and Johnny-Five
• Learning about IoT protocols like MQTT and CoAP and integrate them to the Web of Things via Node libraries
• Using the Semantic Web (JSON-LD, RDFa, etc.) to discover and find Web Things
• Sharing Things via Social Networks to create the Social Web of Things with Passport.js
• Creating physical mashups with Node-RED, and IFTTT and EVRYTHNG.

Dominique will present this talk based on EVRYTHNG's 10 years of experience in the WoT, in particular while writing Building the Web of Things (with examples in Node.js and Raspberry Pi) as well as their experience within the W3C WoT Interest and Working Groups.

Ok, done well they don’t have to be so painful for the user, and designing them well can be an engaging challenge.

However, implementing them… is tedious, repetitive and error prone.

What’s much more interesting is writing a system that writes all that for you! Now there is an interesting coding challenge with problems to solve along the way that will remove the repetition and reduce errors.

During this talk, you will explore creating a simple, cross platform JS class for form creation that can be expanded with support for validation and whatever features you care to add. Even if your client wants a static HTML form, you won’t have to write it.

Not intended as a prescriptive “This is the right way” lecture, the guide is intended to encourage problem solving with code that can be reused, expanded and maintained.

Ben will be showing a variety of places where an understanding of binary data is useful in browsers - generating and processing images, videos, and audio and more.

You'll then discover some of the ways that these things can be put together: pushing data in & out of WebAudio nodes, down WebSocket connections and into graphical contexts.

Join Artem in this talk as he will start with setting some base terminology of what types of tests there are in a typical web app, what they're for and then show off a real example.

Is it possible to use Angular 2 for building native mobile apps? If yes, how does it work? What are the benefits and opportunities for developers and software product owners? Join Yuriy and find out the answers.

1. What is Angular Native (NativeScript + Angular2)
2. How does it works
3. Benefits and opportunities
4. Comparison with ReactNative
5. Specifics exemplified with real life cases

Yuriy will also show examples, solutions, and helpful tips. This is the talk for you if you work with Angular 2 and if you are interested in mobile development with JavaScript. New advancements in technology make this tool even more attractive – and you are going to learn why.

Anyway, they still suck, but those simple widgets for interacting with a form can be surprisingly powerful.

In this talk, you will learn how cunning use of form controls, particularly radio buttons, together with some sneaky CSS can recreate common widgets without a single line of Javascript!

The talk is intended to encourage lateral thinking in the way you can manipulate the technologies you can often take for granted, and create lightweight interface widgets without relying on DOM manipulating frameworks or third-party plugins.

During this talk, you will also explore a brief meditation on how form controls can even be combined to create logic gates, leading to the frankly perverted idea that we could build an entire computer emulated in HTML and CSS, and how, as amazing as that concept would be, anyone who ever did it should probably be locked up for the good of humanity.

Most web applications and sites require a back end component running on an always-on server and executing code (or even querying a database) on every request. This is a very wasteful approach both in terms of environmental and running costs. But it also has a big impact on the website visitor experience, making things slower, less reliable and less secure. Caching can go a long way in mitigating these impacts, but it’s difficult to make work well, especially if it’s spread onto multiple layers of the stack requiring a coordinated effort from multiple disciplines.

A much better approach is emerging at the confluence of static site generators, “Serverless" (or “Serviceful") back ends, microservices, browser APIs for working offline, scriptable CDNs and build tools, which are getting smarter and more integrated every day. The core of the idea is to preprocess and serve up as static files as much as possible, while letting the dynamic parts loaded runtime by directly connecting to APIs. This is very similar to how native apps on mobile platforms work (and what makes them popular), by bundling the application shell as a separate download and fetching data on demand, but the web offers a much more granular control and with that a possibility for an even better experience.

Join Daniel as he compares the traditional application server based approach with this new method, offering some practical insights and the pros and cons of each, as of course the applicability depends on the type of project at hand and the structure of the team delivering it.

By the end of the talk you will learn:

• the basics of financial trading platforms from a developer's perspective (APIs/concepts/terminology)
• how you can use the skills you've gained building full stack applications to write trading software
• how static typing and Typescript can speed up your workflow
• how functional programming can help you refine your trading algorithms and verify the correctness of your program

We live in a world of rich client side applications, web and mobile, and we need a secure way to authenticate our users. Session IDs have been the traditional solution, but how well do they work for single page applications? And what about authenticating to 3rd party services? You can't leave your credentials in the client, there's always someone malicious just waiting to steal them.

Enter the JWT, or JSON Web Token. These fancy little tokens can authenticate our users and our transactions because they know what they're allowed to do.

Join Phil and discover what JWTs can be used for, why to choose JWTs, how to generate them, and most importantly how to keep them secure. Finally, you'll find out if putting abbreviations inside other abbreviations really is the secret to web security.

Making sure that those guidelines are followed is a difficult task - even if all team members agree to do so, sometimes we simply forget or don't have time to implement the necessary changes.

Once we've agreed on our development guidelines, I was looking for a tool to automate such auditing for our team, so that in the same way as eslint can be used for testing code guidelines based on the rules, we could use this tool to audit our repositories in GitHub organisations. I couldn't find one so I created it.

Meet gh-lint - a rule-based command-line utility that audits all your GitHub repositories generating results in TAP (Test Anything Protocol) format that can be consumed by tap-github-issues reporter (WIP) that can create, update and close issues in github repositories.

Join Alex and learn how to create a very simple DevOps infrastructure from scratch using nothing but Node.js (and a few modules). First you will create a logging library, then an error collection tool, a website monitor, an orchestration engine and finally a dashboard that puts all of this together. Each piece builds upon the previous one and is fully functional, although not necessarily polished. In fact more sophisticated versions of the tools are used every day at my company, mediasmart.

The talk is eminently practical and it will encourage you to build more stuff, which is the main aim. The second aim is to make you think about DevOps as a first class citizen inside their organization, and not just a random collection of tools that more or less work together.

Premise: The past 10+ years of affordable and easy to scale cloud services & platforms has dulled our collective edge when it comes to matters of performance optimization and benchmarking our software creations.

While computing power goes higher costs go lower, and along with that, power and resource hungry software platforms, libraries and practices are becoming more common!

When was the last time you benchmarked the library you are using? how about all it's dependencies? come to think of it, when was the last time you inspected your dependency tree for inefficiencies? How deep does that rabbit hole go?

In this talk, I will showcase:

• How to accurately benchmark & measure your code
• Where to start in identifying bottlenecks inside and outside your project
• How to contribute your findings back to the community to improve our libraries ecosystem

AVA is a relatively new test runner that's designed to make testing fun and fast. This talk covers AVA's design philosophy and some of its great features, like built-in support for the newest JavaScript syntax, powerful yet minimal assertions and intelligent error output. Writing tests doesn't have to be a slog if you use AVA!

We'll also discuss how we're engaging contributors to both AVA itself and surrounding projects such as translations, an ESLint plugin and editor plugins.

See AVA.

AVA is opinionated. It's test and assertion interface is especially unorthodox, without support for the typical BDD or TDD interfaces, nor as bare-bones in its output as node-tap. This talk aims to provide a fresh take on JavaScript test runners, making the audience think about how they really want to write tests.

AVA had the largest increase in GitHub stars for 2016. Growing an open source project can be challenging, but also fun! There'll be ideas on how to manage your own open source project, and hopefully we'll be able to interest some attendees to contribute to AVA itself.

First off, during this talk, you will learn the most important UX concepts you as a developer should be familiar with, and how to apply them in order to impress both their client and themselves.

Secondly, you will discover the tools you need to know, and specifically what subtools you can limit yourself to be able to manage your assets and your designs successfully.

During this talk, you will explore building Pino, a JSON\n logger that’s up to 17 times faster than pre-existing loggers, with a growing ecosystem of support libraries, including high performance integration with Express, Hapi, Koa and Restify.

How did we make it so fast? After showing what Pino can do, you will discover Matteo and David's tooling: 0x for flamegraphs, and autocannon for HTTP/1.1 benchmarking. Then we’ll discuss V8 optimizing compilers, string flattening and other mad-science optimizations that we embedded inside Pino.

It's been two years since ES6 was finalized, and much has changed in the world of JS. Join Dylan for this keynote and explore the factors contributing to fatigue, where things are standardizing, and what new trends may lead to further fatigue.

You'll also learn what's new in ES2017 and a quick overview of current trends across frameworks.

Join Tim for this talk as he shares the fundamentals and benefits of GraphQL, discussing where it shines and where there's still a bit yet to refine. You'll then see a real world application demonstration with Node.js and Tim will show how it interacts with the client via Apollo. Learn how DataLoader, Facebook's data fetching library, can be used to drastically reduce queries and make your GraphQL experience super performant out of the box.

Join Surma as he introduces the benefits of HTTP/2, what it means for developers, how to use it in production and what tooling there is.

Philipp Burckhardt will share insights obtained in the process of developing a session logging system that tracks every click and every action of a given student. From weighing the pros and cons of using cookies, local storage or server-side storage to deciding upon whether to store the collected data in a SQL database or document store, he will reflect on the decisions made and the lessons learned.

Gathering data is only the first step, though. Analyzing the data is a much more difficult undertaking. Since collected data does not lend itself to a simple spreadsheet format but consists of time stamps, unstructured text and the like, cleaning and molding the data into an appropriate format is a delicate task. Join Philipp as he elaborates on the development of an online dashboard allowing professors to visualize the collected data, view summary statistics, and apply advanced machine-learning methods to predict future student behaviour and outcomes.

Find out more at www.isledocs.com.

The distributed management of frontend components, from version control to component-level a/b testing to distributed state strategy to scenario-aware component mutation all requires intensive communication between teams; usually resulting in monotonous error-prone maintenance tasks.

One common way organisations attempt to mitigate the communication overhead is to deploy view services that serve HTML to iframes. This embraces a Continuous Deployment strategy and allows for autonomy in individual teams. It tends to result in bloat through duplication, complex inefficient approaches to intra-component communication, poor rendering performance, intensive resource usage on user devices and a high risk of potential security issues resulting from human error and misunderstanding.

During this talk, you will discover another approach, a distributed live build system where a view service serves partial JavaScript bundles in serialised format (which are individual components) to an application server that assembles the components into a React application.

Centered around a web-based to-do list application, built on the Polymer 2 RC, topics covered will include spinning up your own Blockchain (Hyperledger Fabric 1.0) node, writing and deploying a "smart contract" to perform CRUD operations, and integration using Web standards. With proficiency obtained, you will also take a look at blockchain scaffolding tools. You will leave understanding where and how to use Blockchain technolgies, with the knowledge needed to get started.

During this talk, you will explore a tour of what goes into painting pixels onto the screen and what you can do to help the browser do it better. You will learn more about tiles, layers, compositing, painting and why the GPU is so great at pushing pixels around.

You will discover what’s the difference between using CSS, 2D Canvas and WebGL for image manipulation and how antialiasing, filtering and blending work.

Add to that Angular with TypeScript and you will get a truly amazing combination. But Sebastian knows what you’re thinking: another way of building apps? What makes NativeScript special?

Here are a few cool things you can learn: - Direct access to native APIs—no plugins required. Want to create a file on Android? Run new java.io.File()—in JavaScript! - Completely native performance through the use of a JavaScript bridge natively available on all three mobile platforms. - Cross-platform libraries for common use cases. Need to call a JSON API? Run http.getJSON - Style native apps using CSS. Yep, that’s actually a thing.

Curious about how it all works? Come learn! Architectures will be explained; apps will be built; and fun will be had by all.

But you know nothing, John Snow. In the talk Vladimir and Sergey will cover all the parts of BEM methodology: CSS (and much deeper then you used to know it), powerful DOM abstraction, declarative templates and JavaScript, file system organisation and bunch of great tools.

These things give you super power to build extremely flexible, scalable and maintainable web apps. They strongly believe BEM is like WebComponents... but better.

Don't miss the chance to learn about it!

Find out more here.

Jouni is a web developer, who was tasked to write a web UI for an old-school industrial product. Little did he know that the 3 years working on this would completely change his understanding of how adaptable a modern web technology stack really is, and how far you can push the boundaries of it.

In this talk you will learn what Jouni discovered about approaching large-scale IoT installations in practise, dealing with massive amounts of data and designing fully reactive systems. You will also hear why web technologies will rule the world of IoT, and why web developers will be the ones finally delivering actual value from it.

Today things are significantly different - not only is JS standard in web development, but it has broken out of browsers and it's taking over new development frontiers.

TypeScript is taking JS up a notch. It's introducing a bunch of new concepts that JS doesn't have (at least for now).

The main question is: does it pay off to start writing TypeScript? If so, how would TypeScript play with existing JS code?

Join Milos in this talk as heexplores TypeScript features, as well as potential migration paths from JS to TS.

Marcos had a huge revelation when he discovered the Reusable API (a modular structure to create and reuse d3 elements) and his code was elevated to even higher levels with Test Driven Development.

Join Marcos in this session as he walks you through his journey toward beautiful, maintainable D3 graphs with step by step examples of refactoring crufty code to be shiny and new and testable.

By the end of the talk you too will know how to build decoupled, composable, encapsulated and consistent D3 graphs and be proud of your code again!

In this talk, you will discover why you should love IndexedDB and the kind of apps you can create when you have the power of a database in the browser. Then, you will explore how to use IndexedDB with a look at both the terrifying API and the friendly libraries that will help you along the way. Together we'll discover a new love for IndexedDB.

The background is that it’s quite difficult to hire developers in Estonia, as there are significantly more vacancies than developers fit for the positions, meaning it’s very hard to get candidates and then retain their interest. This is especially the case if the company hiring is not a sexy startup or an already well-established technology company but rather falls in the middle part of the employer-attractiveness spectrum.

Nele and her teammate created a hiring test task (and later a front-end task) and promoted both of them publicly, calling anyone interested to try to solve it. They saw that although this was a simple premise, the task encouraged people to show off their skills and tools of choice, providing valuable information on whether or not they would fit in at their company.

They also made sure to provide thorough feedback on each solution they received to make sure that everyone at least heard back from the company and got some thoughts on how to improve their coding practices.

Join Nele as she shares the statistics from the results and the lessons learned, encouraging other companies to also approach hiring developers/technical people in a more creative manner.

Laura Carvajal explains how her team introduced accessibility to the Financial Times website, FT.com—and their journey from being generally oblivious about accessibility to making it a core part of their process across multiple divisions. Laura shares the the roadblocks encountered and lessons learned along the way as well as practical solutions you can implement in your project today, regardless of available time, resources, or support.

As the framework matured and became isomorphic, we realised just how powerful it’s reactive data connections could be. What if we connected milo models in the server with those on the client using websockets? Could we create a full stack reactive data graph? Data flowing from the view, to the client model, across to the server, into the database and back out to other clients. All with very little server code and the same, concise connector syntax that milo has.

Throughout the presentation we will take a slack style chat clone and use Milo to create a full stack reactive data graph.

Skyscanner has recently adopted the OpenComponents framework to create a decentralized architecture to encourage sharing and re-using HTML components. During this talk, you will discover how we’re using OpenComponents to do the following:

• encourage re-usability of parts of the website

• maintain consistency across products

• maintain ownership of separate parts of the website

• enhance our web performance in general

Consider starting a new project when modularity is at the forefront of your architectural mind; you might think you'll have 5 packages, and each will have a corresponding git repository. While this may sound like a modular dream, I can speak from experience that it isn't! These are some things that you can expect to face when you have separate git repositories that are highly dependent on each other:

• Friction around pull requests that cut across multiple packages

• Broken builds due to bad changes in separate repositories

• Time spent around pull request coordination

• Code out of sync across the different repos

Lerna to the rescue! If you are not aware of what a monorepo is, this is a good starting place, for what, why, and how; with some good previous discussion. These are some of the things that we have happily embraced as a result of using lerna:

• Code will always be in sync, one pull request will complete one feature

• Master will never be broken

• Code reviews happen in one place

• No code in dependent repos/packages

• Faster CI cycle time

"Do you spend too much time creating CRUD APIs? Let LoopBack handle the dirty work of CRUD and spend your time instead on what makes your APIs and data useful, interesting, and valuable to your users. In this lightning-speed lightning talk, you'll see how you can have a full CRUD API (with real data!) up and running in 15 minutes ... with time to spare. You'll never waste time on CRUDdy API tasks again. :)

(I think that developers spend too much time writing what should be boilerplate CRUD code and not enough time understanding their data and thinking about their users. So I love advocating for developers to use the [free, open-source] LoopBack API framework and get that time back so it can be put to better use.)"

Richard will also include a comparison of React Native and alternative mobile solutions and the relative merits of each.

Login pages are probably the single type of page that users on the web interact with more than any other. In recent years the sign in experience has changed with the advent of federation via social networks, but whether a user has to type an email address and password or click a link and be redirected via Facebook, the process still interrupts the journey. The Credential Management API, designed by Mike West at Google, is an attempt to help streamline this process at the user agent level.

Join James as he investigate the new API and explores how you can use it to progressively enhance customer journeys in the apps we build.

However, in order to understand them, we must step back to fundamentals all these rely on: the mechanics of event loop and run to completion rule, as well as learn to distinguish between sync and async flow. Then we proceed to design patterns built on top of each of the 5 approaches, discussing their strengths and limitations. Funfacts, such as famous Promise.race() included!

In this session, you'll be introduced to Kraken.js by PayPal, as well as Oracle JET which is Oracle's JavaScript toolkit, including data visualizations, architectures, templates, components, and a range of enterprise solutions, such as modularity, internationalization, and accessibility.

Everything is free and open sourced on GitHub and you'll be shown how to get started with it, via demos and live coding. By the end of the session, you'll be able to leverage free and open source technologies as the basis of your own web and mobile solutions, today!

However, the website was entirely created by developers and a few years later, the need to improve both the look and feel and the usability of the main website arose.

James Holland, UX expert at Ocado, has been working on redesigning Code For Life. Florian Aucomte, software intern, has reworked most of the Front End of the project to make it happen with the help of Ruth Wall, Front end team lead at Ocado. They will talk about the teamwork and challenges behind refactoring the website, using UX research, github, Django/Python, JavaScript, Sass... But it's not finished: they will still be listening to users and more improvements are to be made.

The Dojo Toolkit has been around since 2004 as an approach to building elegant JavaScript applications, and providing very early implementations of many concepts now found in ES6+.

Dojo 2 is a complete rethink on how we should build applications going forward, leveraging TypeScript, ES6+, Observables, Virtual DOM, etc.

Beyond learning about the capabilities of Dojo 2, this talk will also highlight some of the challenges and lessons learned in building a modern ES6+/TypeScript framework.

During this workshop, you will be learning how to make IoT wearable Twitter badges using the Onion Omega 2! The Omega2 is a full Linux computer with built in Wi-Fi and less than 1/4 the size of the Raspberry Pi. Each person in the workshop will receive a Onion Omega 2, OLED display and a Expansion Dock and 3D Printed Case. You will explore setting up your Onion Omega hardware and web-based console, connecting your twitter feed to display on your OLED. At the end of the workshop you'll have your own wearable tech!

Pre-requisites

• You will need to bring your own Wifi enabled Mac, Windows, or Linux Computer.

• You also need a twitter account.

The concept of microservices is hot and it draws many developers from a diverse background. Unfortunately, we see a lot of ideas from the past rebranded as microservices; whereas the thinking behind microservices imply and promise a bigger change. This talk will go over the details of what actually makes a microservices architecture and how other distributed systems — that rely on queues and other mechanisms to function — fail to fulfill the promise.

A modern microservices implementation should be;

• Zero-configuration: any microservices system will likely have hundreds of services. Therefore, a manual configuration of IP addresses, ports and API capabilities is infeasible.

• Highly-redundant: service failures are very common in this scenario. So it should be very cheap to have copies of such services at disposal with proper fail-over mechanisms.

• Fault-tolerant: the system should tolerate and gracefully handle miscommunication, errors in message processing, timeouts and more.

• Self-healing: it’s normal for outages and failures to occur. The implementation should automatically recover any lost service and functionality.

• Auto-discovery: the services should automatically identify other new services that are introduced to the system to start communication without manual intervention or downtime.

Finally, this talk will present how such a system can be easily realised using Node.js and Docker.

After understanding WebGL basics and the render pipeline, you’ll learn what Three.js brings to the table and you will discover a live coding demonstration you can code along to in which you will build a 3D web app from the ground up with all elements: Lighting, loading 3D models and keyboard/mouse controls

What’s in this workshop?

You will explore an introduction into 3D and WebGL basics, live coding demonstration and a bunch of tips & tricks on how to tweak performance and perceived performance & quality. You will learn how to build 3D games and applications that run without any plugin right from the browser - even on mobile. You will discover how you can start creating this content today and how to bring it to production quality.

Topics

• Introduction: CPU vs. GPU - Canvas vs. WebGL

• 3D Vocabulary: Vertices, Faces, Shaders and their friends

• WebGL 101

• Introduction into Three.js

• Performance pitfalls

The Tessel 2 is an open-source hardware and software platform that can be programmed with JavaScript out of the box! Johnny-Five is a JavaScript robotics and IoT library, like jQuery for hardware. Bringing those 2 pieces together is one of the greatest ways to start building your very first electronics project!

Using the materials in the Johnny-Five Inventor's Kit, https://www.sparkfun.com/products/13847, workshop attendees will go from blinking an LED to building a web-connected services for monitoring a sensor of their choosing. They'll gain knowledge about breadboard prototyping, polarity and resistance, interrupts, and a few hardware communication protocols, like SPI.

Having a knowledge of JavaScript and Node will be helpful for working with the web-service parts of the workshop but not directly required for attending.

Pre-Requisites: - Node.js version 4 or 6 - npm install -g t2-cli

How does a project moving at the pace of node maintain multiple release lines? How does a commit get backported? How is a release actually made?

You will learn all this and more on this week's episode of "Node.js Releases, how do they work?".

Moving fast shouldn’t mean breaking things, but Facebook’s old mantra often reflects the realities of a rapidly evolving codebase and infrastructure. The Guardian’s development culture is designed to allow us to move quickly, deploy a dozen times a day and get statistically-significant A/B test results within hours.

Sometimes, though, that leads to the odd slip up.

Join Gareth for this talk as he lays bare just a few of the mistakes they made and more importantly, the lessons learned and remediation they took to avoid the problems in the future.

There is nothing that is more full stack than an Electron app. Combining the power of NodeJS and a Chromium Browser, companies are delivering powerful applications that blur the line between the “web” and “thick clients”.

Join Kitson for this talk as he will cover an overview of Electron, the opportunities and challenges when developing an app on Electron and a live coding demonstration.

With XComponent, merchants can plug-in on PayPal's React components directly to build their shopping experiences. PayPal is open-sourcing tools to let you build cross-domain components too, releasing the power of Node/React to third-party sites, and sharing your web experiences.

• Using Node, React and XComponent to build drop-in cross-domain components

• Allowing iframes to be used as React components, with props and callbacks

• Exposing PayPal's Button and Checkout experiences as cross-domain components

• The open-source cross-domain component libraries that you can start using today

In this talk Jan Jongboom, Developer Evangelist IoT at ARM and JerryScript contributor, will go into the current state of JavaScript on embedded devices. He'll cover the developments among the industry, shows where JS is already applied, and what problems we'll need to solve to bring JavaScript to all the things.

Node-RED is an open-source visual tool for wiring the Internet of Things. Built on top of node.js, it provides a light-weight, browser-based editor that makes it easy to integrate different streams of both physical and digital events.

This session explores what Node-RED can do, show cases how it has been used to great success across a range of industries and looks to the future of the project.

Some things just don't mix:

• oil & water
• freshly brushed teeth & orange juice
• conference WiFi & tech demos

As the popularity of IoT and realtime experiences continues to grow, you often look to the ease of "cloud" environments, like AWS or Heroku, to demo these applications at conferences and meetups. Overloaded, slow wifi at these events causes trouble for the speakers who can do little to resolve this issue while their app sits on a server hundreds of miles away.

Nick proposes that you can combat latency and reduce your dependency on "the cloud" for realtime and IoT by running our applications on the devices providing that wifi: our routers! Through the use of existing protocols, like mDNS and adhoc/mesh communication, you can distribute the load across these portable devices powered by Node.js and open-source hardware.

During this talk, you will learn how this technology can benefit tech events and affect the way we build applications for our homes and communities around the world.

In many ways modern web sites are similar to video games: They both offer engaging interactive experiences. They both also often encounter the same difficulties like performance issues, adjusting to different screen size and device fragmentation. In this talk, you will learn how to apply video game principles when designing and building websites. You will also present Javascript/CSS libraries for particles, physics, multiplayer, camera movement and interactive video so your visitors can stop watching passively and start playing actively!

Looking for a way to detect DOM changes to update a different part of the page? MutationObserver got you covered. Want to get notified when elements enter the viewport to load assets? IntersectionObserver is your friend. Are you dealing with sequences of events over time and want to save yourself some headaches? Observables will make your life way easier.

Join Stefan for this talk as he covers the use cases of Observer/Observable APIs, go over implementation details, and cover everything you need to know to use them in production.

We live in a world with enormous amount of data presented to us and with the advancement of technology and research, we process more information and are empowered to make data-informed decision about many things in our lives. For example, we can get suggestions on the movies we are more likely to enjoy, be reminded by things we have to buy when we enter a grocery store and even avoid traffic congestions and receive fastest route getting from point a to b.

Data Visualization has played a critical role on our ability to consume large sets of data. Even though commonly used chart types such as bar charts and line charts have been effective ways to present data, leading publishers and companies have been exploring better ways to tell stories using data by leveraging the latest technology and research.

Pega has been developing this project because we think building these complex data visualizations is very code-dependent and time-consuming. With tens of thousands of application developers and partners, we needed a flexible yet highly maintainable approach to produce and deploy these visualizations. Writing javascript which has been a primary method to develop these visualizations is not scalable and painful to maintain and troubleshoot. Visual programming method allows Pega to control fundamental building blocks and core architecture while enabling application developers to create data visualizations to meet demand and specifications of many enterprises.

He started a journey to write an HTTP framework with extremely low overhead, and Fastify was born. With its ability to reach an astonishing 20k requests/sec, Fastify can halve your cloud server bill.

How can Fastify be so... fast? Join Matteo and start by analyzing flamegraphs with 0x, and then delve into --v8-options, discovering how to leverage V8’s feedback and optimize your code. He will explore function inlining, optimizations and deoptimizations. You will learn about the tools and the libraries you can use to do performance analysis on your code. In Fastify you reach a point where even allocating a callback is too slow: Ludicrous Speed.

Join Gergely and learn how to do thread modelling for applications written in Node.js.

• What is threat modelling?

• Threat modelling in practice

• Threat modelling Node.js applications

– HTTP Security headers

– What are timing attacks and how to defend against them

– Regex Denial of Service attacks and how to defend against them

– Monitoring insecure dependencies coming from npm

– CSRF attacks, how to defend against them

Tiny computers such as the RaspberryPi, Arduino and C.H.I.P. have finally reached a level of performance and affordability that makes hardware experimentation accessible to everyone. At the same time, JavaScript has emerged as the lingua franca of web programming and can be found in many places beyond just the browser.

What if George told you there was a mature protocol that's been around since 1983 and was uniquely poised to take advantage of this development?

Well, wonder no more and meet MIDI!

Sitting at convergence of these two things is MIDI — a niche protocol that's been around since 1983 and was originally designed for musical instruments to communicate with one another. It's event-oriented approach to messaging feels right at home in the asynchronous world of JavaScript & Node, and the prevalence of MIDI support in older musical equipment means you can find unique, hackable and affordable hardware at your local pawnshop or Craig's List.

This unlikely tech stack — Tiny Computers + JavaScript + MIDI — can lend itself to creative programming beyond music. George's talk will explain how to get started, walk through several examples and elaborate on the future of this stack, not only as a platform for experimentation but for education as well.

This talk will explore the value systems that exist in Open Source communities and discuss how they shape the ideas of leadership, management, and mentorship in Open Source projects. It will compare these ontologies in projects (both Open Source and not) of varying size, scope, and focus and demonstrate how they manifest directly into actions or structures in the projects. If you've ever wondered how Open Source gets made, this is the talk for you!

Progressive Web Apps are a wonderful way to make the web and the app space work in harmony. There is a lot of confusion though about what they are and what we should do to make them a true success. In this keynote, Chris Heilmann will share the why and how of PWA beyond "make it work offline on the newest mobile devices".

Webpack, a module bundler, has become popular in the web development community.

In this entry level workshop I'll discuss the core ideas behind it, and given there's enough time, I'll also cover some of its advanced features like bundle and code splitting.

The workshop is based on my free book, "SurviveJS - Webpack", and the material is available online.

Join Christos and Luciano in this workshop as they take you through a discovery path and show you how to embrace the serverless architecture in your projects.

They want to help you understanding what serverless really is and why you should use it to power up your next ambitious application whether it’s running on Azure or AWS.

The workshop will involve a fair amount of code that you’ll need to implement to solve different real-world problems and thus at the end you should be familiar and comfortable with the serverless concepts.

Topics

• Exploring the Serverless paradigm

• What are the typical use cases and the cloud providers you can use

• Taking AWS Lambda and Azure Functions for a spin with some entertaining examples

• Closing up with an advanced example showcased by the mentors

Pre-requisites

• An existing subscription on AWS or Azure (ideally both)

• Familiarity with JavaScript/Node.js (nice to have)

• A laptop with Node.js installed >= 6.11 and a Bash (*nix) /Command (Windows) terminal

• Azure Functions Core Tools CLI installed

• AWS CLI installed

• A REST client of their choice (Postman, Fiddler, Chrome extensions etc

After a quick introduction to GraphQL, you'll setup a fully-functional GraphQL backend using Graphcool. Afterwards, the goal for you is to build a simple messenger app with realtime functionality using GraphQL subscriptions.

Nikolas works as a developer at Graphcool. They strongly believe that GraphQL is the future of API design and have been using it intensely for over a year. Their goal is to share their learnings with the greater web community and make it as easy as possible for you to get started with GraphQL.

The rise of Node.js and Electron are powering a new era where JavaScript continues to expand beyond the browser and becomes a critical component of server and desktop applications. With JavaScript being everywhere, one of the emerging next frontiers for JavaScript world domination is data science.

In this workshop, you will learn how to utilize the JavaScript open-source library stdlib for various data science tasks. Through a series of brief exercises, attendees will get a hands-on introduction, ranging from analytics to machine learning to exploratory data analysis and visualization. For example, you will investigate the accuracy of the native JavaScript Math functions, build a spam classifier, and generate synthetic texts using Markov chains.

After completing this workshop, you will have a solid understanding of what kind of problems they can approach by which techniques. Furthermore, you will have experience in conducting a full analysis from start to end, i.e., exploring, cleaning, transforming, and analyzing data with state-of-the-art techniques.

The workshop will close with an outline of future steps for data science in JavaScript and opportunities for community development of next-generation tools.

WHAT YOU'LL LEARN:

This workshop will combine front end development, filmmaking and classic storytelling with gaming mechanics to introduce interactive narrative. You'll learn how to use JS and CSS libraries along with Eko Studio to create an interactive video experience of your own.

WHO IS IT FOR?

You are a front end developer with interest in storytelling, gaming and interactive media. You're comfortable with modern Javascript and CSS developing techniques.

WHAT HARDWARE/SOFTWARE DO YOU NEED?

A laptop with git and a favorite text editor/IDE pre-installed. Please sign up for a user account here before starting the workshop

It's also a story of missed deadlines, half-baked standards, last-minute decisions, ridiculous business models, and some of the stupidest ideas anybody has ever had in the history of technology. Some of them are nothing more now than an amusing footnote in history... some of them we're still living with, and working around, every single day. And it could easily have been so very, very different.

Join Dylan Beattie for an offbeat and irreverent journey back to the earliest days of the digital frontier, as we look at the ideas and innovations that have shaped the modern web... and then fast-forward to an alternate 2017, where you are all using Netscape Composer to create rich online experiences on our WebTVs, Microsoft Office is a Java applet, CueCats are more popular than fidget-spinners, and the really cool kids are using MSN to hand-code custom avatars in VRML.