Kyle Simpson offers observations from seven years of conference talks.
The Angular team has been investing in building techniques that enable large teams to build robust applications that span desktop and mobile. Brad Green covers the new specs for zones and decorators and explains how new techniques make it easy to use advanced browser features like web workers, HTTP/2, and service workers for building robust apps.
Angular 2 comes with new paradigms and features that make it a powerful tool for today's Web. Jeremy Wilken explains how to structure and build an Angular 2 app using TypeScript and ES6+. You'll get practical training on Angular 2 architecture as you learn how TypeScript can improve your applications and how ES6+ makes Angular 2 more approachable and easier to work with.
MQTT is a standards-based, lightweight pub/sub messaging protocol ideal for Internet of Things use cases. With implementations in a number of different languages, using MQTT in your applications is simple and straightforward. Ryan Baxter shows how to build an application that connects to an MQTT broker and can receive data from—and issue commands to—a number of different IoT devices.
Scalable vector graphics (SVGs) are now extremely well supported. In the age of multiple screen resolutions, SVGs offer the potential for clarity, reduced byte size, and a navigable DOM. What does this mean in terms of animation? Sarah Drasner covers advanced, performant SVG-animation techniques that offer cross-browser stability.
Sarah Drasner demonstrates how to use GreenSock (GSAP) to create seamless, engaging, complex SVG animations with ease.
Elijah Manor brings backend or junior devs up to speed on CSS by explaining foundational concepts, such as the box model, specificity, position, cascading, and sizing, and introducing newer concepts, including Flexbox, Sass, BEM, Autoprefixer, and CSS modules. You'll walk away with a set of tips and techniques that make CSS easier to organize, understand, and maintain.
Progressively enhanced sites are awesome, but testing all their permutations across browsers is not. Using Nightwatch.js, Brian Belhumeur demonstrates some techniques you can use to write end-to-end tests that will adapt to the capabilities of the targeted browser so you can spend less time maintaining your test matrix and more time making it more adaptable and future-proof.
Failure is inevitable—even praised in startups and technology—so why aren't we better prepared for it? Josh Simmons has failed in freelancing, small businesses, agencies, and startups. Let him be your cautionary tale. Josh outlines the top 10 ways to fail and explains the 3 major components of failing well.
Jamund Ferguson offers an overview of Paypal's transition from AMD to CommonJS, a very beneficial move. Moving from RequireJS to webpack meant Paypal could use any module in npm on its frontend and has made it easier to explore new technologies like Flux and React. Jamund summarizes Paypal's experiences to demonstrate how you too can move to webpack with ease.
After you've built an application, written some unit tests, integrated a linter, and hooked up a CI system, what should you do next? Level up, as Ariya Hidayat explains how to track code coverage, leverage Docker for a consistent development platform, and implement cross-browser testing.
Developers want to rapidly build cloud applications and make them available to as many users as possible, as fast as possible. However, translating applications has not changed very much. Steve Atkin explores IBM's new Bluemix service, Globalization Pipeline, which seamlessly integrates real-time machine translation and persistent human postediting capabilities.
Nicolas Bevacqua explores the past, present, and future of web performance. Nicolas quickly covers what you're already doing—minifying, bundling, and using progressive enhancement—before moving on to what you should be doing—optimizing TCP, inlining the important stuff, and deferring the rest so that you don't block the rendering path. Nicolas also explores what HTTP/2 has in store for the future.
Laurie Voss tells the story of how npm made the journey from a monolithic, single-process registry to a distributed system made up of separate measurable, testable, and manageable microservices. Laurie highlights the process and philosophy behind this immense behind-the-scenes change.
There are compelling arguments why companies need to care about serving faster pages to their users. Countless studies have found an irrefutable connection between load times and key performance indicators, ranging from page views to revenue. Tammy Everts outlines research-based reasons why you need to care about web performance and what you can do to make your pages faster.
The new HTTP/2 protocol is mostly focused on web performance, but what kind of performance improvement can you expect by switching to HTTP/2? Ragnar Lönn explains the key improvements within HTTP/2 and demos a new application developers can use to see how their applications will function on the new protocol.
Typography pervades most facets of our modern lives. We can learn a lot from typography's rich, colorful history as well as from the modern trends that affect every aspect of the design and development of digital products. Jonathan Beebe demonstrates the most effective uses of typography to influence users and explores the current set of problems designers must grapple with.
Programming is hard; making compilers is harder. Or so people think. The truth is that making a compiler is just a series of small steps using regular language constructs. It's so easy, we'll make one in this talk.
Even though each of us is only 1 of 7 billion, we all want to feel special. Product personalization is transforming the Internet experience to be all about me (and you too!). Yao Morin explores how to create customer-centric experiences through data science and software engineering, using Intuit TurboTax as a case study.
A "living" style guide uses an actual library of frontend assets instead of existing as a static PDF. Living style guides can bring consistency, agility, and many other benefits to an organization's web apps, but there are potential pitfalls. Shane Russell melds dev-community wisdom with a firsthand account of implementing a living style guide across a suite of web apps at a health provider.
Flexbox and Grid offer powerful layout methods for the Web. However, to make best use of them, you must familiarize yourself with some new core concepts. Rachel Andrew demystifies the new CSS layout methods so you can fully benefit from their power.
Web apps have long been considered underpowered compared to native mobile apps, but what's really at the root of this perception? Alex Russell describes a new way to build that combines emerging browser features into something that just might answer the question.
The state of web accessibility is rapidly improving. This rising tide lifts all boats by driving quality frontend development. Laura Palmaro explains how we can continue this upward trajectory using the rich array of tools and learning resources now available.
Cory House gets participants started in React and Flux by helping them build a real-world application from the ground up, using react-router, Node.js, Browserify, and ESLint to help make it happen. You’ll be amazed how quickly you can build a responsive single-page application in this modern stack.
Is your AngularJS application becoming too difficult to maintain? Corinna Cohn explains how to take an overburdened application and make it maintainable by separating concerns of retrieving models, creating components, and isolating business logic. You will learn techniques for making your own code cleaner and more maintainable by writing small, testable modules instead of tangled monoliths.
Building Docker images is easy; that’s why there are over 45,000 public images on Docker Hub today (albeit only 100 of them "official" images). Creating reproducible, secure images from source that are easily maintained and updated takes a bit more planning and automation. Ryan Jarvinen illustrates what it takes to create a successful (and secure) build strategy.
Oliver Friedmann introduces Ziggeo's open source framework for video recording and playback, which features responsive HTML5-enabled components with Flash fallbacks for older browsers. It is customizable and extendable via the components' state machines and their dynamic templating system and works across all platforms, including mobile browsers.
Web apps are complex and comprised of many technologies. It can be difficult to simultaneously scale large server and client codebases. Scala is an expressive, performant language that can now run in your browser as well as on the JVM. Paul Draper explains how Scala's presence on the two most ubiquitous runtimes greatly assists web developers.
It's one thing to create a sample RESTful API using Node.js, but it's quite another to horizontally scale your architecture to hundreds of thousands of concurrent connections while trying to ensure redundancy and high availability. Volkan Özçelik shows what it takes to create real-life, scalable, highly available, and highly responsive Node.js applications.
If you work with web technology, at some point you'll work on something people will see. What's the quickest way to better interfaces? Tracy Osborn explores the two most important principles to get you started on the path to being a better designer.
“Feel free to submit a pull request.” For some, this is a welcome invitation, but for many developers, pull requests are intimidating, discouraging them from contributing to the community. Kent Dodds demonstrates how easy and fun it is to create a pull request as a first timer. And if you’re a project maintainer, Kent will show what you can do to make contributing easier and more inviting.
From unit testing to visual-regression testing to even testing accessibility, the list of frameworks that help you test your code—already quite a large landscape—continues to grow over time. Alicia Sedlock gives an overview of the state of frontend testing and explains how you should go about choosing which tests work best for your product.
The Web has grown to become a hugely important medium, but it has also become horrendously complex, which extends development schedules and promotes bug formation. Douglas Crockford introduces Seif, an open source project started at PayPal with the goal of transitioning the Web into an application delivery system that will be safer, easier to use, and easier to develop for.
If you've always wanted to play around with D3 or Julia, Philip Tellis will bring you up to speed very quickly. Philip explores both Julia and D3 to demonstrate how to extract meaningful information from web-performance data and guides participants through some fun visualizations that are possible only when using these tools together.
The ability to visualize millions of data points opens up a world of applications. But it’s hard to quickly render that much data, let alone compute anything with it. Thibaud Hottelier shares the GPU technology—a hybrid client/server GPU engine using Node-OpenCL and a new library, CL.js—that Graphistry used to break the million datapoint barrier for fast, interactive visualizations.
The Internet's security depends on cryptography. People use "secure" websites to take advantage of current cryptography methods. But what if users can't (or don't want to) trust the web server with their secrets? Web-page authors can use the Web Cryptography API to give their users end-to-end secrecy and authentication through web servers, not just to them. Charles and Laurie will show you how.
Tony Parisi explores the latest developments in web graphics using WebGL 2. Tony covers the new version of the 3D standard, as well as related technologies such as glTF for 3D data transmission and WebVR for web-based virtual reality.