London's Node.js User Group

Quick fire community announcements, items of interest and community projects covering: Adobe Firefly, Serverless Frameworks Plug Ins And an anti-social app!

Could you access the Prisma client on the frontend - without revealing any environment variables? This talk goes into my experimentation with Object proxies and websockets, allowing a developer to access server-side objects on the client, with type-safety. I'll walk through how the proxying works, the type-safety features, and everything else which makes the library works. https://rocketrpc.com

Fastify's remarkable features include native TypeScript support, providing enhanced type safety and productivity during development. By leveraging TypeScript, developers can ensure type correctness in request and response bodies, query string parameters, and even custom HTTP headers. This type safety extends to runtime as well, thanks to Fastify's built-in JSON schema validation, which guarantees the validity of incoming data, enhancing security and stability.

Through insightful case studies and examples, explore the key elements that make an SDK exceptional, from intuitiveness and easy documentation discovery to adaptability and tailored experiences. Gain practical tips and best practices for designing SDKs that are easy to use, maintain, and extend.

Node.js is one of the key runtimes to develop applications on AWS Lambda. It was announced 13 years ago and is now considered to be [boring technology](https://mcfunley.com/choose-boring-technology) by many. But over the past few years, a few newer JavaScript runtimes have emerged, to solve some of the issues with Node.js.

Building an API typically starts with designing the API interface, integrating a database library, wiring up CRUD endpoints, adding request validation, documenting the API — the list goes on! It’s a lot of repetitive and time consuming work. I’ll show you how Platformatic DB enables you to you rapidly develop REST and GraphQL APIs with Node.js, helping you skip all of that painful groundwork. We’ll also explore how the Fastify framework it’s built on top of allows you to add custom functionality with familiar tools.

Aris Markogiannakis On those critical times, I took the chance to learn something new and tried to PRISMA 2, to create a small website, that shows where there are supplies [Bread, Pasta and ToiletRolls]. I will go through all the difficulties of developing the app as Prisma2 is still in development, and how to deploy the app in Heroku. For the frontend I used NextJS that connects to a nodejs API (very simple) that uses the Prisma client. Aris is a developer for a number of years in FullStack development and a servant of the London's community powering CityJS and JSMonthly.

A look at the mechanisms inside web bundlers e.g Webpack. Starting with why they are still useful. Then how to build a small compiler, akin to Webpack. There are many interesting topics in a very small space here. Next how to use the output of our compiler with an application. Finishing with all the additional parts Webpack does which ours doesn't, hopefully with some idea on how those could be done. About me I'm a senior developer at Nested with over 10 years experience. We do dev team talks every week and I have taken a couple, usually on the "under-the-hood of" theme. I was previously at the BBC. I enjoy blogging at https://craigtaub.dev

Node.js provides the developer a system with single threaded event loop architecture, that provides non blocking I/O mechanism. This work great until we get to CPU intensive tasks. In this case, Node doesn’t perform up to mark. This has changed with the release of the worker threads in latest Node versions. We can use threads and write CPU intensive code in Node. This can make Node popular in many other fields of software development, starting from algorithms , AI , complicated computations and more. In this talk I will go over the concept, API and architecture of worker threads. I will show a demo of a Node server that implements CPU intensive task , to assist you to retain a cool new ability to you Node.js coding skills I am a software manager and architect. In the past, I managed large development teams, and was a CTO of a start up of my own. I have a decade of software engineering experience in various technologies: Server side, big data, mobile, web technologies, and security. I am currently focusing on Node.js, and have a deep knowledge of Node.js server architecture and Node.js performance optimizations. @SternTwena on twitter

Node.js has been around for a long time now, and it’s worth looking at what went great, what went well, what didn’t go so well, and where we’ll go from here. Having been a core contributor for a long time now, I’ll reflect on the processes around Node.js and the results we’re getting out of them, and try to have an honest conversation on where the community stands and how fresh new projects like deno will change the landscape of JS outside of the browser. Over the last 4 years, Anna has been one of the most active contributors to Node.js core. She is fueled by a passion for Node.js and its community. @addaleax on twitter, working at NearForm

[Editor's note: apologies, we lost the last couple minutes of the talk - but the best bits are here :)] DevOps is a necessity nowadays. It is not a job title itself but a set of practices, many of them spanning across development. It is extremely important that the applications that we write are adapted to run in a DevOps environment: Monitoring Process management Log aggregation Are only few of the aspects to be considered when building a Node application in order to succeed on DevOps environments, specially containers and Kubernetes. David Gonzalez is a DevOps Architect at NearForm, building systems at scale for our customers. He is also a Google Developer Expert on Kubernetes and avid coder. Author of three books around microservices and DevOps, he is always challenging the comfort zone of his day to day work finding new ways of delivering highly transactional systems. Twitter: @dagonzago LinkedIn GitHub: @dgonzalez

Auth0 is a leading world class authentification platform. And I'd like to present it using Node and Serverless. Regular methods of authentication include setting up a custom authentification API, user, session and token management. Which is time consuming, not productive and plainly put, not very secure if a solution doesn't aspire to RFC specifications. In my talk I will present to the audience; Auth0 as a solution, Netlify serverless functions, a Node API implementation of passwordless authentication, and basic API endpoint protection using JWT. I'm Bernard, I'm working for myself. An e-commerce startup. @bernibear2000.

Almost all tech startups send out a bunch of emails to their users. Many of those will be based on certain triggers, like creating accounts, new posts, invoice creation, etc. Based on my experience building some companies and apps that rely heavily on transactional emails, I'd like to talk about how to manage and structure those. Building and managing templates with involvement of stakeholders (marketing/partnerships team, designers, etc.) My solution: Macaw (repo | blog) - a Node.js toolset to streamline email sending and template management Setting up an email sending flow in your serverless app (optional - depending on time) Ensuring your emails arrive: your own IP address, SPF and DKIM, reply-to, etc. Bio Starting my first tech company at age 16, I've co-founded several startups that focus on improving communication and helping small businesses, including NearSt, which partners with Google to help local shops make their products searchable and Infowijs, which helps Dutch high schools communicate better with their students, parents and teachers. I'm on Twitter as @tschoffelen.

In this talk we'll go over why these two technologies (Graphql & Serverless) have drastically gained popularity and what problems they were made to solve. Then we'll go through how the two can be used together and I'll do a little demo with the Serverless framework I've been a professional developer for about 3 years. In that time I've worked for small startups to large corporations. List includes Ruuby, Sky and Eurostar to name a few. Twitter handle is @shadrech17

There is a lot of noise about the Coronavirus for a few latest weeks. I've created a simple Alexa Skill which provides users with the latest update about the figures. Here it is https://www.amazon.co.uk/Artsiom-Mezin-Coronavirus-News/dp/B084M81B6Q However, it feels like there are tons of stuff that could be improved. I'd like to talk about the following things: How to design and implement an Alexa app for less than one weekend? What to expect from validation and rolling out processes? Where to get and how to store the data? How to automate the routine? How this sort of app can help people? What else could be done? I am eager to collaborate! Given the fact that I'm doing this in a little rush, it feels more like a lightning talk.

QEWD-JSdb is a new concept for databases in Node.js. Although it's implemented on top of two incredibly fast, industrial-strength (though little-known) physical database technologies (the Open Source YottaDB and the proprietary IRIS databases), QEWD-JSdb abstracts their underlying hierarchical physical storage as on-disk JavaScript objects, blurring the boundary between what's in-memory and what's on-disk. With QEWD-JSdb, the database is no longer something that exists on another server, no longer effectively a separate technology that you access via a network connection using its in-built APIs, and which imposes on you a database model over which you have no control. Let's face it: most mainstream databases are "one trick ponies" that model data in one particular way: fine if all your database requirements fit that model, but most likely you'll have circumstances that mean you either end up consuming valuable time fighting that model to fit your needs. or end up having to support multiple databases with all the resulting additional pain, aggravation and maintenance overhead. With QEWD-JSdb, there's none of those restrictions and annoyances: your persistent data and its modelling is in your direct control within your Node.js processes! As far as you're concerned, you're just dealing with JavaScript objects/JSON, but rather than being in-memory, they happen to be on-disk! But you're not limited to persistent JSON: it's easy to model pretty much any type of database, both NoSQL and Relational/SQL on top of the basic persistent JSON data structures. In fact, QEWD-JSdb comes with some already created for you to use and/or explore, including: Redis-like Key/Value (actually Key/Object) store Redis-like Lists Document/JSON database storage XML DOM database storage via the DOM API, with XPath querying Relational with SQL read/write access Once you're familiar with the basics of QEWD-JSdb, you can create your own custom database model if the built-in models don't meet your needs: no more time wasted fighting the database! It's even possible to simultaneously apply different database models to the same physical QEWD-JSdb data! All sounds too good to be true? Come and find out at Rob's talk on QEWD-JSdb. Rob Tweed (@rtweed) is a Director of M/Gateway Developments Ltd, and has been part of the LNUG scene since its earliest days - he was one of the speakers at its inaugural meeting, and has given a number of talks over the years, mainly focused on his Node.js-based QEWD technology/platform. Rob has several decades of experience, developing and advising on real-world complex, business-critical applications around the world, in sectors such as healthcare IT, financial services and retail systems. He's specialised in database integration for Web and Internet technologies since the early days in the mid-90s, and has been immersed in Node.js since its earliest days in 2011! A keen proponent of Open Source software, you can find all his work (including QEWD-JSdb) at @robtweed

"The world’s first hackable open source JavaScript-powered and TensorFlow-powered smartwatch" Nodewatch/ Bangle.js was introduced as the conference badge at Nodeconf EU in November. A Kickstarter that followed was swiftly funded. I received my watch from NearForm in the post the other day - and I don't know what to do with it yet - but this is too good not to share for a quick lightning demo. Adam aka admataz is a core LNUG organiser, a hacker, and a software developer at NearForm Some links: https://nodewatch.dev https://www.nearform.com/blog/bangle-js-hackable-oss-js-and-tensorflow-smartwatch/ https://nearform.com https://admataz.com

Adam Davis (admataz) explores the pusher.com Channels and messaging platform with a game developed using svelte.js and fastify.js - getting the audience to join and play. A talk for London Node User Group (LNUG) in November 2019

Lightning talk at LNUG - November 2019

LNUG lightning talks - October 2019

You often want to build an app as quickly as possible. To get some kind of MVP in the hands of users, giving them value and something for you to incrementally improve. Most features can come later, but if you ever intend to offer a shared editing experience of any kind, you really need to think about it up front. At Threads Styling we were faced with such a prospect when planning their Social Story builder. Having worked with CMSs in the past, we knew the pain of managing document locks with all their edge cases. We also knew that eventually the use case will arise to concurrently edit the document, and if you haven’t planned for it, it is a monumental task. By treating the document as a stream of JSON patch changes from the very beginning, we were able to offer real-time collaborative editing with conflict resolution smoothly handled by an Operational Transformation algorithm. In this talk, Jason will discuss the concepts involved and demonstrate a simple, but working example of a shared document using our open source library. By Jason Green, Principal Developer at Threads Styling - Twitter: @aziraphael

### Abstract Ever since the start of [Node-RED](https://nodered.org), the runtime and editor components have been packaged together as a single blob of npm module. With the 0.20 release we split the internals apart into 6 separate new npm modules, along with the original node-red module to glue it all back together - and we did it without end users ever knowing (apart from us talking about it at every chance we got). This talk reveals how we went about this refactoring and the challenges of managing multiple modules in a single repo. I'll talk about why we ultimately decided not to use one of the various mono-repo tools, such as Lerna, and ultimately decided to roll our own approach. ### About me I'm an Open Source developer at IBM and the creator of Node-RED. I can be found online as @knolleary in lots of the usual places. I presented about Node-RED at LNUG in its very early days of September 2013, not long after we'd first open sourced it.

While working on large node.js projects, I’ve noticed that there is no clear answer to common questions like “how do I securely store passwords”. I’ve also noticed that all the popular frameworks lack key security features such as CSRF protection and Rate Limiting by default. It’s really easy to get security wrong, and it’s not your fault that this is so difficult. In this talk, I’ll present some practical steps you can take to secure your applications, including protecting against some of the most common attack vectors. I’ll also attempt to inspire you to think differently about what the defaults should be when you build new applications and libraries. We can make our code default to security; it doesn’t have to be this way. I'm a tech lead at Threads Styling and maintain several large open source projects, such as Pug, [@authentication](https://www.atauthentication.com/) and [@databases](https://www.atdatabases.org/). My twitter handle is @ForbesLindesay

Sometimes I get jealous of the speed people can build complex apps with things like laravel/rails. Node is a great run time but it is arguably a more complex choice for your tech stack, there is no standout MVC framework that does it all for you, instead, there are lots of small specialised tools. I want to talk about one of those. It’s called [Postgraphile](https://www.graphile.org/). It lets you generate a GraphQL API from a schema in a Postgres database. By writing just a little SQL you can create an application that would take a long time to create normally! I'm going to show you how you can use it to build a meetup.com clone complete with JWT based authentication, real-time meetup ratings, and role-based access control. I'm a senior software engineer at Near.st. We are building a real-time local inventory data platform to help small businesses fight back against the growth of online shopping. Outside of work, I'm chasing my life long dream of having a dog, and building silly things with javascript. [Follow me on twitter](https://twitter.com/thomasankcorn)

At Karakuri we build robots for the food industry. I would love to share a peek into our decentralised architecture and how the different robot components interact and communicate with each other. As the physical world is quite I/O heavy, Node.js (TypeScript) was a great choice as our main programming language/framework. https://www.linkedin.com/in/orfeonicolai/ I'm a computer scientist with almost 20 years of industry experience. I have a double Masters degree in Innovation Design Engineering and am the course leader of the robotics course at the Imperial College Global Summer School. I work as Head of Software at Karakuri, a robotics startup. We just secured a seed funding round led by Ocado (https://techcrunch.com/2019/05/09/robotics-startups-wont-win-without-also-incorporating-ai-as-karakuris-fundraise-shows/?guccounter=1)

Remote desktop apps are widely used. All of them work pretty much the same way: you can see the user's desktop and control their mouse and keyboard. And one of the main purposes of using them is providing support to users. Assuming you are not Microsoft or RedHat probably you are interested only in resolving issues which are related to that piece of software that had been delivered by you. E.g. your web application. But what if you can't obligate your users to install additional software only for support purposes? Or they simply don't want to install anything. I'm going to talk about how to add a remote control functionality to your web apps using pure JavaScript and native browser APIs. SPOILER: Even without using browser extensions! About me: I am a Senior Frontend Engineer at Behavox. I have almost 10 years of experience in JavaScript development behind my back. Originally I am from Minsk, Belarus. For now, working for a very promising AI company in London. And the topic of this talk is inspired by the real issue which we resolved recently. You can find more about me on [LinkedIn](https://www.linkedin.com/in/artsiommezin/).

Abstract An overview of ML in JS and what I was able to do with it. How and why would you use Machine Learning in NodeJS. I’ll go over some general concepts in ML and then dive into how I leveraged limdu and created a multi-label classifier (called ac-learn) and how you can do the same. All while seeing how fun and amazing it can be. The talk would be focused on giving you the pointers and tools to solve problems where ML is usually the best solution as well as how you can hit the ground running. About me I'm a Computer Science placement student working at BWC in Project Management, Web Dev and various other things (e.g. GDPR and IT support). I've been working with JS for about 7 years and with NodeJS for about 3 years and simply love almost everything about it. Twitter: @Berkmann18

Abstract How hard is it to make your own state management library? By using React hooks, Context and other open source projects you can easily build your own useful library. I wanted first class TypeScript support, immutable data, zero boilerplate and hassle free wiring. I built it in a few dozen lines of code: Immutable Context. I'll demo how to use it via a Code Sandbox demo, how it works under the hood and then look at some lessons learned, with suggestions on how to build your own state management library in 2019. About I'm a polyglot developer and data scientist. I've built lots of apps, for example this iPhone app for Isometric graphics. My website/blog is www.amimetic.co.uk. I work with React/React Native at JPMorgan. My Twitter handle is @complexview

Abstract Over my last holiday I started a project I am quite enjoying. It is an implementation of the functionality of curl written done purely in node. It presently is nothing close to done, but you can do some basic curl stuff with it (e.g. make multipart form data posts to some url, pipe responses to files, handle http and https proxies (provided they support the connect header) to do requests over to http or https, recursively follow location headers, set headers, etc.). There's presently some vague ftp ideas that are not at all done. The rather bigger challenge I was working on last time I was doing my project was to establish an ssh connection, (which on account of doing everything from scratch will make a number of assumptions about the server it's connecting to). I'm hoping to over the next month or so get it all done nicely. Overall it's a pleasant way to learn some details of networking, starting to write an ssh client in particular requires manually writing the packets as per the ssh protocol which has been a reasonable education in how that sort of things works. It has also been good for me to appreicate how excellent node is, it really does seem to provide nice apis for everything you want. About me I'm a former mathematician who over the last 9 or so months has turned programmer, I currently work as a developer mostly working with JavaScript. I mostly like doing algorithms and stuff and have only recently begun to learn the broader aspects of programming. I really love doing things from 'scratch' (in the sense of just using the stuff provided by the language) as I find it quite insightful.

Zero to prod in 2 hours Writing code is great, working out how to host it is less great (for most people!). We recently ran a workshop at CityJs and made sure that everyone walked out of that workshop with an app deployed. In this talk we’ll chat through some of the things that helped us do that (Netlify, serverless functions and Vue) as well as some alternatives (The Serverless framework + lambda etc, firebase and other SPA hosting). The aim? To get everyone to feel empowered to build something fun (and potentially silly). About Us Hew Ingram I’m a Full Stack engineer at Applied (a little startup striving to make hiring fairer, smarter and easier - driving forward diversity in companies). I predominantly use JS but dabble with bits of python, PHP and others. Lover of all things Javascript + a big fan of building cool (weird) things, often for the hell of it. Thomas Ankcorn I'm a Software Engineer at BAE. I like JavaScript , starting but not finishing side projects and cats. Often referred to as some dude with a scooter.

## Build your own WebAssembly Compiler For more than 20 years JavaScript has been the only 'native' language of the web. That's all changed with the release of WebAssembly. In the coming years, you'll see people writing web apps in Rust, C#, C++ and all manner of other languages. But just what is WebAssembly? And what’s all the fuss about? WebAssembly is a low-level compilation target, which means that it is unlikely you’ll use it directly. However, as developers and hackers, we love to know how technology works! In this talk, Colin will look at some of the internals of WebAssembly, explore how it works ‘under the hood’, and look at how you can create your own (simple) compiler that targets this runtime. About me - I'm a technology enthusiast, working for a consultancy by day, and enjoying myself with open source by night. Here's [my blog](https://blog.scottlogic.com/ceberhardt/) if you want to find out more about me! I'm a keen WebAssembly enthusiast, I run [WebAssembly weekly](https://wasmweekly.news/) and did quite a few 'scene setting' talks on WebAssembly last year. For this talk I want to do something different, delving into the details of what WebAssembly actually is, through the process of creating a compiler that targets WebAssembly.

Over the last 18 months I have bootstrapped my startup using SailsJS. What did I learn? What do you get out of the box? How has the project evolved? Am I happy with my choice 18 months later? I have previously used Rails, ASP.MVC and Laravell. I had decided on Node for the backend - but what framework would I choose? What do I really need? What can I trust? How does SailsJS differ to the aforementioned frameworks and how much bang can my buck get? ## About Me Hi I'm Simon, physics graduate, software engineer, team lead and now technical co-founder of Kiffgo.com. After previously working at a consumer facing marketplace startup I teamed up with a motivated co-founder to create my own. As the technical co-founder I had some stack decisions to make. I arrived at Node + SailsJS. From webpack integration, unit testing to production deployment I've done it with SailsJS and am willing to share my experience. I've been to LNUG a number of times in the past and have always found it a friendly, welcoming and informative experience.

Our choices in wording are frequently more powerful than we realise, and we risk using this power liberally and erroneously. Let’s take a look at our ideas about how we communicate in our code and in our speech, and what effects those ideas have. My name is Gabrielle von Koss, and I work as a developer at the Financial Times. You can find my retweeting activity on @gvonkoss

In this talk we will examine strategies and best practices to develop and test node apps that make heavy use of third-party API integrations. As reliance on third-party services becomes more and more prevalent in the node ecosystem, developers need cost-effective, secure, reliable and fast ways to mock these services for both dev/staging environments and testing. We will start with looking at nock, and open-source mocking solution for local development, and move onto unmock which provides mocks-as-a-service of popular APIs. The session will have live coding for both nock and unmock using express to create a simple microservice and jest for testing. It will also present several popular design patterns for isolating and testing third-party integrations as well as strategies for integration testing apps that rely on third-party APIs, including corner-case and error testing. Presenters will be myself (Mike Solomon - unmock.io) and I will invite some of our London-based clients to chime in about the importance of testing third-party integrations and the emerging ecosystem of developer sandbox environments for API testing. This is the same talk that we are giving at SFNode (sfnode/sfnode#98). We'd love to bring it to your community, share our learnings and hear your feedback. Bio Mike Solomon is the founder and CEO of Meeshkan (meeshkan.com), a Helsinki-based DevOps company. A music major at Stanford University, Queen's University Belfast and the University of Florida, Mike has been a guest researcher at the University of Paris VI and has held the post of artistic director of the Ensemble 101 (ensemble101.fr) from 2011 until the present day. While working at the IRCAM as a computer music designer, he fell in love with Machine Learning and founded Meeshkan to ease several DevOps pain points in the ML pipeline. Since then, Meeshkan has expanded to other areas of DevOps, including API testing with unmock (unmock.io).

Nothing to do with node.js - a lightning talk at our last meetup extending to Apple Shortcuts and probably the most elaborate RSS reader replacement... ever. Simon is a JavaScript / Node developer at the FT

Abstract An exploration of async iterators in NodeJS including when and why to use them, how they compare to other reactive libraries, how they perform and what to look out for when you do use them. About me JavaScript enthusiast, Open Source Contributor, Co-founder of a number of successful startups, OpenBankHack17 hackathon winner, Head of Technology for Business Banking at Investec. You can find me at https://jamie.mccrindle.org

If you don’t want to learn a new language but still want to make a quality mobile app, then a cross platform tool like Titanium is what you’re looking for. In this talk you’ll be shown how easy it is to start building your app using skills you already know from web and NodeJS. About me Rene Pot, Developer Evangelist at Axway Appcelerator since 2018. I've been developing since I was 12, full time cross-platform mobile developer since 2011. Twitter: @Wraldpyk

TypeScript adoption it's been a reality in the last years. This presentation is going to be a demonstration on how we can take advantage of the TypeScript compiler to have a smooth migration from JavaScript to TypeScript. I am Marco, Software Engineer that believes software must be simple, intuitive and reliable. Currently working at Beamery. https://twitter.com/Talento90

AWS lambda allows you to build microservices that can be triggered both through HTTP and other ways such as when something is added to a queue, or on a schedule. We'll show how it is possible to build an API which consists of small, individual functions that respond to different HTTP requests using AWS lambda and API gateway. In addition to this, we will be deploying using serverless within minutes! About me Polyglot developer with a passion for learning new things.

Over the years we've seen many attempts by developers to avoid writing Javascript at all costs - creating new languages that compile into JavaScript is still a common practice in many language communities. But things are changing, for the better. We're reaching an age where potentially any high-level language will one day be able run in a browser, with greater speed and safety - all thanks to Web Assembly. This talk will provide practical information about how you can take code written in a shiny new language like Rust, compile it to a Web Assembly module and then execute it in the browser.

Refactoring is part of the process of maintaining an application, but large scale refactoring that are more complicated than a find and replace are time consuming. Codemods are a tool to refactor code by manipulating the abstract syntax tree (AST). In this talk I'll teach you what ASTs are, why we use ASTs in tools like Babel and eslint, and how to write a codemod that manipulates an AST. About me I'm a Vue core contributor, and software engineer at the BBC. https://twitter.com/EddYerburgh

ECMAScript modules are just around the corner, but they may not be what you expect. I'll go into the reasoning behind the change and what it means for the future of javascript. I'm Andy, a full stack JS developer with a love of native apps.

Docker is an ecosystem that allows you to work with containers. Whilst the initial learning curve can be steep, it can ultimately make your development and deployment cycles much faster. In this talk, I will show you how to deploy a simple front- and back-end application using Docker, and show how much faster it is than the traditional, more manual approach. ### Resources * You can try out the code yourself using the repository on [GitHub](https://github.com/d4nyll/docker-demo) * A variation of the presentation is also available on [Google Slides](https://docs.google.com/presentation/d/1ELRYLJI2Lgqk0zK0qQnVIYeZA2Nc0IG8jRaYRFr_TTM/) * A recording of the talk is available on [YouTube](https://www.youtube.com/watch?v=N5WKMVF_qlw) ### About Me I am a JavaScript developer at [Nexmo](https://www.nexmo.com/). Before that, I ran my own digital agency, [Brew](http://www.brew.com.hk/), in Hong Kong, specializing in [Meteor](https://www.meteor.com/).

The CloudNativeJS.io community project provides a number of assets, tools and core modules for building Cloud Native Node.js applications. This session will show users how to use those to easily take an existing application and deploy it to Kubernetes with full support for liveness checks, metrics and request tracking. Beth Griggs, Developer & Node.js Core Collaborator, IBM Runtimes ([@BethGriggs_](https://twitter.com/BethGriggs_) ) Neeraj Laad, Developer, IBM Runtimes ([@NeerajLaad](https://twitter.com/NeerajLaad))

Developers can build engaging voice experiences, aka Skills, for their services with the Alexa Skills Kit. In this 20 minute session, learn how to build a voice experience for Amazon Alexa: from idea to working skill including some best practices to consider along the way. **Personal Info:** Tech Evangelist at Amazon, Twitter: [@muttonia](https://twitter.com/muttonia)

Speaker: Alex Dytrych GraphQL is kind of a buzzword right now - but what even is this new API tech from Facebook? In this talk, we’ll take a look at GraphQL and understand what it is, why you might use it, and how it fits in with the existing API landscape. We’ll have a go at writing some simple GraphQL queries together, and hopefully you’ll go away excited about using this awesome tech in your own work & projects.

Speakers: Michelle and Faduma You've heard of GraphQL. But what kind of problems can it solve? This is the story of why we chose GraphQL to power the Vogue and GQ websites, and how it helped us get the data we needed for our frontend. You'll learn about some ways in which GraphQL can improve your application, and understand how you might implement it.

An introduction to GraphQL on Serverless. We'll talk about the benefits of running GraphQL (and other API gateway patterns) on the Edge (the performance benefits batching and so on).

It’s been weeks and the organisation you work for seems to be slowly turning against you. At least that’s what it feels like. User experience is poor because of slow API’s, sales are being missed, performance-linked SEO heuristics are causing a drop in page ranking. Mobile users have all but given up. Operations have reported that a critical Node.js service owned by your team is spinning at 70-100% CPU, and all parts of the application dependent on the service are experiencing intermittent slowdowns or in some cases, complete unavailability. What are you going to do now?

Zero Knowledge Proofs in Node.JS - Federico Rampazzo (@framp) LNUG - August 2018 Zero Knowledge Proofs are one of cryptography's best hidden gems and they're behind recent advancements in privacy conscious crypto-currencies. We're going to see how to use them in node.js and improve your applications' security, whether centralised or distributed.

LNUG meetup talk June 2018 http4js is a lightweight http framework. It's immutable, has zero dependencies and is written in typescript. The docs are quite descriptive. This talk would be mainly live coding to show the main benefits of using http4js over another node http framework. I've presented to colleagues who are now adopting http4js. I'd love to show the community why I think it's a better way to write web apps, by demonstration!

LNUG meetup talk, June 2018 At EVRYTHNG we had to a build a number of Node.js applications that required managing multiple resources in a distributed environment. For example, handling real-time connections to other clouds such as Nest and Honeywell and sending notifications to IFTTT applets. What if there was a library that handled the allocation and distribution of these resources so developers could focus on the core business logic of their application? The EVRYTHNG distributed resource manager is a Node.js library that solves this problem. Developers don’t need to worry about maintaining real-time connections when new nodes are added to the system or if one of them goes down. In this talk I would demonstrate the resource manager so attendees will see what problems it solves for us at EVRYTHNG. In addition, they will gain an understanding of how we use Node.js at our company and how it helps us scale. Please note that this library is not currently open source but it should be in the next 1-2 months. I work as a Technical Lead for EVRYTHNG who provide an IoT platform for businesses around the world. It’s my role to decide on the architecture for various parts of the platform and how we will build these components using Node.js. I’ve been programming in Node for five years.

Heard about Serverless? Already know Express.js? Too afraid to use the two? My talk will last ~20 mins and will cover the following: - Where are my servers? (Moving from the classic setup to a serverless one) - Express.js + Serverless? - How can I test my serverless app? (Offline testing) - Where are my logs? - Wait, are my apis public? (Securing your endpoints) - Shhhhh....(Keeping secrets) ### About me: I started my career over a decade ago writing code for firewalls and security systems (c/c++/java). In recent years I've been specialising in cloud engineering, microservices, aws and serverless (mostly in node.js). Now: I'm the CTO of a young and still in stealth mode startup - [sourcingbot.com](http://sourcingbot.com)

Objection.js is a SQL ORM (Object Relational mapping) for Node.js. In this talk, I will walk you through how the module works, show live examples of it in action, and present the case for considering it in your Node.js projects. Things that we'll cover are: - Quick setup - Creating the underlying database schema for your models via Knex.js - Creating models and executing SQL queries via the models - Implementing validation in your models with JSON schema - Defining relationships between models - Doing graph inserts and updates - Setting up a GraphQL API with the objection-graphql plugin - Other interesting objection.js plugins My name is Paul Jensen, I'm the author of [Manning's "Cross Platform Desktop Applications - Using Node, Electron, and NW.js"](http://manning.com/books/cross-platform-desktop-applications). You can find me on [Twitter](https://twitter.com/paulbjensen) and [Github](https://github.com/paulbjensen).

Developing web applications as separate front end and back end parts is a common practice, but brings with it the challenge of how to test those parts together in an end-to-end fashion. In this talk, I will show you a strategy for being able to test your web application with Cucumber.js and Puppeteer, a library for running Google Chrome in headless mode. We'll also explore how to handle things like seeding the database for the API before running tests, how to select elements in the DOM via Cucumber step definitions, and how to do this in a nice fashion using Node 8's async/await feature. My name is Paul Jensen, I'm the author of Manning's Cross Platform Desktop Applications, and I'm the Lead Innovation Engineer at Starcount. My twitter handle is paulbjensen.

How easy is it for a non-techie lay-person to set up a personal server and have their own apps running on it? There's been much talk recently about how large companies host our data, control it, and sell ads against it. But what if we all had our own servers with our own applications running on them holding our data which we control? Is that doable today, using existing cloud services and node.js? What does it take? How easy is it? For the past few years, I've been running my personal node.js-based server on AWS, Google Cloud, Openshift and Heroku, using mlabs and Mongo, as well as Dropbox! So I'll talk about what it takes for a non-techie (or at least a newbie) to set up a node.js server using each of those environments - the pluses and minuses of each ... and why doing this would be a good thing in general. About me: I am clean tech entrepreneur (@zemenergy.com) and VC executive (@top-funds.com). I code for fun. See http://freezr.info twitter:salmanff github:salmanff

AWS Lambda has changed the way we deploy and run software, but this new serverless paradigm has created new challenges to old problems - how do you test a cloud-hosted function locally? How do you monitor them? What about logging and config management? And how do we start migrating from existing architectures? In this talk Yan will discuss solutions to these challenges by drawing from real-world experience running Lambda in production and migrating from an existing monolithic architecture. ### About me: Yan (@theburningmonk) is a polyglot developer and architect, he is a regular speaker at user groups and conferences internationally. Yan is the author of `AWS Lambda in Motion`, a co-author of `F# Deep Dives`, and he keeps an active blog at http://theburningmonk.com where he shares his thoughts on topics such as AWS, serverless, functional programming and chaos engineering. my co-speaker is **Scott Smethurst** : Scott’s passion for computing began when he was gifted a Commodore 64 for Christmas in 1988 and really took hold while studying Computer Science at the University of Manchester. He’s been an architect, lead developer and consultant within a variety of industries, working with organisations ranging from a multi-billion pound corporation to a failed start-up. Scott has spent most of the past 2 years designing and building several serverless architectures and has decided to start sharing some of those experiences.

At 10am on Black Friday, your phone rings: the new JS application you deployed came under too much load, and the site has gone down! Your employer is losing sales opportunities... your employer is losing money! But you don’t lose your cool. You log into your cloud provider and tweak your autoscaling settings. Now the deployment can handle the load spike but with four times the number of servers, which is four times the cost. The next day, you try to analyze what happened and begin to optimize your application to prepare for future load spikes. This talk is a journey into the world of Node.js performance, taking a look at the available tools and optimization techniques inspired by insight gained from glimpsing under the hood of Node and V8. ### Bio Matteo is a code pirate and mad scientist. He spends most of his days programming in Node.js, but in the past he worked with Ruby, Java and Objective-C. In 2014, he defended his Ph.D. thesis titled "Application Platforms for the Internet of Things". Now he is a Principal Architect at [nearForm](http://nearform.com), where he consults for the top brands of the world. Matteo is also the author of the Node.js MQTT Broker, [Mosca](http://mosca.io), the fast logger [Pino](https://github.com/mcollina/pino) and of the [Fastify](https://www.fastify.io) web framework. Matteo is also a member of the Node.js Technical Steering Committee. Matteo spoke at several international conferences: Node.js Interactive, NodeConf.eu, NodeSummit, JSConf.Asia, WebRebels, and JsDay to name a few. He is also co-author of the book "Node.js Cookbook, Third Edition" edited by Packt. In the summer he loves sailing the _Sirocco_. Twitter handle: [@matteocollina](https://twitter.com/matteocollina)

Who hasn't found themselves in despair after hours of trying to debug a problem that seemed simple, because halfway down the line the stack trace ended in a file called `throw-error.js`, or simply there were no errors thrown and the code just didn't work as expected? The talk will last between 15 and 20 minutes, will be structured in two parts and there will be plenty of gifs and emojis. It should cover errors in Node and browsers. ### 1. Common bad error handling scenarios - Stacktrace lost. - Code exits without error. - Generic error messages (`something has failed`). - ... ### 2. Exploring possible solutions (examples) - Custom errors. - Formatting error api responses. - Displaying errors in the UI. - Examples when using Apollo (GraphQL), React and maybe other tools. Conclusion: your library/utility/api should be built around its users, and they shouldn't need to read the code to know why something is wrong. (I'm really bad with titles 😳) I'm a freelance front-end developer, currently working with React and GraphQL. [twitter](twitter.com/claudiamatosa) | [github](github.com/claudiamatosa)

Javascript inheritance has always been a challenging issue for new and seasoned developers. In this talk, we will dive deep into the inner workings of Javascript inheritance and see the beauty of prototypical inheritance and the prototype chain. While this is a classic talk, it is particularly relevant to the current debate in the React community over the use of fat arrow vs pre-bounded methods. [Talk slides](https://speakerdeck.com/thanpolas/classical-inheritance-in-javascript) Github: [thanpolas](https://github.com/thanpolas), Twitter: [@thanpolas](https://twitter.com/thanpolas), [LinkedIn](http://www.linkedin.com/in/thanpolas), [website](http://thanpol.as)

We've spent the last 14 months working with Node.js to migrate the Holiday Extras engineering team away from Node.js monolith applications and over to Node.js microservices. Node.js is the heart and soul of the operation and the time has come to share how it's taken us above and beyond our wildest dreams. In this talk I'll be sharing how we're using Node.js throughout our stack, some of the key projects we've built and the problems they solve, and how to really make the most out of Node.js to build an incredibly powerful engineering experience. I'm a software engineer in the tech-foundations pod at [Holiday Extras](http://join.holidayextras.co.uk/) with a remit to improve the efficiency of our engineering team. I've been writing Node.js day-in-day-out for over 5 years and dabble with infrastructure on the side.

I have been experimenting with different variations of chess as a tool to improve memory and abstract thinking, as a tool for social interventions, a variation for blind people and more. I started my experiments in 2015 and have created an app www.Halfchess.com at a slow pace since 2016. The talk is a flash talk and starts with why I got interested in the particular topic; and, the things I built and experiments I did along the way. I also briefly talk about the technologies I used and show how easy it is to hack a chess engine (p4wn) for making your own variations. [A bit about you, e.g. current job, twitter handle, etc.] I currently work at Mckinsey and am visiting London (from New Delhi) for a quarterly sprint planning meet . If you are really interested in reaching out to me - you can find my CV at www.flipflopapp.com, which has my email address.

* This is a lightweight and entertaining 15 minutes long talk. * It is aimed at developers on **ALL** levels. * Covers basic and advanced concepts. Bio: I am a JavaScript Engineer with growth mindset. Connect with me on [Twitter](https://twitter.com/lazlojuly), [LinkedIn](https://www.linkedin.com/in/lazlojuly) or [GitHub](https://github.com/lazlojuly)

Mongoose has helped us greatly to maintain the integrity of our data against a mongodb database. However, we are not able to share the models we use on our apis anywhere outside those apis. And Mongoose schemas are not shareable, which means we cannot consume them on any other level of our applications. This means either using conversion plugins, or else writing and maintaining some other solution. In addition, the mongoose models themselves are not shareable, which means even if we solve the schema issue, we still have at least two sets of models to maintain. Finally, we use Typescript, which means ideally we can share schema definitions with that which would allow us to define our entities once and have those definitions propagate to all levels of our applications. The final part of this presentation will focus on the solution we now intend to adopt as we begin to overhaul our entire architecture in the coming months.

It turns out that you don't need Microsoft Office to create PowerPoint files - you can create them in Node.js. In this talk I will show you how libraries like Officegen allow you to generate PowerPoint files containing text, shapes, charts and images, and demonstrate a real-world use of this tool that we've been crafting to save us some time. My name is Paul Jensen, I'm the author of Manning's Cross Platform Desktop Applications, and I'm the Lead Innovation Engineer at Starcount. My twitter handle is @paulbjensen.

The LNUG website uses AppCache with the help of app-cache-nanny but with its upcoming depreciation I’ve been investigating how Service Workers might improve the experience. In this talk I will explain how the LNUG website gets built, how it uses appCache / service workers and some of the things I’ve learned along the way. I'm a remote Javascript engineer, part time conference organiser and my opinions can often be found on twitter: @simonmcmanus.

Would like to introduce my project binary-repository (https://github.com/forbesmyester/binary-repository) and solicit contributions / talk briefly about the components yargs, GPG, BASH(!), AWS S3, AWS CLI(!) etc and what I have learnt using them.

NodeJS has many uses, but what about taking the traditional web development offline and developing NodeJS application for the desktop. This talk introduces Electron. A nifty framework which makes desktop application development with NodeJS a breeze and stretches the horizon for businesses and developers to offer desktop applications as solutions to client and business needs. Watch Bernard Baker (BTAB @bernibear2000) walk you through the development of a production ready application which is being used at Sky which converts videos into sprite sheets for use by online display campaigns. Bernard Baker is an aspiring programmer who has been coding for over ten years. Currently working as a Digital Innovations Specialist - dreaming up new product ideas, mentoring programmers and investigating new technologies for their benefits in his business domain.

What you could be doing with node.js. A quick node--on-hardware demo lightning talk.

Some tips for writing a command line scripts. Watch out for passwords though,

Quickly compiled lightning talk with some great insights from CTO at Tido

An ad-hoc talk and great tip

Have you ever found yourself completely lost in front of a yield statement? What is this? Where does my promise go? How come I get the result back? Generators are widely used amoung Node and javascript libraries to enable developers to write powerful code in a simple way. I will try to answer all these questions and we will recreate together the co library that is used, for example, in Koajs. I would then like to go into a step by step decomposition of redux-saga to understand how this wonderful library uses generators. A bit about me I'm a full stack developer at Theodo UK, a web agency in central London. We help our clients to solve their business problems through code. Our clients range from young startups to large corporates. Twitter: @switcher7707

Pizza Hut website is powered by a system of 20+ microservices, all docker-ised and running in AWS. What challenges did we meet while writing it? How do you maintain, develop for, and test a system with extremely high availability on such a scale? It's a bit like juggling twenty fragile glass balls while riding a bicycle. Nevertheless, it's a surprisingly reliable way of delivering the best user experience, and pizza, to our users. More info I'll introduce our (complex) infrastructure and will talk a bit more about challenges we have faced and how we solved them. Splitting logic into microservices; changes made into several microservices at once & deployment. Testing our huge products API; running over 20000 unit tests on one microservice, we need to micro-optimise. Making sure it actually works; a system of logging, monitoring, and support About me I'm a software engineer at Pizza Hut (contractor), speaker, node and react developer. Previously worked at Red Badger and Time Out. I recently spoke at JeffConf, React London 2017, several meetups. Twitter handler: @lithinn

Huncwot is an opinionated & minimal Node.js (yet another) web framework, slightly inspired by Clojure and built for ES6/7 era with « batteries included » approach. It tries to formalize conventions and eliminate choices by providing solid defaults for building web applications that increase the programmers productivity. In this talk we'll explore how to build an application with Huncwot, what it brings to the table and how to make (web) programming more approachable, especially to non-programmers. A bit about me I run a software company called Nukomeet. In my spare time I organise PolyConf. Twitter: @zaiste

Abstract Most likely you are choosing Node.js because it has the reputation to be super-fast, easy to use and you heard a lot of success stories at meetups and conferences. Sure you did performance and scalability tests which confirmed that your decision was correct to go with Node.js. What Daniel has seen is that in enterprise environments Node.js often acts as the (often microservice based) gluing tier that connects legacy services to modern offerings like mobile apps or your HTML5 SPA (Single Page Apps) via a REST API Layer. This means that once you integrate your application into the company infrastructure, connect it to internal & external services and go productive you may be the first person to be blamed because "the website is slow" or even better "something broke – there is an error we have not seen before". But who knows if in fact a service consumed or brokered by Node or a database is slow? In this session Daniel will cover - how to trace down problems inside Node - the challenges operations is facing in todays highly heterogeneous applications - how to protect the boundaries of your service to pinpoint problems in other tiers - new tracing features in upcoming versions of Node. Bio Pragmatic fullstack engineer from BGP to AJAX. Speaker, mentor and course author. I am leading the Node.js technology efforts of Dynatrace. Member of Node.js Diagnostics WG. Let's chat about the old days, todays cutting edge technologies, (web) performance ... you name it.

Fade in. An opened terminal window. iTerm2 is the flavour. Dracula, the theme. You split the panes in two. You are at it again: a stash of audio buffers and that dream of manipulating a lossless file. With node as your language of choice you embark on the night. You manipulate, you transform, you have your byte order sorted, on their own accord your fingers start to type gzip -f yourFavPhilCollinsSong.wav. All of a sudden, a whisper: But what if. we stream. file compression. on the fly. Fade to black. In this talk we will walk through file compression algorithms in node as well compression standards. We will cover working with streams, audio buffers, and typed arrays to get us to compress and decompress files, and yourFavPhilCollinsSong.wav. bio tl;dr javascript, infrastructure, 🍜 🍜 🍜. The not so short: Irina is a Berlin via London via Vancouver (geeeez grrrl) software developer who is, oh hey, hello, really into node.js. She writes node over at scripto.cc and contributes to a few open-source projects in the meantime. Outside of coding, she spends quite a bit of her time exploring the outdoors, gushing over trains, and reading some Beatniks.

Description: The aim of the talk is to show what i have learnt and the libraries and tools i have developed over the last couple years after getting into trading bitcoin and ethereum, which turned out later into trading all sorts of things based on technical analysis and a bit of flaky statistics. I'm really bad at making graphs and charts and what not, so expect some hands on approach, the talk should cover the very basics of trading and then how to use trading APIs to actually buy and sell stuff online directly from your command line. About me: The first time i programmed javascript was twenty years ago and since them i have played around with pretty much all the interesting programming languages i have found in front of me just to discover in 2011 i would actually end up doing everything again using only node.js. During this long journey i have worked on backend and frontend applications, interactive games, multiplayer applications, and whatnot. The last few years my big interest turned to be blockchain, cryptocurrencies and trading. After moving to London nearly seven years ago i worked for a few years in a very nice design studio and then later left to create my own little technology company where all those crazy experiments happen.

My tale of writing "Cross Platform Desktop Applications" 3 years ago I gave a talk at LNUG on Node Webkit, and then posted online. Little did I know that the end result would be writing a book for Manning publications on Electron and NW.js. This talk is about how that happened, the process of writing a book about those Node.js frameworks, and the learnings from undertaking the whole project. My name is Paul Jensen, and I'm a Senior Pre-Sales Consultant at Starcount. My Twitter handle is @paulbjensen.

Tips for running faster builds with nodejs and docker. This talk mainly outlines lessons learned and optimisations which will hopefully help you get quicker feedback from your CI pipeline and make your deployments run quicker. Although I have more experience in the back end side of things, I strive to be a full stack developer. I like working on well tested codebases with a well oiled CI pipeline

Moving from a company where everything ran on 'bare metal' in a DC on Goswell Road to a startup where everything was already running in AWS has proven to be an interesting learning curve. This talk will take you through some of my learnings along the way and some of the ways we use bits of the AWS toolkit now at Tido. Clarkie CTO @ Tido twitter.com/@clarkieclarkie

9 months after you’ve started writing a hybrid app, you’re going to stumble across some unexpected native problems that don’t show up in tutorials. This talk will go over these and other oddities that most web developers wouldn’t expect. Talk includes: classic Android and iOS architecture for restful apps weird native bugs (with fixes) * great things that javascript/web should have I'm Andy Trevorah, app developer for hire. Twitter: @trevorah_ Website: https://trev.sh

REST is recognized as the "good practice" in terms of web APIs, but can quickly become a hassle as your application grows and evolves. QraphQL is a new paradigm, allowing developers to request deeply nested information in a single call, without cluttering the response with unneeded fields. In this talk, I will show how GraphQL overcomes the rest limitations to send only the information a caller wants, without changing anything on your backend. I am currently working at Theodo (http://www.theodo.co.uk/) and have been for the past 18 months, as a fullstack developer.

Everyone is hacking everything. Everything is vulnerable. Your site, your users, even you. Are you worried about this? You should be! Don't worry, I'm not trying to scare you (that much). We have plenty of safeguards against attempts on our applications' user data. We all (hopefully) recognise Two Factor Auth as one of those safeguards, but what actually goes on under the hood of 2FA? We'll take a look into generating one time passwords in JavaScript, implementing 2FA in Node.js applications and the only real life compelling use case for QR codes. Together, we'll make the web a more secure place.

Join me in a wild adventure to take a computationally heavy single-use NodeJS application and automagically scale it across many cores and many servers in the hunt for lazy performance. Disclaimer: This is all for fun, games and science.

What's the fastest way to ship a Web, iOS and Android app? React Native goes beyond making native apps with web technology. You use javascript, granted that's a web technology, to make a fully fledged React app, using native components. It's more than leveraging the power of the state -- UI mapping of React. It's about code reuse. Being this DRY hurts. All the high-level logic is portable and you have one single codebase for all three target platforms. All of this is free, as long as you embrace React.

Holiday Extras, a times top 100 company, maintains a big online presence selling airport parking, travel insurance and overnight stays in hotels. We made over 4,000,000 bookings last year and our API serves around 35 requests/second - we aren't big big, but we're big enough to have to deal with 'big website' problems. We've spent 3 years fully migrating our production traffic away from a 10 year old LAMP stack to a NodeJS API. I want to share our journey - the migration plan, the evolution of our NodeJS codebase from beginning to end, our biggest mistakes and our biggest victories.

Everything you need to take advantage of npm in your browser side code, and avoid the pitfalls! Including: Building browser bundles with gulp and npm build - and how they compare How to identify the modules that contribute to bundle file size Pros, cons and workarounds for the izs style 'no lib dir, everything is a module' coding style Ensuring consistent versioning during deploys How to include templates in your browserify bundles Based on experiences in a real world, production, profitable application.

This is a project I've been working on for few months and I just released it on github.com/liwe (under MIT). It's a service to let web developers (frontend guys) to use smartphones as remote for their webapps. Of course it's built with NodeJS. But at the moment it look more like a prototype than a robust piece of code. It won't be very techy, especially in front of NodeJS developers. The talk would be axed on two main points: Make a technology accessible to other developers. Like sockets (think about jQuery and PHP devs) Find contributors I have absolutely no idea if this talk respect the idea of LNUG. I think I can hold 20 minutes demo included. https://github.com/liwe http://liwe.co

Mikeal giving an overview of the state of node following the merge or io.js and node.js, and the engagement of the Linux Foundation.

Founders & Coders are a non-profit organisation, run with the objective of providing a first class training in full-stack JS, for free. In this talk we will discuss the origins of Founders & Coders; why we started and our original goals. We will then talk about the last 18 months; how the organisation has developed and how our curriculum has shifted dramatically as we have experimented with different educational models. We will then talk briefly about the future of F&C; what we have planned and where we think our organisation is going.

Users of our apps and products yearn to be immersed; but so often, the worlds we build with software show surprising seams, shattering immersion for our users. In this talk, we'll look at the magic of tokenization, and how it can transform the UX of your application.

With great load comes great scaling responsibility. If we need to scale then hopefully it means we're doing something right. The problem is how to scale without increasing complexity and re-writing the application. In this talk, Ben will discuss how he scales Katacoda.com, an online learning platform for developers. Ben will show how to deploy Node.js applications with Docker. Once deployed, Ben will highlight how to scale the processes and take advantage of container based deployments.

A talk about an in-development javascript to c++ transpiler which currently kind of works and implements closures, numbers, objects, functions and strings. Watch it compile and run hello world, and beat node in an EPIC FIB() BENCHMARK! Be compelled by the power of tern.js to figure out what you think you're actually writing!

A short talk on DB DiaYAML, which is a journey-to-work and weekend project for drawing simple database diagrams. It's not particularly a serious project but it scratches an itch I had and has a nice MVP feel to it. There's a blog post about it at http://keyboardwritescode.blogspot.co.uk/2015/07/weekend-project-db-diayaml.html

You are writing a mobile or HTML5 web application that needs just a little bit of a backend. Maybe you want to access MongoDB, send an SMS, or an e-mail. Do you really need to host your own Node.js service to run this small snippet of backend logic? In this talk I will take a hard look at the role of the backend in modern applications. I will introduce the concept of a webtask - a lightweight representation of backend logic that can safely be embedded in a client application. I will show how you can use modern container technologies based on CoreOS and Docker to build a generic, multi-tenant runtime for securely executing webtasks directly from a mobile or HTML5 application. You don’t need a backend to run backend code. This talk is based on lessons learned when building the Node.js sandboxing technology for internal use in our core operations at Auth0.

WebRTC has had a real tough 3 or 4 years, and so have those working with it. Only a few short years ago, the development world were excited about WebRTC and proclaiming how awesome it was. You might have played with the technology a couple of years ago, only to find the extra infrastructure requirements were painful to implement and poorly documented. This probably left a bitter taste in your mouth, especially when things went wrong. Those in the industry have been working hard to sweeten the deal again - efforts have been made to bring WebRTC into the mainstream and as a result the technology is experiencing a rebirth. Thanks to those who have remained dedicated to improving the situation for those around them, WebRTC is finally starting to fulfil the original expectations that were had of it. Both the technology and the support networks have been built up to make experimenting with it again a pleasure, not a pain. WebRTC has grown up; in this talk you will learn how far along the tech has come, its current capabilities, the amazing things that people are starting to do with it, and how simple getting started with the new toolsets available.

You've heard of TypeScript, but you're not sure if it's a good idea, and you've never really seen it in action. TypeScript is powerful though, rapidly gaining momentum, and has a lot more to offer than just JS + classes. Let's take a proper look. In this talk, we'll dig a bit deeper and play around with some of the more interesting features TypeScript gives you. We'll walk through the extras that TypeScript provides and how they'll solve your every woe, learn a bit about where the types come in and why you care, and see how exactly you might put it into action on your next Node project.

We use streams on a daily basis when handling data with our Node.js applications, but how do they work, and more importantly, how do we keep them efficient and performant? This talk focus mainly on analysing applications that utilises streaming data, identifying bottlenecks and making improvements. Be wow’ed by Flame{graphs,charts}, awed by benchmarks and take away some tips in writing decent stream implementations.

Flux is one of the newer cool kids on the block, but it has it's fair share of problems. With all of the different implementations fighting for recognition, to first time users and abusers it can seem overly complicated. Redux is one Flux framework which has gained a lot of traction recently, thanks to its novel take on the architecture (vastly simpler than Facebooks sample implementation, for instance) and neat debugging features. This talk can show the differences between Redux's approach and more 'traditional' Flux architectures, running over its benefits for developers. It will also briefly explain the difference between Flux applications and other MVC implementations, for anyone curious and unfamiliar.

This is not yet another how do you do BDD in JavaScript talk. This is a talk about how you can apply widespread software design practices such as Design Patterns, BDD, TDD, DDD and SOLID to full-stack development. Less how to use these practices, more how to select and use them effectively. Just using these tools on their own can lead to unnecessary complexity that can be hard to understand or avoid. So let’s set aside discussions of the language syntax or capabilities and focus on what is important - delivering value to the customer. This presentation will show how BDD practices can be applied to the different contexts of developing features through a multi-layer stack whilst smoothing the communication, providing detailed direction and showing the value for business owners and developers alike. The result is a feature that meets the business owner’s expectations with happy side effects such as the code being clean, well designed, understandable, fully tested and documented.

Writing front-end code today is very challenging when you have to be resilient and robust in a big corporation. Working on a website that involves dozens of engineers based in three different continents, I learned that the complexity lies not only within the code itself. Allowing people to develop new features and deploy the code multiple times a day, keeping it up and running, is hard to achieve: we want small teams to be independent and not to interfere each other, in order to be quick and happy, but we also want to optimise cooperation when it is needed. In the front-end world components are very small units of code providing application functionality that are all connected in order to become a web-site. During this talk I’m going to speak about how we tried to approach to components at OpenTable. After breaking our monolithic back-end into smaller parts, we tried to break the front-end into smaller parts too, called micro-sites. Then, following the SOA principles, we tried to elevate components as services, in order to make engineers able to create and consume them via clear and well-defined contracts and interfaces. This allowed us to put in place the infrastructure to optimise testing and to have hundreds of changes live every day without conflicts. The result is OpenComponents, a framework that we recently open-sourced. References: http://tech.opentable.co.uk/blog/2015/02/09/dismantling-the-monolith-microsites-at-opentable/ https://github.com/opentable/oc

A talk about this thing I built called upmon. It's essentially a description of what it is and how to use it and how using node streams is a great way to create modular and compose-able software.

On February 20th the first release candidate of the 6th edition of the ECMAScript specification (ECMAScript 2015 as it is now officially known) was released. The language is rapidly stabilising and the new features are slowly but surely making their way into the existing JavaScript engines. Unfortunately, it will still be a while before we're able to write ES6 code and have it run natively in either browsers or Node and io.js. Thankfully TC39 (the group responsible for the development of the ECMAScript specification) put a lot of effort into ensuring backwards compatibility so it is possible to use a large and growing proportion of ES6 today. This talk will look into some of the technologies and techniques that can be used to write, publish and deploy ES6 code today, without having to wait until the engines catch up. We'll explore source-to-source compilation, standard library polyfills, publishing modules written in ES6 to npm and the consumption of those modules by existing ES5 and new ES6 code.

Advances in JavaScript are changing the way that we think about the web; it's no longer just a platform for information, but for complex interactions too. As we race into the future, we risk losing some of the things that make the web so special. In this talk I will outline why I believe progressive enhancement is still important. Demonstrating processes, techniques and architectures which provide the benefits without introducing an overhead.

Node/io.js and npm is now the most flourishing ecosystem with over 200 npm modules being published a day*. While this poses a lot of opportunities for us to work together and build better software, it also comes with problems we as developers have to face: Which package should I now choose? How do I use it in my app? What input does it expect? etc. Making a multitude of these simple decision drains a lot of our energy - more than you might even think initially. Imagine now npm install and you are ready to go. You installed your addon, you already know what to expect and it hooks itself up into your app. This is the philosophy behind convention-over-configuration: having a standard we all work with to automate mundane decisions. So we can focus on making our software better. *Source: http://www.modulecounts.com/

Guvnor is a fully featured, multi user process manager for node.js/io.js that leans heavily on the Unix permissions model for security. It's also got a neat web interface that monitors multiple hosts, reports live statistics about your application and lets you interact with it - debugging, monitoring resource usage, live logs, restarting, etc. The talk will cover why the world needs another process manager, CLI usage, deploying apps from git repositories, cluster management, using the web interface and live coding a small app that uses the programmatic interface.

Building NodeJS Applications with Docker & CoreOS

web components, microservices, and the shared principles behind both of them (complete with node-based example)

Why the days of the server are numbered as our most basic building block and building on top of services is the future.

- Why fork node? - What new/broken IOJS 1.0.0 - Node/IOJS Compatibility - Should I be scared / Should I deploy it? - My take on what the future holds for the node community Slides @ http://rosskukulinski.github.io/iojs_talk

Avoid stepping into the rabbit hole with common anti-patterns and bad code. With a strong emphasis on how JavaScript code can be done beautiful and maintainable, this talk explains how to write very readable and testable code. At eBay we love to have our code clean, so we’ll use some examples of eBay’s code during this presentation. We’ll touch topics on how functional can intersect with object oriented programming to decrease the learning curve to your code. Or how choosing the correct data structures is more important than ever to guarantee optimal performance. All of this in a framework agnostic way, so that it is easy to take home and apply to your projects with ease. Hopefully after you have attended this talk you will code cleaner. Topics covered: Code readability Functional JS Object Oriented JS Unit Testing Code structuring

Luke's talk at the London Node User Group meetup, 25th February 2015, in which he launches Open Source project, Paz to the world - live on stage.

This talk will start with a very brief overview of what the jade templating language is and why it's so powerful. It will then deep dive into how the nitty gritty of the compiler is implemented, this will include some discussion of the many other modules that jade depends on. I will then take the audience on a tour of a couple of my favourite spinoffs of jade. Finally, I will end with a description of how we have built a community around the jade project that is capable of achieving far more than I could on my own.

Creating, releasing, maintaining, versioning, getting input for, etc, etc an open-source node module. Including: Some good practices when versioning, releasing, and documenting your open-source code: - Some NPM tips - How to make your code inclusive - Some GitHub tips

Node Anti-patterns

JSON throughout the Stack