The focus of JS Kongress 2020 is Scaling JS – Pushing the Limits: Massive Platforms, Data-Driven Architectures, and Modern APIs.

The #DeepTrack is about all things JavaScript. YOU create the program!

Join us, and let's watch out for solutions and best practices.

JS Kongress

2020

Are you into React, React Native, GraphQL and hungry to learn from the best? Welcome to the Web of tomorrow.

Take part in the exploration of the React universe! Focusing on in-depth talks, hands-on workshops, and finding new opportunities, React Day Berlin conference provides space for everyone to make friends and develop stellar apps together.

Since 2017 we're running Berlin based React community of people passioned about Open Source and JavaScript engineering. Since then we have also landed 2 React conferences, with last one uniting 800 engineers from Germany and worldwide.

Join our third edition in 2019 to celebrate all things React and meet engineers caring about their craft alike.

React Day Berlin

Opening

The Past, Present and Future of CSS-in-JS

Best practices, auditing tools to help you improve the accessibility of your React applications, and an in-depth live example on how to build reusable accessible components in React.

Accessibility should be a priority in the design and development process, not merely an afterthought. 

So I’ll demonstrate best practices, auditing tools to help you improve the accessibility of your React applications and provide a live example by going in depth into how I’m building my own reusable accessible component library in React.

Compassion-Driven Development: Building Accessible React UI

Do you worry about the performance of your React applications? This is a how-to of performance improvement, with techniques to track and increase speed. 

Do you worry about the performance of your React applications? Do not worry anymore, I will take you through a how-to of performance improvement. 

We will look at how to use techniques to track and increase speed.

We will start with an example app which loads data into a table and discuss how we can make the performance better.

Performance anxiety with React

IPFS is a stack of protocols for decentralized, p2p communication and data transfer on the web. Learn how you can use IPFS to host files and apps, created p2p databases, and more!

IPFS is a stack of protocols for decentralized, p2p communication and data transfer on the web. In this talk we will present how to use the IPFS protocols alongside local storage to achieve multi-device p2p or multi-user p2p synchronization on the web.

Decentralized React states - using IPFS to sync, store, and recover state

Useful techniques for customizing data visualizations, numbers, dates, right-to-left, iconography, and colors for a global audience.

Building React custom data visualizations with full international support is not always easy.

This past year, I’ve worked to add new data visualizations features and modify legacy visualizations, for an international audience - on my team at Adobe. It’s been a learning process to correctly format strings, numbers, dates, times, currencies, calendars, x/y axis, and more!

In this talk, I will share some of the useful techniques I’ve learned about customizing data visualizations for a global audience. With a focus on React and high level ideas to keep in mind when designing, coding, testing, internationalizing, and localizing data visualizations for the world!

Data Visualizations and Internationalization

This presentation will show you how to create an a Progressive Web Application using Gatsby.

This presentation will show you how to create an a Progressive Web Application using Gatsby. 

We'll learn:
- What is a Progressive Web App (PWA)
- Why PWA's are important for a more inclusive web
- How to build your own PWA app using Gatsby.

Performant Websites for All - How to Build Fast, Inclusive Applications using Gatsby

In this talk you’ll learn how to write React like its fiction and what you can gain by doing so.

You don’t know it but you are an author. You write stories every day. You build narratives, characters and plots — but you aren’t writing a novel, you’re writing components. 

I came to engineering from the world of creative writing and what surprised me the most is how similar code is to fiction. React itself follows tenants of creative writing and when you lean into those rules, you create solid component architecture. 

In this talk you’ll learn how to write React like its fiction and what you can gain by doing so.

React Is Fiction

Learn the principles that will increase your test confidence, when building React apps

Should we use react-testing-library or Enzyme? What about snapshot testing? What should be our code coverage? Those are questions we often hear when discussing testing. 

Those questions are easy to discuss but the answers won’t necessarily make us write more reliable and flexible code. 

Many developers struggle to write tests 1) quickly and 2) that increase their degree of confidence. Writing good tests requires writing good code. Writing good code that is easy to test requires a good understanding of programming principles and how they apply to the libraries of choice. 

Discussing principles is harder than discussing tools. 

In this talk, we’ll discuss the principles that will make developers increase their test confidence when building React apps. I’ll also use those principles to challenge some believes that the audience might have about certain testing libraries or methodologies.

Testing Is All About Principles

Dive into the architecture of a programmable UI platform, which both allows you to have a fully working UI out of the box and also be able to customize every functionality and user experience to your needs, using the full power of React.

For backend services having a flexible API is a common practice that allows you to combine them with different APIs as if they were LEGO blocks and solve almost any business need. At Twilio we’ve been building REST APIs for over 10 years. When we recently decided to ship Twilio Flex, a software that has a working UI out of the box, we still wanted to make sure that it was as flexible as the rest of our APIs.

In this talk we’ll dive into how we architected a programmable UI platform using React that both allows you to have a fully working UI out of the box but also be able to customize every functionality and user experience to your needs using the full power of React.

UI as API

Learn some of Firebase's best features for the web, and how to easily integrate them into your React app with ReactFire.

Whether you want to A/B test your new dark theme, stream live updates to users while seamlessly handling spotty mobile connections, or just make your site load faster, Firebase can help you develop and grow your app. 

You'll learn some of Firebase's best features for the web, and I'll demonstrate how to easily integrate them into your React app with ReactFire, a new Firebase library that uses React's latest and greatest APIs such as Hooks, Suspense, and Context.

Modern React apps with Hooks, Suspense, Context, and Firebase

Learn about errors in JavaScript, and modern ways to handle them in React.

Error handling is an important subject matter as it cuts across concerns from creating resilient code as well as improving user experience. 

The talk is broken down into the following structure:
- Modern ways to handle errors in React
- Mental models for determining which parts of the UI should handle their own errors.
- How error handling reduced our customer success workload.
- Some live coding full of errors.

How Many Ways to Say I'm Sorry, Error Handling in React

Using Expo you can build an app that runs natively for iOS, Android, and web. 

Using Expo you can build an app that runs natively for iOS, Android, and web. 

You’ll see how Expo and React Native for web enable you to use cutting-edge browser functionality to create progressive web apps that emulate the functionality of your native app as closely as possible. 

You’ll also learn what you can do with it, why you would use it, and how it works with other popular web development tools.

Build it Once with Expo for Web

See the new version of React Navigation and learn about navigation and routing in React and React Native apps.

Component based Navigation in React Native

The challenges to expect when transitioning from native to React Native and how to avoid/overcome those challenges. 

Rewriting an app is an exciting process, but it comes with its drawbacks. 

In this talk, I’ll focus on the challenges to expect when transitioning from native to React Native and how to avoid/overcome those challenges. 

I’ll share learnings from my team’s first-hand experience and cover:
- Factors to consider when deciding to use React Native
- Organizational and technical challenges that can arise and how to deal with these challenges
- Expectations post-release.

From Native to React Native

Working with contractually-sound REST APIs in a React application using powerful new tooling.

GraphQL is an incredible technology. It provides developers with concrete, solid guarantees at the API layer, preventing surprises when interacting with client-server applications. 

REST has been often criticized as weaker in this regard, since it is not a formal specification. 

This talk explores working with similar (if not better) contractually-sound REST APIs in a React application using powerful new tooling.

Strong RESTful Contracts in a GraphQL world

Real-world example of a typed functional language actually making your developer life better, in an existing Javascript code base. And it's something your team might not cringe at, either.

You've seen it all. You are not working on a ""green field."" You slay dragons.

This talk would like to show a real-world example of a typed functional language actually making your developer life better, in an existing Javascript code base. And it's something your team might not cringe at either.

ReasonML for Skeptics

This talk aims to eliminate the school of thought that React Native is mostly for small mobile applications.

Ever wondered how to use microservices approach in a FED\mobile application? hesitating to choose React Native for your big project? I’m here to eliminate the school of thought that React Native is mostly for small mobile applications.

React Native At Wix - Building an App for 150 Million Users

React Native is the best framework for rapid prototyping.

React Native is the best framework for rapid prototyping. In this lightning talk, I present a case study of how React Native was used to build three successful mobile prototypes, what tools we used to measure the effectiveness of those prototypes, and how React Native allowed us to test our product hypotheses faster

Successful rapid prototyping with React Native

An often-missing ingredient in many React Applications is a focus on accessibility best practices—especially when component libraries are part of the application. 

Building React applications has been fairly easy now, However, an often-missing ingredient in many React Applications is a focus on accessibility best practices — especially when component libraries are part of their application. 

Nothing in React prevents us from building accessible web apps, but we need to learn to harness its power in the right way while dealing with some unique challenges caused by creating web pages with JavaScript. 

This talk will focus on these issues and how to solve them in the real world, while also adding some a11y power to your development process. This talk will also focus on why it is important to build accessible web apps.

Building Webapps for everyone - a11y with React

Modern features like Web Workers, WebAssembly, Worklets, and Service Worker allow us to leverage multi-threaded computing to run tasks in parallel.

User is working with your application, suddenly, UI freezes and probably, one of the CPU cores is burning! They cannot do anything. The only perception you can feel is as hot as a hell metal case of the laptop. Although this sounds like a horror movie, this is your application that cannot leverage modern APIs to lift heavy computation to a different thread where consequently user suffers the pain.

Modern features like Web Workers, WebAssembly, Worklets, and Service Worker allow us to leverage multithreading computing to run tasks parallelly, which at the end, makes the user feel like in a rainbow paradise instead of a nightmare, even though JavaScript is a single-threaded programming language!

In this session, I am going to show my experience running jobs in parallel on a React.Js application that will provide a pleasant user experience and exciting development.

Parallel computing in ReactJS

Building complex user interfaces can be tricky if all you have is JS and CSS. That’s where React and SVGs come in.

Building complex user interfaces can be tricky if all you have is JS and CSS. That’s where React and SVGs come in. 

When it comes to exploring audio, creativity is key and SVGs in React enable endless design possibilities. 

So, in this talk, I’m going to show you a few powerful examples to inspire you and help you create amazing audio projects.

Exploring audio with React and SVGs

A microinteraction goal is to provide feedback based on the user’s action. This can help users visualize how the interface moves or behaves, even though it’s purely digital on a flat screen.

Microinteractions and Animations in React Native

Basic insights in how Bluetooth LE works and how to access it in React Native.

This talk will give you some basic insights in how Bluetooth LE works and how to access it in React Native. We will look at our motivation for doing this, which library to work with and how to use it. We will create a simple app and show some basic pitfalls. All code will be available via GitHub.

Event-Driven Bluetooth handling in React Native

Learn why and how to server-render components in React Native and how it works.

In this talk you will learn why and how to server render components in React Native and how it works!

Server Rendered React Native

Apify SDK - The scalable web crawling and scraping library for JavaScript

Want to create a companion CLI tool for the next big thing that you are working on? Build it with React!

Text-based CLI tools are great. They are fast, lightweight, and universally accessible. But what does CLI have to do with React?

In this lightning talk, we will have a look at Ink - a wonderful custom React renderer that allows us to use Flexbox to create excellent command-line interfaces with ease. 

Want to create a companion CLI tool for the next big thing that you are working on? Build it with React!

React for Command-Line Interfaces! (feat. Ink)

Ever tried to click a button or a link on a paper printout? Yeah, me neither! So why are these interactive elements included in the printout of most websites? 

Ever tried to click a button or a link on a paper printout? Yeah, me neither! So why are these interactive elements included in the printout of most websites? 

If your website has content, there will always be somebody who wants to print it - let’s be prepared! I will talk about common mistakes that lead to horrible printouts and how and why we should get rid of these.

Print-friendliness - Why should you care?

React has a functional nature, however, TypeScript has not. Fortunately, there is a rising library called fp-ts.

TypeScript is the main dialect developers use for writing React applications. React has a functional nature, however, TypeScript has not. 

It lacks some popular patterns and data structures we use and love in other functional languages like ReasonML, Elm, or PureScript. 

Fortunately, for the rescue, there is a rising library called fp-ts. Let me show you how it can help you.

Typed Functional Programming in TypeScript with fp-ts

Flow makes it possible to add types to already existed projects gradually, without the need to re-write a business logic part of an application to another language. 

Flow makes it possible to add types to already existed projects gradually, without the need to re-write a business logic part of an application to another language. 

Having a typing system in place is beneficial in many cases - from refactoring old code to onboarding new team members. 

However, in the attempts to increase coverage it is easy to shoot yourself in the foot and end up with a system that is not helpful enough or even slows down development time. 

Let’s figure out together, how spending the same amount of time on this task can lead to a more resilient and effective type system in your React projects.

Empowering your React application with types using flow

This talk will go through the Algorand JS SDK with examples in using standalone functions for generating accounts, signing transactions as well as client wrapper functions for sending transactions and querying the blockchain. 

We will also see examples on building React components.

Building Blockchain Applications with JS

How to continuously deliver design changes to the react design system?

In 2019, product design teams use a design system at the level of a graphic editor. Developers teams move this design system into code using the React component approach.

But there is a problem. The final version of the product does not exist. As there is no final iPhone.

Product teams work daily on product. But design layouts and components in the code live in different worlds, they need to be updated manually.

How to continuously deliver design changes to the react design system?

Figma is a new design tool that is gaining popularity. Unlike Sketch, Figma works in the web, the native environment of component design systems. It has an API. 

Sasha (designer) and Zar (developer) will show how to synchronize design systems from two worlds.

Figma to React: Efficient Delivery Design to the Code

The challenges of choosing self-taught route, how much time it took. How welcoming the industry is? Let me share the insights!

How I landed my first developer role after coming from a non-traditional background. 

The challenges of choosing self-taught route, how much time it took. How welcoming the industry is? Let me share the insights!

Short Story - A dentist turned software developer

HobbyTrack: Technical Diving

HobbyTrack: FPV Drone racing, a virtual adrenaline kick?

HobbyTrack: Making a tiny videogame with Arduino

HobbyTrack: Fashion and Tech: can these live together?

HobbyTrack: How to perform live trippy visuals with WebGL

Goober, a less than 1KB css-in-js solution

Handling time in React

How we have built a Node.js Registry with React

Frontend Application Bundles

Closing

2019

JSConf EU is a professional, not-for-profit, labour-of-love conference for the JavaScript community. It’s a two day affair, with many related side events in the days surrounding it. JSConf EU is an invitation for the community to come together and for new people to get to know and join the community.

Learn about GraphQL, DevOps, Machine Learning, Accessibility, New and upcoming JavaScript features, JavaScript frameworks like React, Vue, and Angular, Node.js, Web performance, and Progressive Web Apps.

JSConf EU

With {Live : JS }, Jaume Sanchez, Paul Irish, Tiffany Conroy, Karolina Szczur, and a choir. Produced by Malte Ubl
1:00 Intro
3:35 Paul Irish
7:12 Visuals 1
9:49 History of JSConf EU talk
20:24 The X

Music by 2xAA https://soundcloud.com/2xaa/never-forget-take-that-jsconf-eu-2xaa-cover
22:54 The Choir

Opening JSConf EU 2019 Festival X

The JS package commons is in the hands of a for-profit entity. We trust npm with our shared code, but we have no way to hold npm accountable for its behavior. A trust-based system cannot function without accountability, but somebody still has to pay for the servers. How did we get here, and what should JavaScript do now?

The economics of open source

Very few developers have the need to write super optimized code. In application development we tend to favor readability over optimization. But that’s not the case with frameworks. Developers who use frameworks expect them to run as fast as possible. In fact, speed is often a defining characteristic when choosing a framework. 

There are techniques that make code run faster. You’ve probably heard about linked lists, monomorphism and bitmasks, right? Maybe you’ve even used some. Well, you can find all these and a bunch of other interesting approaches in the sources of most popular JS frameworks. 

Over the past year I’ve seen a lot while reverse-engineering Angular and React. In this talk I want to share my findings with you. Some of you may end up applying them at work. And others, who knows, may even end up writing the next big framework.

A sneak peek into super optimized code in JS frameworks

Have you wondered how JS engines work? This past year I built an engine from scratch in Rust. It was fun, weird, exciting and sometimes exhausting. I will share my experience as well as what it is like to work on the specification, collaborate with TC39, and lessons from engines in use today.

Let’s build a JavaScript Engine in Rust

Thankfully, every year ECMAScript gives us new shinies to advance how we code JavaScript. I’ve found myself digging into features & proposals ever since my curiosity of ES2017’s SharedArrayBuffer took me down a fascinating rabbit hole. 

Let’s delve into some of the features & proposals we get to look forward to in 2019.

ES2019 Features: What Even Are They?

PWAs are now installable on every mobile and desktop OSs, but there is a lot of new things since last year we need to do to create a successful experience. 

We will start understanding the App Lifecycle on every OS including new APIs, the limitations on iOS and how to deal with them, and how WebAPK works on Android. 

We will mention challenges on desktop PWAs, including multi-window management and we will finally cover distribution channels, including new DOM events to improve analytics, how to create a custom Install experience, and how to distribute the app in the store.

The modern PWA Cheat Sheet

Npm has more data than anyone about who JavaScript developers are and what we’re up to. Using registry stats and the results of our 2019 ecosystem survey of over 30,000 developers, I break down the current state of JavaScript and where trends look like they’re headed, so you can make more informed technical choices.

JavaScript: Who, What, Where, Why and Next

With over 1,000,000 packages, the npm ecosystem is the largest out there, by far – but the ecosystem and its package manager were created in more humble times, for small projects and packages centered around the Node.js ecosystem itself.

It’s about time we redefined package management for modern web development, and that redefinition is tink: a package unwinder for JavaScript brought to you by npm itself. With tink, you’ll find unprecedented speeds, deep compatibility with everything from Node.js to bundlers, and a UX workflow optimized for the modern web developer. 

Come join us for the official unveiling and find out what the future of all package management will look like for years to come.

Tink: A Next Generation Package Manager

In September of 2008, Google’s Chromium Project released V8, a JavaScript engine, as part of a browser optimization wave that heralded the era of JavaScript browser applications that we both love, and love to hate. Less than a year later, in 2009, Ryan Dahl announced (at this very conference!) a way to run the V8 browser environment outside of the browser- Node.js, a platform that held the promise of unifying web application development, where both client and server side development could happen in the same language - JavaScript.

A decade later, V8, JavaScript, and its new buddy WebAssembly, have expanded to lands charted only a few years after Node.js debuted- known (confusingly) as the “Edge”. In this talk, we’ll introduce what the “Edge” is and why we are excited for it to revolutionize computation on the web. We’ll explore how this adventurous JavaScript engine, V8, is so well suited to tasks previously limited to Virtual Machines, Containers, or even simply Operating Systems. Finally, we’ll talk about security, Spectre, and ask ourselves the age old question, “You can do it, but should you?”.

In true JSConf EU tradition, this talk itself is going be an exciting announcement. You should come if you want to be there for the beginning of a new era of the Internet.

JavaScript's Journey to the Edge

We all know and love framework-like features such as hot module replacement, reactive properties, templating, CSS-in-JS, lazy-loaded bundling, etc. Stencil is a new approach, a build-time abstraction with framework-level productivity, that generates hand-optimized components using future-proof web APIs. 

We’ll discuss the architecture of Stencil and the innovations a compiler can introduce to your apps and design systems!

Stencil: a built-time approach to the web

Most people connected to the Web are carrying JavaScript in their pocket without even knowing it, and those of us making tools for building with it are either unaware of or blissfully ignoring that population. 

While JavaScript’s pervasiveness grows, so is the gap in its literacy, and this is a gap we need to solve if we’re ever going to survive self-driving cars on the blockchain. 

Let’s talk about JavaScript, the tool, as opposed to JavaScript, the Oracle-run Twitter account.

Javascript Considered...Useful

Since its creation in 2016, Yarn continuously pushed for better standards in the JavaScript ecosystem in particular. Dependency locking, built-in monorepos, zero-network modes, Plug’n’Play resolution, we’ve been on all fronts. 

Let’s discuss what we have in store for the future, and what it means for our ecosystem!

Yarn — 2019 and Beyond

Join us for the third annual TC39 panel at JSConf EU! TC39 is the standards committee that designs the JavaScript language (sometimes called ECMAScript). The panel will feature a range of committee members and is your chance to ask questions about the past, present and future of JavaScript!

Panel by TC39 Committee

It’s almost here! Houdini — the future of CSS! This spec allows developers to write web worklets with JavaScript syntax and access the CSS Object Model for the very first time. Everything will change!

In this talk, we’ll will walk through some of the visual magic we can create by using Houdini and its various upcoming browser APIs, and go through a live demo of how we can get started with implementation. 

Learn about how to use Houdini and what it means for the future of web application styling.

CSS Houdini & The Future of Styling

Node.js has been using a derivative of nginx’s parser with a lot of customization/rewrite since its inception. Despite being fast enough, the project architecture made it very hard to maintain in a long run. 

To mitigate that, the author has created a tool to generate the new HTTP parser called “llhttp” from the TypeScript code in understandable, verifiable, and maintainable way. Incidentally, the performance of “llhttp” is two times better than of the old parser. 

In this talk we’ll walk through the basics of generating such parsers and how “llhttp” works.

llhttp - new HTTP 1.1 parser for Node.js

V8 is the JavaScript engine powering Google Chrome, Node.js and NativeScript. NativeScript embeds V8 to process JavaScript and dynamically call Android APIs. This enables developers to write Android applications in JavaScript and directly access the underlying OS. 

Come to this session to learn what challenges the NativeScript team met embedding V8 in a mobile framework and how you can power any C++ based application with one of the most sophisticated JavaScript engines.

Embedding V8 in the real world

Travelling to JSConf EU from another country? You probably had to pay an arm and a leg for a data roaming package on your phone. But there’s a better way! 

What if I told you that you could stay connected to the internet with a phone that can only send and receive text messages? 

In this talk we’ll build our own browser that makes all requests over SMS, so that next time you can forget about that fancy data package.

Bringing back dial-up: the internet over SMS

For millennia, mathematicians and artists have been fascinated by polyhedra, 3D shapes that encode complex symmetries and relationships. 

My name is Nat Alison, and for the last ten years I have dedicated my life to sharing the beauty of these shapes with the world. Join me on an epic quest filled with ancient 3D libraries, arcane mathematical data structures, and Pokémon GIFs as I strive to make my vision a reality the only way I know how: an interactive web app. 

Come and twist, expand, and gyroelongate polyhedra with me, and let my journey inspire you to use the web to make your own passions come to life.

Polyhedra, I Choose You! Letting Your Passions Take Form

Performance advocates spend a lot of time telling developers how to build fast and reliable experiences on the web. Every website is built differently, however.

Instead of just listing a number of progressive enhancements and techniques, this talk will try to take a different approach. We’ll first explore who needs to consider improving their site in the first place and see if their is a messaging problem between advocates and developers in the community. 

We’ll then address concerns that can arise when performance is being worked on and discuss some real and practical solutions.

Performance Empathy

“Queers hate techies,” the slogan proudly proclaimed in a window in San Francisco. Being a queer techie, I was immediately conflicted.

The tech industry provides a safe haven for many queer folks, myself included. It offers stable employment to us more willingly than other industries. These benefits don’t extend to all queer folks though, and these benefits are often revoked as soon as we step out of line. Queer folks are a model minority in an industry who’s products often negatively impact our community.

This talk will dive into these complications and how we can improve the tech industry to make it a truly welcoming place for queer folks.

The Contentious Relationship Between the LGBTQ+ community and Tech

Many would argue there are only two hard problems in software: naming and cache invalidation. I’d argue there’s a third problem - abstractions. 

Whether you’re implementing an API for devs outside of your organization or creating a reusable library for devs on your team, creating the right level of abstraction is difficult. You have to balance flexibility with the ease-of-use. The correct choice is often a function of time constraints, compromise, and trial & error. 

I’ll talk about how to navigate these issues more efficiently.

Finding Your Abstraction Sweet Spot

Until 1992, the web was largely textual, reserved almost exclusively to academia, with the charm of searching for library books via card catalogs.

The sea change came when a browser allowed for both text and images to now be displayed in the viewport. Despite some vehement opposition, this was described as the “gateway to the riches of the internet”.

This was a technological advancement that some had wagered would further fuel more advancement. We now have seen technologies like APIs, PWAs, DevTools and many more.

“The Shape Of The Web” is about both accomplishments and challenges that lay in past, present and future of the web - from its technologies employed and its employed technologists.

Shape Of The Web

There’s a divisive movement around the world which has arguable impacted the software development community. How can we remain open-minded and respectful when talking about different programming paradigms or languages?

In this talk, I will be talking about empathy, how we can have divergent views and still have meaningful conversations.

Why Can’t We All Just Get Along?

Remember loving to read comics on a Sunday afternoon when you were a kid? Maybe you don’t. In the past, traditional print comics have made it impossible for blind and visually-impaired readers to experience their heroes’ adventures first-hand. Today an increasing number of initiatives like comic book stores for the blind aim to overcome this challenge.

What if I told you that the web platform empowers us to even create comics for literally everyone?

Alongside a demo application, you see how accessibility best practices enable you to craft an immersive webcomic experience that is not only engaging for the sighted but accessible for everyone.

Crafting Comics for Literally Everyone

Not long ago, it seemed like JavaScript devices were going to free JS developers from the constraints of the browser and let us control every aspect of our lives as easily as we once controlled hover menus. 

Though nodebots were captivating, many of us were anxious for the JS device revolution to reach a more mundane destination: our phones. 

And yet today the constraints of the mobile landscape look not much different from several years ago. We have the same two operating systems, the same two app stores, and same option to write a native app or push people to save what is still mostly a bookmark. 

How did we cover so little distance, given the enthusiasm, resources, and potential that appeared to exist, and more importantly, how close can we come to a JavaScript phone today?

What happened to my JS phone?

Javascript runs on nearly any platform. Most languages can compile to Javascript. It’s well-positioned to become the lingua franca of programmers, with one problem: Like most programming languages, Javascript is based on English. 89% of the world’s population doesn’t speak any English. Many of those people can’t even read the Latin script. If we want Javascript to be a lingua franca, we need to ensure it is accessible to all people, regardless of their native language.

Let’s look at the barriers that non-native speakers face when contributing to OSS Javascript projects and what it would take to remove them entirely, so that two developers could collaborate without speaking the same language. We will see what techniques Javascript can borrow from other languages by taking a look at করো (koro), a project which adds Bengali support to the Go compiler. And, we will learn enough about compilers and character encoding to answer the eternal question: “Could we do this in Javascript?”

করো: Translating Code to Other (Human) Languages, and Back Again

As usage of ad blocking software has risen over the years, an entire micro-industry has popped up catering to publishers - promising to get around the ad blocker and show ads to users of ad blocking software.

Some of these techniques rely on browser bugs, or limitations of browser extensions and some are just extremely creative ways to get around ad-blockers. This has forced ad blockers to come up with their own ingenious ways to counter and block the circumvented ads.

In this talk, we’ll go over some of the techniques used in this cat and mouse game between ad blocking extensions and the people who want to circumvent them. It’s a fascinating peek into a world very few people seem to know.

Block, unblock, block! How ad blockers are being circumvented…

In 2009 I was managing Yahoo’s tech event budget when we agreed to sponsor the very first JSConf, the one that almost didn’t happen, the one that started something… And though I’ve still never attended a JSConf, nor learned to code, the zeitgeist of the JavaScript community and its event culture have had a profound effect on how I live and the devrel work I do.

I’d like to speak about cultivating “JavaScript: The Good Times”—the evolution of inclusiveness, the effort to replace customs that no longer reflect the values and demographics of the community, the focus on new practices for joyful conference-going and knowledge sharing. The JavaScript ethos has fueled a reinvention of the tech gathering as an act of participation and experiment, generating enduring artifacts for learning and excellent new habits for our relationships - personal and professional.

In the land of the JavaScripters

Machine Learning is a powerful tool that offers unique opportunities for JavaScript developers. This is why we created TensorFlow.js, a library for training and deploying ML models in the browser and in Node.js. 

In this talk, you will learn about the TensorFlow.js ecosystem: how to bring an existing ML model into your JS app and re-train the model using your data. We’ll also go over our efforts beyond the browser to bring ML to platforms such as React Native, Raspberry Pi, and Electron, and we’ll do a live demo of some of our favorite and unique applications!

TensorFlow.js Bringing Machine Learning to the Web and Beyond

How WordPress built its own brand new visual editor experience from the ground up. The talk will include an introduction of WordPress and how the Gutenberg editor project started, details of how it works and how we incrementally improved the block editor over two years, and what our plans are for the future.

Designing a Rich Content Editor for a Third of the Web

This talk will discuss why we think that JavaScript is a good language option for IoT development by walking you through a loosely coupled end-to-end IoT system, from new device on-boarding to remote access via gateway.

Technologies we have been used and/or contributed to for building the IoT system using JavaScript will be discussed. At each stage, GDPR compliance of these technologies will be looked into.

To address the issue of resource restriction in embedded devices, we will introduce you to JerryScript, an ultra-light JavaScript engine by Samsung. It is followed by a comparison of popular JavaScript platforms based on JerryScript that provide direct JavaScript APIs to developers. The open gateway framework is node.js-based and targets at decentralized ‘Internet of Things’ with privacy and security in mind.

Build an end-to-end IoT system using JavaScript with "GDPR awareness"

Join us for a walk through of the JavaScript magic powering the JSConf EU stage. 

{ live : js } collective of audio and visual artists who build live experiences, shows and installations. Why JS? Because that’s the main technology we use: JavaScript. 

Making of this Stage

After so many years sitting with the computer you can take your old scratched Les Paul or Stratocaster from the case and fill all the space around with warm riffs. I’m going to show how to transform the code into Kirk Hammett’s wah-wah, Stevie Ray Vaughan’s overdrive and Kurt Cobain’s distortion. You’ll learn how to parse audio input in real-time using JavaScript and the Web Audio API.

I’ll be jamming live on stage with my guitar to demo every code example and we’ll also use WebRTC to jam with friends across the world! After this talk, you will be familiar with the principles behind pedal sound effects and how to create them in code. Let’s rock the Web!

JavaScript, JavaScript…. Rocks You!

The JavaScript ecosystem has been breaking ground in both the Browser and in the backend with Node.js since JSConfEU launched 10 years ago. 

We’ve recently recognized that in the same way that using JavaScript both on the front and back end unlocks opportunities for more people to contribute to a larger part of an overall application, combining the JavaScript and Node.js Foundations allows for easier collaboration and contribution to larger portions of the JavaScript ecosystem. 

This panel will cover the key issues, concerns, discussions, and lessons learned that were part of the effort to bring the JavaScript and Node.js Foundations together. We’ll also dive into the new opportunities and exciting future it brings to people and projects across the JS ecosystem.

OpenJS Foundation Panel

To build inclusive websites, developers have to consider accessibility, performance and user flows. Crafted source code forms the foundation for thought-through UIs, but it’s not only about the code. Let’s have a look at HTTP, and to be specific, its headers that can have a direct impact on user experience.

HTTP headers for the responsible developer

Augmented reality is already making its way into everyday browsers! This talk will dive into what that might mean for the traditional web developer, and why developing immersive experiences makes so much sense on the web, even in the face of native alternatives. 

We will cover topics like off-the-shelf web technologies, performance, and privacy all in the context of augmented reality.

The Case for Augmented Reality on the Web

When I was a child I dreamt a lot about creating robots that helped me in my daily life, like tidying up my bedroom. That was just a dream till I grow up and found out that there’s something called home automation. So I decided to build Sasha, my cats’ pet sitter, that helps me by feeding my cats when I have to get home a little bit late. Sasha changed my life and my cats are stressless, because they can eat their meal at the right time.

In this talk I will share my experience on using JavaScript to build Sasha and will walkthrough its features. Last, I’ll talk about other possible use cases and the potential of home automation with JavaScript.

About life, robots and cats!

I will share my story of establishing and growing JS Community in a developing country Nepal. How tech communities will help you and other grow together ? Challenges that you might face while starting a community in your place. (Based on my experience) How to overcome these challenges?

You should start a tech community too

Teaching programming to children is hard. Computer Science topics can be difficult to grasp using standard programming languages and tools. Using MIT’s Scratch programming platform, creating games and working software is simple and fun thanks to their drag and drop interface.

To prove that this is as simple as it sounds, this session will be led by a 13-year-old. What better way to learn how to teach kids how to code than by learning from a kid?

Teaching Kids to Code by a 13 year-old

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 things I learned making the fastest JS server runtime in the world

Web APIs developed and standardized by the browsers have been serving client-side JavaScript applications with a wide selection of features out of the box, while Node.js have been developing another set of APIs that are today the de-facto standards for server-side JavaScript runtimes. There is now a conscious effort to bring the two worlds closer together, in particular by introducing more Web APIs into Node.js core, but it’s not an easy ride - not every Web API, designed for the browsers, makes sense for Node.js.

In this talk, we are going to take a look at the story of Web APIs in Node.js core - what Node.js have implemented, what are being discussed, what are blocking more APIs from being implemented, and what we can do to improve the developer experience of the JavaScript ecosystem.

Web APIs in Node.js Core: Past, Present, and Future

Currently only ‘fs’ and ‘dns’ have an experimental promise api in Node core. People LOL at node.js core modules for still using the callback pattern. I could launch into a bunch of puns here but instead I’ll just say the current status is sad but fixable. Where are we? What do we need to do? How can you help?

Promises API in Node.js core: where we are and where we’ll get to

Teaching absolute beginners with no technical experience whatsoever to understand Javascript can be quite a daunting task. It’s more challenging if you have a thick British accent and your students are mostly African students. If you’ve ever designed a tech curriculum then you understand how complicated this can be. 

At code Afrique where we help the community by offering a free weekend intensive bootcamp, we explored and have now achieved success with ember where we had earlier failed. The aim of this talk is to show, what we tried, where we failed and how Javascript via Ember brought us success like no other.

Javascript is for Everyone!

From its friendly developer experience to its performance benefits, a lot has been said about GraphQL. Underlying it all is the GraphQL query language, made possible by GraphQL schema language. These surprisingly versatile features have the potential to provide a single interface for all modern web app development concerns.

We will start with a case study on how we use GraphQL queries as an universal interface to resolve data over a variety of datasources ranging from remote HTTP requests, to local CSV files, and in-memory data stores. Next we will explore these ideas further, using GraphQL queries as an interface over the DOM and various other web APIs.

GraphQL: Towards a universal query language

“Falling sand games” were a beloved childhood curiosity, but when I set out to write my own in Javascript, performance got in the way of the scale and granularity I wanted.

Could WebAssembly be the tool to build the sand simulation of my dreams, or is it still just for blog posts?

I’ll share with you the history and beauty of falling sand games, what I learned building mine to leverage the power of modern browsers, and show you how WebAssembly can cooperate productively with the JS ecosystem to enable awesome web experiences.

Simulating Sand: Building Interactivity With WebAssembly

With CSS animations and web animations moving elements became possible in the browser. But how one moves an object in such a way that it appears “correct” for the human eye? How does a motion feel natural? These and similar questions confronted the artists who brought cartoons to life as early as 1906. 

Let’s take a look behind the scenes and see how drawings learned to walk and what we can learn from it for animations in the browser.

Animations — Learning from Cartoons

Before personal computing became a thing, there was a handful of programmers and artists saw computers as a tool beyond their intended purpose: to create art.

In this talk, we will explore the early history of computer art, from ghostly oscilloscope paints to pre-ASCII text art. We’ll discuss how simple techniques with limited technology back then could yield compelling pieces. We’ll see how the history of computer displays and printers have evolved in the 1950s to 1980s.

While quite a bit of retro art survives today, most of them do not come preserved with their algorithms. In this talk, I’ll also demo some attempts to recreate retro art pieces using p5.js, a JavaScript graphics library as well as talk through some of the techniques of creating generative computer art.