1. Jul 3, 2015
    03:27

    What Is Tracker?

    Introducing the Tracker class. Meteor uses a programming technique called 'Reactive Programming' in the browser to automatically propagate data changes through your application. You're probably already using several reactive data sources like Session and Cursor. In this class you'll...

  2. Apr 21, 2015
    01:50

    Introduction To Understanding React

    Introducing the Understanding React class.

  3. Mar 30, 2015
    03:19

    What Is React?

    React is a user interface framework built by Facebook to build reactive user interfaces in JavaScript. These UI components can be rendered on the server or in the browser. In this introduction you'll get a quick tour of the React technologies by building a counter component. You'll see...

  4. Feb 27, 2015
    14:05

    Customizing Login with Meteor OAuth

    Meteor has packages for multiple OAuth providers including Facebook, Github and several others. Meteor also provides their own OAuth service called Meteor Developer Accounts. In this video you'll integrate with Meteor Developer Accounts and customize the UI. You'll also see how to store...

  5. Dec 5, 2014
    05:43

    What is a Runtime?

    In this video I'll introduce The JavaScript Runtime class. A runtime is the code that runs our code. In NodeJS or the Chrome browser, the runtime is written in C++ in a project called V8. In this class you'll learn about the parts of the runtime that affect our application code.

  6. Nov 27, 2014
    08:10

    The New Packaging System

    Just prior to releasing v1.0, Meteor pulled the packaging system into Core. In this episode I'll show you around the new packaging system.

  7. Sep 19, 2014
    07:07

    Preview - Layouts and Regions in Iron Router

    The new iron:router coming in a few weeks has better support for layouts and dynamic regions. In this video, from the Using Iron Router Class coming soon, shows you around some of these features. You can play around by installing iron:router@1.0.0-pre2.

  8. Sep 12, 2014
    08:05

    Preview - The New Iron Router Controllers

    Use reactive state and event handlers with the next major version of Iron Router Controllers.

  9. Sep 5, 2014
    06:18

    Using a Start Script

    Starting Meteor apps with different configurations in development, test and production can be a bit cumbersome. In this video I'll show you a start script that makes starting a Meteor application across different environments easier.

  10. Aug 25, 2014
    14:41

    Writing a Custom Inherits Function

    Objects inherit from other objects in JavaScript. But how do we allow multiple levels of inheritance from constructor functions? In this video we'll implement our own inherits function.

  11. Aug 19, 2014
    13:02

    Type Checking Objects

    JavaScript is a weakly typed language but there are still ways to check the type of an object. Getting comfortable with these techniques will help you understand framework source code and build more sophisticated applications.

  12. Aug 14, 2014
    10:32

    Reactive Properties

    JavaScript allows us to configure object properties. We can use this idea to create reactive properties in Meteor. In this video I'll show you how to create a reactive property method and turn it into a local package.

  13. Aug 5, 2014
    11:23

    Using wait, waitOn and ready in Routes

    Confused about how to use waitOn, wait and the reactive ready method in your routes? In this video I'll show you how these work using the reactive WaitList.

  14. Aug 1, 2014
    10:59

    The Reactive WaitList Data Structure

    The WaitList lets us determine if everything in a list is ready. We use it in iron-router when you call this.wait(..) or return a subscription handle from waitOn. In this video I'll show you why I built it and how it works.

  15. Jul 29, 2014
    10:32

    Waiting on Subscriptions

    What does it mean to "wait" on a subscription to be ready? In this video we'll explore the DDP "ready" message and two ways of waiting on subscription data to be ready.

  16. Jun 12, 2014
    10:08

    Synchronizing Method Writes

    Meteor synchronizes writes that happen on the client with the result we ultimately get back from the server. In this video you'll get some intuition about what this means. Then in the rest of the class we'll dive into the mechanics of how it works. This video is part of the RPC with...

  17. Apr 28, 2014
    16:13

    Github Issues and Reproductions

    Collaborating on an open source project can be tricky. In this video I'll show you a good way to create new Github issues, whether for bugs, new features or questions. Then we'll create a reproduction and I'll show you what it looks like from a project maintainer's perspective.

  18. Apr 28, 2014
    10:54

    Setting up to Contribute

    In this video I'll show you how to set up to contribute to the Iron Router project. We'll fork the project and clone it to our machine, pull in changes from the upstream repository, and use the local package in a development application.

  19. Mar 31, 2014
    11:05

    Introducing the em Scaffolding Tool

    em is a new command line tool for generating scaffolds in your application. A scaffold is just boilerplate folders, files and code that you tend to create over and over. In this video I'll show you how to install and use em in your own projects.

    Archived
  20. Mar 31, 2014
    02:50

    Creating a Mixpanel UserAgent Blacklist

    As your site grows, the indexing bots like Google will spend more time crawling your site. In this video I'll show you how to filter out metrics from a list (blacklist) of user agents.

  21. Mar 31, 2014
    05:16

    Updating Meteor and Package Versions

    In this video we'll update a project to use Meteor 0.8.0 and iron-router 0.7.0.

    Archived
  22. Jan 17, 2014
    08:45

    Make a Reactive Join in the UI

    How do you reactively join two collections in the user interface? In this video we'll explore two ways to join documents in the user interface. The first prevents reactivity. The second enables reactivity.

  23. Jan 3, 2014
    11:02

    The UI.Each Component

    The each block helper renders a UI.Each Component. In this video we'll explore the UI.Each component's implementation and its new features and benefits.

    Archived
  24. Dec 26, 2013
    09:22

    Rendering Components

    The UI.Component render function works hand in hand with UI.render and UI.materialize. In this episode we'll explore various render functions in a custom component.

    Archived
  25. Dec 20, 2013
    09:08

    Reactive DOM with UI.materialize

    UI.materialize allows us to add reactive DOM elements to the page. In this episode we'll explore the various input types of UI.materialize. This is part of the latest round of Meteor.UI work. It will likely change before v1 but these episodes will track progress closely on the "shark"...

    Archived
  26. Dec 13, 2013
    06:00

    Using a Custom onMigrate API

    The Reload._onMigrate private API is powerful but tricky to use correctly. The meteor-migration package makes it easier to control migrations. In this episode I'll show you how you can use the migration package, or even to create your own.

  27. Dec 6, 2013
    06:44

    Build a Simple Reactive Data Source

    Let's tie together each of the Deps concepts by building a simple reactive data source. We'll see how a reactive data source works with a Dependency and Computations to complete the Meteor Deps reactivity system.

  28. Nov 29, 2013
    07:20

    Template Reactivity in the New UI System

    In the new Meteor template system, reactive DOM changes are much more precise. In this episode I'll show you a few examples of reactivity Meteor UI. This uses code from the Meteor shark branch.

    Archived
  29. Nov 15, 2013
    07:48

    Get Your Facts Straight

    Facts is a new package on the Meteor development branch to report internal app statistics. It's really useful for debugging. For example, you can look at how many live result sets and observe handles have been created, and whether they are being stopped properly.

  30. Nov 7, 2013
    06:59

    Bundling

    In this episode I'll show you how to bundle your Meteor application and run it directly from Node. We'll also look at how many processes Meteor uses, in development and in production.

  31. Nov 1, 2013
    09:56

    Subscriptions and Computations

    Subscriptions and computations can work together. For example, if you stop a computation, any subscription created in the computation is stopped automatically. If you invalidate a computation, subscriptions that haven't changed aren't resubscribed. In this episode we'll explore the...

  32. Oct 25, 2013
    07:45

    Organizing Environment Variables and Settings

    You can store global configuration variables in Meteor.settings or environment variables. In this video I'll show you how I organize these variables using a bash file. Then we'll look at how you can load your Meteor settings json file directly into an environment variable. This video is...

  33. Oct 18, 2013
    13:31

    Design: Subscriptions and Before Hooks in Iron Router

    Iron Router 0.6.0 is almost ready for release. We've been working on a better mechanism for handling subscriptions and hooks. In this video I'll show you a proposal for a better way of waiting on subscriptions in your routes. Then, we'll take a look at the internals of RouteController...

    Archived
  34. Oct 11, 2013
    07:27

    How To: Use an iOS7 Style Loading Indicator with Iron Router

    Iron Router before hooks are reactive. We can use this feature in combination with Meteor subscriptions to show a custom loading indicator. In this episode, I'll show you how to integrate the NProgress widget and create a before hook that shows the iOS7 style loading indicator while...

    Archived
  35. Oct 4, 2013
    14:00

    How To: Publish a Many-to-Many Relationship

    Although we're using document oriented storage with MongoDB, sometimes it's useful to normalize our data in separate collections. For example, we might want to use Meteor's native cursor object with the collection. In this episode, I'll show you how to publish a many-to-many...

  36. Sep 27, 2013
    08:45

    How To: Publish to a Client Only Collection

    In this episode we'll publish automatically refreshing, signed CloudFront urls to a client only Collection. We'll use Iron Router for routing and subscribing to a publish function depending on which page we're on. Then, in our publish function we'll send DDP messages to populate a...

  37. Sep 20, 2013
    08:22

    The Livedata WriteFence

    A write fence is a cool data structure that collects a group of writes and runs its callbacks when all writes are committed. When we call a Meteor method from a client, the callback function is called when the client receives the "updated" message for the method from the server. The...

  38. Sep 13, 2013
    12:21

    How does the Client Synchronize Writes with the Server?

    How does Meteor synchronize a document write on the client with the result from the server? In this video, I'll look at what happens when you call the update method on a collection. More generally, we'll look at what happens when you make a write on a LocalCollection from inside a...

  39. Sep 6, 2013
    08:02

    Meteor._wrapAsync

    Meteor._wrapAsync allows us to wrap an asynchronous function so we can call it in a synchronous style. It does this without sacrificing the performance benefits of IO related asynchronous functions by using Fibers and Meteor.bindEnvironment. In this video I'll review what it means to be...

  40. Aug 30, 2013
    12:44

    What is Meteor.bindEnvironment?

    We can bind a function to the current value of all the environment variables by using Meteor.bindEnvironment. The function returned from Meteor.bindEnvironment also automatically gets run in a Fiber. In this episode we'll explore what Meteor.bindEnvironment gives us specifically, and...

  41. Aug 30, 2013
    10:10

    Dynamic Scoping with Environment Variables

    Meteor dynamics gives us global dynamically scoped variables that work with fibers. This episode will be a precursor to understanding why the method Meteor.bindEnvironment is used. It will also help you understand why you sometimes get an error message saying that Meteor code must be...

  42. Aug 22, 2013
    18:21

    IronRouter

    In this episode, I'll walk through some of the new features of the iron-router package. Things have changed a bit since the last router episode. We'll walk through setting up routes, using a layout, waiting on subscriptions, and the new render method of RouteController.

    Archived
  43. Aug 15, 2013
    11:50

    Versioning and Packages

    Some tips for understanding Meteor core versioning, using local packages and packages from Atmosphere.

    Archived
  44. Aug 9, 2013
    10:32

    Linker Package Namespacing

    The new linker branch work has a lot of great features. In this episode we'll talk about package name-spacing and dependencies amongst packages and your application.

  45. Aug 2, 2013
    12:59

    LiveResultsSet

    A LiveResultsSet is how Meteor broadcasts real time changes to a query's result set to observing cursors. In this episode we'll explore how it works. We'll also see when LiveResultsSets get created and explore their memory and CPU characteristics.

    Archived
  46. Aug 2, 2013
    12:33

    Anatomy of a Collection Insert

    What happens when you use the insert method on a Meteor Collection? First, we'll look at the difference between inserting into the local cache and making an RPC (Meteor method) call. Then, we'll take a look at the DDP messages being sent by the client and the server to get a better...

  47. Jul 19, 2013
    13:45

    LivedataSession

    In this episode we'll explore the client's view of data on the server. What is the merge box? What happens when we subscribe to two publish functions that use the same collection?

    Archived
  48. Jul 5, 2013
    09:12

    The Spiderable Package

    The spiderable package allows search engines to index our Meteor applications. In this episode we'll look under the hood to see how the spiderable package works. We'll also look at one gotcha with publications that can cause problems with Spiderable.

  49. Jun 28, 2013
    12:49

    Routing in the new EventedMind Site

    In this episode I'll give you a tour of how I'm using routing in the new EventedMind site. The new router project is called IronRouter and I've been working in collaboration with Tom Coleman and several people in the community to make it. It's still private as we work out early issues....

    Archived
  50. Jun 21, 2013
    07:54

    Giving Meteor a little Posture

    I'd like to show you my initial sketch of Posture, a Meteor package that provides Module and Class support. Key features include inheritance, extending class methods, including (mixing in) objects, and hooks for plugging into the inheritance and include processes. Another neat feature...

    Archived
  51. Jun 14, 2013
    08:12

    Building Reusable Controls

    I've been working hard on the next version of EventedMind and have been using a few patterns to better organize my code. One of those patterns is building UI controls for various behaviors I need, like submitting a form. In this episode I'll introduce you to the `controls` package that...

    Archived
  52. Jun 7, 2013
    12:11

    Using Futures

    The Futures library that comes with Fibers provides a nicer interface around Fibers and also allows us to wrap async style code so that we can use it in a synchronous style. In this episode I'll walk you through the various ways we can use the Futures module to wrap an asynchronous...

  53. May 31, 2013
    15:16

    Introducing Fibers

    Fibers provide coroutine support for v8 and node. Applications can use Fibers to allow users to write code without using a ton of callbacks, without sacrificing the performance benefits of asynchronous IO. In this episode I'll review what async means in Node, introduce the event loop,...

  54. May 24, 2013
    09:34

    Testing Packages with Tinytest

    Meteor now allows you to test packages with the test-packages command. In this episode we'll explore Tinytest, the early testing framework that ships with Meteor.

  55. May 24, 2013
    12:29

    File Uploader Part 9: Build a UI Component

    The Meteor UI Component framework isn't finished yet. But that doesn't mean we can't build our own simple UI components. In this episode I'll add a UI component to the file uploader that automatically handles events, and allows us to show an upload progress table.

    Archived
  56. May 24, 2013
    12:40

    File Uploader Part 8: Reactive upload progress

    In this episode I'll enhance the file upload package to include a reactive progress indicator. I'll track read progress (on the browser) and upload progress (to the server) so that we can display a progress indicator widget.

    Archived
  57. May 17, 2013
    05:44

    File Uploader Part 7: Streaming Writes

    In this episode we'll enhance our server side save method to support streaming writes. As data comes off the wire for the file, the save method will either create a new file or append to an existing one.

    Archived
  58. May 17, 2013
    08:12

    File Uploader Part 6: Streaming Uploads

    Continuing with the File Uploader series, in this episode we'll implement the streaming upload method on the client. It will upload chunks of a file at a time using a Meteor method.

    Archived
  59. May 17, 2013
    11:39

    File Uploader Part 5: Streaming Reads

    The meteor-file package currently loads the entire file into memory in the browser, uploads the entire file in one DDP message, and writes the entire file to disk on the server. In this episode we'll start a streaming upload API beginning with the read method on the client.

    Archived
  60. May 10, 2013
    06:02

    File Uploader Part 3: Using Packages from Github

    Github and git can be a useful way to manage internal packages across your projects. We're about ready to publish the meteor-file package for beta release. In this episode I'll show you how to use packages in your projects from Github and git.

    Archived
  61. May 10, 2013
    07:31

    File Uploader Part 2: Server Side Save

    In this episode we'll continue building the meteor-file package by adding server side methods to our custom type. We can use npm modules on the server using the Meteor package system. This will let us use the fs and path modules from NodeJS to save a file to disk.

    Archived
  62. May 10, 2013
    06:51

    File Uploader Part 4: Publishing Packages with Meteorite and Atmosphere

    Atmosphere is the most popular way for Meteor community members to publish and distribute packages to other users. Meteorite is the command line tools for using packages and releasing your own. In this episode we'll deploy the meteor-file package to atmosphere.

    Archived
  63. May 3, 2013
    12:00

    Introducing the Package System

    The new Meteor package system is a useful way to organize projects. You can leverage npm dependencies, control file load order, and decide which files should be on the client vs. the server (or both).

    Archived
  64. May 3, 2013
    10:29

    Introducing the File API

    The HTML5 File API allows us to read files into memory in the browser with the file input control. In this episode we'll explore the File and FileReader objects to see how to asynchronously read multiple files into various formats in the browser.

  65. May 3, 2013
    16:01

    Build a File Upload Package

    We can use our knowledge of EJSON and packages to begin building a binary file uploader that uses DDP to upload files. After a few episodes of improvements, we'll open source the package.

    Archived
  66. Apr 26, 2013
    08:35

    Create a Custom EJSON Type

    Meteor EJSON allows us to create custom types that are serialized and deserialized over the wire. Custom types can be sent as a parameter to a Meteor method, published in a subscription, or even stored in MongoDB. In this episode we'll write a constructor function that has a prototype...

  67. Apr 26, 2013
    08:17

    Transforming Collection Documents

    The transform option on Meteor Collections allows us to transform MongoDB documents before they're returned in a fetch, findOne or find call, and before they are passed to observer callbacks. It lays the foundation for a Model layer. In this episode I'll build a simple transform class...

  68. Apr 19, 2013
    08:02

    What is EJSON?

    EJSON is an extension of JSON built by the Meteor team. It allows us to pass binary, date and user-defined types over the wire. In this screencast I'll introduce EJSON and why it's useful and we'll look at how EJSON represents binary and date types.

  69. Apr 19, 2013
    08:14

    EJSON in Methods and Subscriptions

    EJSON data types are automatically serialized and deserialized over the wire when using Meteor methods or subscriptions. In this episode I'll show you how to pass a valid EJSON type as a parameter to a method and how to publish a valid EJSON type in a subscription.

  70. Apr 13, 2013
    06:12

    Build a Reactive Data Source

    In this episode we'll build our own reactive data source using the new `Deps.Dependency` constructor. After watching you should have a better intuition about what a reactive data source does to trigger an invalidation.

  71. Apr 12, 2013
    07:26

    Introducing Deps

    The Meteor reactivity system has been cleaned up and improved in the new `Deps` package. In this video we'll revisit what it means to be "reactive" and I'll illustrate how to use the `Deps.autorun` and `Deps.flush` methods.

  72. Mar 7, 2013
    09:44

    UI Reactivity in Slow Motion

    In this episode we'll take a step back from the details of Spark, and look in slow motion at the user interface updating because of a reactive data source. In this screencast we'll use a list for our example. We'll have a parent template that uses the `{{#each items}}` helper to iterate...

    Archived
  73. Mar 5, 2013
    11:53

    Live Ranges

    You can think of a LiveRange as a hidden enclosing tag around one or more html elements. It gets created during the *materialization* process of rendering. LiveRanges can even contain other LiveRanges. So in effect, the LiveRange tree looks similar to an annotation tree.

    Archived
  74. Feb 28, 2013
    14:08

    Spark Data Annotation and Data Contexts

    In this episode we'll see how the Data annotation works and what a "data context" means.

    Archived
  75. Feb 26, 2013
    10:56

    Spark Landmark Annotation

    How do Meteor templates get their created, rendered and destroyed callbacks? And where do preservations get stored and used? In this episode we'll look at the Landmark Annotation using the Spark.createLandmark annotation method. I think it's one of the coolest annotations so I hope you...

    Archived
  76. Feb 25, 2013
    14:57

    Spark Event Annotations

    Continuing with the rendering series, in this episode we'll look at the "watch" and "events" annotations applied by calling the Spark.attachEvents method. We'll also see how reactive re-rendering affects event handlers.

    Archived
  77. Feb 19, 2013
    14:14

    Spark Isolate Annotation

    How does reactive rendering work? Continuing with our series on the Meteor rendering process, in this episode we'll look at the Spark.isolate annotation.

    Archived
  78. Feb 16, 2013
    11:28

    Spark Annotation Functions

    How does functionality get attached to DOM nodes in Meteor? For example, how does Meteor wire up event handlers or the code that re-renders html reactively? In this episode we'll dig deeper into Spark, Meteor's rendering engine, to see how annotations work.

    Archived
  79. Feb 15, 2013
    11:50

    Rendering Template Functions

    Let's take a closer look at Meteor templates. What happens when I call a template function? Where does Meteor store events and helper methods? How does Meteor attach functionality to the resulting document object?

    Archived
  80. Feb 14, 2013
    10:49

    Introduction to Rendering

    What happens in Meteor when the page is first loaded? How does the html end up on the page? In this episode we'll start a series on the Meteor rendering process by looking at the code that runs in Meteor.startup at DOM ready time.

    Archived
  81. Feb 8, 2013
    07:56

    How do Client Cursors Work?

    A cursor is just a way of storing information about a query, controlling execution of the query, and controlling iteration over the result set. In this screencast we'll look at client side cursors and dive into selectors as well as sort, limit and skip modifiers.

  82. Feb 7, 2013
    08:20

    Observe in a Publish Function

    How does observe work inside a publish function? How does Meteor publish a cursor using the observer framework under the hood? In this screencast we'll use node-inspector and our custom ddp client to see what's actually happening when we publish a cursor or create custom observers on a...

  83. Feb 6, 2013
    05:52

    Observing Cursors

    How do we create observer callbacks on a cursor? How does a cursor compile the selector to decide whether a changed document should fire the cursor's observer callbacks? And how does a collection notify cursors that a document has been added, removed or changed? In this screencast we'll...

  84. Jan 24, 2013
    12:07

    Build a Multi-Page App

    Let's build a multi-page app in Meteor. Using the **mini-pages** package for client-side routing, we'll look at how to reactively create filters, highlight nav tabs and perform redirects.

    Archived
  85. Jan 10, 2013
    09:31

    Subscriptions and DDP

    Meteor subscriptions and DDP work hand-in-hand. In this screencast we'll look at how subscriptions work, and write a custom DDP client to inspect messages as they come off the wire.

  86. Jan 3, 2013
    09:17

    Methods

    In this video I'll walk you through how to make an asynchronous Meteor method call, compensate for latency (delay) with method stubs, and throw errors from the server with Meteor.Error.

  87. Dec 25, 2012
    05:40

    Block Helpers

    Handlebars block helpers let us embed html or other expressions in between helper expression tags. Block helpers are primarily used for writing conditional logic and for iterating over collections. In this video we'll start by writing our own Handlebars iterator helper. Then we'll...

  88. Dec 24, 2012
    02:57

    Helpers

    What if you want to call JavaScript methods inside your Handlebars template? Handlebars lets you register helper methods you can use inside your templates. In this episode we'll look at how to do this using the Handlebars.registerHelper function. We'll also take a closer look at what...

  89. Dec 23, 2012
    03:05

    Precompiling

    Compiling a Handlebars template into a function is expensive so it's better if we can do it on the server. This is called precompiling your Handlebars templates and in this episode we'll look at how to do it.

  90. Dec 22, 2012
    03:00

    How it works

    Handlebars is a popular JavaScript template engine used in Meteor, Ember and other frameworks. It allows us to inject results from a function or object property directly into our html. In this episode we'll look at how Handlebars works using templates and a compilation process.

  91. Dec 12, 2012
    12:52

    Customizing Login

    Meteor comes with the accounts-base and accounts-ui packages. But what if we want to build our own login interface? In this video we'll build a custom UI to let users login with their Github account, and grab additional attributes for the user from Github.

    Archived
  92. Dec 11, 2012
    12:09

    The Reactive Session Object

    The Meteor Session object is a little confusing since it's not exactly what we normally consider 'session.' We can think of a Session as a hash of key value pairs that can be accessed throughout the client side application. But, Session is even more powerful than that. It's a reactive...

  93. Dec 9, 2012
    08:44

    Reactivity with Contexts

    Reactivity is a key concept in Meteor apps. In this video we'll look at the Meteor.deps package. We'll see how a Meteor.deps.Context and Meteor.deps._ContextSet can be used to write some reactive code.

    Archived