All Tekpub Productions

Image

Mastering Git takes you deep into Git to give you the working knowledge you need to confidently use this system. Git is an amazing source control system and will change the way you work - we've devoted over 3 hours and hopefully you'll agree that Git's rockin.

  • Branching

    In this episode you learn all the goodness that is Git branching

  • Drive-by Demo

    In this quick demo we'll show you what it's like to work with Git in an "Everyday" way. Subjects include basic repository creation, where the repository is, adding files to it, ignoring files, committing, and pushing to a remote.

  • Git Internal Workings

    In this episode we take a deep-dive into the internals of Git to see how it works, what makes it tick, and also how to extend it using scripting.

  • Git And Visual Studio

    Many developers like to have source control integrated into Visual Studio - in this episode we show you how to hook Git up in one of two ways: Using the Git Extensions add in and Mapping command line "stuff" to VS 2008s external tools.

  • How Git Works

    This episode takes a look at the mechanisms that make Git Git to help you understand the underpinnings of the system. Topics covered include Git's file snapshot system and the way Git stores its data.

  • Introduction

    A quick overview of the Git with some History and why you should care about this source control system. Mostly a presention designed to answer "Why Should I Care".

  • Merge Conflict

    The most-often asked question about Git is "what do I do when I have to unravel a big conflict"? The good news is that Git makes this relatively simple and this screencast shows you how to handle just about every conflict that might come up. In addition, Rob shows you how to hook up your favorite merge/diff tools.

  • Correcting Mistakes

    Mistakes happen! In this episode we show you how to "Unwind/Undo" your commits if you goof up, and also what to do when you want to erase the last few commits. You can even erase selectively!

  • Rebasing

    One of the core features of Git is Rebasing - which is effectively rewriting/realigning your commit history to be a lot cleaner. Whenever you push your local branch in Git, all of the commit history goes with it. Sometimes this can make the overall graph look a bit explosive. Rebasing helps to "cleanup" your local implementation.

  • Remotes

    Working with remotes is fundamental for source control - most people are used to dealing with a remote server anyway (if you use Subversion or TFS). Git is a local source control system, but is built to push to work with many developers as well. In this episode we show you various ways to share your work, including a few strategies for Windows network shops.

  • Submodules

    One very compelling feature of Git is the idea of "Submodules" - pluggable "sub repositories" that are a bit like Subversion's externals mixed with Rails' plugin setup. In this episode we show you how you can keep your code library up on Github and plug in what you need (when you need it) using Git's Submodules feature.

  • Tips and Tricks

    In this episode Rob shows you loads of tips and tricks to help you get the most out of Git. Subjects include:
  • Tagging
  • Using a Better Console
  • Saving Temporary Changes with Stash
  • Scripting Git with Ruby and Extending it in general
Image

In this series Ayende integrates NHibernate into Kona (the MVC Storefront) and during the process shows Rob how NHibernate works.

  • Getting Started

    In this episode I give a brief intro to ORMs and NHibernate and talk about it's place in the .NET world. Ayende and I then hook NHibernate up to Kona and talk about the various "issues" that people face when getting started with NHibernate. Ayende shows me NHProf (which is awesome) and I run my first query.

  • Basic Mapping

    In this episode Ayende takes me deeper into the NHibernate jungle, showing me how to hook up self-referencing joines, one to many, and many to many associations. We then use NHProfiler to examine what we're doing, and Ayende then walks me through a whole host of ways to optimize our queries and in the process blows my mind.

  • Fluent NHibernate

    In this episode I take a look at FluentNHibernate while Ayende is off at a conference. I show how you can kick XML to the curb, configuring things with code and mapping with a groovy fluent interface using FluentNhibernate.

  • Basic Optimizations

    In this episode Ayende reflects on FluentNhibernate a bit, and then shows me how to take 4 queries and mash them into one to optimize the Kona homepage, bending NHibernate to my will.

  • Inheritance with Discriminators and IUserType

    In this episode Ayende and I fix a bug cause by our previous use of Future() using Transformers and then look at ways to implement the StatePattern.

  • Complex Statistical Queries

    In this episode Ayende walks me through setting up a triple-nested Co-Occurrence query using NHibernate. Note that this is an example and you probably wouldn't want to do this in production - it's fun nonetheless to see what NHibernate can do!

  • Transactions and Raw SQL

    In this episode Oren shows me how to wire up Transaction support right into the fabric of ASP.NET MVC using Action Filters, and we get ugly with raw SQL and NHibernate's Named Queries.

  • Search

    In this episode we try 3 types of search: Bad with Contains(), using FullText Indexing with Microsoft Full Text, and Lucene. Note: there is a LOT more to be said about Lucene but in this episode we focus on getting it working with NHibernate.
Image

In this series I walk you through a "Day In The Life" as I build out my blog. This is less "instructional" and more watching me sling my way through creating a blog application, using what I've learned from the MVC Storefront series.

  • Getting Started

    In this episode I get started with the basics and what I'm going to do. I'm using Lean Programming techniques and I can't caveat this enough: I'm not an expert nor is this supposed to be "how Lean works". I've done my best to read up on it -so this is me thrashing a bit.

    I use Nate Kohari's AgileZen website to help me along and discuss what it means to build something you really care about from the client's and developer's perspective. I also dive deep into design.

  • Modeling and Testing

    I finally get to some coding! In this episode I hook up Aaron Jensen's MSpec and get cracking with Behavior-Driven Development and (hopefully) show you some ways that you can improve your development speed using BDD. In addition I dive into Blueprint CSS, a great way to work positioning with very little effort.

  • Refactor 1: Adding ViewModel and Service

    In this episode I start down the path of adding in a Service class for delivering my PostViewModel and find out that my plan needs to be changed...

  • Setting up Metaweblog and Refactoring

    In this episode I tear up my data access, realizing that I'm building in complexity without paying attention to YAGNI. It's a blog after all... Then I plug in Metaweblog API and make my first post from LiveWriter!

  • Setting up Comments, Stats, and RSS

    My current WordPress blog is beginning to buckle and melt... for whatever reason. I need to change over so I put a fire under my development process and setup my Comments, RSS feeds, and Stats so I can get this thing live!

  • Deployment

    In this episode I finally get to "press the button" and kick my site live. I spend most of the episode trying to automate deployment - not much fun with ASP.NET.
Image

In this free Tekpub series we take a look at some of the practices and patterns being used by Microsoft developers today.

  • Dependency Injection and Inversion of Control

    In this episode I dive into Dependency Injection and what it's all about as a programming pattern. I then show you how you can use Nate Kohari's Ninject as an IoC container for your application.

  • Lambdas

    Lamdbas are weird little bits of funk (Func?) in code that can perplex people new to the 3.5 platform. In this screencast I show those who are not familiar with them just what they are and where they come from.

  • Unit Testing

    Unit Testing is fundamental to software development and something every geek should understand at least at a basic level. In this screencast I talk about the basics of Unit Testing and also show how it can aid in your design process.

  • Loose Design with Interfaces

    Interfaces are weird things that are sort of objects and sort of not - yet they can make a world of difference in the way you build your app.
Image

In this free Tekpub series I do a remake of Mike Gunderloy's classic developer book, Coder to Developer - but with an update for some of the practices used today.

  • Introduction

    In this episode I dive into what it takes to advance your career, from personal level as well as tips for progressing as fast as possible.

  • The Project

    In this episode I talk about things to consider when you finally get the chance to setup your own project as lead developer.

  • Organization

    In this episode I talk about various issues you'll face when organizing your project. Topics cover various processes as well as the 80/20 rule.

  • Source Control

    Source Control is a fundamental developer tool that should never be overlooked. In this episode I talk about why the use of a source control system is important, as well as the various choices out there. Note: I don't go into details about how to use these systems - this is just an overview of the popular features.
Image

In this production I set up a Linux server with Apache and Passenger, a module which allows Apache to process Ruby on Rails applications. This is an introductory series meant for folks unfamiliar with Linux, Apache, and Rails

  • Introduction and Installation

    In this episode I install Ubuntu server and configure it to use Apache/MySQL (LAMP install). In addition I discuss the history of Unix, GNU, and Linux

  • Useful Linux Commands

    In this episode I go over the basics of using Linux, beginning with a pep-talk for people unfamiliar with the Unix OS. I go on to show the main commands you'll be using, and I talk about using VI

  • Setting up Apache with Rails

    In this episode I walk through using Apache and how to configure a web application. I then create a Rails app and get it to run using Passenger.
Image

Mastering jQuery walks through the basics of using jQuery, the revolutionary JavaScript framework that makes writing client-side code fun and easy, and then dives into the details of writing AJAX enabled ASP.NET MVC and ASP.NET Web Forms applications. We will also cover popular plugins and extending jQuery in future episodes.

  • Getting Started with jQuery

    In this episode we cover the basics of getting started with jQuery. We start with a basic HTML page and show how to include jQuery, how to write your first code, and explain all of the moving pieces and how they work.

  • Building a task application in jQuery

    In this episode we start building a new application all in jQuery, again we focus on just the fundamentals of jQuery and working with HTML in NotePad2.

  • jQuery and AJAX Pt. 1

    In Episode 3 we being to cover working with jQuery and AJAX. We explain what AJAX is and what the benefits are then jump into using the Load function in a very simple scenario. Then we wire up our task application to a simple ASP.NET MVC application using the jQuery Form plugin. This is just the first part of working with Ajax, in Episode 4 we will cover using Ajax directly (without the jQuery Form Plugin).

  • jQuery and Ajax Pt. 2

    In this episode Dave and James dig deeper into working with Ajax and jQuery. They cover making direct calls using the post function as well as using JSON. This episode uses ASP.NET MVC for the server-side code.

  • ASP.NET Web Forms with jQuery and AJAX

    In this episode Dave and James convert their task application to web forms and wire up the Ajax calls using both Page Methods and Web Services.
Image

In this series Steven Sanderson and Rob Conery take you from introductory level all the way through to advanced, offering real-world examples and industrial-strength tips and tricks, derived from years of work with the platform.

  • Why You Should Care About ASP.NET MVC 2.0

    In this episode Rob Conery takes on the discussion of why you should care about ASP.NET MVC 2.0. Rob discusses business and technical reasons, plus highlights the typical workflow of using ASP.NET MVC 2.0. Note: this is a summary video, all topics will be discussed in depth in later episodes.

  • Controllers, Part 1

    In this episode Steven Sanderson walks you through the basics of what a Controller is and how to work with it, including strategies for using Search.

  • Controllers, Part 2

    In this episode Steven continues working with Controllers, going deeper to show you how to map HTTP verbs to your controller actions, how to create your own ControllerFactory to implement Dependency Injection and Inversion of Control, and how to scale your application with Asynchronous Controllers.

  • Views: The Basics

    In this episode I get to the very, very basics of working with a View. I dive into the machinery that actually causes the rendering to happen in the first place and then work my way back out from there, showing you the nuts and bolts of what makes a View work.

  • Views: Working With Data

    In this episode I show you how data is passed from your Controller to your view, and then discuss ways to keep your views DRY with Helper classes and Partials. We'll be working a lot more with the Html Helpers (and Partials) in a later episode.

  • Views: ViewEngines

    In this episode I show you how to override the default ViewEngine and then throw it away altogether, rolling your own. I also do an overview of Spark, rolling my little demo app over to the popular ViewEngine.

  • Views: HtmlHelpers

    In this episode I show you how to work with the HTML Helpers - and why you would want to. Specifically I show you how to get around the loss of "Stateful Postback" that you had with WebForms and also how to work a DropDownList properly. In addition I show you what's new with MVC 2.0

  • Views: Partials and Templates

    In this episode i continue working with Partials and also show you an old/new friend: RenderAction, which injects the HTML from a separate Action into a given View. I then transition to a new feature of ASP.NET MVC 2: Templates and show you how they work with ModelMetaData and DataAnnotations.

  • Models and Metadata

    In this episode Steven walks you through building out a UI using changes to ModelMetada using DataAnnotations. In addition he shows you how to create your own MetaDataProvider.

  • Model Binding

    In this episode Steven walks you through using ASP.NET MVC 2.0's Model Binding feature - the automatic way to bind incoming post data to your model objects (and a lot more). Steven also takes a deep dive into custom model binders.

  • Model Validation

    In this episode Steven walks through Model Validation using the built-in ModelBinders as well as DataAnnotations.
Image

In this series Justin Etheredge starts out by diving into the fundamentals of Linq, how it works, and the features added to C# 2.0 and 3.0 that make it possible (Episodes 1 & 2). Justin will then dig into all of the various Linq functions available and how each of them works. He will then touch on Parallel Linq and introductions to Linq to XML and Linq to SQL.

  • The Fundamentals of Linq Pt. 1

    In this episode Justin covers the var keyword, extension methods, collection initializers, delegates, anonymous delegates, and lambas to show all the features used to make Linq possible.

  • Working with yield, Where, Select and the Stack Overflow Data

    In this episode Justin digs into how yield works, a complete look at the Where function and a beginning look at the Select function. In this episode Justin introduces the Stack Overflow data set that will be used as an example data set for the rest of the episodes.

  • Exploring Select, Tuples, and Anonymous Types

    In this episode Justin digs into the Select function and shows various ways to control what is returned including using custom classes, tuples, and anonymous types.

  • Exploring Order, Take, Skip, and Aggregation Functions

    In this episode Justin explores the OrderBy, OrderByDescending, Take, Skip, TakeWhile, SkipWhile, Sum, Average, and Aggregate functions of Linq.
Image

In this series I build out the same blog engine that I created with ASP.NET MVC in our other series, Building My Own Blog. The idea with this series is a thought experiment - building two o the same application with different framework trying to use "best practices" in both cases.

  • Getting Started

    In this episode I install Ruby, Rails, and get a Windows 7 box up and running with all the tools we're going to need. I then do a walk-through of what a Rails site looks like.

  • Introduction to Cucumber

    In this episode I show you Cucumber, the Rails BDD testing framework that focuses on letting you write tests in plain English, or whatever language you're comfortable in (currently supports 37 spoken languages).

  • Automating Test Data with Pickle

    One of the hardest things to do when testing is reliably working with data. Rails makes this easy by running tests in a test environment, allowing you to work directly with a relational system. In this episode I show you how to automate all of this with Pickle.

  • MetaweblogAPI and Many to Many Relationships

    In this episode I tackle implementing the MetaweblogAPI with Ruby (which has XMLRPC built right in) as well as show you how to implement Many to Many relationships with Rails ActiveRecord

  • Moving to MongoDB

    In this episode I roll the blog's database to MongoDb, an open-source document database (which is kind of like an Object Database). I put my blog where my mouth has been lately - see what happens!

  • RSS, Mongo Associations, and Rails debugging

    In this episode I build up an RSS feed by flexxing Rails RESTful conventions, writing all of 10 lines of code or so. I also show you how associations work in Mongo - including one to many as well as many to many. Finally I show you the wicked power of Rails debugging using Script/Console.

  • Importing Data with Rake

    In this episode I import my old blog data using XMLRPC and slap myself upside the head for overthinking things. The answer (as with most things) is RAKE - the Ruby task application that makes development a lot of fun. I also try to improve my blog's SEO by bettering my CSS.

  • Deployment Made Easy with Capistrano

    In this episode I show you various ways to push your Rails application to the world, including Heroku, the Rails equivalent of chocolate. I then show you Jamis Buck's amazing tool Capistrano, which automates deployment to a level of sheer silliness. Finally, I launch my blog right before your eyes...

  • Windows Setup Revisited

    This episode is a late-comer to the series and is meant to help folks having a hard time getting things running on Windows. In addition, we have a long-running thread on our support site.

  • Code Review with TopFunky

    In this episode Geoffrey Grosenbach of the Ruby on Rails podcast and Peepcode.com joins me to review the code I've written for my blog. He offers some different ways to do things as well as thoughts on what would make "Rubyists" happy.
Image

In this series Craig Shoemaker walks through the new ASP.NET Ajax Library. Craig will cover how to use the ScriptLoader, DataView Control, DataContext Control, Observer Framework, and how to work with WCF Data Services. Craig will cover how to use the library in pure HTML or with ASP.NET WebForms or ASP.NET MVC.

  • Using the ScriptLoader

    In this episode Craig walks through using the ScriptLoader to manage your client side scripts. He covers how to use a CDN, how to maintain debug and release versions of your scripts, and how to minify your JavaScript.

  • Working with the DataView Control Pt. 1

    In this episode Craig digs into the DataView Control in the ASP.NEt Ajax Library. Craig covers the basics of the DataView Control and covers Binding Modes and Binding Customizations.

  • Working with the DataView Control Pt. 2

    Craig digs deeper into using the DataView control. He talks about customizing the look and feel of the view as well as using Ajax with ASP.NET WebForms and ASP.NET MVC.
Image

In this production Rob delivers more than 3 hours of content focused on getting you and your company up and running on Mercurial. Topics include the basics: adding, committing, cloning, and push/pull. More advanced topics include working the console commands for improved speed, setting up the built in Hg web server behind IIS with authentication, and importing from Subversion.

  • Introduction

    In this episode Rob talks about Distributed Source Control and how why you should care about Mercurial. In addition Rob does a quick 10 minute demo showing off the basics of Mercurial.

  • Everyday Tasks

    In this episode Rob shows you common workflows for working with Mercurial everyday. Rob covers the basics as well as how to effectively take advantage of branching with Mercurial.

  • Working with a Team

    In this episode Rob shows the various ways Mercurial kicks butt in a team environment. Topics covered include: emailing changes with Tortoise's built in patch tool, and setting up Hg Server behind IIS 7 with full authentication.

  • Tips and Tricks

    In this episode Rob shows you how to improve your efficiency by working with the console a bit more and by kicking the VS plugin in favor of wiring the Hg tools in directly. In addition Rob shows how to Rebase with Hg, setup the Notify extension to send emails on checkin, and how to import a Subversion repository.
Image

Ben Scheirman shows you how to get your first iPhone application off the ground and into the App Store

  • Introduction

    In this episode Ben walks you through the basics of iPhone development, showing you many of the cool features of this platform. He then builds out a quick application to show you what the process looks like.

Coming Soon

Mastering Resharper

Resharper is, for the most part, *the* Visual Studio Addin. I've never had any luck with the thing but I'm going to have my mind changed by working with a Resharper Ninja who shows me all the awesome groovy tricks that this tool is capable of.

Scaling and Perf-Tweaking Your Web Application

James Avery takes a deep dive into what scaling means for a web application and shows you various ways that you can keep your app from taking a dirt-nap. James will touch on common techniques for squeezing the most from your server as well as effective caching techniques.

Cloud Computing And You

Cloud computing is all the rage with "servers as services" coming on strong. James Avery dives deep into Azure and shows various ways to hook your application up to Microsoft's cloud offering. Rob Conery talks with David Nielsen from CloudCamp about "what the Cloud's all about".

Mono

You hear the word "Mono" (pronounced Mow-no) a lot on blogs and in conferences - but what is this thing and why do we need to care? Rob Conery spends time with Miguel deIcaza, creater of GNOME and benevelonent dictator of Mono to find out just what is so awesome about Mono.

Mastering SubSonic

SubSonic is one of the favorite ORMs in the .NET world and in this set of screencasts Rob Conery walks you through the details of using the toolset.