This collection of domain events is then used as the write model in the CQRS model. These same events are then launched into a secondary database to build the read model for the application. During this session, Maurice de Beijer explains why you might want to use Event-Sourcing. He further explains how to get started with this design in your React and Flux applications.

Peter will share how to use Bluetooth to start controlling the real world around us. You'll have a programmable drone at your disposal in no time!

This talk will introduce an architecture that uses streaming as its main means of communication. It will explore three frontiers of streaming: how to stream from module to module in the back end, sending a stream response from the server to the client, and receiving/processing a stream response on the client. By the end, you will learn the basics of UNIX streams, how to use them with Node.js scripts, and how to write web applications that profit from all the benefits of streams.

This talk demonstrates how the advanced features of Chrome’s JavaScript debugger can be used to find, understand, and fix code more effectively.

In this talk you'll discover that with JSON Schema, and a good validator library, you can do so much more. Automatic form generation, recursive data transformation, data generation and basically any other operations you would like to do over a deeply nested data structure. You can even do business process automation with schemas.

In the talk Jason will kick off with an introduction into some of the concepts involved before exploring 2-3 unexpected but useful examples of JSON Schema use.

Complex React applications require deep thinking about State, Stying, Asynchronous Communication, and application structure. Not only that but developer tooling and using sensible modern workflows (like SASS, Browserfiy, ES6/Babel, Promises, etc) can create a codebase that is not only easy to reason about - but a pleasure to maintain.

The team learned a lot doing this, and Gregory wants to share that with you.

These are all questions we faced while building a new mobile e-commerce experience for a global audience. With each sprint came new decisions to be made, new learnings about what approaches work, and new discoveries about which libraries wreck havoc with everything in their path. Wading through the gotchas and facing an immovable deadline, we answered the question - will Redux scale?

Join us for session exploring the ins and outs of Redux at scale, and discover how you could implement it in your own next project.

Let Shaun introduce you to WebVR. Yes. VR on the Web, in your browser and it works right now. Its early days yet but specs are being written and things are being built with it - not only is it awesome to experience its super fun to build with and experiment new ideas with and has a very low barrier to entry. You need a decent smartphone with a browser, a cardboard VR headset and a little bit of Code and you're rolling.

A superb way to create super responsive and fast applications that are a delight to use and develop. Using one language (to rule them all), JavaScript, for both the front and back end, in this session you will see how you can:

• Build modern web applications that feel like desktop apps not a bunch of lose pages strung together

• Make a great experience for both the browser and mobile

• Learn how Meteor applications are super fast and see live data updates (puppies and unicorns!)

• Use one language both in the back end and the front end

• Deploy your applications to mobile and web instantly (ok, in a few seconds at least!)

PLEASE NOTE - You should have some knowledge in building web dynamic applications, whether it is just one form or a fully dynamic web application.

Polymer project was introduced with one thing in mind - making reusable components that just work out of the box without too much hassle. And that they work the same way irrespective of where they are. It tackles this problem by allowing you to create complex UI widgets which are extensible as well. This revolution is powered by a new set of standards being pioneered by Google called “Web Components”.

This session will guide you through the pain areas in front-end web development and introduce everyone to the world of Polymer. You’ll take a quick look at how to create and use custom/pre-built web components, the mystery of shadow DOM and all the hoopla surrounding Polymer.

You will also discover how they scale their systems using AWS, using React to deliver fast documents and websockets to simultaneously push to all connected clients.

A prior knowledge of Angular is required to attend this talk.

here are several factors that exist both in theory and practice that make efficient load balancing an exceptionally hard problem. For instance:

• Poisson request arrival times;

• Exponentially distributed response latency;

• Oscillations when sharing data between multiple load balancers .

You will explore techniques and algorithms such as Randomized Least-conns, Join-Idle-Queue, and Load Interpretation. Load balancing perfectly may be impossible in the real world, but you can do better than “random,” “round-robin,” and naive “least-conns”.

You will walk away with an understanding of why traditional load balancing techniques are sub-optimal, practical techniques for improving it, as well as longer term theoretical approaches. You will also learn what makes load balancing such a difficult problem and why it's impossible to solve precisely.

As internet-connected versions of devices like thermostats, syringe pumps, and centrifuges become commercially successful, you’re finding that little thought has gone into securing the data collected or controlled by them. When considering everyday objects like refrigerators and toasters, the risk is arguably limited. But consider the ramifications when products that bear the keys to our life & livelihood, devices like cars and pacemakers, are compromised. How “smart” are these devices if they are more often than not susceptible to potentially lethal attacks?

In this talk you will explore:

1. Recent, successful IoT attacks

2. A first-hand account working with an early-stage company to identify potentially dangerous vulnerabilities

3. How to take a proactive approach to security: what you can do moving forward to keep yourself safe from “smart” devices?

In this talk you will explore web security issues and how to fix them when using Node.js. Some of these issues are among the OWASP Top 10 and pose serious risk for web applications.

Mark is exploring the construction of distributed systems in Node.js with a set of reliable, non-prescriptive building blocks. The goal is to make it easier to build systems that fit your needs without having to maintain separate infrastructure.

As a first step Mark is writing Buoyant, a framework for implementing servers using the Raft Consensus Algorithm. It's designed to be a reliable Raft implementation without requiring a particular network protocol or storage mechanism.

You will discover why Raft is important and, and Mark will offer a basic explanation of how it works. You will also learn how Buoyant orchestrates its actions to avoid interleaving (this, though counter-intuitive, is necessary as Raft assumes synchronous behavior). Finally Mark will cover how fuzz testing is used to increase confidence in the implementation.

So how do you build websites and applications with the future in mind?

Ashley will share with you his insights on how he’s addressed these issues during the redevelopment of the JUST EAT International Platform. He’ll relive the tears he shed when being faced with a monolithic legacy codebase, what the team has changed to make its development process far easier to work with and how these principles can be applied to websites or applications of any scale.

If you've never animated on the web before, then this talk will put you on the right track.

If you've already animated using CSS3, you'll definitely want to attend to master your animation skills.

Zipnish is a new open source project developed to overcome this difficulties. It is built using Varnish Cache and it is used to track performance and help resolve latency issues in microservices architecture. The tool gives you insights on the status of each microservice component regardless of development and deployment architecture.

During the talk you will learn:

• How Zipnish works and what components it consists of;

• How Zipnish will help you solve performance issues in your microservices architecture;

• How Zipnish works as a performance monitor;

• How you can implement the tool .

Find out more on Zipnish on Github.

In this talk Kirsten will cover the example in 5 different languages (Perl, Ruby, PHP, Python, Node) and show how to map the exact same functionality to different languages.

The code can be found on Github at http://www.github.com/synedra/polyglot.

For the upcoming version (2.4) the physics engine was completely rewritten, to allow an easy integration of other physics engines.

Raanan will discuss how he used TypeScript to implement the new physics engine and its new plugins architecture. He will show how he selected the functionality to be implemented and how to keep power-users satisfied with low-level access to the external engine.

The main code can be found here, and the official announcement here.

However, initially, Angular had some interesting design flaws, especially in minding-its-own business department. It wanted to be everywhere, meddle with everything. It wasn't easy at all to separate your own business logic from Angular code.

In this talk you'll explore how Angular has grown and changed over the years: how in the beginning it was trying to take over your own show, and eventually became what it's supposed to be from the very beginning - superheroic assistant, always ready to support your webapp when needed.

Defining a JSON Schema for your data enables a number of interesting use-cases. In a client-server scenario, e.g. a RESTful API, the content of the requests and replies can be exactly defined (also see OpenAPI/Swagger). In addition you can easily validate JSON against its JSON Schema to provide users with feedback for their input on the client side or to check data validity on the server side - based on the same definition. The metadata provided by the JSON Schema is also an enabler for many other runtime use-cases such as serialization, form-based UIs or data interchange. At build-time it can be used as a basis for code generation to automatically derive a data API, e.g. in Typescript, or to enable property-based testing.

Of course where there is light there is also shadow, e.g. you are required to define your data and the available tooling to do so is not really great (yet). In this presentation we will provide you with criteria to judge whether JSON Schema could be beneficial for your project or is just too much overhead.

Find out more on JSON schema here.

Code and robots are nothing without people, so we must take better care of ourselves and our community.

In this talk, Kassandra will walk you through her own very personal journey, talk about the impact that these three categories have on each other, and discuss ways we can all work together to create a better tech community for us all.

For Claire, this is an opportunity to show others that there is more to just writing code. She will share her views on what Claire sees contributes to being a good developer - inspired by her experience, things she's learnt and the books and resources she's come across.

It can be achieved in three ways:

1. Sending multiple requests to the server and implementing all the processing logic in the client. The advantage of this approach is that the server remains unchanged and the client can easily change the logic and flow of requests. The disadvantage is the latency and the traffic - each request should travel via the network.

2. Implementing additional methods/endpoints/parameters in the server. The advantage of this approach is that the client has to make only one request. The disadvantage is that it requires changing the server (= coding + testing + documenting + deploying + monitoring + supporting...). When it is possible, it inevitably leads to the growing complexity of the remote system as more and more specialised methods/APIs are added to it.

3. Implement batch endpoints, e.g. using JSON RPC standard. While they allows to execute multiple calls in a single HTTP request, it doesn’t allow to implement any logic between the calls.

JSONScript is a simple tool that allows to create “a batch endpoint on steroids” - server-side scripted execution of existing endpoints and services.

It is currently implemented in express middleware that allows to add JSONScript batch endpoint in a single line of code.

Follow up detail:

Motivation:

Why did we choose React over Angular and Meteor? How does React allow us to create a reusable app architecture?

What problem are we trying to solve?

The current project involves transforming the way that the client and their suppliers manage the supply of parts and the supplier relationship. This has historically been a manual process of phone calls, spreadsheets and hand-written notes, which has led to waste and delayed product launches.

Approach:

Early prototyping and proof of concepts to cover a lot of issues around offline storage and syncing of data. Working closely with product owners and iterating of the product.

But what if you could have all the advantages of a BaaS… on your own server? Something like a ready-to-use backend you could install withone (yes one) Docker command and extend with your own business logic. Something built on cutting-edge technologies, like Node.js. And oh, it would be open-source so you’d be able to contribute if something doesn’t fit your needs. Does it sound too good to be true? No. Meet Kuzzle.io - the backend your projects were looking for.

If you already feel confident using git, Mike will spend the second half of the talk covering some tips and tricks for optimising your workflow, and hopefully all of you can end the talk with your tools a little sharper than they were at the beginning!

Angular 2 introduces some major improvements over its predecessor. We are going to cover the main areas so you can start creating your own projects and enjoy its benefits Today. In this workshop you are going to build a basic application while looking into different Angular 2 features like: bootstrapping, components, services, new template syntax and component routing.

UPDATE

Hi everyone!

Hope you are as excited as I am about Angular 2. As an Angular GDE (Google Developer Expert), I have been following the Angular Team and their progress has been amazing to reach current RC4.

Angular 2 introduces some major improvements over its predecessor. We are going to cover the main areas so you can start creating your own projects and enjoy its benefits Today.

Do check out this Keynote from Brad Green about future plans for Angular 2 in preparation for this workshop.

Instructions

We are going to use a seed project to do the workshop: angular2-webpack-starter by @AngularClass. A top of the shelf Angular 2 starter kit. This is a solid base that will stand time so we can focus on learning Angular 2.

The final solution will be provided during the workshop. Angular 2 is very exciting but can be frustrating sometimes. Don’t forget to have fun! =)

Setting up Angular 2

Follow the instructions on the following link to get the basic environment working in your laptop before the session - quick-start. If you find any bug or need support please report it here.

Social Media

I would love to hear about you, hear your feedback and maybe even connect before or after the workshop. You can get a feeling of what I do at @gerardsans or @angular_zone on Twitter.

Looking forward to meet you!

Gerard

In this workshop, Athan Reines will first provide an overview of numeric computation in JavaScript, libraries currently available, and what makes these libraries competitive with and even superior to alternatives on other platforms. Next, he will guide attendees through a series of brief exercises to demonstrate use cases ranging from analytics to machine learning to exploratory data analysis and visualization. He will then show how to leverage Node and JavaScript to build feature rich numeric compute applications both at the command-line and in the browser. Finally, he will outline future steps and identify opportunities for community development of next-generation tools.

IMPORTANT - You will need your laptop and an LTS version of Node 4.x already installed.

Be ready to work in a team as spare parts might not be enough.

IMPORTANT - Bring your own laptop if you're planning to attend this session (with a USB Type A extension lead).

Be ready to work in a team as spare parts might not be enough.

Unity 3D is a free to use game engine with full VR integration.

PLEASE NOTE - A google Cardboard and a compatible Android or IOS device is recommended.

You will go through how to navigate the Unity Editor, how VR works and what's the logic to make VR works.

By the end of the workshop, you will have an Google Cardboard app that's running on your mobile phones.

Download Unity 3D and install the Android or IOS support from here.

Download Google Cardboard SDK for Unity.

This talk is about how to create scalable applications using serverless architecture with AWS Lambda, API Gateway, and other services based on your experience building a large serverless platform.

Having attended this talk you will walk away with an understanding of:

• How serverless differs from traditional architectures, its major benefits and disadvantages. How Peter built a serverless system that supports tens of thousands of concurrent users, the challenges they faced and how they solved them.

• JavaScript patterns and practices for creating Lambda functions.

• Best practice for using a front-end SPA framework with serverless architecture.

Buy Serverless Architectures on AWS (Peter Sbarski with Sam Kroonenburg) at manning.com and quote sbarskiFSL to get a 39% off! Only for FullStack attendees!

The same kind of native APIs you already have now for creating applications with components in a declarative way. This is Web Components technology and Google Polymer framework on top of them which requires less hassle to set up and code to run because based on APIs which are already there in a browser platform. The feature Polymer lacked before is a bridge to native components similar to React Native. Denis and the team at Liberty Global / UPC fixed this and want to show how Polymer Native works.

It would be much simpler if all of these devices used Web standards. In this talk Stephen will demonstrate how you can use the Web to interact with IoT appliances using the EVRYTHNG platform, HTTP and REST.

• this enables users without JS enabled to use your application, hence increasing your audience;

• it also solves the common SPA problem of search engine crawlers being unable to fully read the site;

• by building the site this way round, you can build for non-JS clients and then layer JS support on, meaning we can give users with JS an incredibly snappy site without compromising.

Jack will share with you a briefly overview of the reasons why you’re able to do this, and how the trend of ReactJS’s abstractions have lead the way here. By removing data binding and unifying the flow of data, it removes the complexity that is impossible to replicate on the server. You'll also learn about some side benefits of this approach, including much easier testing. ReactJS is used here as the example, but EmberJS is also taking this approach and Jack expects other frameworks too in the future.

You will then explore how to build these applications, using React as the example and using Webpack as the build tool. Jack will demonstrate how to configure Webpack to generate client side bundles for your application whilst running React on the server through NodeJS. You'll discover the development workflow and some additional 3rd party tools that make building these apps as straight forward as they can be.

You will discover what instrumentation is most scalable and effective across languages this includes the commonly used APIs and possibilities to capture data from common languages like Java, .NET and PHP, but you'll also learn about methods which work with Python, Node.js, and golang. Jonah will discuss browser and mobile instrumentation techniques. How these are done? Which APIs are being used? What open source tools and frameworks can be leveraged? Most importantly how to coordinate and communicate requirements across your organization.

You will walk away with a clear understanding of:

• What is instrumentation, and what do you instrument, collect, and store?

• The understanding of overhead and how this can be accomplished on common software stacks?

• How to work with application owners to collect business data.

• How correlation works in custom open source or packaged monitoring tools.

The costs and the benefits of mocking the entire API. The three possible architectural approaches in doing so. Mock engine examples in Angular.js and sinon.js. Simulating business logic in mocks using plain JavaScript and JSONs. Using JSON Schema to generate massive amounts of mock data on the fly. The technical and business aspects of separating frontend and backend - these are the topics Tomasz will cover.

Mock your API and make your frontend truly independent!

Demonstrated uses:

• Git-backed Wiki

• Family Tree

• Complicated Data tree

In this talk, you will learn about an approach to documentation writing based on adding comments directly to the source code. Marcos will show you its benefits applied to three different types of codebases.

You will also learn how to generate documentation from those same comments in two different flavors as well as when each of them work best.

You will discover about the Angular Team's learnings and explain the details of their new template compiler that drove most of these improvements.

Of course, that was a long time ago, and nobody really believes the stories any more. Some say the webmasters are gone. Some say they never existed in the first place - it was just a bunch of marketing people with delusions of grandeur. But a few, a select few, believe they changed. They evolved. They learned new skills, they embraced new technology... and the Legend of the Full Stack Developer was born.

The history of software development is rich with tales of extraordinary individuals, whose knowledge of their own systems was absolutely unrivalled. But here in 2016, in a world where distributed systems, machine learning and autoscaling cloud systems are ubiquitous and the average web app uses three JavaScript frameworks, four server-side languages and six different kinds of caching technology, does it really make any sense to talk about full stack developers? Are we clinging to outdated paradigms, nostalgic for the simple days when one person really could know all the answers - or does overspecialisation represent a genuine threat to the established discipline of software development? And if it does - should we be resisting it, or embracing it as a change that's long overdue?

This August, it will be 25 years since Tim Berners-Lee created the first web page - and 24 years since Dylan created HIS first web page. In this talk, Dylan will reflect on the history of the World Wide Web, exploring what we've learned - and forgotten - along the way. He'll share lessons learned over a quarter century of building sites, writing code, designing systems, hiring developers, managing teams and delivering working software, and take a speculative look at the next 25 years of the web, and how it's going to keep on changing the world.

This talk aims at introducing functional programming in JavaScript with real life examples whose logic is "simple" to visualise. You will use functions as logic steps and apply them to 'filters', 'map' and 'reduce'. You will discover how to use Typescript to help with the visualisation of arguments and return types. All typescript examples will be simple to understand and a very short introduction will be provided to provide context if you are not familiar with the concepts.

By the end of the session you should be able to start coding functionally and finally be on the path to avoid callback and promise hell.

Practical applications of functional programming on display will include an Elm app interfacing with D3 graphics, and IoT gadgets with interactive mini-games.

Jon's perspective is that of a mostly imperative languages programmer venturing into functional programming, keen to share with you the ideas and concepts he's learnt and also to learn himself from your feedback on his code.

The talk relates to two Haskell solutions that Jon wrote to solve a puzzle encountered in a computer game. The first solution does not scale, while the second does and the aim is to generate some audience response on the difference. Jon uses a browser front-end coded in Elm to make the talk more interactive, and for a demo of time-travel debugging.

The talk will mention the difference between lazy evaluation in Haskell and strict or eager evaluation in Elm. Jon may say something on Javascript generators, and tail-call optimisation (both relating to ES6). Jon finishes by showing the Haskell solutions rewritten into C# and JavaScript.

In this talk Alex will present the real-world experience they had at MediaSmart building their own DevOps tools using Node.js, and then adopting emerging packages like StriderCD or ShipIt. Along the way they have orchestrated tens of servers, built their own traffic balancer to handle 300+ thousand requests per second, monitored their systems at several levels, built several continuous deployment systems, and automated all of their Amazon AWS infrastructure.

You will also explore the limits of Node.js and JavaScript, and where the MediaSmart team has had to resort to different languages and platforms.