JSConf US 2015 Speakers

Marcy  Sutton

Marcy Sutton

30 Minutes or Less: The Magic of Automated Accessibility Testing

In the amount of time it would take to have a pizza delivered, I'll teach you about accessibility through JavaScript testing. By using a pragmatic approach to software quality, we can create a more inclusive Web. Take it from someone who has broken high-profile builds: you can win by automating tests for common accessibility problems and catching them before they are deployed out into the world.

Meet Marcy

Marcy Sutton is a developer at Substantial and Angular core team member working on Material Design for Angular. She is a primary contributor to ngAria, the accessibility module, as well as the author of a new accessibility plug-in for Protractor, the end-to-end testing framework. In her spare time, she co-organizes the Seattle chapter of Girl Develop It. She's also in love with riding bicycles and throwing the frisbee for her dog/Muppet.

Jacob  Roufa

Jacob Roufa

Maintaining a Local Dev Meetup

What do you do when you only have a few regular attendees? Is your own schedule so crammed you can't sustainably present every topic every month? Do you still want a local user group? Some hard won experience from a local web developer meetup co-organizer. Or, how we kept the user group going and helped foster continued growth in attendance and participation.

Meet Jacob

Doing things with webs since interning for the Chicago Technology Cooperative in 2007, Jacob is a mostly front-end focused web developer that enjoys building purposeful applications and elegant, usable solutions. Co-organizer of the Rockford Web Devs meetup and rockdevs.com. Interactive Developer for Quiet Light Communications, a full service agency located in downtown Rockford, IL. Veteran of FatWallet.com and the Rockford Register Star.

Tim  Griesser

Tim Griesser

Making Relational Cool Again (or: JavaScript on ACID)

Who in their right mind would ever want to work with RDBMS anymore. Especially in JavaScript, where you can just call "save" on your JSON and turn it into web-scale BSON, or get to choose between so many levels of DB that we don't even know which to use. This will be a story about one person's journey to try and make people believe that Node can actually be a thing for boring, early-2000's era web applications using (gasp) SQL. It'll also share some discoveries along the way including how ACID / transactions can be super useful in the everything-async world of JavaScript, and some tips and tricks for keeping a sane and organized data layer when venturing into the abyss of hybrid single-page / server-rendered applications.

Meet Tim

Tim is a software engineer from Philadelphia. He enjoys building things for the web and collaborating on open source JavaScript. He is passionate about learning from and teaching the best ideas from different languages and frameworks.

Sebastian  McKenzie

Sebastian McKenzie

JavaScript Transformation

I made the open source project Babel and will be presenting on how JavaScript transformation and ES6 can help improve developer workflow and how it can futureproof their code. Not only transpilation to ES6 but how Babel has support for Flow, JSX and React so it can be integrated into many workflows extremely nicely. There are many challenges associated with transforming JavaScript as well as AST manipulation that I think would be extremely beneficial for the average developer to know about. There's even crazy stuff like transpiling proxies/Object.observe which wraps every single expression in a method.

Meet Sebastian

Sebastian McKenzie is a JavaScript enthusiast based in London, UK. He's extremely passionate about open source as well as web standards and is always looking to push the boundaries of what is possible. He currently works at Cloudflare as a JavaScript engineer working on website optimisation and delivery. Sebastian is also the creator of the popular Babel compiler that's used by many developers to bring their code to life.

Ashley  Williams

Ashley Williams

If you wish to learn ES6/2015 from scratch, you must first invent the universe

Javascript has always been a language with very little syntactic sugar—for better or worse. With ES6/2015, and future iterations,though, Javascript is gaining a more and more abstract and expressive syntax. To some it might appear that our language—which already seems accessible and approachable for beginners— is becoming even more accessible and approachable. However, both the humanities and CS education research have proven that abstraction, while a powerful tool for knowledgeable practitioners, can be an equally powerful foil for beginners. As we enter the era of language-level abstractions in ES6/2015, we are charged with the task of rethinking how we teach JavaScript. Through an interdisciplinary montage I will identify the problem of teaching abstraction as a ubiquitous demand across nearly every domain, and align the issues of creativity and critical thinking in the humanities with issues in computer science. The talk will conclude with a discussion of how the discipline of computer science and that of the humanities can inform each other to produce more effective and creative solutions to both developing and teaching abstractions.

Meet Ashley

Formerly a NYC Teaching Fellow, Ashley learned the ropes teaching middle school science in Harlem, NYC. Since then, she has spent the vast majority of the past few years teaching web development to beginners, most notably running the NYC Web Development Fellowship in its flagship year. When not headlong in a discussion about pedagogy, she is probably getting seriously fired up about philosophy, language, systems, and/or jokes.

Michael  Matuzak

Michael Matuzak

Amazing Things One Can Do With JS and the NES

Have you ever wanted to make those 8-bit sounding tunes from your childhood? What better way to do it than using the actual hardware to get that classic sound? Oh wait. I have to learn some archaic assembler? Not anymore! Now make those classic sounds from your childhood with JavaScript. This talk will go over the basics of how sound works on the NES, and how we can use JavaScript to make music on the NES.

Meet Michael

I got my first NES when I was 4 and have loved it ever since. Now as an adult I still love video games, but am more interested in doing crazy mad science with the console. I am an organizer of js.la and am trying to make the JavaScript community in Los Angeles awesome.

Jafar  Husain

Jafar Husain

Async Programming in ES7

Currently there are ES7 features proposed for async programming that have never been seen in a programming language before. If accepted, these proposals could allow entire JS applications to be written without a single callback! By providing the same level of support for async functions as regular functions, ES7 could dramatically alter the way everyday developers write code. Imagine reading data from a stream or a web socket with a simple loop. Imagine catching async errors using try/catch, and never again finding yourself in the callback pyramid of doom.

Meet Jafar

Jafar Husain is the Cross-Team Technical Lead for the Netflix UI's. He is the architect of Netflix's UI data platform, and specializes in building reactive, event-driven systems. A highly-rated speaker, he has spoken at QCon, HTML Dev Conf, QCon, CodeMesh, YOW! and given Channel 9 interviews. He has also trained hundreds of developers to build event-driven systems in JS. He is the Netflix representative on the JavaScript standards committee (TC-39) and is actively working to add better async primitives to the JavaScript language.

Dann  Toliver

Dann Toliver

Visualizing process evolution

What actually happens when your code is run? Our programs are simple text documents composed of patterns of rules, but the processes they guide aren't nearly as well behaved. Function scopes are generated, data is plumbed through pathways, bits are shifted and applications are evaluated. There's a lot of ins, a lot of outs. It's a very complicated case. We can gain some insight into the process with console.log and step-through debuggers, but we're left to develop a full program simulation in our minds based only on the code we wrote and the tiny snapshots our debugger gives us -- effectively requiring a JS interpreter to be compiled into our wetware. This can make it somewhat challenging to reason about our work. We'll look at some ways of remedying this, starting with basic data structures and tiptoeing toward full programs. Your code is the DNA for a process: let's build an illustrated anatomy guide.

Meet Dann

Dann enjoys building things, like programming languages, databases, distributed systems, communities of smart friendly humans, and pony castles with his two year old.

Parsha  Pourkhomami

Parsha Pourkhomami

JavaScript CSS

CSS has a number of deficiencies: no namespacing, dependency management, code isolation, or robust dead code elimination. It also has confusing cascading behavior and no way to share logic or constants with front-end code. We've created various hacks and alternative languages to resolve these issues, but the best solution has been right under our noses: JavaScript. By using JavaScript and its ecosystem, the require() module system gives us namespacing and dependency management, existing tools like UglifyJS can eliminate dead code, the confusing cascading behavior of CSS can be bypassed completely, and shared logic and constants can be written in one place. Take it a step further and we can polyfill CSS features, calculate critical path styles, and perform other mad science.

Meet Parsha

Parsha grew up programming with a Commodore 64 and started creating websites in 1995. His interests include language design, decentralized systems, hardware, databases, and of course, the web platform. Parsha enjoys working on tooling and developer efficiency. When not hacking on games, home automation, and other projects, he enjoys skiing and playing tennis.

Jan  Jongboom

Jan Jongboom

Altering the real world with JavaScript

JavaScript is everywhere, but too often it's locked in computers and phones. We need to bridge the gap between the physical world and your computer... It's time to alter the world around us with JavaScript! In previous JSConf talks Jan Jongboom ripped mainboards out of phones; abused sensors; and juggled devices, but this session is going to be harder, deeper, higher and more crazy! How about procedural music generated by the sensor data of all members of the audience? Using bluetooth beacons to find out if the person next to you is worth talking to? Hardware hacking your Firefox OS phone to add more sensors? Geofencing your newborn with a phone mainboard? And all of that... with JavaScript! Loaded with demo's this talk will forever change the way you think about JavaScript in the real world. LET'S DO THIS!

Meet Jan

Half the day I'm a developer for Telenor Digital where I work on Firefox OS / IoT / Open Hardware. I'm a core contributor for Firefox OS and submitted hundreds of patches to various open source projects. Furthermore I'm working as Firefox OS Evangelist, building community in countries where Telenor launches. I'm known for juggling phones on stage, and one Bengali newspaper credited me as "Firefox OS Grand Master"

Steve  Kinney

Steve Kinney

Building a musical instrument with the Web Audio API

When you weren't looking, someone stuck a synthesizer into your favorite web browser. The Web Audio API is widely supported and makes it easy—and more importantly, fun—to create, process, and control audio in the browser. We can spin up oscillators, adjust gain, tweak frequencies, and slap on some funky delay. Additionally, we can also take existing sounds and manipulate them to our heart's content. We can grab input from cameras and microphones and use them as we see fit. But, the fun doesn't stop there—we still have the rest of the browser's media APIs at our disposal. We'll talk a little bit about the Web Audio API. We'll explore the browser as a vehicle for creative expression. We'll fire up some audio contexts and connect some nodes. We'll also leverage the getUserMedia Web API, WebSockets, and others to build unique musical instruments that could only be possible in the web browser. We'll not only talk about the API itself, but also some of the fundamental concepts for working with audio and making music.

Meet Steve

Steve is originally from the great state of New Jersey. He was a New York City public school teacher for seven years, where he taught special education, science, and—eventually—JavaScript to students in high-need schools in Manhattan, Brooklyn, and Queens. These days, his bread and butter is teaching JavaScript to aspiring developers at the Turing School of Software and Design in Denver, Colorado. In his copious free time, he teaches classes on web development with Girl Develop It.

Sam  Saccone

Sam Saccone

Recreating a dialup modem in javascript

Pshhhkkkkkkrrrr​kakingkakingkakingtsh​chchchchchchchcch​dingdingding The siren song of the dialup modem that summoned AIM and the Book of Mozilla has a language unto itself. In this talk, we’ll learn how to implement an end-to-end frequency-shift keying modem, capable of sending and receiving data between computers using the Web Audio API. By using a browser, I’ll provide an interactive session detailing how we can use javascript to encode and decode what modem tones really mean.

Meet Sam

Sam Saccone is an engineer working at MojoTech. In his free time he works on MarionetteJS, TodoMVC, and when not in front of his computer likes to wear hats.

John  Brown

John Brown

(math == art && art == code)

The formula for a Bezier curve is beautiful. Using sine and cosine to create orbiting objects is dazzling. L-systems create fractals through elegant simplicity. Developers, as a group, may be losing site of the beauty that code can create. Designers by the bunch are picking up a keyboard and creating amazing pieces, but it's happening the other way very slowly. That's a shame, because the computer lets otherwise unexpressed ideas go unexplored. Developers have the ability to embrace the art of programming and the art of art because of the myriad frameworks available. Use the language of your choice to make some art, whether it’s in the browser or in the physical realm. Walk away with the confidence and the inspiration to put down the work for a minute and pick up a digital paintbrush.

Meet John

John Brown is a Swiss Army developer, a Jack of all Trades, a serial "knows just enough to be dangerous" sort. In Portland, OR, he fits in perfectly with his beard, tattoos, self-roasted coffee, homemade sodas, and handmade furniture made from reclaimed lumber. He's working on at least two side projects at any time, so ask him about either of them!

Simon  Swain

Simon Swain

Cold War

Growing up in the '80s wasn't as cool as it's made out to be. As a teenager of that decade, we not only lacked any reasonable fashion sense, we lived under the constant shadow of nuclear oblivion. In hindsight, the arms race begat some huge advances in computing theory and practice, and since your average mobile phone is more powerful than that era's entire North American early warning system, makes a great target for simulation. Cold War is an in-browser recreation of the nightmare that was the '80s, exploring emergent systems, the limits of Javascript performance, and some techniques that might actually be useful in your day job when you get back to civilization. Expect vector graphics, high altitude bombers, missiles, killer satellites and explosions. More than a few explosions. And unlike the '80s, lasers that actually work.

Meet Simon

Simon spends most of his day using Javascript to design systems and human interfaces for real-time data. Based in Sydney, Australia he's come full circle back to his electronic engineering roots to work for a startup creating tiny but powerful wifi enabled modules that will be brains for the coming flood of internet connected devices. On the side Simon produces Techno, keeps obsessively fit and is still trying to work out Wing Chun.

Felipe  de Albuquerque

Felipe de Albuquerque

Accessibility and JS: side-by-side

Through out history, JS has been pointed out as the villain when the matter is accessible websites. By presenting some tricks and techniques, we plan to provoke this discussion among developers, and show that Accessibility and JS may live together, as long as you take the right steps.

Meet Felipe

Web Designer and Front-End developer with over ten years of experience in software development, including web applications, mobile, desktop & digital TV. Currently working at CESAR (Recife Center for Advanced Studies and Systems), which is amongst the top IT innovation institutes in Brazil, having participated in relevant projects for large customers, such as Samsung, Motorola, HP, Coca-Cola and Fiat Chrysler. Being a Front-End evangelist, he likes to spend his time sharing his knowledge and presenting lectures on this subject. Also works at CESAR's Educational Branch, called CESAR EDU, where he teaches some online courses as well as face-to-face classes on the post-graduation degree in "Interaction design for mobile devices", such as "Rich Internet Applications" applied with HTML5, CSS3 and JavaScript, "Responsive Web Design", among other academic and mentoring initiatives. As a fun, dynamic and versatile person, his hobbies can vary from science & technology to art & music, surfing & skating.

Kate  Hudson

Kate Hudson

Beyond Responsive: Building a mobile web you're f*ing proud of

Making the mobile web platform better, both for ourselves and for the next two billion users, is one of the most important challenges of our careers. It's not enough to rely on standards organizations and browser vendors to solve our technical and cultural problems. We've got to do more. I'm going to take a look at solving problems such as performance, routing, and offline experiences by circumventing the DOM, building hybrid Android apps, and using persistent background queues. Not that these approaches will solve all your problems – but rather, help you set new benchmarks, give greater clarity and direction to the bugs you file on browser vendors, and ultimately get you better results. By making bold technical decisions, we move the web forward. Instead of improving and optimizing the problematic paradigms/assumptions under which the web was built, we should borrow patterns from other mobile platforms or invent new ones. We also need to understand how the experience of coming online for the first time will be very different for the next generation of primarily non-North American mobile users.

Meet Kate

I work with Javascript, Android and humans – humans are the most challenging. Lately I've been interested in mobile performance, automation, and adding more cute animals to my Twitter feed, but I'm up for anything.

Mariko  Kosaka

Mariko Kosaka

Knitting for Javascripters

Wouldn't it be cool if you could "print out" your own javascript generated bitmap art as a knitted scarf ? Well, you can ! Knitting textiles is a lot like programing computers. You write your knit pattern (code), your brain compiles it, and your hands render knit stitches (1s) and purl stitches (0s). It means you can decipher knitting nomenclature like "k2, m1L, k1, m1L, k until 3 sts remain, m1R, k1, m1R, k2" into JavaScript. This talk will cover how you can program knitting patterns in JavaScript and then use an electronic knitting machine from the 1980's to make beautiful knitted textiles.

Meet Mariko

Mariko is an engineer living in New York City. When she is not making internal tools at Percolate, she uses JavaScript to help her knit and organize local meetup BrooklynJS.

Naveed  Ihsanullah

Naveed Ihsanullah

Parallelism experiments in JavaScript

With the amazing performance of modern single threaded JavaScript how can we catch up in parallelism? Today’s hardware provides specialized instructions that can operate on data in parallel and provides multiple execution units that can run code in parallel. The single threaded nature of classic JavaScript cannot take advantage of these resources. When quad-core smartphones are already available today that leaves a lot of performance potential on the table. I will share work we are doing to extend JavaScript with flexible and powerful primitives for parallelism that will unlock new performance opportunities to the Web. Let’s explore how native code concepts like shared memory and execution synchronization could work in JavaScript. With great power comes great responsibility so I will touch on some mitigation strategies we have in place to make sure tomorrow’s web applications stay well behaved as they use all the horsepower your hardware can provide.

Meet Naveed

Naveed is an Engineering Manager at Mozilla leading their JavaScript and Low Level Tools teams. He is intensely focused on making the web platform the best platform for all development. Step one is functional parity with native code in a web friendly way. Step two… profit? Naveed has decades of experience in building low-level development tools, reverse engineering, cyber security, web development and enterprise knowledge management. He also enjoys dabbling in the Arduino platform, cycling, playing guitar badly and working his way through Will Durant’s Story of Civilization. Follow his adventures @naveedi

Tracy  Hinds

Tracy Hinds

Re-examining recipe search--a dash of sugar, just a smidgen of graph database

I’m starvin’. I throw open my laptop, and search by what I've got in the house to minimize me running to the store. I'm craving a flavor, not necessarily a cuisine. Some southern food has its origins in West African food. How do recipe searches address this? How do we combine curation of good recipe content with better search to avoid having to build a recommendation engine? In this talk, we’ll take a look at the current state of web recipe discovery and how I naively tried to come up with an alternative with brute JavaScript force and graph-databasing; like baking a souffle for a dinner party and doing a no-fall dance before it comes out of the oven. Plan for the worst and be delighted when it doesn’t happen(or chuckle when it does)!

Meet Tracy

Tracy is a cat herder of JavaScript events(of the people variety). In her spare time, she’s on her 6th life as a Web Engineer at Urban Airship. While never a butcher nor a candlestick maker, in prior lives she has been a baker, a restaurant manager, and addictions clinic coordinator. She’ll try just about anything once(kayaking down a waterfall and boiled peanuts fall into that category) and especially likes rock climbing--which may explain why she’s quickly coming up on her 9th life.

Nick  Nisi

Nick Nisi

JavaScript Fundamentals

JavaScript is one of the world’s most popular programming languages, used by virtually all web applications. Learn the basics with this focused introduction to JavaScript Fundamentals. From variable types and functions to scope and prototype chains, you’ll gain a solid understanding of the language and a firm foundation for creating real world applications while writing clean, maintainable JavaScript.

Meet Nick

Nick is a JavaScript Engineer at SitePen and hails from Omaha, NE where he herds NebraskaJS. He is also a Dojo contributor and known in some parts for his legendary karaoke skills.

Kassandra  Perch

Kassandra Perch

Intro to Node.js

In this intensive training segment, we’re going to get you started developing in Node.js. We’ll build a small application that serves a static webpage, has dynamic routing, and interacts with a third-party API (maybe even of the NodeBot variety...?). No knowledge of Node.js necessary, though a knowledge of JavaScript is a good thing to have for this training.

Meet Kassandra

Kassandra is an educator and Mad Scientist at Bocoup. When she's not building NodeBots, she's thinking about web architecture, or seeing a movie.

John K.  Paul

John K. Paul

ES6 Overview Workshop

Coming soon, in a theater near you. It’s bigger than Ultron. It’s better than Ultron. It’s more ubiquitous than Robert Downey Jr. It’s ES6, JavaScript’s next in-your-face revsion. You’ve never seen a sequel, until you’ve seen this. I’d like to take you all to the movies. Explain to you all about ES6, and what new features are accessible now, even in older browsers or node.js. You’ll see what we can access with a single new script tag. I’ll also go through many of the features that are “transpilable” and explain what that means. I’ll even go so far as to say why some don’t like the word “transpile” at all. It’ll be an excuse for me to get into the fun and tangled web of compilers. The goal of this workshop will be to give everyone a taste and experience of the future JavaScript features that we can all use with only a few tweaks to our current processes.

Meet John K.

John K. Paul is the organizer of the NYC HTML5 meetup group, the VP of engineering at Penton Media and former lead technical architect of Condé Nast's platform engineering team. He is a also contributor to a few open source projects including requireify, jquery-ajax-retry and one single commit into jQuery.

Brian  Arnold Sinclair

Brian Arnold Sinclair

Debugging Deep Dive

Debugging is one of those things that (almost) everyone despises, but that absolutely every software developer needs to know how to do. Over the past fifteen years, Brian has worked through some of the weirdest, wildest bits of JavaScript, and has the mental scars to prove it. In this deep dive, come and absorb some of his knowledge on how to debug all the things! We'll be focusing on the front-end mostly, as that's more commonly where the weirdness happens. We'll explore devtools in various browsers, as well as use of tools like proxies to help figure out what the heck is wrong with things.

Meet Brian

Brian Arnold Sinclair is a Staff Software Engineer at Bazaarvoice. He's also a board games fanatic and is overly excited about Rock Band 4.

Jeff  Barczewski

Jeff Barczewski

Introduction and Getting Started with React.js

Why is React.js a game changer in a world with so many UI frameworks? We'll have fun learning what makes React.js special and uncover its simple core concepts. As we continue our journey, we'll apply our React.js skills to building some reactive web apps. You'll emerge from this workshop knowing the basics of React.js and will be ready to use it for your own projects.

Meet Jeff

Jeff is the founder of CodeWinds. He is developing leading edge web developer training on topics like React.js, Hapi.js, and Node.js which will be delivered as online video courses. Jeff has worked as a full-stack engineer at MasterCard (for the ApplePay project), Elsevier, RGA, and served as an officer in the USAF. He enjoys speaking, mentoring and training developers on the best ways to build resilient systems.

Rey Bango

Woah, You Can Test IE & Microsoft Edge on a Mac & Linux?

OS X and Linux are two very popular operating system choices for web developers but they still want to be able to test Internet Explorer and the new Microsoft Edge browsers. In this talk, we'll discuss the state of browser marketshare, the options available for testing these browsers on OS X & Linux and new tools that offer enhanced testing capabilities for mobile browsers

Mike Ball

Headless Testing Against Real Web Browsers

Continuous integration ensures software's health with each each codebase change, ideally via automated tests and other quality-assurance processes. Tools like Phantomjs offer a great path towards headless JavaScript testing, but what about those scenarios where the software under test requires an actual GUI web browser? Think NW.js, Flash, and Google Polymer web-component-tester. X Virtual Frame Buffer provides an excellent solution towards lightweight, headless testing against real web browsers. In this talk, I'll offer some background on X Virtual Frame Buffer, and demo how to test a Google Polymer web component on a lightweight Ubuntu VM in continuous integration.

Kyle Tyacke

Communicate All the Things... With WebRTC!

In this talk we’ll look take a look at WebRTC, a rather new technology that is giving Javascript developers the tools to add real-time communications features to their applications without the need for plugins or learning a new language. We’ll examine the key components of this standard, look at how peer to peer connections are established, and discuss how you can start adding features like video calling and screen sharing to your applications today using the Respoke Javascript library!

Jonathan Martin

You Won’t Believe This One Weird Way to Rewrite Closures

Closures are undoubtedly the most powerful feature JavaScript inherited from its Lisp forbears. But would JS be so powerful… without them? We’ll reimplement closures entirely from scratch without the convenience of native local variables or function parameters. Entirely in JavaScript. Using prototypal inheritance, some clever hat-tips from graphics programming, amnesic function bodies, and this one weird global variable.

Myles Borins

Would a sample at any other rate sound as sweet? An introduction to how our brains interpret sound

In this talk we will explore signal processing, specifically how our brain interprets sound. We will explore some of the basic theory behind how music is digitally encoded and look back at some of the history and science behind the western musical cannon.

Laney Kuenzel

Mutations and Subscriptions in Relay

A dive into how the Relay framework makes it simple for developers to implement mutations (data writes) and real-time updates.

Charlie McConnell

Pebble Timeline - A Web API For Your Wrist

Where is my train? When is my next talk? Is now a good time to use the restroom? Pebble is a device intended to give you constant access to the tools and data that matter most without having to dig out your phone. In this talk we will show off how easy it is to start programming data driven applications for Pebble with just a few lines of JS.

Jory Burson

Organizational Design for Open Source

Lessons from the intersections of organizational design, human psychology, and business in order to better organize ourselves, our projects, and our communities.

Michael O'Brien

Introducing Mixed Mode

This talk will introduce the idea of working with both Dom + GL in a single co-ordinate system.

Chris Lorenzo

Polymer: The future of Web Components

What are web components and why you should be using them. Find out how to get started and how Comcast is using Polymer for customer facing applications.

Andrew Rota

Tungsten.js: Virtual DOM + Server Rendering in a Legacy Codebase

Why we wrote our own framework to deliver high-performance UI updates and fast server-side rendering within our existing tech stack.

Peter Piekarczyk

The Hybrid Backbone & React App

Have a large Backbone application that you'd like to try React on with the hopes of moving away from Backbone in the future? I'll guide you through some of the options and techniques you can do so without going crazy.

Gord Tanner

Umm... I have to do WHAT to run this code?

Whether you work on open source or are hiring developers to work with you, first impressions matter. The first day on with a project is both exciting and challenging for any developer. From missing documentation, unknown dependencies, complex codebases and install processes, it’s a wonder that most people don’t just quit on the spot. However, when a plan is in place and when things are handled correctly, the first day with a codebase can become one of the most motivating days for any developer.

Kassandra Perch

NodeBots: LIVE!

Our semi-yearly episode of NodeBots:Live! We'll have so much to talk (and dance) about! Want to be on the panel? Let me know: the@nodebotani.st


Drawing Hands: Built-ins written in JavaScript

Learn about how browsers/engines leverage JavaScript to implement built-in APIs. Knowing @jdalton there's likely going to be some performance bits too.

Dave Cadwallader

Zombies and Soup: Why End-to-End testing sucks (and why it doesn't have to)

At WalmartLabs, we like to automate-away all our boring and tedious work, so we can focus on the fun stuff. But automated cross-browser end-to-end testing is really really hard to get right. We'll show you how we did it, and unveil some open source tools we're releasing to help with your zombie apocalypse, too.

Matt Edelman

Nemo. The natural nodejs automation solution

Introducing NemoJS (http://nemo.js.org, https://github.com/paypal/nemo), a test and task runner agnostic selenium wrapper - with confit (https://github.com/krakenjs/confit) for configuration and a plugin architecture for precise customization and modularity.