Sessions

Registration is live and additional sessions are being confirmed- check back for latest updates


Imagine how easy building your web application would be if all of your data was available in-memory on the client. Falcor lets you to code that way.

Falcor is the open-source, JS data access framework that powers Netflix. Falcor lets you represent all of your cloud data sources as one virtual JSON model on the server. On the client, Falcor makes it appear as if the entire JSON model is available locally and allows you to access data the same way you would from an in-memory JSON object. Falcor retrieves the model data you request from the cloud on-demand, transparently handling all the network communication and keeping the server and client in sync.

Falcor is not a replacement for your MVC framework, your database, or your application server. Falcor fits seamlessly into your existing stack and lets the layers communicate more efficiently.

Get an inside look at the innovative data platform that powers the Netflix UIs and the new UI design patterns it enables. Learn more how Falcor powers Netflix, and how you can integrate into your existing stack.
TBD something good from Chris
TDB on React
TBD
Which would you rather have: A rich design or a fast user experience? Users want both, but sometimes the interplay between design and performance feels like a fixed sum game: One side’s gain is the other side’s loss. Design and performance are indeed connected, but it’s more like the yin and yang. They aren’t opposing forces, but instead complement each other. Users want an experience that is rich and fast. The trick for us as designers and developers is figuring out how to do that.

The answer is to adopt an approach that considers both design and performance from the outset. With this approach, designs are conceived by teams of designers and developers working together. Developers benefit by participating in the product definition process. Designers benefit from understanding more about how designs are implemented. There’s an emphasis on early prototyping and tracking performance from the get-go.

With new metrics that focus on what a user actually sees as the page loads, we can now bridge the technical and language gaps that have hindered the seamless creation of great user experiences. In this presentation, Steve Souders, former Chief Performance Yahoo! and Google head performance engineer, explains how promoting a process that brings design and performance together at the beginning of a project helps deliver a web experience that is both fast and rich.
How to build web sites that work well across various browsers versions and devices is always challenging for web developers. In the session, you’ll learn the best practices and strategy to develop cross-browser web sites that will work with the existing and future browsers. Tools for interoperability tests, cross-browser fundamentals, and tips and tricks on HTML5, CSS, JavaScript development will be illustrated. Browser detection, UA sniffing, CSS prefix, and fallbacks will all be examined in the session. A real life example will be used to demonstrate step by step how to build cross-browser and plug-in-Free experiences. With a couple of simple changes to your sites, you can take advantage of web standards and HTML5 features today without breaking your sites in the future.
Every company starts off with a simple web app that eventually becomes a huge monolith. In many cases the same application serves public web apps, private administrative web apps, backend mobile APIs, etc. As a team grows, the monolith doesn’t scale for the organization. Scaling backend APIs are solved with Service Oriented Architecture. The frontend community has barely scratched the surface using services to scale frontend engineering.

At Yelp, we’ve been going through the transition of splitting our monolith and we’ve learned a lot about what does and doesn’t work to break up a frontend into a set of services. In this talk we’ll cover available open source tooling for packaging like bower/npm, build tools, tradeoffs building small and large frontend services, developer education and product/design support for moving to the services world.
The WebSocket protocol has proven to be a humongous advance for the web by providing a standard full-duplex connection over the web. However most applications of WebSocket merely use it as a push mechanism to send data from the server to the client. As with most innovations, using something new for legacy applications is a common reaction.

WebSocket is effectively a persistent and fat pipe that is compatible with a standard web infrastructure; a "TCP for the Web". If you think of WebSocket in this light, there are other more hugely interesting applications of WebSocket than just simply sending data to a browser.

This session looks at how WebSocket provides truly innovative enhancements for dynamic cloud computing connectivity and microservices transports. And by providing proprietary TCP-based IoT with a common connectable substrate (Web of Things), we can obtain advantages for connected devices such as global reach, ease of deployment, economies of scale, ease of development, etc. In addition, we will demonstrate some novel applications of WebSocket that go well beyond simple push.
Enhancing your website with stunning 3D content is a lot easier than you think. Join us for an introductory tour of the most popular, simple to use publishing tools for adding 3D to your website. You don’t need to be a JavaScript or WebGL guru – the tools we’ll show you require (virtually) no coding to use. And because every modern web browser now supports WebGL natively, your 3D content just works – no need to download any annoying plugins.
Everyone seems to be talking about the Internet of Things. From houseplants to ice machines, from fitness bracelets to fish tanks: everything seems to be fair game.

This is a whole new world of computing. It's a lot of fun, but it also comes with new challenges. Validating your idea early is critical. You need to be confident that your plan is going to work before you instruct your manufacturer to sandblast your molds.

In this talk Jenny Tong, a Developer Advocate on Google Cloud Platform, will show you how node.js, Firebase, the Johnny Five library, and boards like the Raspberry Pi come together to make your IoT project real. This talk will include live electronics hacking, and live coding.

By the time you leave, you'll learn:

- A little bit about some common electronics development boards
- Cool things you can do with that Raspberry Pi that's gathering dust on your shelf
- What Johnny Five is, and why it's so awesome
- How to use your existing JavaScript skills to get things moving, literally

The Firebase guest wifi password used to be, "Realtime all the things!" And we really do mean things
You already have an amazing, modern, responsive web app so why should you maintain separate native apps? iOS, Android, Windows 10, FireFox and Chrome all have powerful app stores with users that we all want to reach and now you can with Manifoldjs. This session will walk you through the importance of the W3C “manifest for web apps” (also how to create one) and why it powers the apps generated by ManifoldJS. We will also walk you through app creation and how to unlock a world of APIs for you app that you don’t have in the browser.
Building complex async applications is really hard. Whether you use callbacks, Promises, or EventEmitters, Error objects should have a place in your utility belt. They are indispensable when it comes to managing work flows in a highly asynchronous environment. This talk will cover patterns for using JavaScript Error (with a capital E) objects to build resilient applications, and introduce some modules that can be used to build errors with an elegant history of stack traces even through multiple asynchronous operations.
The web stands as a ubiquitous, pervasive platform with unmatched access for digital entertainment. As HTML5, WebGL and VR fills the gaps between the flat, 2-dimensional experiences of old to bring flowing animations and immersive graphics, web-based audio has lagged behind until now. Using the first of what is expected to be several browser clients to support more engaging audio, Web developers have the ability to deliver premium audio experiences directly to users — no helper applications or plugins needed.

Dolby Senior Product Manager for web technologies, Todd Gehring, will explain how Web developers can take advantage of Dolby Audio in the browser and access the gold standard in audio. Todd will also explain how the format brings efficiencies to Web developers, enabling consistent high quality multi-channel audio playback across devices.

Then, hear how Garrett Nantz, Creative Director and Principal of Luxurious Animals detects browser capabilities, and delivers his audience the best audio experience possible in the ever popular HTML5 pirate mayhem game “Lux Ahoy.” Visit www.luxahoy.com with Microsoft Edge to hear for yourself.
The web stands as a ubiquitous, pervasive platform with unmatched access for digital entertainment. As HTML5, WebGL and VR fills the gaps between the flat, 2-dimensional experiences of old to bring flowing animations and immersive graphics, web-based audio has lagged behind until now. Using the first of what is expected to be several browser clients to support more engaging audio, Web developers have the ability to deliver premium audio experiences directly to users — no helper applications or plugins needed.

Dolby Senior Product Manager for web technologies, Todd Gehring, will explain how Web developers can take advantage of Dolby Audio in the browser and access the gold standard in audio. Todd will also explain how the format brings efficiencies to Web developers, enabling consistent high quality multi-channel audio playback across devices.

Then, hear how Garrett Nantz, Creative Director and Principal of Luxurious Animals detects browser capabilities, and delivers his audience the best audio experience possible in the ever popular HTML5 pirate mayhem game “Lux Ahoy.” Visit www.luxahoy.com with Microsoft Edge to hear for yourself.
Vorlon.js is intended to debug any device remotely with plugins like DOM explorer, Object explorer, network analyzer, etc..

During this talk, I will show you how to debug your web pages or web apps which can run on any device and even on your connected fridge with this browser agnostic tool based on node.js and socket.io.

I will also guide you through the plugin creation process.
JavaScript just got an exciting upgrade with the finalization of the ECMAScript 2015 spec, popularly known as "ES6," and browsers have already started adding the new language features. Even if your web app has to work in browsers going back to Internet Explorer 8, you can still use a large set of ES6 features in your apps today by using a source-to-source transpiler such as Babel. In the past year, ES transpilation has gone from a curiosity to a best practice, and it is likely to be the way we write JavaScript for the next several years. I'll talk about which features you can use right now and how -- with little to no impact on performance, debuggability, or browser compatibility -- and which features you may have to wait on.
The arena of proper authentication and data security standards is often some of the most misunderstood, confusing, and tricky aspects of building any Node site, app, or service, and the fear of data breaches with unencrypted or poorly encrypted data doesn’t make it any better.

We’re going to tackle this field, exploring the proper methodologies for building secure authentication and data security standards. We’ll run through:

* Building on top of OAuth 2 and OpenID Connect
* Node middleware services for authentication
* Working with proper hashing and salting algorithms, and avoiding others, for private user data
* Common auth and security pitfalls and solutions

In the end, we’re going to see that by understanding proper data security and authentication standards, pitfalls, and reasons for choosing one solution over another, we can make intelligent decisions on creating a solid infrastructure to protect our users and data.
You’re trying to develop the application of the future. You’re pushing the envelope by mashing up speech recognition, cryptocurrencies, machine learning, and virtual reality. Every last cycle counts. The web platform is great for getting your application out there, but too often the web is all about what you CAN’T do. Python on the page, nope. That C++ library you wanted to use, sorry, guess you’ll have to send the data to the server. Don’t like the latency? Want it to work offline? Forget about it. Garbage collector got you down? Your app runs too slow? Too bad. Your users are running on machines with dozens of cores, vector processing, and reams of memory, but you’re stuck on the outside looking in. All that is about to change...

Recent announcements from Mozilla, Microsoft, and Google hail a future in which web browsers will finally allow your application to securely tap into the full power of your user’s computing devices by way of technologies like Portable Native Client and LLVM’s Javascript backend. Native Code, threads, and SIMD will soon be useable out of the box in all the major browsers on desktop and mobile. Applications and libraries written in C/C++, Python, Lua, Ruby, and more will no longer be confined to the server.

Native Code is coming to the web in earnest, but standards take time, and you needed it yesterday. Fortunately, the Native Client SDK from Google lets you use a single toolchain to target all the browsers. We’ll help you navigate this changing landscape with best practices, workarounds, polyfills, and a feature roadmap. Come learn about what you can do today, what’s coming tomorrow, and how you can start building powerful apps that run everywhere.
he Node.js movement has transformed the landscape of UI development. In this session we'll look at how Node.js can be leveraged on multiple layers of the web application development lifecycle. Attendees will learn how incorporating Node.js into your front-end build process can optimize code, allow you to use use new and upcoming JavaScript features in your code today, and to improve your asset delivery pipeline. This session will also cover how Node is changing the template rendering landscape, allowing developers to write "isomorphic" code that runs on the client and server. Lastly we'll look into using Node to achieve developer zen by keeping the codebase clean and limiting the risk of changes to the code causing unknown errors.
Web Components is a term used to denote a number of experimental technologies that are instrumental in the advent of the Open Web. Web Components help in creating custom markup and script based intelligent controls, encapsulation of complex DOM from the end user (Shadow DOM), template-based rendering and reuse of markup within client code (HTML Templates), and partial HTML files and ability to connect them together.

This talk will cover custom elements including their lifecycle callbacks, new pseudo classes, Shadow DOM and its practical use cases, HTML Imports, and HTML Templates and how they help avoid using another framework for template based rendering
Sass: The learning bridge between HTML/CSS and JavaScript. Many design students new to the programming world enter by learning HTML and CSS. As they make a leap to their first programming language, such as JavaScript, or a library like jQuery, many encounter difficulties, and some drop out of the web world entirely. Teaching resources for JavaScript aren’t necessarily presented with designers in mind — they are created for those who have a programming mindset, or they already know a programming language.

Sass, the CSS preprocessor, features data structures like if/else, loops, variables, and functions. Sass can be written in SCSS format, where the syntax is like CSS, but it must be compiled before sending to the browser. By introducing students to common data structures through Sass, the leap from Sass to JavaScript or jQuery is much smaller and smoother.

In this talk, Jen Kramer proposes a curriculum for easing design students gently into learning JavaScript or jQuery, or any other programming language of interest, by introducing data structures in Sass first.
One of the benefits of a library like jQuery is that it smooths out all of the weird browser inconsistencies you might run into. But, all that abstraction and extra code adds a lot of weight and performance latency to a site.

Modern web and JavaScript APIs make it much easier to write scripts without the bloat (and dependency) of a library. This talk provides participants with modern techniques for building feature-rich websites, and explores native JavaScript equivalents of common jQuery tasks.
Momma always said, "Don't roll your own crypto." Luckily, now that browsers have finally started to implement WebCryptoAPI, websites don't have to roll their own javascript cryptography anymore. Rejoice!

In this talk, I will give an overview of WebCryptoAPI. What crypto primitives are included? How do you use the API? What browsers support what? What are some examples? What are the best practices? What should be avoided like the plague?

Webcrypto Examples
With ES2015 now a standard and powerful transpilers like Babel at our fingertips, we are able to write cleaner, more expressive JavaScript. But why stop there? Features for ES7, or ES2016, are now going through several proposal stages and offer even more syntactical power. In this daring presentation, we will look at many of the new proposals, even those that are still on the table for being accepted. We will learn about async/await, class decorators, the function bind operator, comprehensions, and other ES7 features. We will see the benefits these new features offer and be better informed to support the addition of them in the next ES standard.
I'm excited to share with how EcmaScript 6 (ES6) has helped us clean up our code base and standardize conventions at PayPal. We'll cover some of my favorite syntax enhancements and show a lot of real-world code and how it compares to doing things the old way. This talk is really meant for people of all skill levels with JS. I'll be talking through the basics of ES6 and showing how they make life much easier in practice. If there's time we'll also chat briefly about platform support for ES6 and how to build code in ES6 that you can run everywhere!
If there is bad press about our favourite server side platform it is because of performance issues and how hard it is to track them down. Usually these problems are hiding during development but start to kick in under high load. Not good.

In my talk we will go through the "hall of fame" of Node.js performance problems and the error patterns behind them.

Then we will take a pleasant walk to "Mount Doom" ... this means we will learn how to create and decipher flame charts to hunt and understand memory leaks. By doing so, we will even look at some C++ code and get some insights on how Node.js is working internally.

After taking the hard road we will explore tools and techniques that help us to tackle performance issues more easily - even during development.
The power of VR is being used to create a brand new class of web experiences. We will explore examples of what the holographic web is capable of, describe what we have built to make it happen, and demonstrate how you can create holographic web apps using Three.js and AltspaceVR.
This talk is dedicated to helping you use analytics to find out more about your mobile customers through their hardware as well as how they interact with your website. I’ll share with you concrete tactics that have helped me put into practice the Lean UX ideal of build, measure, and learn.

In this energetic talk you will see real-time demos and illustrative slides serving an audience of designers and developers wanting to learn more about their customers. Whether you’re already analytics driven, or simply curious, we’ll take a deep dive into techniques empowering your decision making to rise above your competition.

We’ll quickly move past obsolete vanity metrics such as page hits and visit counts. Introducing JavaScript source code examples will tell what buttons, options, and selections your users make. This is especially crucial for modern, single-page web applications. You can use these code samples to evaluate legacy feature use, adoption of recently added features, operating system upgrades, and device screen sizes.

A brief survey shows how these same techniques work for other applications including iOS and Android native apps, Java backend services, and any connected device. Google Analytics is the focus because it’s within easy reach, and a market leader.

Top Takeaways

1. How you can transform analytics big data into actionable knowledge better informing your decisions for building and fine-tuning your user experience

2. What can analytics tell you about hardware your users have, what operating systems, and browsers they use guiding where you spend your design and development budget

3. How to code precise user interactions with button and toggle controls on your web page/web app.

4. See how to build a custom dashboard for reporting key mobile-first trends regarding your website, app, and how content serves your users’ needs

5. Quickly survey how analytics can be useful in a backend service, and coded in a native mobile app.
In this I will talk about how javascript has evolved from an in browser language used to change html and css to full programming language with many libraries and frameworks built aroun it. I will dive into the basic javascript then jquery, then jquery mobile, backbone angular and then more recent freamworks that are not just used at the client site but also works on the server side such as nodejs, marionette for backbone, meteor, invisible.js etc. To commence this I will go over how front end has evolved into career independent of the backend, supporting the statement that full stack developer is a myth.
For years, front-end developers have turned to preprocessors like SASS and CoffeeScript to fill in the gaps in native languages like CSS and JavaScript. Although these tools have transformed and enhanced the way we write code, they've also forced us to work in nonstandard syntaxes, bouncing from one compiler to the next as we try to find the perfect build process. But what if there's a better way? Learn how postprocessors and transpilers can revolutionize your code and workflow. If the idea of writing CSS4 and ES7 code today without compromising browser support sounds like crazy talk, you're in for a wonderful surprise.
To measure is to know, said Lord Kelvin and we couldn't stress enough the importance of monitoring from the simplest website to very sophisticated applications. It helps us know how a system performs and how our customers are using it, so we can keep improving.

Many developers won't implement monitoring or opt for outsourcing it because they believe it is too hard to build or maintain. Let's debunk this myth and help them in their journey to becoming better full-stack engineers by owning and understanding a critical piece of their systems.

In this talk, we will demonstrate how developers can easily build a homegrown monitoring solution by leveraging the some of the new W3C APIs: Navigation Timing, Performance Timeline, Resource Timing and Beacon. We will check the latest browser support and polyfill when needed. Then, we will learn how to stream all that data down to a time series database, where it should be ready to be queried and analyzed.
Web applications need to evolve over time. The best way to encourage this evolution is by building module based component systems. This allows for easier iteration, less refactoring, and better products for the consumers.

Mike Kivikoski will show how to design a module based component system using a CSS preprocessor, such as Sass. This technique allows us to design faster and in the browser, gives us the chance to put together various layouts while reusing UI patterns, and to help create cohesion and comfort for the user. Mike will demonstrate how to setup this system, build it, and use it within a product.

At the end of this talk, you’ll understand the concepts of:

- What a module component system is
- Sketching layouts using components
- Building reusable components
- Putting together a flexible syste
Still using a “generic” CI pipeline to get your UI into production? This talk will identify and capitalize on some important characteristics of in-browser code, that will allow you to get features and fixes into production sooner (and more safely) than you ever thought possible. We’ll discuss:

* multi-tenancy - having multiple apps served up by one asset serving layer
* allowing a subset of your users to opt-in to a regression testing environment
* feature “buckets” for A/B testing
* previewing individual builds before users get their hands on them
* zero-downtime deployments
* handling cross-component dependencies properl
Do you want to know why CSS works the way it does? Learn to think about CSS from a technical, not just visual perspective. This is an in-depth workshop covering the intricacies of CSS.

Best suited for developers of all types who want to get a deep understanding of CSS architecture. You would benefit the most if you already have some basic understanding of HTML and CSS.

- CSS box model
- Unique characteristics of CSS display types
- Solving the mysteries of floats
- CSS unit types
- Vertical rhythm
Babel is a transpiler, a program for performing transformations on JavaScript code, and then outputting new code. The main thing this allows is for you write your code using the newest JavaScript specification, ECMAScript 2015 (ES6), and then transform it into code that will work in browsers and platforms that don't support all ES2015 features.

In this talk, we'll walk through building a simple ES2015 (ES6) application that will run anywhere, whether or not the original platform or browser supports the newer version of JavaScript. This will include using Babel for browser-based applications, as well as Node applications, and will also cover how to approach using ES2015 transparently when developing distributed NPM modules.
Creating dynamic data visualizations on the web is a pain in the ass.

You either have to use dumbed down libraries that won't let you do what you want, or make everything from scratch. Every time.

d3.js is marvelous - a jQuery for SVG and dataviz. But building complex interactive data visualizations in pure d3.js feels just like building rich web apps in pure jQuery. Messy.

You want a quick way to build complex visualizations. Build once, use everywhere. In every project.

That's where React comes in. Its speedy rendering and spectacular modularization make it the perfect companion to d3's computation functions.

In this talk I will show you why using them together was the most fun I've had with a computer since I was 17.
Layout on the web has been missing a proper solution for creating grid designs since the beginning. But this dark period is coming to an end with the new CSS Grid Layout spec. Grid layout is being implemented in every major web engine. The good news is that it will be hitting your browsers very soon.

During this talk we will not only review its syntax and main features, but also explain the internal details about what the browser has to do to render a CSS grid. After the talk, you'll be able to start playing with CSS Grid Layout, understanding the underlying steps involved, and provide feedback to the spec editors and browser implementors.
Internationalization is hard. To make things easier, we use abbreviations like i18n and i10n.

However, when it came time to actually internationalize and localize our application, it gets even harder.

Fortunately, there are an endless array of open source tools that your team can pull together to make the whole process a lot easier. Let’s talk about the tools that we decided to use and how we’ve made it easy for our team to integrate them through the best way programmers know how: automation.
In the last few years, PhoneGap and Apache Cordova have gained a lot of traction among mobile app developers. Using a shared codebase, JavaScript developers can build apps for iOS, Android and Windows using the same frameworks they use for the web. But mobile apps carry a different set of user expectations. Users expect “native performance” – i.e. slick animations, fluid page transitions, snappy load times and instant visual feedback for user interactions. I've talked with developers building some of the most popular control frameworks (e.g. Ionic, OnsenUI, KendoUI) to learn how they think about building performance into the mobile web and hybrid apps. In this session, we’ll learn from their experience and chase this elusive rabbit with all the tools at our disposal. We’ll answer:

1. By the numbers, what really constitutes “native performance”?
2. What pitfalls lead to poor JS performance in hybrid apps?
3. How can you avoid the most common performance pitfalls?
4. How can you use diagnostic tools to identify problems in your apps?
5. What design tricks can you use to get that authentic “native” look-and-feel?
We are all thrilled to welcome exciting new HTML5 features for modern web application development. Nevertheless, HTML5 does not guarantee seamless migrations, making the transition to this new standard non-trivial. For instance, HTML5 lowered the precedence of HTML comment, as compared to HTML4. As a result, developers cannot blindly upgrade by changing only the doctype of an existing HTML4 document. On the other hand, amid meeting the HTML5 standard for new applications, developers cannot neglect legacy browsers which do not understand HTML5, yet are still substantially popular.

In case the issues are not properly handled, a document being “misinterpreted” by browsers will produce different DOM trees, and that break not only the presentation visually, but also business logic and even security. The traditional validator (or, lint) approach can give some warnings due to parsing discrepancies between HTML 4 and 5. However, it is still non-scalable and error-prone for developers to fix them manually, let alone other compatibility issues arising from typos and browser quirks.

We present a novel canonicalisation approach to automatically correct these compatibility issues, in which the corrections are decided in favor of security and the parsing rules of HTML5. We have built and open-sourced a developer-friendly utility [1]. The rewritten HTML is compliant to HTML5, and could be consistently parsed across popular browsers. This can significantly relieve developers’ burden by ensuring consistent HTML parsing and a resulted DOM tree for display and JavaScript logics to work on.

The importance of this work is also justified by its use in the Safe JavaScript Templating framework to defend against Cross-Site Scripting (XSS) [2]. This framework performs HTML contextual analysis and applies context-sensitive output escaping filters accordingly. In particular, the HTML analysis must first clean up the compatibility issues with the canonicalisation process, without which an XSS vulnerability could be resulted. This is because an output escaping filter would render ineffective if it is applied to a position where the HTML output context is ambiguous among different browsers and the analyser.

In this talk, we will cover the identified compatibility issues, arising from different HTML versions and browser parsers. There however exists no automated solutions, and it does not scale to fix them manually. We propose the canonicalisation process to rewrite HTML that can be consistently parsed across popular browsers, thus preserving the presentation, business logic, and security of web applications. We will introduce how to use the automated utility, and how the issues are resolved automatically, gracefully, and securely. We also provide a proven use case in Safe JS Templating, in which the canonicalisation is crucial in defending against XSS attacks. The automated solution can help not only developers address the compatibility issues, but also the community in embracing HTML5 more aggressively.

References:
[1] Context Parser
[2] Safe JavaScript Templating

========
This work has a second author Nera Liu (neraliu@yahoo-inc.com), also from Yahoo Paranoid.
HTTP/2 and QUIC are both advanced transport protocols for. Many users today receive data using one or both, without realizing it. This talk will focus on the current state of play in the industry for these protocols, how they work (or not!) and how you can use them to make your site faster and smarter
It gives an overview of JS independent principles, that helps to create an application which is not coupled with frameworks. It shows what are the benefits and risks to follow these principles. It shows how to apply these principles to JS and what are the differences to other heavily OO languages. It tells why is it applicable to functional programming styles, and how it helps to write cleaner code. Shows a real life example, how to structure the code and create the directory structures. Shows in examples how it is helping Test Driven Development, and how it makes easy to write tests.
How do transpilers work?
How do you trust a minifier to not break your code?
Why do require() calls and browserify sometimes work and sometimes not?
How might you autogenerate documentation for your application?

A substantial portion of the tools you use now and will use in the future are operating on your source code as the input data. In order to do this consistently and effectively, your source code needs to be parsed into a data structure that can be analyzed, modified, and transformed back into JavaScript.

How does that happen? What kinds of things can you do when you start treating your source code as data? There are numerous tools you can use right now to start exploring ideas that have only just started to be imagined.
Secure Peer-to-Peer Browser Communication: Using PGP and webRTC to create a trusted decentralized communication network in the browser. Encrypted direct messaging between two browsers? There’s a lot of specialized tools designed to communicate securely, but what if truly private communication was as simple as opening a browser?

Explore the challenges of building a JavaScript driven decentralized network including trusted peer lookups in a partitioned system, mitigating malicious peers, and handling tracker failures. We will discuss using nodeJS, webRTC, and PGP (via Keybase.io) to create a robust, decentralized, system for establishing trusted communications between browsers.
“Hold my beer.” Those three words have preceded some of the greatest moments in history. But who would’ve thought they’d pave the way for an epic user testing session? In this talk, Austin Knight (UX Designer at HubSpot) will discuss a drunken usability experiment and the unexpected influence that it had on the way that user research is conducted. Learn about new and unconventional methods for overcoming the struggles and pitfalls of traditional user testing, obtaining true and honest user feedback, and verifying the usability and simplicity of a design. Discover the resulting impact on bottom-line metrics like conversion rate, retention, engagement, and revenue. Walk away with a list of tools that you can use to conduct similar research and experiments on your own projects. Finally, learn about what it means to have a Culture of UX and gain actionable advice on how you can create it within your own company.
Not long ago, WebGL was the purview of a few brave creative coders. Today, it runs on virtually any device you could want to support, and is adopted in mainstream apps that we use every day. And the pace of adoption is accelerating, with WebVR just around the corner.

Web delivery of interactive 3D is what will unlock VR and highly engaging content for the Enterprise. In this talk I'll show where we are today, dig into the technologies underpinning this transition, and preview the interest and demand that we're seeing for interactive 3D.

This talk will be of interest to anyone who builds applications at scale, either for enterprise clients or aspiring to be an enterprise scale business. I'll use three.js and MozVR for code walkthroughs, but this will be also of interest to designers conceptualizing next generation content experiences.
D3.js is no longer the new kid on the block, but still remains the weapon of choice of many for data visualization in the browser. Like most frameworks, there is a certain "D3 way" to follow, and deviation from that path is fraught with peril and frustration.

You know those sessions where you sit for an hour and pick up only one or two tidbits of useful knowledge? This is a presentation of just those good parts. I'll reveal the secret on how to think the "D3 way" and show practical work examples that illustrate both design concepts and implementation details specific to D3. I'll share some common dead ends, false starts, easy wins, epic fails, and ultimate triumphs.
This would be a "sneak peek" into CSS4. I would talk about what's new and what's gone. How CSS4 going to be useful and what problems is it going to be solving?

TBD

Sponsors