A warm welcome to IJS 2019 in London! Conference host Sebastian Meyen will discuss some trends and news in the JavaScript ecosystem and will give an outlook to the conference program with some of the speakers.
Amidst the rapidly evolving software ecosystem, two technologies have categorically stood out: GraphQL and Serverless. On the frontend, GraphQL not only brings the robustness of a type system, it also brings a whole new way of using APIs. Whereas on the backend, serverless has brought in the next phase of infrastructure abstraction by delegating the runtime to managed services.
In this talk, we will demystify the concepts and motivate why these technologies are here to stay for the foreseeable future. We will begin with the challenges of API-driven applications and how the status quo falls short of meeting the challenges. We will introduce GraphQL and showcase its advantages including 1) strong type system, 2) flexible data gathering, 3) unified data access across disparate data stores and more.
Although GraphQL is a boon for API access, it does not encompass the complex domain of building modern internet-scale apps. We will make a case for async event-driven design for building modern apps. We will segue into using serverless as the infrastructure bedrock on which these apps stand. Being a natural extension of container runtimes, we will showcase the advantages of no-ops and free scale with unit economics of serverless.
Building applications for the modern web can be complicated, having to choose from so many different approaches out there. Everyone seems to be talking about using NgRx to solve all of their problems, but maybe I'm not ready for that. The idea of writing actions, reducers, effects, and selectors seems like too much work for me right now; there has to be some middle ground that I can start with!
Your presenter, Jesse Sanders, will be diving into an alternative approach to using NgRx for developing applications, while understanding concepts that can be applied later to such patterns. We will talk about how to design our components using a container and presenter pattern to help us maximize component reuse, while reducing complexity. We will also explore the service with a subject pattern that will allow us to reuse data between components. We will wrap it all up in our demo application that will show you how to bring it all together and apply this to your next project or refactor your existing one.
We’re entering a promising new era of computing. The advance of machine learning and artificial intelligence has revived interest in conversational interfaces. This creates the potential for conversation as the new mode of interaction with technology. As its biggest limitation, recognizing spoken input, has been more or less solved, a new challenge has arisen: how to build a user experience that is modeled after natural human conversation.
This talk outlines the basic mechanics of conversation, introduces core principles to design by, and presents you with a practical way to start creating bots that engage, delight, and truly help your users. Examples will be shown in in JavaScript, with DialogFlow and the WebSpeech API.
Building a huge web application is challenging enough in itself, but developing it in an enterprise environment adds more complexity and raises several concerns. Nowadays, we often build such applications with Angular. In the web development world, modularization and component based development are all the buzz now, and monolithic architectures have a bad reputation. However, a new approach is emerging for codebases worked on by multiple teams: the monorepo.
We will talk in detail about the evolution of our Angular monorepo project, from a single application to a collection of related applications used by different functions in the company, made with built in Angular tools. We’ll look into how different development teams could cooperate working on the same codebase, keeping the code quality, and without breaking the other team’s application. We explore how we managed code reviews and permissioning for each part of the application.
We will discuss the technical challenges we have faced as well: how the monorepo fits with the modularization principle, how we managed our CI process and kept build times at bay. Also, how we made certain parts of the app reusable to other teams without entering the monorepos themselves.
Cypress is a powerful E2E testing tool that allows developers to reliably test the functionality of their applications through the use of stubs and fixtures. This provides a powerful way to verify that an application will respond appropriately to the various situations as dictated by the business rules that have been implemented. Verifying functionality is critical, but what if we also want to verify that the way the application is displayed stays consistent? In the past, QA teams would be responsible for comparing the rendered interfaces between environments and manually deciding if the UI has changed too much to pass. Visual testing allows developers to capture base images for test scenarios and compare the current results against the base images.
In this talk, we will introduce you to visual testing, discuss the pros and cons, and show you how to successfully implement visual testing into your cypress tests using both free and paid tools. At the end of this talk, you will understand the benefits of visual testing and be ready to implement it into your next or current project.
For years, functional programming has been discussed in various mainstream environments again and again. Sometimes, new languages adopt functional principles. Or perhaps it re-enters the spotlight when there is a new focus on parallelization or comparisons of functional ideas with REST or MVC.
In this session, Oliver shows how functional programming has become an everyday approach for JavaScript with lots of practical examples. You'll take away some ideas for a more expressive, efficient, and compact programming style in any environment!
You know your Lookbehind Assertions, your fat arrows and asynchronous iteration. But if your code is assembling HTML to get delivered to a user's browser, how much do you know about HTML's semantics? Choosing the correct HTML element rather than vomiting a "div" or belching out a "span" can greatly enhance the end users' experience, with no fragile extra code to write and maintain.
One of the co-editors of the HTML5.3 spec will take you on a magical treasure hunt around HTML, showing you marvellous gifts and hidden wonders that will also help future-proof your code, and turn you into a time-travelling Frontend Superhero, adored by millions*.
(* actual number not guaranteed. But your users will be happy.)
This talk is all about data storage and data access. Although CQRS is quite a simple pattern to split responsibilities when working with data, incredibly complicated papers have been written about it! Event sourcing can be viewed as a natural extension of CQRS. However, in reality, a decision for or against it is independent and comes with its own consequences. In this session, Oliver uses practical examples to demonstrate implementation and combination of both patterns.
For sure, Progressive Web Apps (PWA) are one of the hottest topics on the web today. A PWA should feel like a real app, including the ability to show push notifications.
In this talk, Thinktecture’s Christian Liebel (@christianliebel), a member of the W3C Web Platform Working Group, will show you how to implement push messaging in your PWA or website using the Push API, including a look at helpful libraries and third-party services. As a part of Google’s Project Fugu, push notifications will get even better thanks to the advent of the Badging API.
Node.js is a very popular server-side framework that is slowly becoming the main platform for developing server-side applications. A lot of phrases are mentioned when developers talk about Node.js, such as 'Single process with event loop', 'Non blocking IO' , 'generational garbage collector', and more. But what do those phrases mean? Is Node.js really single threaded? How do the event loop and other internal mechanisms of the platform really work?
In this talk, I will give an overview on some of the platform internals. We will do a deep dive into the event loop, how it works, what its different phases are, and how it enables non-blocking IO. And, of course, we will answer the repeating question - is the event loop single threaded? We will also talk about the JIT compiler and the v8 engine. The session will end with a look at the garbage collector mechanism, the different algorithms that exists in each garbage collector phase, and how we can monitor our software to start detecting memory leaks.
Nuxt.js is an opinionated framework based on Vue.js that excels when it comes to running the same codebase both server-side and client-side. In this talk, we will focus on how it encourages convention over configuration and what kind of projects it suits best. Also, we will power up our code from a rather static (but very fast-loading) website to a full-blown SPA directly in the browser.
React has evolved from "yet another JavaScript Framework" to one of the biggest players in the JS ecosystem. It's not hard to see why it is a good fit for enterprise applications, thanks to its excellent track record with backwards compatibility and how it can be used concurrently with TypeScript.
In this introductory workshop, we will take a look at how to use both React and TypeScript and discuss some of the bigger pitfalls and challenges in bringing these two technologies together. We'll wrap up our day with a discussion on the future of the React ecosystem.
Angular, Google’s popular application framework for modern web-based solutions, offers developers component orientation, static type checking, and a breath-taking performance. By leveraging the single-page application architecture as well as modern web standards, it makes the creation of ambitious and enterprise-scale applications very easy.
This workshop showcases the possibilities of Angular and introduces it with an example application. We will go over the fundamental building blocks and discuss the kinds of architectural decisions developers will have to deal with when building maintainable enterprise applications.
Web Platform is amazing. It is becoming more and more performant, feature-rich while keeping its universal nature. We call “progressive” the web apps we build using the latest browser APIs, allowing us to achieve a totally new level of user experience. In this workshop, we’ll focus on what Angular, as a framework, contributes to the PWA concept.
Web development has changed dramatically in the past few years. Today, more than ever, when you build your front-end application, you will probably want to reuse components across your application. But HTML elements are very limited, so what can we do?
In this full day workshop, we will dive deeper into ways you can componentize your front-end. We will start by presenting the Web Components standard. Later on, we will delve into the Stencil compiler, which can help you build web components faster and with ease. At the end of the day, attendees will learn how to work with different data flow patterns to make components interact with each other.