Archive

Miss something from the past? Here's all the content ever published on Evented Mind in reverse chronological order.

  1. April 5, 2016
    51:13

    Ansible

    Deploy apps, manage systems and automate provisioning over ssh.

    • Servers and Tools
  2. March 29, 2016
    39:11

    SSL

    Create a domain and EC2 instance on AWS and add SSL to the site.

    • Servers and Tools
  3. March 29, 2016
    54:57

    Getting Started with NGINX

    Install and configure NGINX as a proxy server to our application.

    • Servers and Tools
  4. March 29, 2016
    44:38

    OAuth From Scratch

    Build an OAuth 2.0 client from scratch using http and session cookies.

    • Web
  5. March 29, 2016
    50:49

    Session Cookies

    Learn how user sessions are implemented with cookies.

    • Web
  6. March 23, 2016
    49:53

    Git Deploy

    Deploy an application using a Git push workflow.

    • Servers and Tools
  7. March 19, 2016
    1:05:07

    Git Workflow

    Use Git and GitHub with team workflows.

    • Servers and Tools
  8. March 11, 2016
    39:11

    Git Merging

    Learn how to merge, apply patches and rebase in git.

    • Servers and Tools
  9. March 11, 2016
    1:05:45

    Inside Git

    Learn how Git works under the hood by exploring the object database.

    • Servers and Tools
  10. March 11, 2016
    36:11

    Getting Started with Git

    Get started with the git version control system.

    • Servers and Tools
  11. February 29, 2016
    39:41

    Managing Processes with systemd

    Manage server processes uniformly and safely with systemd.

    • Servers and Tools
  12. February 29, 2016
    30:13

    Processes

    Learn how our programs run as processes on a Unix computer.

    • Servers and Tools
  13. January 8, 2016
    34:13

    SSH

    Work with remote servers using ssh and scp.

    • Servers and Tools
  14. December 29, 2015
    51:36

    Running Time and Asymptotic Notation

    What is the difference between Θ(n), Ο(n) and Ω(n)?

    • Computer Science
  15. December 18, 2015
    39:44

    Users, Groups and Permissions

    Create users and groups and manage file permissions on Unix systems.

    • Servers and Tools
  16. December 7, 2015
    1:01:31

    The Shell

    Learn your way around the shell and Unix operating systems.

    • Servers and Tools
  17. December 2, 2015
    9:51

    WebSockets and the Real-Time Web

    Explore strategies for the server to send real-time data to the browser.

    • Web
    • Tutorial
  18. November 25, 2015
    15:15

    Understanding AJAX

    Ajax allows us to make HTTP requests using JavaScript.

    • Web
    • Tutorial
  19. November 18, 2015
    14:08

    Template Engines

    Web frameworks use template engines to generate dynamic html.

    • Web
    • Tutorial
  20. November 12, 2015
    36:53

    The npm Package System

    Learn about the npm package manager and command line tool.

    • Node.js
  21. November 2, 2015
    51:00

    The Binary Number System

    Learn how computers use 1s and 0s to store and compute numbers.

    • Computer Science
  22. October 29, 2015
    8:50

    VirtualBox and Vagrant

    Create and configure virtual machines with VirtualBox and Vagrant.

    • Servers and Tools
    • Tutorial
  23. October 26, 2015
    7:13

    Pattern: Asynchronous Iteration

    Use a common pattern in Node.js to control iteration with asynchronous functions.

    • Node.js
    • Tutorial
  24. October 19, 2015
    9:35

    HTTP Middleware With Connect

    Use the Connect npm package to provide http middleware support.

    • Node.js
    • Tutorial
  25. October 13, 2015
    37:36

    Introduction to Node.js

    Learn how to write server-side JavaScript programs in the Node.js runtime.

    • Node.js
  26. October 8, 2015
    9:13

    Uploading a File with Node.js and Busboy

    Busboy is a NodeJS package that will parse HTTP multipart forms.

    • Node.js
    • Tutorial
  27. October 5, 2015
    10:41

    What Happens When You Upload a File?

    Learn how files are uploaded using HTTP, forms and the file input control.

    • Web
    • Tutorial
  28. October 1, 2015
    14:38

    Customizing Meteor Login with React

    Build a custom Meteor login interface using React components.

    • Meteor
    • Tutorial
  29. September 28, 2015
    15:36

    Customizing Meteor Login

    Customize the Meteor login interface and configuration.

    • Meteor
    • Tutorial
  30. September 24, 2015
    8:16

    Passing Components and Methods As React Properties

    Pass functions and html elements to React components using properties.

    • React
    • Tutorial
  31. September 21, 2015
    13:18

    Creating a Reusable React Dialog Box

    Create a reusable React dialog box.

    • React
    • Tutorial
  32. September 16, 2015
    8:43

    Render a Collection with Meteor and React

    Use React to render a reactive Meteor Mongo collection to the page.

    • Meteor
    • Tutorial
  33. September 14, 2015
    8:01

    Using React With Meteor

    Create a Meteor project with React components and routing.

    • Meteor
    • Tutorial
  34. September 10, 2015
    1:02:33

    ES2015

    Learn the key new features of the latest version of JavaScript.

    • JavaScript
  35. September 1, 2015
    10:17

    Meteor 1.2 - ES6 and React

    Tour the ES6 and React features of Meteor 1.2.

    • Meteor
    • News
  36. July 10, 2015
    1:04:37

    How The Web Works

    Explore how the HTTP protocol delivers web applications.

    • Web
  37. July 3, 2015
    1:07:44

    Tracker

    Learn how Meteor's reactive system works with the Tracker package.

    • Meteor
  38. April 21, 2015
    36:33

    Understanding React

    Learn how React Elements, Components and JSX work together in the browser and the server.

    • React
  39. March 30, 2015
    51:36

    Getting Started With React

    Learn about the key technologies of Facebook's React framework by building a comment component.

    • React
  40. February 28, 2015
    1:43:43

    Build a Multi Page App with Iron Meteor

    Build a multi-page application with Meteor.

    • Meteor
  41. January 29, 2015
    32:13

    Introduction to DDP

    DDP is Meteor's real-time wire protocol based on simple JSON messages

    • Meteor
  42. January 29, 2015
    58:40

    Meteor Fibers and Dynamics

    The meteor runtime lets you write asynchronous code in a synchronous style using the Fibers co-routines module.

    • Meteor
  43. December 24, 2014
    1:04:18

    Setting Up Meteor Projects

    Explore tips and tricks for setting up a more advanced project structure.

    • Meteor
  44. December 5, 2014
    55:25

    The JavaScript Runtime

    The runtime is the code that runs your JavaScript. Dive into the call stack, try catch and throw, the event loop, timers and what it means to be asynchronous.

    • JavaScript
  45. November 27, 2014
    8:09

    The New Packaging System

    • Meteor
    • Tutorial
  46. October 27, 2014
    1:44:57

    JavaScript Functions

    Functions are first class objects in JavaScript. They're one of the key features that differentiates JavaScript from a class based language.

    • JavaScript
  47. September 29, 2014
    1:31:57

    Using Iron Router

    Learn about the most popular Meteor router, designed to work in the browser and on the server.

    • Meteor
  48. September 19, 2014
    7:06

    Preview - Layouts and Regions in Iron Router

    • Meteor
    • Tutorial
  49. September 12, 2014
    8:04

    Preview - The New Iron Router Controllers

    • Meteor
    • Tutorial
  50. August 25, 2014
    14:39

    Writing a Custom Inherits Function

    • JavaScript
    • Tutorial
  51. August 19, 2014
    13:01

    Type Checking Objects

    • JavaScript
    • Tutorial
  52. August 15, 2014
    1:30:20

    JavaScript Objects

    Everything in JavaScript is an object. Understanding object allocation, construction and inheritance is key to being fluent in the language.

    • JavaScript
  53. August 14, 2014
    10:31

    Reactive Properties

    • Meteor
    • Tutorial
  54. August 5, 2014
    11:22

    Using wait, waitOn and ready in Routes

    • Meteor
    • Tutorial
  55. August 1, 2014
    10:58

    The Reactive WaitList Data Structure

    • Meteor
    • Tutorial
  56. July 29, 2014
    10:31

    Waiting on Subscriptions

    • Meteor
    • Tutorial
  57. June 12, 2014
    10:07

    Synchronizing Method Writes

    • Meteor
    • Tutorial
  58. May 29, 2014
    47:33

    Publish Subscribe in Meteor

    In the Meteor PubSub system the server publishes data to subscribing clients.

    • Meteor
  59. May 29, 2014
    2:00:47

    RPC with Meteor Methods

    A Meteor remote procedure call (RPC) invokes a function on the server from the client using DDP.

    • Meteor
  60. April 28, 2014
    10:54

    Setting up to Contribute

    • Meteor
    • Tutorial
  61. April 28, 2014
    16:13

    Github Issues and Reproductions

    • Github
    • Tutorial
  62. April 24, 2014
    1:48:07

    Inside Iron Router

    A router that works on the client and the server has a lot of moving parts. Learn how a router like Iron Router is built.

    • Meteor
  63. March 31, 2014
    11:05

    Introducing the em Scaffolding Tool

    • Meteor
    • Tutorial
  64. March 31, 2014
    2:50

    Creating a Mixpanel UserAgent Blacklist

    • Meteor
    • Tutorial
  65. March 31, 2014
    5:16

    Updating Meteor and Package Versions

    • Meteor
    • Tutorial
  66. March 31, 2014
    1:43:33

    Building an Application with Meteor and Iron Router

    Build a real application with Iron Router and scaffolding. This class is made for Meteor 0.8.0.

    • Meteor
  67. February 26, 2014
    55:57

    Getting Started with Meteor

    New to Meteor? Start here. Meteor is a full-stack framework for building real-time JavaScript web applications.

    • Meteor
  68. January 17, 2014
    8:45

    Make a Reactive Join in the UI

    How do you reactively join two collections in the user interface?

    • Meteor
    • Tutorial
  69. January 3, 2014
    11:02

    The UI.Each Component

    The each block helper renders a UI.Each Component.

    • Meteor
    • Tutorial
  70. December 26, 2013
    9:22

    Rendering Components

    Understand the UI.Component render function.

    • Meteor
    • Tutorial
  71. December 20, 2013
    9:08

    Reactive DOM with UI.materialize

    UI.materialize allows us to add reactive DOM elements to the page.

    • Meteor
    • Tutorial
  72. December 13, 2013
    6:00

    Using a Custom onMigrate API

    The meteor-migration package (on Github) makes it easier to control migrations.

    • Meteor
    • Tutorial
  73. December 11, 2013
    28:45

    Hot Code Push with Reload and Autoupdate

    Meteor can automatically reload the browser in response to code changes using the autoupdate and reload packages. You can customize this behavior in your application and package code.

    • Meteor
  74. December 6, 2013
    6:44

    Build a Simple Reactive Data Source

    Let's tie together each of the Deps concepts by building a simple reactive data source.

    • Meteor
    • Tutorial
  75. December 5, 2013
    33:40

    Meteor Reactivity with Deps

    The deps package is the core reactivity package in Meteor. It powers reactive templates and numerous other data structures in the browser.

    • Meteor
  76. November 29, 2013
    7:20

    Template Reactivity in the New UI System

    A few examples of reactivity in the new Meteor UI.

    • Meteor
    • Tutorial
  77. November 29, 2013
    2:42:09

    Shark UI Preview

    Learn how the pre-release templating package (code-named Shark) works.

    • Meteor
  78. November 15, 2013
    7:48

    Get Your Facts Straight

    Facts is a new package on the Meteor development branch to report internal app statistics.

    • Meteor
    • Tutorial
  79. November 7, 2013
    6:59

    Bundling

    Run your Meteor application directly from NodeJS.

    • Meteor
    • Tutorial
  80. November 1, 2013
    9:56

    Subscriptions and Computations

    Explore how computations and subscriptions work together.

    • Meteor
    • Tutorial
  81. October 25, 2013
    7:45

    Organizing Environment Variables and Settings

    A nice way to organize environment variables in development and production.

    • Meteor
    • Tutorial
  82. October 18, 2013
    13:31

    Design: Subscriptions and Before Hooks in Iron Router

    A proposal for using before hooks and waiting on subscriptions in your routes.

    • Meteor
    • Tutorial
  83. October 11, 2013
    7:27

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

    Use an Iron Router before hook to show a custom loading indicator.

    • Meteor
    • Tutorial
  84. October 4, 2013
    14:00

    How To: Publish a Many-to-Many Relationship

    How to publish a many-to-many relationship in a single publish function.

    • Meteor
    • Tutorial
  85. September 27, 2013
    8:45

    How To: Publish to a Client Only Collection

    Publish documents to a client side collection.

    • Meteor
    • Tutorial
  86. September 20, 2013
    8:22

    The Livedata WriteFence

    A write fence collects a group of writes and runs its callbacks when all writes are committed.

    • Meteor
    • Tutorial
  87. September 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?

    • Meteor
    • Tutorial
  88. September 6, 2013
    8:02

    Meteor._wrapAsync

    Meteor._wrapAsync allows us to wrap an asynchronous function so we can call it in a synchronous style.

    • Meteor
    • Tutorial
  89. August 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.

    • Meteor
    • Tutorial
  90. August 30, 2013
    10:10

    Dynamic Scoping with Environment Variables

    Meteor dynamics gives us global dynamically scoped variables that work with fibers.

    • Meteor
    • Tutorial
  91. August 22, 2013
    18:21

    IronRouter

    An overview of the iron-router package and some of its new features.

    • Meteor
    • Tutorial
  92. August 15, 2013
    11:50

    Versioning and Packages

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

    • Meteor
    • Tutorial
  93. August 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.

    • Meteor
    • Tutorial
  94. August 2, 2013
    12:59

    LiveResultsSet

    A LiveResultsSet is how Meteor broadcasts real time changes to a query's result set to observing cursors

    • Meteor
    • Tutorial
  95. August 2, 2013
    12:33

    Anatomy of a Collection Insert

    What happens when you use the insert method on a Meteor Collection?

    • Meteor
    • Tutorial
  96. July 19, 2013
    13:45

    LivedataSession

    In this episode we'll explore the client's view of data on the server

    • Meteor
    • Tutorial
  97. July 5, 2013
    9:12

    The Spiderable Package

    The spiderable package allows search engines to index our Meteor applications

    • Meteor
    • Tutorial
  98. June 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

    • Meteor
    • Tutorial
  99. June 21, 2013
    7: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

    • Meteor
    • Tutorial
  100. June 14, 2013
    8: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

    • Meteor
    • Tutorial
  101. June 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

    • Node.js
    • Tutorial
  102. May 31, 2013
    15:16

    Introducing Fibers

    Fibers provide coroutine support for v8 and node

    • Node.js
    • Tutorial
  103. May 24, 2013
    12:29

    File Uploader Part 9: Build a UI Component

    The Meteor UI Component framework isn't finished yet

    • Meteor
    • Tutorial
  104. May 24, 2013
    9:34

    Testing Packages with Tinytest

    Meteor now allows you to test packages with the test-packages command

    • Meteor
    • Tutorial
  105. 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

    • Meteor
    • Tutorial
  106. May 17, 2013
    5:44

    File Uploader Part 7: Streaming Writes

    In this episode we'll enhance our server side save method to support streaming writes

    • Meteor
    • Tutorial
  107. May 17, 2013
    8: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

    • Meteor
    • Tutorial
  108. 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

    • Meteor
    • Tutorial
  109. May 10, 2013
    7: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

    • Meteor
    • Tutorial
  110. May 10, 2013
    6:02

    File Uploader Part 3: Using Packages from Github

    Github and git can be a useful way to manage internal packages across your projects

    • Meteor
    • Tutorial
  111. May 10, 2013
    6: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

    • Meteor
    • Tutorial
  112. 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

    • Meteor
    • Tutorial
  113. 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

    • Meteor
    • Tutorial
  114. May 3, 2013
    12:00

    Introducing the Package System

    The new Meteor package system is a useful way to organize projects

    • Meteor
    • Tutorial
  115. April 26, 2013
    8:17

    Transforming Collection Documents

    Transform collection documents with a custom function.

    • Meteor
    • Tutorial
  116. April 26, 2013
    8:35

    Create a Custom EJSON Type

    Meteor EJSON allows us to create custom types that are serialized and deserialized over the wire

    • Meteor
    • Tutorial
  117. April 19, 2013
    8:02

    What is EJSON?

    EJSON is an extension of JSON built by the Meteor team

    • Meteor
    • Tutorial
  118. April 19, 2013
    8:14

    EJSON in Methods and Subscriptions

    EJSON data types are automatically serialized and deserialized over the wire when using Meteor methods or subscriptions

    • Meteor
    • Tutorial
  119. April 13, 2013
    6:12

    Build a Reactive Data Source

    In this episode we'll build our own reactive data source using the new `Deps

    • Meteor
    • Tutorial
  120. April 12, 2013
    7:26

    Introducing Deps

    The Meteor reactivity system has been cleaned up and improved in the new `Deps` package

    • Meteor
    • Tutorial
  121. March 7, 2013
    9: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

    • Meteor
    • Tutorial
  122. March 5, 2013
    11:53

    Live Ranges

    You can think of a LiveRange as a hidden enclosing tag around one or more html elements

    • Meteor
    • Tutorial
  123. February 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

    • Meteor
    • Tutorial
  124. February 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

    • Meteor
    • Tutorial
  125. February 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

    • Meteor
    • Tutorial
  126. February 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

    • Meteor
    • Tutorial
  127. February 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

    • Meteor
    • Tutorial
  128. February 15, 2013
    11:50

    Rendering Template Functions

    Let's take a closer look at Meteor templates

    • Meteor
    • Tutorial
  129. February 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

    • Meteor
    • Tutorial
  130. February 8, 2013
    7:56

    How do Client Cursors Work?

    Cursors are the control data structures for a collection of documents for a query.

    • Meteor
    • Tutorial
  131. February 7, 2013
    8:20

    Observe in a Publish Function

    Learn how Meteor publishes data from a cursor.

    • Meteor
    • Tutorial
  132. February 6, 2013
    5:52

    Observing Cursors

    Learn how to observe a cursor

    • Meteor
    • Tutorial
  133. January 24, 2013
    12:07

    Build a Multi-Page App

    Let's build a multi-page app in Meteor

    • Meteor
    • Tutorial
  134. January 10, 2013
    9:32

    Subscriptions and DDP

    Meteor subscriptions and DDP work hand-in-hand

    • Meteor
    • Tutorial
  135. January 3, 2013
    9: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

    • Meteor
    • Tutorial
  136. December 25, 2012
    5:40

    Block Helpers

    Handlebars block helpers let us embed html or other expressions in between helper expression tags

    • Handlebars
    • Tutorial
  137. December 24, 2012
    2: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

    • Handlebars
    • Tutorial
  138. December 23, 2012
    3:05

    Precompiling

    Compiling a Handlebars template into a function is expensive so it's better if we can do it on the server

    • Handlebars
    • Tutorial
  139. December 22, 2012
    3:00

    How it works

    Handlebars is a popular JavaScript template engine used in Meteor, Ember and other frameworks

    • Handlebars
    • Tutorial
  140. December 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

    • Meteor
    • Tutorial
  141. December 9, 2012
    8:44

    Reactivity with Contexts

    Reactivity is a key concept in Meteor apps

    • Meteor
    • Tutorial