All decks
  • Learn React

    This course is for React newbies and those looking to get a better understanding of React fundamentals. With a focus on React fundamentals, you'll come out of this course knowing what problems React can solve for you and how it goes about solving those problems. You will have a good grasp on what JSX is and how it translates to regular JavaScript function calls and objects. Each lesson in this course is just a single index.html file which will help you keep your focus on learning React and not distracted by all the tools that make production applications work. The course wraps up with a lesson on how to move from these index.html files to a more production ready development environment and even how to deploy your app to a great service like Netlify. Enjoy!

  • JS@PayPal

    JavaScript + PayPal = ❤️

  • Confident React

    We want to make sure that when we ship new code, our users can use the application. The best way we've found to do that is to write automated tests that run before we deploy a new version of the app. But if our tests aren't doing exactly what the user will do, then how do we really know that things will work when users interact with our apps? Let's rethink what it means to ship applications with confidence and what it takes to get there. With improved tools and practices, we can be more certain that what we're shipping to our users will work the way it's intended.

  • Advanced React Patterns

    Making React components that can be used in multiple places is not hard. What is hard is when the use cases differ. Without the right patterns, you can find yourself with a highly complex component that requires a lot of configuration props and way too many if statements. With this course, you'll not only learn great patterns you can use, but also the strengths and weaknesses of each so you know which to reach for to provide your components the flexibility and power you need. I have contributed to and published some of the most successful React components in the React ecosystem. Through that experience, I've learned and taught patterns that enhance flexibility, usefulness, and simplicity.

  • Simply React

    One of the things I love about React is how easy it is to encapsulate UI code into a component. I love this because it makes reuse of those components easy. But is it easy? I’ve made my fair share of components that had to accept a bunch of props to handle a growing list of different use cases resulting in a complex render function full of conditional statements and a confusing API for people using this “reusable” component. Eventually it becomes too much and I had to make a new version of the same component to handle slightly different use cases. Lots of code/bug duplication there because my reusable component wasn’t reusable enough. There are patterns that have emerged in React that allow you to promote code reuse without sacrificing the simplicity or flexibility of the component. In this talk we’ll go over 5 of these patterns that will make your React components more useful.

  • How open source has made me and the stuff I make better

    The open source community and ecosystem have made me a better software developer and helped me develop better software. I get to see how other people work. Other people get to see how I work. It encourages me to put forth my best effort, think critically about the software I'm creating, and ensure it has great documentation. It's also easier to develop software in an isolated environment like an open source project. In this talk, we'll see how open source can help improve your skills and improve the software that you create. This makes you a much more skilled, marketable, and gives you work that you can share with the public and contribute to the open source ecosystem.

  • How to React

    Learning React can be confusing. React is a library, but even more than that, React is an ecosystem of tools that you piece together to create a program. This is a powerful property of the React community, however that ecosystem can be frustratingly distracting when you’re a newcomer trying to get your feet wet. The key to avoiding this frustration and confusion is to learn React (and its ecosystem) in the right order. In this talk, we’ll go over what that order is and give a roadmap so you can have a vision of where you’re going. Let’s learn how to React!

  • Testing React and Web Applications

    Developing and deploying production applications with React is one thing, but being confident that you’re not shipping a hidden bug is something else! Knowing how to configure and use testing tools is critical to your success in shipping with confidence, and React's model opens up testing productivity most of us couldn’t even dream of before.

  • Testing Practices and Principles

    The goal of a test is to increase your confidence that the subject of your test is functioning the way it should be. Not all tests provide the same level of confidence (some provide very little confidence at all). If you’re not doing things correctly, you could be wasting your time and giving yourself a false sense of security (even worse than having no tests at all).

  • All About babel-plugin-macros

    babel-plugin-macros is super cool

  • Write tests. Not too many. Mostly integration.

    Guillermo Rauch tweeted this a while back. Let’s take a quick dive into what it means.

  • Maintainable CSS with React

    TODO

  • Tools of modern JavaScript projects

    The cry of JavaScript fatigue still echoes in the minds of developers everywhere as they try to wade through the waters of outdated blog posts, tutorials, Stack Overflow answers, and GitHub repos. Just when things seem to start settling in JavaScript, something new comes to shake things up a little bit. I’ll be you tour guide as we navigate through the tooling set up of a modern JavaScript project that’s leveraging these tools in a way that actually enhances the experience of users using the project and developers working on it.

  • Concerning CSS in JS

    I no longer care about: specificity, CSS linters, CSS preprocessors, vendor prefixing, removing unused CSS, finding CSS dependencies and dependents. I now care more about: whether it’s fast enough, whether it’s small enough, whether it’s familiar enough. These are some of my trade-offs. Because I use CSS-in-JS. I’ve made trade-offs because I write HTML-in-JS. Despite these, I still do it, because the cost is minimal enough, and the benefit is great enough. Let’s tell stories, talk use-cases, explore trade-offs, and inspire more innovation to make the CSS-in-JS trade-offs less trade-offy.

  • Styling React Components

    The CSS-in-JS movement is strong in the community and we're still figuring things out. But one thing is clear: keeping your UI logic, markup, and styles together to make a single component is a great way to build applications.

  • Code Transformation and Linting Workshop

    Have you ever needed to change the API to a widely used function in your JavaScript application? Find and replace can really only take you so far. What about the frustration of iterating over and over again on pull requests because of simple code mistakes developers keep making? These are only some of the problems that you can solve with a basic understanding of Abstract Syntax Trees and the tools you can use to inspect and manipulate them.

  • Testing Workshop

    1. Unit Testing with [Jest](http://facebook.github.io/jest) 2. Integration Testing with [Jest](http://facebook.github.io/jest) 3. End to End (E2E) Testing with [Cypress](https://www.cypress.io/) We'll mention other forms of testing, but these are the types we'll focus on and learn in this workshop. We'll learn about the benefits (and tradeoffs) of [TDD](https://en.wikipedia.org/wiki/Test-driven_development). We'll learn how to configure the tools and why, when, where, and what to test.

  • Faster JavaScript

    This talk is about how a program slicing tool can help us learn code faster as well as ship less code (which will load, parse, and run faster).

  • Template

    This is the template for my decks.

  • Testing React with Jest

    This is a talk about testing React with Jest

  • Testing React with Mocha, Enzyme, and Chai

    This is a talk about testing React with Mocha, Enzyme, and Chai

  • Writing an Open Source JavaScript Library

    We’ll get started by giving an overview of what we’re going to build, then we’ll get our blank slate going with a package.json. We’ll talk about the significance of this file and the various properties we’ll use to help us with the distribution and management of our module and its dependencies. Then we’ll add the tooling needed for testing our library and adding code coverage. This is something that’s really important to get working early on in the project, so we’ll get it done early. Then we’ll jump into setting up the tooling for transpiling our source code from ESNext to ES5 so we distribute code that can be consumed by people delivering to older environments (like old Node or browsers). Then we’ll add the tooling we need to distribute a browser version of our library so people can consume our library in the context of a browser (without having to bundle it themselves). As contributions to our library grows, it’ll be important to be able to check that the contribution passes our unit tests automatically without having to pull down every pull request to test it locally. So we’re going to add continuous integration with TravisCI to automatically run our tests and report the code coverage reports to codecov.io With this infrastructure set up, we’ll then add semantic-release to automate releases of our library. This will help us reduce a great amount of human erro

  • Webpack Deep Dive

    We’ll start out making sure that everyone’s on the same page with what webpack’s role in application development is and some of the core concepts like loaders and plugins. Then we’ll look at the application we’ll be testing our knowledge on and start it off with a basic webpack configuration. Then we’ll set up unit testing with Karma and webpack as this is one of the most important things to get right early on. We’ll go through the whole process including setting up code coverage. After lunch, we’ll dive into some of features that come with webpack which can be used to improve the performance of our applications. We’ll cover code splitting, fine tune our browser caching setup, and wrap up with the CommonsChunkPlugin to optimize how we share common code between different parts of the application.

  • Managing an Open Source Project

    Awesome! You’ve made it big! You’ve published an open source project and people are actually using it to make the world a better place. Achievement unlocked! Great job! But wait… what’s this? An issue? Oh, it’s just a bug. Pretty quick and easy. Fixed, released, done, #likeaboss 😎. What’s this? A PR? How cool! Wait… That’s not quite right… Oh, a question! Cool! And another! And another… eh… and another… Uh oh… I think I’ve just sold my soul to this project. You start an open source project to scratch your own itch and suddenly other people start using it and they need your help. This can easily start eating up your time big time and before you know it, your kids start feeling neglected. I’ve had to deal with this in a few projects and I’ve learned a thing or two about work/life/oss balance. I have a few tricks that help you make the project manage itself a bit more while still being friendly and helpful to users of the project.

  • More than you want to know about ES6 Modules

    ES6 Modules have been standardized and many have already started using them. They have a lot of benefits over CommonJS, AMD, and Globals. Unfortunately, there are many ways to deal with modules with this new syntax and it can be a bit confusing. In this talk, we'll explore the different ways you can use the new syntax and when you'd use the different methods. We'll also investigate what's going on at a high level. Buckle up for a firehose of ES6 information .

  • The First Pull Request

    “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. This talk demonstrates how easy and fun it is to create a pull request as a first timer.

  • Testing React with AVA workshop

    This is a workshop for how to test React code with AVA.

  • Zero to 60 in software development

    Our industry has a problem. We have a "talent shortage," so we're loading the industry with new developers from various bootcamps, but companies aren't willing to hire them. So these new developers are left to themselves to try and find ways to develop the skills they need to be "marketable." I graduated from college in April 2014, just shy of two years ago. In that time, I've been able to learn a ton, build a bunch of stuff, teach workshops, create egghead screencasts, speak at conferences, and generally contribute quite a bit to the JavaScript community. In this talk, I'll cover some solid principles of things that I’ve learned in my experience. This will help new-comers to jumpstart their career. And help old-timers know how they can help new-comers.

  • Writing custom Babel and ESLint plugins

    The Abstract Syntax Tree. It sounds a lot worse than it is. It’s actually quite simple and enables some powerful tools. BabelJS uses it to transform your code from ES.Next to ES5. ESLint uses it to lint your code. And with a knowledge of how it works, you can extend these and other tools to do some mind bustingly powerful things. Prepare to be amazed by ASTs!

  • Webpack Workshop

    Migrating a Backbone + Require.js App to Webpack. Including ES6, testing, code coverage, ESLint, CSS-modules, and more!

  • Open Sourcing Your Stuff

    How to write an Open Source JavaScript Library

  • Learning JavaScript

    The value of Learning JavaScript and staying marketable. A talk for ng-nebraska

  • Open Sourcing Your Stuff

    How to write an Open Source JavaScript Library

  • ES6 Workshop

    ES6 Workshop. The what, why, and how of the new features in JS

  • ng2-introduction

    Introduction to Angular 2. Let's build something together.

  • moxee

    moxee. Enforcing modularity in Angular Applications

  • ng-model-options in 5 minutes

    ng-model is super awesome, but sometimes you want to have a little more control over when your model is updated. You need... options ;-) this is where ng-model-options comes in handy.

  • angular-formly

    Learn why you don't like html and angular-formly can help you with that :-)

  • angular-bindonce

    Utilizing Angular 1.3 one time binding functionality

  • gh-pages

    What are and how to use github pages

  • NG-JWT-Workshop

    A demonstration of why and how to use JSON Web Tokens instead of cookies for Authentication in Web Apps.

  • Bucket Streams

  • Genie

    Genie is a JavaScript library committed to improving user experience by empowering users to interact with web apps using the keyboard (better than cryptic shortcuts).

  • Intro to AngularJS

    A simple introduction to AngularJS for new people. This presentation isn't super useful on its own. It's useful to have someone explain the concepts to you, and to follow along. Attribution for the original presentation goes to Dave Geddes.