lnug / speakers

Open an issue to submit a talk

LNUG Talks

A repo for organising talk proposals and discussing talks with speakers

Talk Format

• Each event has 2-3 speaker slots available.
• Each talk is allocated 20 minutes, however, this can be altered on a per-case basis.
• We also welcome shorter lightning talks for quick dives on node.js topics - 5-10 minutes max. Takes the pressure off
• Talks are recorded and posted onto the LNUG Youtube channel. * Your permission is implied.

Some loose talk guidelines

• we only host live talks with speakers in the house (no video link ups - sorry, they don't work well for our meetup format)
• We prefer hands on demos and live code-in-practice or a developer story to tell over org charts, process diagrams, product demos or corporate promo material.
• this is the London Node.js User group - we are a broad group of developers and touch many technlogies in our day to day lives - but try and keep the link to Node and JavaScript central to your talk

First time speakers

• Our meetup is inclusive and friendly. If you need some speaking mentorship - we're here to help. Our organizers can provide a hand in multiple ways: Review your talk, provide tips & advice regarding public speaking, help with slides and general presentation.

How? Simply add a comment below your talk proposal (the github issue) that you're looking for some advice when you submit a talk.

How

Its simple. Open an issue to submit a talk.

Please structure the issue as following:

• Title: [Talk Title]
• Body:
  • [Abstract of your talk]
  • [A bit about you, e.g. current job, twitter handle, etc.]
• I confirm my talk is 20 mins long in total.
• I confirm that I will abide by the Code of Conduct

If you are looking for feedback on your talk or have additional question, reply to your issue with extra comments stating your questions but please keep them off the body of the original issue text itself

Please conform to the issue structure so that we can use the api to automate some of the event admin.

Confirmation

• Once your issue is assigned a milestone, it has been approved and confirmed.
• Check the milestone date for confirmation of the event date.

Code of conduct:

LNUG has a code of conduct that speakers as well as attendees are expected to observe - please be sure to read it and comply with it in your participation with LNUG

After the event

Please tweet a url to your slides and put the link in your proposal as a comment.

Thanks, <3 LNUGorg team

speakers's Issues

White water streams

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.

Jakub Racek - January 28th - Live programming Pipes and Streams

Description will come

Ross Kukulinski - What to expect when expecting IOJS

Hello!

I'm a co-organizer of BayNode and internet friends with @orliesaurus and @iancrowther. We've been kicking around the idea of sharing pre-recorded talks.

I'm going to be doing a ~20 minute talk at BayNode next week on the 1.0.0 release of iojs. The talk will be recorded and I can send over the video, alternatively, I could live-stream the talk for y'all.

Overview:

• 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

January 1970 session

This is an example.

My talk is about controlling satellites with NodeJS and dealing with latency
You can reach me at @orliesaurus on twitter

George Ornbo - November 26th - Realtime Node.js from the trenches

For about two years I've been using realtime Node.js in production. The talk covers the story of this experience from early days of socket.io and RedisStore to Primus and engine.io. It covers scaling from a single process to running a clustered service with resilience.

Through running in production the application has experienced many things around persistent connections including working with cloud services, configuring Linux servers correctly, mobile devices and which message queues work well.

The talk shares my experience of using many of Node's realtime libraries, running a product critical service, and ultimately asking the question 'Is Node A Good Choice for Realtime?'

I can talk at the September meetup but due to childcare commitments would be the new year before I can do the talk.

Francisco Ferreira - September 24th - JavaScript, Java and Dart! Asynch all around us.

OpenComponents as microservices in the front-end world

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

Load-testing for fun and profit

This talk will (briefly) outline why load-testing should be a part of your testing activities and then dive into an overview of tooling and strategies & processes to get the most out of it when working on a production system. We'll also explore how load-testing can improve our understanding of both our own code and components that our code depends on.

Everything you didn't dare asking about jade

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.

Any thoughts on this are welcome. I think it would be a relatively long talk, maybe 1 hour.

Francisco Ferreira - Javascript Craftsmanship

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

Guvnor: running your processes like a boss

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.

Writing and publishing ES6 code today

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.

The state of web asset pipelines and the description of a new pipeline that combines the best of all worlds.

People soon realised that a task runner is not an asset pipeline, maybe sometime after the millionth spaghetti gruntfile was written. Along came gulp, the wonderful streaming pipeline, but the people saw that it was flawed, being built around 1:1 operations (disallowing nice n:1 stuff such as concatenation of streams together with their source maps).

Then came plumber, broccoli, gobble, and metalsmith, all with unique selling points yet all having drawbacks not found in grunt and/or gulp.

It was time for a new asset pipeline to be born out of the pain of trying to find the holy grail of asset pipelines. It was time to write it using functional reactive programming, ES6 and a geekgasm of buzz-words to seduce the JavaScript community. It was time for a bullshit sensationalised lnug talk abstract. Yes, it's time to sigh. sighjs.

In this talk I will describe the issues with existing asset pipelines (read: trash all the competition) and describe how sighjs improves upon the state of the art (read: gloriously inflate my ego).

This talk will last around 10 minutes long and it will be a little surreal. Here is one of my other talks at HNN.

Mikeal Rogers - Node Foundation Q&A

The following form needs distributing:

https://docs.google.com/forms/d/1XvqIY3OroqUaxQPlfIc1VsCKzsbg1VbzbXrD4IHlx3w/viewform

How Waffle.io separated its API from its core web app

At Waffle.io, we recently built a public API to gain access to Waffle's data (in private beta now). We knew we wanted the API to be deployed, scaled, and monitored separately from our core app. We also wanted the app to use the same API we were providing to our users. Carving the API out as its own service consumed by our app provided some interesting challenges and produced some surprising benefits. This talk will describe the design we came up with, the challenges we faced, and the largely unexpected benefits we received.

Founders & Coders

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.

Benefits of using Convention over Configuration

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/

setup milestones

MVP Diagrams that can do things

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

Liwe, an open source remote control for WebApps

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

Libraries.io beta

Description:

Almost everyone uses and depends on open source software libraries these days, especially with the rise in popularity of NPM, but with nearly 200,000 libraries, how do you know which ones are worth using?

In this talk, Andrew Nesbitt will outline his solution to this problem with Libraries.io, which attempts to index all the world's open source software libraries and provide helpful ways of exploring the data and finding the best libraries for you to depend upon in your projects.

Some of the topics we'll touch on include: 

- What makes a good library
- How to make your open source libraries more user friendly
- Dependency management with npm, bower and more 
- Exploring open source big data to find hidden gems

Offline Apps and Data Synchronization

Hi LNUG,

I would be very interested in doing a talk.

I have been working on a project for many months, which is an attempt to make it easier to develop apps (web or phonegap) that can work offline but also Synchronize data back up to the server when an Internet connection becomes available. This is a pretty difficult problem to solve, particularly in a way which is not tied to any particular application logic.

The guts of the project is basically an asynchronous versioning LocalStorage written in vanilla JavaScript so it is super portable and reusable ( see https://github.com/forbesmyester/SyncIt ).

I have also started other projects that are loosely coupled to SyncIt for the server component and a network monitoring / communication of changes. See https://github.com/forbesmyester/SyncItControl and https://github.com/forbesmyester/syncit-server.

There is of course always more to do, but it is now feature complete and has a base project ( https://github.com/forbesmyester/SyncItBootstrap ) so it is easy to get an App started. There is even a TodoMVC example ( https://github.com/forbesmyester/SyncItBootstrap/tree/todomvc / http://teud.eu )... The blocks at the top are the synchronization status.

It is all Open Source and I am basically now transitioning from development to trying to get the word out about it as I think it could be really useful for lots of people. Doing a talk at LNUG would be an amazing start to my promotion efforts.

I would talk about:

• The reasons it is a non trivial problem, such as network latency and being offline.
• Trying to keep it as a library and not coupled to jQuery or nearly anything else.
• Why it is essential to have a form of version control for detecting conflicts.
• The choice to trigger the app developers handler for conflicts instead of trying to write a universal one.
• Lastly I would talk about the loosely coupled but complementary projects such as the server and communication control component.
• A demo, or perhaps a few throughout to aid visualisation of what is happening...

You can contact me as @forbesmyester on Twitter or through the email on my GitHub account.

Thanks

Matt Forrester

Tom Gallacher - November 26th - "Async: the battle"

Something really awesome, with some nice examples and a simple outcome ;]

Service discovery for your Node.js applications

A talk about service discovery in the context of Node.js. How to build services that talk to each other automatically and respond to changing IP address and ports.

The talk will be practical and technical, and focus on using Etcd as well as @pgte's Skiff Raft implementation. I may decide to do only the latter.

I plan to have an audience participation section at the end. Something along the lines of "clone this repo and run it to discover each other's services and participate in solving some problem".

I'm a Node Module Maintainer (And so can you!)

This is an idea for a fairly simple sort of tutorial on 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

Just to show that I have at least some of the experience necessary for this, I currently am actively maintaining two packages and I've put a couple of others onto NPM: https://www.npmjs.org/~basicallydan and I've picked up a few things along the way.

If this sounds like it's too simple for LNUG, please let me know - I've only been to one event so far, and it seems to me like there's a fairly wide variety of experience levels at the usergroup so I'm sure some people would benefit.

Thoughts?

Preferred Month: February 2015

Dan Sofer - Nov 26th - Lightning talk: the new coding school in Mile End

For the past year, Founders & Coders has been a project at Camden Collective, but the funding has run out and we are setting up a CIC, doing a Kickstarter and moving our free, peer-led, Node-based bootcamp to Mile End. This will be a quick summary of the model and a progress update.

Rethinking backend with webtasks

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.

Find out more:
Webtask concepts
Webtask CLI
Webtask playground
Webtask technology

Graph databases - A holy crap moment!

I don't often get blindsided by a new technology but investigating graph databases for a problem I'm trying to solve lately made me exclaim "Holy crap!"

When you're stuck in a relational world you find ways to make everything fit. We've all learnt the lesson that other types of databases are better suited for certain problems, be it document store, key-value or column based. Graph databases on the other hand have been on the peripheral for me and no doubt many others. Even after reading Seven Databases in Seven Weeks, I still didn't quite get the point of graph DBs.

Since looking into them, I now see that they could well nail down a lot of problems we all encounter and I think I'd like to talk about what we're using OrientDB for and highlight the potential they have in future development.

Full-stack BDD and its side effects

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.

WebRTC Reborn

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.

Tom Cartwright - November 26th - Peer connect all the things

Tim Perry - Web Components & Microservices Are The Same Thing

I've got a talk put together on web components, microservices, and the shared principles behind both of them (complete with node-based example). Does that sound like a good fit for LNUG?

Not sure how long your talks typically are; this is about 30 minutes, but that's a bit tight, so a 35/40 minute slot would be great if that's possible. It looks like the October & November slots are already pretty full, but January 28th would work for me.

Building NodeJS Applications with Docker & CoreOS

Hello!

I'm a co-organizer of BayNode and internet friends with @orliesaurus and @iancrowther. We've been kicking around the idea of sharing pre-recorded talks.

I'm proposing to do a (revised) screencast of a talk I did at BayNode in November. Slides for that talk can be found here

Production browser-side npm

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.

Philipp Fehre - October 22nd - JSON throughout the Stack

Super simple service health monitoring with upmon

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.

Blowing out the LAMP

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.

TypeScript will finally bring peace to your troubled soul

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.

The Miracle of Generators

The ECMAScript 2015 specification introduced iterators, which generalise iteration over common data structures, as well as providing an interface for allowing you to iterate over any custom data structures using common language constructs. ES2015 also introduced generator functions, which make writing arbitrary iterators a lot easier and less boilerplatey.

But generators aren't just for making simple iterators over data structures. Because they're bidirectional—they don't only produce output, they can also take input—they're actually coroutines, which means there's no end to the sort of fun you can apply them to. We're going to explore how we can use them to make asynchronous programming in JavaScript a lot more elegant—to chart a path out of callback hell. And then we're going to take a look at what we've really discovered: one of the most fearsome mysteries of computer science, suddenly laid bare before us.

Joe Nash - Tokenization

Description to follow

July Speakers

• Founders & Coders?
• Joe Nash?

Server mocking with canned

I've been frustrated with the complexity involved with just setting up a mock server so I wrote canned sometime ago making faking a webserver just a matter of putting files in folders. This simple approach led to a whole bunch of usecase from

• frontend development first, backend later
• mock server for testing
• performance testing for mobile apps without backend influence

I think some of this would make an interesting talk and maybe some people might even find a use for canned in their own work.

Ben Hall - October 22nd - Node Anti-patterns

Title : JavaScript, Java and Dart! Asynch all around us.

To fix callback readability and facilitate event oriented programming, we have seen promises and futures emerge in multiple programming languages.

• Dart takes this very seriously by having futures built in by default.
• Java also applies Futures and CompletableFutures that get attributed and completed in isolation under separate threads.
• JS defers into promises to fix pyramid of doom anti-pattern and to facilitate working with events under a single thread system.

This talk shows a bird's eye view on how these three languages apply promises. Adding focus to how the usage of promises and futures influences coding styles and architectural decisions.

Topics covered:

• Quick JS Promises/A+ overview
• Reference to Dart Futures
• Reference to Java Futures and Java8 CompletableFuture
• How promises tend to use the Monad design pattern (examples in JS)
• Why unit testing is even more important when working with promises (examples in JS)
• Using promises to abstract from synch/asynch behavior, and be more reactive.

Jakub - September 24th - Scanner and Printer Pi with Node sides

Company: Pact

Flo Servers are dead, long live the service

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

neil test talk

hackday

2FA, WTF?

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.

Progressive Enhancement Strategies

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.

Rod Petrovic - November 26th - Autoscaling Node on EC2

TVBeat is receiving real time data from multiple pay-TV platforms. For that purpose, I developed a simple ingestion API in Node that scales up and down automatically across EC2 micro instances. The talk would be an overview of how this was done and the main considerations.