Node.js / Node.js Interactive Europe 2016

Creating Native Addons - General Principles - Gabriel Schulhof, Intel Finland Oy

This talk is about creating node.js interfaces for native libraries written in C. It is not so much about the mechanics of writing the code, or about the structure of a npm package containing a native addon, but about the various situations you are likely to face when writing addons. It starts with the assumption that it is best to create an addon that provides as little abstraction as possible so as to allow you to provide a Javascript API to the consumers of your project that is itself written in Javascript. The portion of the node.js documentation that describes native addons, the V8 reference, and the reference provided by the Native Abstractions for Node project give you an ample toolset for creating native addons. Once you’ve managed to create your first native addon, and are ready to bring a complete native library into the node.js world, you will be faced with having to translate the artifacts of the C language into Javascript concepts. At that point, it pays to be systematic. It is beneficial to break the library’s API into constants, enums, structures, and functions, and bind each onto the node.js module you are creating in as automated a fashion as possible. In my presentation, I will describe some patterns for dealing with data structures, pointers, and callbacks one needs to pass to the native library. Finally, I will show some examples of projects where I’ve applied these concepts.

From Pterodactyls and Cactus to Artificial Intelligence - Ivan Seidel Gomes, Tenda Digital

"Among many things I love, what I really appreciate doing is the different, and learn with it.
Breaking barriers is complicated for any person. Knowledge barriers many times are formed by ourselves by incomplete parts of our mind’s puzzle. What If I could help you out with some piece of Artificial Intelligence, without ""puzzling"" your head?
This project consists of an A.I. coded in Node.JS that learns by itself to play the ""Google Chrome""’s Dino game (the one that pops up when there is no internet).
Using Neural Networks, and a Genetic Algorithm, I could manage to let the computer learn by itself how to play the game like a ninja. The project has been hosted in github (https://github.com/ivanseidel/IAMDinosaur) and it’s called IAMDinosaur.
There is also an video with English subtitles in Youtube, explaining it from the ground up how it work: https://www.youtube.com/watch?v=P7XHzqZjXQs

I was invited to speak at Brazil NodeConf 2016, and this is one of my speaker subjects (A.I. in Node.JS)

--
Also, another subject that I love working with NodeJS is Hardware. Interfacing things with Hardware is what I most like (be it through Internet, USB, Bluetooth...). One of my last projects used an ABB robot and could play Tic Tac Toe all programmed in NodeJS (Video: https://www.youtube.com/watch?v=V9dOoicowb0). Also, it’s open-source code: https://github.com/ivanseidel/ABBNator"

Instrumentation and Tracing in Node.js - Thomas Watson, Opbeat

This talk is a head first dive into the next-gen core tracing API’s being developed under the Node.js Tracing Working Group. We’ll learn about the upcoming AsyncWrap API and how this can be used to build your own high level instrumentation logic in production.

Node.js Community Benchmarking Efforts - Gareth Ellis, IBM

Benchmarks and the information they provide are important to ensure that changes going into Node.js don’t regress key attributes like startup speed, memory footprint and throughput. Come and hear about some of the fundamentals of benchmarking, how to go about narrowing down the cause of a regression between versions of node along with the efforts underway in the community benchmarking workgroup (https://github.com/nodejs/benchmarking) to run/capture/report and act on benchmark information.

People_as_computing_nodes.js - Juan Merelo, University of Granada

"Massive distributed computing does not have to be a complicated affair involving many administrators and complicated protocols: all you need is the browser. Setting up a distributed computing experiment needs just a bit of node.js on the server and JavaScript on the client.

However, that is when the complicated part starts. Can you predict the performance of that computing system? Since the computing nodes of such a computing systems include persons that decide how much they are going to stay in the web page and whether they are going to come back the next day, it might seem a priori an impossible hurdle to overcome.

However, usability, complex systems, and social studies can help us give a more or less precise ballpark on how to design the system to maximize the power of people as computing nodes.
In this talk we will present how we are using the node ecosystem to create and deploy a volunteer computing system and what we have found about its performance. Being totally open in our scientific method and results is a design decision that enhances security and also, in this case, performance"

Slaying Monoliths with Docker and Node.js, a Netflix Original - Yunong Xiao, Netflix.com

"At Netflix, our data access platform is at the heart of nearly every request from our subscribers. It enables our innovative UIs to communicate efficiently with our bevvy of backend services while growing our subscriber base to 75 million members. As a result of this scale, this monolithic platform requires ever increasing resources to run and maintain, both regarding hardware (32 vCPUs per instance) and developer productivity (try running that on your laptop!).

As we continue to grow and expand our subscriber base globally (#netflixeverywhere), we need fundamentally to change the monolithic design of our platform. In this talk, I will discuss the new container-based data access platform that’s replacing the monolith. See how the architecture of this cross-cutting project allows us to build isolated microservices with Node.js and Docker. Examine the tools and infrastructure we’re building across our stack that enable engineers to effortlessly build, debug, test and their code on this platform anywhere -- whether it’s locally on your laptop, or remotely in the cloud -- all made possible thanks to Node and Docker."

Take Data Validation Seriously - Paul Milham, WildWorks

Why is data validation important? What are effective ways to ensure data is valid? In this session we’ll explore how data validation is directly linked to security, stability and developer productivity when dealing with untrusted or unknown data sources. We’ll discuss the dangers of code that does not validate its data - everything from injection to DOS attacks. We’ll go hands on with joi (https://github.com/hapijs/joi) and Express (http://expressjs.com/) to see how data validation can make code easier to work with. No more "Uncaught ReferenceError" or if null checks littered around the code base. In the end, we’ll see how code can be secure, stable and magically awesome to work with.

Taking on Genetically Evolving Cellular Automata with JavaScript - Irina Shestak, Small Media Foundation

"Genetically evolving cellular automata -- that’s a mouthful. Let’s break it down

1. We will be looking at cellular automata. A cellular automata is a set of units governed with very simple rules. These units make up a complex system, or model.

2. We can train cellular automata to genetically evolve, making themselves better overtime. We can make them adhere to a set of rules that would make the system reach a certain outcome at the end of N generations. We can even use these concepts in the wild.

3. We will be doing it all with JavaScript."

What’s Up with the Community Post-Mortem Diagnostics Working Group - Yunong Xiao, Netflix.com & Michael Dawson, IBM

It’s important to be able to figure out what’s going on when things go wrong in your Node.js production application. Tools are needed to investigate memory leaks, crashes and other "interesting" events in production. The post-mortem community working group (https://github.com/nodejs/post-mortem) is working on these problems. Come and learn about the key issues being worked, and the progress of the working group so far as illustrated through examples and code.

Alt-Ctrl : Scream into this Arduino - Rachel White, Front End Engineer

"When you think about nodebots, the first thing that pops into your mind is probably cute little robots (as it should be)-- but did you know there’s a whole world out there of modules that can allow you to control items through various means of interaction? Accelerometers, capacitive touch, light, sound, and more! Learn about different modules that you may not have used before and see how easily they integrate with an Arduino through wiring diagrams and code examples. Experience live demos of how some of these work, try them out yourself through a little audience participation, and walk away with a new exciting perspective on fun ways you can get creative with your own node hardware projects.

I will walk through the various module type and inform people on how they function, as well as how they are wired up to the arduino and code that makes them work. There will be various demos that show some different sensor modules. Ex: copper touch sensors to control a video game, yelling to control brightness of LEDs. It is mostly an experiment to get people to think outside of the box of their usual limitations and to encourage more creative coding."

Ambitious Desktop Apps with JavaScript and Electron - Felix Rieseberg, Slack

You may have seen apps like Slack, Visual Studio Code, or Docker’s Kitematic - desktop applications written using Node.js and Chromium. Originally built for the editor Atom, Electron enables developers to build beautiful cross-platform apps, harnessing the power of a being a true Desktop app while using the JavaScript we all love.

This talk presents the lessons learned on the Electron Core, the app for the blogging platform Ghost, and Visual Studio Code. Built with ordinary JavaScript, Electron Apps are crazy powerful - and run on Windows, Mac OS X, and Linux. In particular, we’ll talk about how to integrate into the operating system, how to handle updates, and how to use all the native powers without creating insecure apps. Come and learn how you can use your favorite web frameworks and libraries together with NodeJS to build your next desktop app!

To note, when Felix submitted his presentation he was working at Microsoft. He now works at Slack.

Bitcoin, Blockchain and Node - Portia Burton, The Atlantic Magazine

Board Panel

Breaking Down the Monolith - Peter Marton, RisingStack

"The story of how we broke our Node.js monolith into 15+ services in just a couple of weeks. The talk will focus on what we have learnt during the journey and what technologies we use. This is the tale of how we did this rather than what microservices are in general.

Agenda:

1. monolith and microservices in nutshell
2. advantages of microservices from our view
- well focused service teams, happy customers
- fault tolerance
- distributed responsibility
- improving quality
3. disadvantages of microservices-based our experience
-growing complexity
-errors in transactions
-response time issue
4. how we did it
-service team principles
-co-operation between teams
-company architecture changes
-breaking down via proxy
-request signing
-circuit breaker
-event sourcing"

Building Scalable Web Applications Using Microservices Architecture and NodeJS inside AWS Lambda - Eugene Istrati, Mitoc Group Inc

Scalable applications are by nature resource intensive, expensive to build and difficult to manage. What if we can change this perception and help developers design full-stack applications that are low cost and low maintenance? This session describes the underlying architecture behind www.deep.mg, the microservices marketplace built by Mitoc Group using AngularJS, NodeJS and powered by abstracted services like AWS Lambda, Amazon CloudFront, Amazon DynamoDB, and so on. Eugene Istrati, Technology Partner at Mitoc Group, will dive deep into their approach to microservices architecture using serverless environments from AWS and demonstrate how anyone can use serverless computing to achieve high scalability, high availability, and high performance without huge efforts or expensive resources allocation.

Building the Node.JS Global Distribution Network - Guillermo Rauch, ZEIT

"At ZEIT we’re building the first global distribution network for Node.js applications, websites and microservices. Our mission is to democratize access to the cloud by ensuring that services are fast from and to everywhere, not just Silicon Valley.

We’ll discuss some of the unique technical challenges this endeavor presents in the context of distributed systems."

Closing Keynote - These keynotes will be State of the Unions and will include:

Alexandre Strzelewicz- Overview of PM2 V2
Cian Ó Maidín- nearForm Lightning Talk
Kat Marchán- npm CLI: Where It's At, Where It's Going
Doug Wilson- State of the Union: Express

Containers Panel - Cian O’Maiden, nearForm; Ross Kulinski, nodeSource; Yunong Xiao, Netflix.com Azat Mardan, Capital One Financial Corporation; Guillermo Rauch, ZEIT

Demystifying (JavaScript) Engines - Alejandro Oviedo, nearForm

"How a JavaScript engine works? What are its basic components? How to measure its performance? What is JIT compilation? Stigmatization: is JavaScript fast enough? are some of the questions I think we currently fail to answer in a, somewhat, short and direct way.

The most advanced JavaScript engines (V8, Chakra and SpiderMonkey) are now Open Source. I think that sets the bar pretty high for the upcoming generation of engines along with the runtimes that are using them - Node.js, JXCore, etc - and challenges developers to try to understand a whole new group of concepts hidden in the execution of their JavaScript applications.
Crankshaft, unoptimized hell, LLVM and asm.js sound like names of main characters or places of a George R. R. Martin’s novel. I’ll talk not only about their definitions but also about their cross-engine representation and status."

Diving Deep Into Browserify - Yoshua Wuyts

Browserify has been one of the staple tools for packaging javascript and shipping it to the browser. In this talk Yosh will explain browserify's internals, the current state of tooling and the path that's currently set for the future.

ECMAScript 6 is so 2015! Meet ES2016

Last year we read a lot about ES6, or ES2015. Some have started using it using Babel or other tools, and browsers have started implementing it. But what about the new stuff happening this year? What about ES2016 (and further)? And how can you keep up to date by understanding the spec and it’s different stages?

Elegantly Produce and Consume Compiled Packages (babel, coffee-script, etc) - Benjamin Lupton, Bevry

"JavaScript production use to be as easy as publishing your source code, which worked across all environments, with a few minor tweaks. Consumption was as easy as downloading and requiring the package.

These days, code may be run anywhere, in all sorts of browsers, desktops, and devices, with varying capabilities, not always known by the producer. JavaScript has evolved, incorporating new features that save developers time, although not supported accross all possible environments - with requires either abstinence of time saving features, or reducing environment support, or compiling on the producer or consumer side, all of which is complex and difficult.

Editions solves this problem elegantly in a standardised way. Producers produce their packages in their ideal configurations, then publish the package with multiple editions for the consumers to consume at their digression. Consumers are made aware of this through automated README updates, can select the exact edition that meets their exact needs - or by default, have the best edition for their environment loaded automatically. All the complexity of modern JavaScript publishing is solved, for the consumer and publisher."

Evolving Web Standards in Node.js- James Snell, IMB

The evolution of Node core standards for URL parsing, http/2, better Unicode support, and other facets

Join IBM and others in the community for a discussion on the development and promotion of diversity in the ever growing Node community!

FIPS Comes to Node.js - Michael Dawson, IBM

FIPS 140-2 is a cryptographic functionality standard that is often required when handling sensitive information, particularly in government and regulated industries. Support for FIPS was a community request that has been addressed thanks to numerous contributors. Come hear about the journey taken by the Node.js community to allow building and testing a FIPS capable runtime. The talk will cover FIPS requirements, and the specific enablement, test updates, and changes to dependencies that were required. We’ll include code samples and walkthroughs, and end with an overview of how to use FIPS capable Node.js through sample deployments in the cloud.

Get Hired: How to Grab the Attention of Employers - Alane Boyd, NodeGurus

"After spending hours and hours learning to code and perfect your Node.js skills, the most discouraging problem you can run into, is not getting hired. Overcome what may be holding you back by finding out what employers are really looking for and how to get hired. In the presentation you will learn:

1. The secrets to impressing employers immediately when submitting your application
2. What you are doing that is killing your $100,000 job opportunity
3. How to go from being the worst interviewee and best employee candidate to being the best at both
4. The top five things employers are looking for in a developer
5. Knowing how to keep a balance between developer and employer viewpoints
6. Why learning design fundamentals opens communication barriers that employers are looking for
7. Don’t screw yourself over by having your sister perform your hiring tests
8. Be Realistic. How to determine if your current skills meet job expectations
9. The first interview is only the first step
10. Do your research, don’t assume you you can walk into any interview and nail it."

How to Build a Reliable Checkout Experience - Pedro Teixeira, YLD

"The checkout experience is usually the one part of the application that delivers the most value, but unfortunately, it's the one that usually contains the most friction. We've all been victims of this: a checkout experience where the spinning wheel of death spins indefinitely, or one that warns you not to move a muscle while the next page is loading, or even one that makes a double reservation when you only wanted to make the one.

Now that you have your shiny new micro-services architecture running and you're able to deploy new features and fixes several times a day, how do you best deliver complex transactions to your customers? How do you deliver payments, trip reservations or purchasing an entire shopping cart with a good user experience?

HTTP has taken us far, but it's probably not the best transport to deliver complex transactions like these, especially when these transactions are performed over flaky mobile networks. A lot of error-handling logic must fall on the client: how does the client react to timeouts or gateway problems? Can it assume the transaction failed with no fear of duplication? Can the transaction survive client crashes? Can the client solve all these existing edge cases without making it overly complex and bug-prone?

This talk proposes an original architecture style that will sit in front of your micro-service stack and that you can attach to any existing service back-end. The author will show an implementation of this architecture pattern: a proof-of-concept application and a set of client and server open-source libraries built on top of PouchDB, and Node.js."

IoT Panel - Cate Lawerence, ReadWrite; Pawel Szymczykowski, Wedgies; Matteo Collina, nearForm

JavaScript Will Let Your Site Work Without JavaScript - Sarah Saltrick Meyer, Rent the Runway

What does your site look like without JavaScript turned off? Are your users waiting for all your JavaScript to be delivered and rendered before they see anything interesting on your pages? Is your site heavy and slow, especially on mobile devices? Isomorphic JavaScript with Node can help. No matter what server-side language you currently use, you can render your HTML with JavaScript on the server before sending it down to your client. We will discuss how to seamlessly build serverside-rendered content into stacks using popular frameworks like React and Ember and the performance, stability, and UX benefits that come with it.

Keeping the Node.js Community Infrastructure Humming - an Update From the Build Workgroup - Michael Dawson, IBM

"The build workgroup (https://github.com/nodejs/build/) has the
mission to provide Node.js Foundation projects with solid computing
infrastructure covering a wide range of platforms and different
software stacks. In this talk we will introduce the
general philosophy of how infrastructure is sourced, which has
a strong focus on community donations, the
overall picture of the substantial infrastructure we’ve manged
to build using this approach, some of the interesting
interactions and, just as important, how you might get involved.
Come learn about the infrastructure that powers
the delivery of Node.js !"

Life API: Personal Tracking with JavaScript - Jane Kim

Morning Keynote- Everything You Need to Know About Node.js Event Loop - Bert Belder, IBM

If you're a Node.js programmer, you probably know that node has an event loop, just like a web browser. But there are many misconceptions about how it really works. Does Node use threads, or not? Where do callbacks come from? Is it better to use nextTick or setImmediate? Node's event loop is built on libuv, and libuv's author is here to tell you all a Node developer needs to know about the event loop.

Morning Keynote- Node Foundation - Opening Remarks - Mikeal Rogers

Morning Keynote- Node Together - Ashley Williams

Morning Keynote- Node.js Core State of the Union - James Snell, IBM

Morning Keynote- The Road Forward - Tracy Hinds

"In OSS and the Node.js project, we ask of total strangers to collaborate on a project that we all benefit from. In order for them to feel welcomed and stick around, they should feel like they belong.

To create that sense of welcome, barriers to access and biases must be surfaced. People must feel safe enough to contribute. An inclusive, open-source community will result in better code from a more diverse range of developers. We are making up for a lot of lost time due to systemic failures and biases.​ In order to actualize this change, ​​it should be reflected in representation at every level of leadership in Node.js. We lead by example. This means finding champions within the ​B​oard, within leadership of the working groups, and with role model developers in the community.​ ​We'd like to talk about how every person in the community can contribute to this, feel a sense of ownership in the community, and see a road forward."

Node in Europe

Node.JS and Containers Go Together Like Peanut Butter and Jelly - Ross Kukulinski, NodeSource

"A recent Node.js Foundation survey found that 45% of developers surveyed use Node.js with containers. As companies look to build out their microservice architectures, Node.js is emerging as a major component for powering Internet-scale computing.
Additionally, JavaScript, including Node.js and frameworks such as React, are becoming the de facto choice for IoT developers working in connected, device-driven environments, according to the recent survey.

However, these environments are challenging, for even for the most experienced developers out there. In this presentation, Ross Kukulinski, a NodeJS Evangelist and container enthusiast, will discuss why Node.js has become a popular choice in microservices-oriented, containerized dynamic environments. He will discuss how to get started with Node.js, Docker and Kubernetes and what pitfalls often occur when starting and how to avoid them."

Node.js and Microsoft: A Love Story About Developer Tools - Sara Itani, Microsoft

Node.js + Microsoft?! Yep, you heard us right. In this session, you’ll learn why Node.js is so exciting, why Microsoft cares, and – more importantly – what’s in it for you. Additionally, we’ll touch on many of Microsoft’s Node.js offerings and contributions, paying special attention to some of the exciting new developments in both Visual Studio and Visual Studio Code, as well as glimpse into the future with Node Chakra’s time-travel debugging.

NodeSchool: A Chapter in the Making - Lydia Kats, craigslist

To date, there are 167 chapters of NodeSchool all over the globe. The basic framework and resources for running a chapter are a URL away, for anyone to use. All it takes to run your own chapter is effort, commitment, and dedication to cultivating a community of students and mentors centered around learning. And yet, NodeSchool as a global organization has potential to grow to support even more beginners worldwide. A co-organizer of the San Francisco chapter NodeSchool shares lessons learned and her perspective on the future of NodeSchool.

Panel: Best Practices for Contributing to Node.js Core - James Snell, IBM

A panel of current Node.js core collaborators will discuss the Ins and Outs of contributing to Node.js core, covering best practices, recommendations, tips and tricks.

Programming for the NES with JS

The NES (Nintendo Entertainment System) still is the favourite retro console in the hearts of many of us. What if I told you that you can write software and games for it using Javascript? (live demo included)

Radical Modularity - Aria Stewart, npm, Inc.

SWIMming in the Microservices Ocean - Luca Maraschi, nearForm

This talk aims to speak about the theoretical and practical migration from thinking in services to think in distributed execution blocks. The audience is going to get an introduction on the common problems of scaling HTTP REST based micro-services and how cooperative RPC functions can facilitate our lives. Designing and deployment are going to be the main focus, with a final focus on how to operate such an architecture at scale (from development, to people and finally to production). When software and hardware can scale performances at unimaginable boundaries, people and operations are forced to follow and that’s where most of the time all of these becomes complex and unmaintainable…but we have a solution for that.

Text Mining with Node.js - Philipp Burckhardt, Carnegie Mellon University

Today, more data is accumulated than ever before. It has been estimated that over 80% of data collected by businesses is unstructured, mostly in the form of free text. The statistical community has developed many tools for analyzing textual data, both in the areas of exploratory data analysis (e.g. clustering methods) and predictive analytics. In this talk, Philipp Burckhardt will discuss tools and libraries that you can use today to perform text mining with Node.js. Creative strategies to overcome the limitations of the V8 engine in the areas of high-performance and memory-intensive computing will be discussed. You will be introduced to how you can use Node.js streams to analyze text in real-time, how to leverage native add-ons for performance-intensive code and how to build command-line interfaces to process text directly from the terminal.

The CITGM Diaries - Myles Borins, IBM

"During October of 2015 I was given the task of working on The Canary in the Gold Mine, a smoke testing utility that automates running unit tests of various various modules in the node.js ecosystem. CITGM has been incredibly successful, finding all sorts of regressions across the ecosystem and in node core itself.

I have kept a diary of all the weirdness, lets examine how things break!"

The Cost of Logging - Matteo Collina, nearForm

Sunday morning and your phone rings: production is down. After two hours, you manage to solve it: you could have fixed it in one minute if you had the right information from the start. First thing in the morning, you add logging everywhere, to avoid this issue and be able to triage and solve problems easily. Then, your application requires twice as much servers to run. This talk is for you: I will introduce you to Pino. It logs in JSON, and it’s up to 17 times faster than traditional loggers, and it comes with nice Express and Hapi integrations.

Where Did My Servers Go?- Trevor Bodz, IBM

Does provisioning and maintaining servers bore you? Have you ever wished that you spent more time writing application code? Find out how others have ditched their servers with this introduction to Serverless. Trevor Bodz introduces the concepts behind serverless, debunks some of the hype and more importantly explains how it is different from the past. We’ll cover best practices and the lessons learned from building serverless Node.js applications. Apply these concepts to quickly build, assemble and scale your applications through reusable components leveraging the power of Node.js and the opensource serverless platform OpenWhisk.

Why Did the Robot Cross the Road? Computer Vision, Robots and Mobile Games - Pawel Szymczykowski, Wedgies

"The popularity of mobile gaming and in-app purchases has changed the way games are played. Once upon a time, the only limit to how far you could progress was your skill level and persistence. Now, games seem to be designed to hinder us until we have either shelled out real currency for a lot of virtual gems, or watched a lot of advertisements. That’s not fun, that’s tedious!

Robots are good at tasks that require precision and speed, but they are also great at tasks that are tedious and require an infinite amount of patience. What if we programmed a robot to do the crap parts of mobile games for us? Then we can enjoy the fun parts and / or collect all of the things as we of the Pokémon generation have been programmed to do.

In this talk we’ll learn how to use an open source robot called Tapsterbot, a webcam, and Node.js OpenCV bindings to teach your computer to play your favorite mobile games for you (or just watch the ads) so that you can do more important things!"