The best part is, I’ll let you check it out for free! For those who currently do not have a subscription to Pluralsight, I’ll give you a 1-week subscription so you can check out my Ruby on Rails course. Send me an email with your name, twitter and what you normally develop with and I’ll send back a subscription.

Send email to programmersunlimited@gmail.com

Supplies are limited though!

There have been too many times when the 24 hour period prior to the flight occurs when I’m away from my computer. This web application, however, will check into your Southwest flight for you.

Instead of going to a website where you input the information necessary for you to check in (name and confirmation number), you now can you just forward your Southwest flight confirmation email (the one with the subject that says ‘Your trip is right around the corner!’) to sw@to.andyjiang.com. Then, when the 24 hour check in window opens up, the web application will check in to the flight for you.

How does the app work?

The Mandrill (hosted by Mailchimp) server receives an inbound email and sends a POST request to the web server. The web server then extracts the text from the body of the email from the POST request and runs several regular expressions on it to get the following pieces of information: first name, last name, confirmation number, your email address, the URL it needs to go to in order to check in for you. It saves this data into a Mongo database (MongoHQ add-on with Heroku).

An hourly task runs on the server (Heroku Scheduler) to look at all of the records in the mongo database; for each record, if it is time to check in, the web server  uses the Mechanize library to get and parse the HTML of the confirmation web site, fill in the required information, and check in for you. Then it takes your boarding group and boarding position and sends you a confirmation email.

Tools I used

Since debugging is 90% of any project, it is important to learn to break the project into small, achievable goals, to quickly isolate problems and to iterate through working solutions. Below is a list of some of the tools I used to test quickly and build out the application.

Rubular: Regular expressions were critical to parsing the body of the inbound email. This nifty website allows you to test all of your regexp patterns against Strings of your choice. Combined with IRB and .class?, you can very quickly determine the right commands to extract the information needed from the text.

Localtunnel: Localtunnel, hosted by Twilio, allows you to expose an endpoint on your local server to receive HTTP requests from other servers. This is important when you are using a service that will send you webhooks (Twilio, Mandrill inbound emails, etc.), so you don’t have to push your changes to a production server in order to test whether your app correctly processes the POST request to your endpoint. With Localtunnel, you just follow the instructions on the site, copy and paste the localtunnel URL/endpoint generated (tied to your local server), and provide it to the web service so it knows the address to send its request, thereby allowing you to test locally.

View Elements in Developer Tools: In Chrome (Firefox and Safari, also), you can view the HTML document of each page you are on by going to View > Developer > Developer Tools (or Option + Command + I). This is important when you are using Mechanize, which allows you to parse HTML given the HTML element, id, class, name, etc. I would test code by using IRB, initialize a Mechanize object, open up the browser, and navigate the web from the terminal.

Conclusion

Feedback is always welcome. If you think you are going to forget to use this next time you fly Southwest, go into your Gmail account right now and set up an instant email forwarding. Go to your Gmail’s Settings > Forwarding and POP/IMAP > Forwarding, then select Add a Forwarding Address. Type in “sw@to.andyjiang.com” and send the verification email that will contain the confirmation code.

Forwarding and POP/IMAP > Forwarding to set up a new email address to auto forward your Southwest itinerary emails” class /> Go to your Gmail’s Settings > Forwarding and POP/IMAP > Forwarding to set up a new email address to auto forward your Southwest itinerary emails.

You will receive shortly an email that will provide you with the confirmation code that you can enter in the above field. The return email will also include a link that you can just click on to verify and confirm sw@to.andyjiang.com as the new forwarded email address.

The generated email with your confirmation code to verify the auto forwarding email address

Once you confirmed the email address to allow you to auto forward to it, then you will have to set up the filter for the right emails to be auto forwarded. Click on the link in the tip ‘You can also forward only some of your mail by creating a filter!’ and then either copy and paste “from:southwest subject:(Your trip is around the corner)” into your Gmail search bar or use the template in your ‘Show Search Options’ drop down below.

Setting up autoforward for any Southwest itinerary emails to sw@to.andyjiang.com

Creating the filter to auto forward specific emails to sw@to.andyjiang.com

That should set it up so that any future email from Southwest with that particular subject will be automatically forwarded to my web app, which should hopefully check you in so you won’t have to sit in the back between the two fat, sweaty guys.

I will blog more about the actual code in future posts.

If you have any questions, please let me know!

Andy

[EDIT]: Please note that this is still not 100% battle tested, but it will improve over time the more emails it receives! Thanks, everyone!

sudo apt-get install build-essential bison openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-0 libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev libcurl4-openssl-dev libqt4-dev libmysqlclient-dev libpq-dev openjdk-7-jdk

• libcurl4-openssl-dev is specifically for the ‘curb’ gem
• libqt4-dev is specifically for the ‘capybara-webkit’ gem
• libmysqlclient-dev is specifically for the ‘mysql’ gem (mysql databases)
• libpq-dev is specifically for the ‘pg’ gem (postgresql databases)
• openjdk-7-jdk is specifically for JRuby (if you want to connect to Oracle/Sybase with JRuby)

rbenv + ruby-build

cd
git clone git://github.com/sstephenson/rbenv.git .rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec $SHELL
mkdir -p ~/.rbenv/plugins
cd ~/.rbenv/plugins
git clone git://github.com/sstephenson/ruby-build.git
cd
rbenv install 2.0.0-p195
rbenv rehash
rbenv global 2.0.0-p195

Rails

gem install bundler rails therubyracer

make sure your Gemfile has therubyracer if you use the asset_pipeline

Rails with SQLite

rails new *myapp*

Rails with MySQL

rails new *myapp* -d mysql

Rails with PostgreSQL

rails new *myapp* -d postgresql

Rails can generate controllers when fed the controller’s name – in this case RSpec is employed throughout the chapter. RSpec is a testing tool which is employed as part of TDD. TDD involves going from Red (failure) to Green (code working) and refactoring along the way. In generating the StaticPages controller the following files are created

The key file used in the chapter is the controller static_pages_controller.rb. The ‘/config/routes.rb’, which guides ‘correspondence between URIs and pages’ file looks like this:

Any requests to /static_pages/home will be mapped to the home action found within the static_pages_controller file, which looks like this

The class StaticPagesController inherets from class ApplicationController and contains the defined methods ‘home’, ‘help’ etc, which appear empty. The home action has a corresponding view home.html.erb (note the double file extension). The approach that emphasises the application’s behaviour is known as Behaviour Driven Development, a variation of TDD. This chapter will involve focusing in ‘integration tests’, in an RSpec context called request specs, which simulate a user/browser interacting with the application. This avoids having to manually check each page by identifying certain criteria that need to be fulfilled, and then testing the pages for this.

You start with the test, a necessarily failing test, but this ensures that we build an application that adheres to the correct framework as we develop it. The book argues that the fail-implement-pass induces flowstate.

An integration test is generated which creates the static pages spec. At the conclusion of this chapter it looks like this:

At the command line you can run the tests using the RSpec environment, with the prefix of “bundle exec” to ensure RSpec adheres to the environment identified in the Gemfile. You’re basically running through the whole static_pages_spec file and seeing that the “its” identified are true.

The next stage adds a new page. This requires

1. Adding the ‘about’ page to the route file
2. Adding the method ‘about’ to the StaticPagesController file
3. Adding a new file ‘about.html.erb’ to the view/static_pages folder

Basically during this part of the chapter I worked with – setting up a ruby application with RSpec to allow for BDD & TDD. Primarily spending time working with the route file, the StaticPagesController file and the static_pages_spec file to write up the tests that were to be undertaken.

The last part of the work is to add an element of dynamic content to the page by
a) having the title change for each page
b) creating a standard HTML framework that you just load particular content into for each page

There is a further condition added to the tests of having a ‘title’ – page.should have_selector. First argument ‘title’ second a Hash with key :text symbol and value the text being sought.

Couple of interesting bits are:

This is an example of Embedded Ruby (ERb). executes the code within and inserts the code.

In the static_pages_spec file there’s a lot of duplication around the first part of the title. The solution is to use the ‘let’ method to define a string which is then interpolated each time. The ‘let’ approach is contrasted to instance variables here.

The last part is to alter the application.hml.rb file. The /layout/application.html.rb file in a Rails app dictates the general layout of the views.

The title has been added here to it’s replicated in every view page. The within the body tags inserts the contents of each view page into the layout. This means that you can get read of a lot of the beginning and end tags on each view page and be left with just, for instance

I then completed the follow up exercise of adding a Contact page (making sure to edit the route, StaticPagesController and static_pages_spec files), and adding the RSpec ‘let’ function as above.

<strong<background noise:
Deerhunter – Monomania

This has a couple of significant plus points: First, no instance variables, so both the controller action and the view are more readable and easier to refactor. Second, no instance variables! So there’s a clear, documented, named interface between the controller and the view. And third, this is so transparently readable that I never bother to test it.

The wiki used in the above action is a repository, built in a memoizing helper method that most of the controllers use:

In this case the correct kind of repository is created for the current user, and all of the other code in this request sits on top of that. So the controller action, helped by the memoized repository builder, effectively constructs an entire hexagonal architecture for each request, and the domain logic is thus blissfully unaware of its context.

Here’s a slightly bigger example. This is for a page that shows a variety of informative graphs about the wiki; and because I may want to re-organise my admin pages in the future, each graph’s data is built independently of the others:

That’s the most complex query controller action I have, and I maintain that it’s so simple I don’t need to test it. Would you?

1. Rake
2. REST architecture
3. Revise HTTP requests

Rake
I already installed Rake. It’s a program that is effectively RubyMake, used to do bits and pieces around web apps. This morning rake db:migrate was used.

REST architecture & HTTP requests
“Representational State Transfer” is a style for designing applications. RESTful applications use HTTP protocols Get, Post, Read & Delete (CRUD)

The following is a summary from stack overflow

“A RESTful application is an application that exposes its state and functionality as a set of resources that the clients can manipulate and conforms to a certain set of principles:

Extra: Working through the introductory chapters of ‘Professional Javascript for Web Developers’. Mostly historical (and interesting). During the discussion of including Javascript in a page it identifies the problem of XHTML’s literal syntax. So things like Less Than operators would be seen as an opening of a tag. Rather than use the HTML tag (<) a hack identified is to wrap the code in a ‘CDATA’ section within a Javascript comment:

background noise:
Interpol – Turn on the Bright Lights
Pavement – Crooked Rain, Crooked Rain

Installing Stately

Installing Stately was not too much of a problem.  I downloaded Stately, added the four font files to vendor/assets/fonts/ and then added _customizations.scss, _setup.scss, and stately.scss to vendor/assets/stylesheets.  I modified vendor.css.scss to include stately.scss by simply adding ‘@import “stately”;’.  I had some trouble getting things to work, but after Googling around I found this post which describes how you need to change the csetup.scss stylesheet so that the @font-face src attribute simply refers to the font name by removing the relative path from ‘../font/stately-webfont.eot’ to ‘stately-webfont.eot’.

Using Stately

The Stately instructions tell you to create a big html list of alpha characters representing each state.  I didn’t want to carry that around in my view so I created a helper to do the mapping.  We already have a static list of states sorted alphabetically by state code, and I wanted to use that to map to alpha characters on the fly, but unfortunately the Stately state codes are not quite sorted alphabetically so I had to create my own map:

module Stately
  STATE_TO_CHAR = {
    "al" =>; "A",
    "ak" =>; "B",
    "ar" =>; "C",
    # ...
    "wy" => "y"
  }
end
 

With this done, I can do

<% Stately::STATE_TO_CHAR.each do |state, char| %>
  <li data-state="<%= state %>" id="<%= state %>"><%= char %></li>
<% end %>
 

This will give me a nice, if uninteresting map that looks like this:

Now for the interesting part. We have a model called a ViewingSession that contains a number of attributes including time watched and an IP address.  I can use MaxMind’s regional GeoIP service to pull out a state code from each ViewingSession like so:

Net::GeoIP.region_instance.region_by_addr(viewing_session.ip_address).downcase
 

From here it’s straightforward to build up a hash of state to percent viewing time.  I can assign a specific CSS class to each state:

<% Stately::STATE_TO_CHAR.each do |state, char| %>
  <% percentage = @state_data[state] ? @state_data[state] : 0 %>
  <li data-state="<%= state %>" id="<%= state %>" class="<%= class_from_percentage(percentage) %>"><%= char %></li>
<% end %>
 

The class_from_percentage method simply assigns a class level depending on the percentage.  With our data I found seven levels to work best.  In order to get good a good gradient of colors I used the color scale generator I found here.

Here’s the final viewing heat map result:

Made a little edit wakeboarding with my roommate and buddy Wes a couple of weeks ago so check it out!

http://guides.spreecommerce.com/view_customization.html

http://deface.heroku.com/

https://github.com/spree/deface

2)Theams

1) https://github.com/spree/spree_fancy

https://github.com/search?langOverride=&p=5&q=spree+theme&repo=&start_value=1&type=Repositories

3) Gem

http://guides.rubygems.org/specification-reference/#licenses=http://docs.rubygems.org/read/chapter/20

www.klairvoyant.in

gem install pry

and then insert ‘binding.pry’ at the line of code that you want pry to stop and inspect. At run-time, you can inspect all the variables, and even change them on the fly.

Pry is meant not only as a debugging tool – it’s a whole replacement for the regular ruby console (irb), and can be invoked in the terminal by typing ‘$ pry’.

And you can use Pry as a rails console replacement as well! Just add

gem 'pry-rails', :group => :development

to your Gemfile, bundle install, and (assuming you have Rails >=3.2.0) create a new initializer with the following code:

MyApplication::Application.configure do
  # Use Pry instead of IRB
  silence_warnings do
    begin
      require 'pry'
      IRB = Pry
    rescue LoadError
    end
  end
end

This uses the the ‘pry-rails’ gem by the Pry project, which causes ‘$ rails console’ or ‘$ rails c’ to open pry directly.

For more information, see the Pry-rails Github page.

Edit (20/5/2013): Switched back to the standard console. I think there’s a bit of a speed issue – requests seem to be a bit less snappy. Also the intense colours are lovely, but they’re a bit much for me.

“Barquin International announced today its partnership with the National Institute of Food and Agriculture (NIFA), an agency of the United States Department of Agriculture (USDA), in the development of the recently-launched Research, Education, and Extension Project Online Reporting Tool (REEport). This integrated data collection, analysis and reporting application was successfully developed and deployed by NIFA to provide a singular, consistent method to support oversight and tracking of competitive and formula grant projects managed by the agency.”

For the full press release, following this link:

http://www.prweb.com/releases/2013/5/prweb10713717.htm

Friday, May 3rd

So I went to Home Depot and rented an auger the night before we were to begin, so I wouldn’t kill myself trying to dig post holes in the clay that Los Angeles substitutes for regular dirt.

Saturday, May 4th

Got up early on Saturday morning and hauled out said auger.

My good friend Jonathan was helping me cut the lumber. These boards were being cut in half to be used as fence posts.

My son Micah using the auger to dig a post hole.

Aaron was lending a hand doing something constructive (destructive?) with this shovel.

Jonathan wanted a turn with the auger and wound up with a small burn on his arm when the auger kicked back and tagged him with the exhaust. :-/

Arielle, not one to be left out, was assisting with clay/dirt scattering. Because scattering is a big part of building… apparently.

I wanted to make sure that each of the posts were not only the same height, but level as well. My dad was supervising.

We decided on an 18 inch inset for the posts near our neighbors driveway so they wouldn’t have trouble getting into/our of their cars.

Jonathan and I discussing the finer points of cement pouring. This is important as I didn’t realize cement pouring had fine points.

My dad mixing the cement for us to, well… pour. Now that we’d agreed on all the finer points.

Fence building is a family project.

Another check of the post height. With all of the posts in and the cement poured, that was all we were able to do on the first day. We had to let the cement set before we could proceed any further.

Thursday, May 9th

My wife wanted to paint the posts before we started adding the rails.

So she went around to all 15 posts and did just that.

My wife’s beautiful handiwork.

Avery decided to show up and demonstrate how easy it is to apply fence paint to clothing.

Rail progress!

Then, in the middle of everything, we had a beautiful evening rainbow that bloomed out of nowhere.

We were trying to figure out what caused such an unusual glow and I later found out that there was an eclipse taking place. The residual light reflected off the moisture in the air, causing an ambient glow that lit up the entire neighborhood.

Friday, May 10th

By the time we were done, it was too dark to get a good picture. So I took a few this morning before I headed in to work.

We worked well into the night and managed to get all of the rails up. Now on Saturday we’ll start adding the pickets.

> Great introdutory tutorial with a very complete explanation of the steps, features used and good practices.

> I’ve listened to a few episodes of this podcast and so far found it very interesting. There’s a lot of things that they talk about that is alien to me but in the overall of the episodes, it doesn’t ‘scare’ the listener (me )

- enable_submodule does not work properly
- it does not get the latest code from submodules
- it does not allow you to choose specific branch and sha of any submodule
- in fact for main repo it does not allow you to switch to any specific branch and sha
- for some reason it says branch=version, who knows why ….

I tried correcting all above, and below is one of my examples, its working for me

The SQL query used by this find call will be somewhat like:
SELECT id FROM clients

Be careful because this also means you’re initializing a model object with only the fields that you’ve selected. If you attempt to access a field that is not in the initialized record you’ll receive:

example:

a = Person.select(:name).uniq
=> [#<Person name: "Mary">, #<People name: "John">]
irb(main):011:0> a.first.name
=> “Mary”
irb(main):012:0> a.first.address
ActiveModel::MissingAttributeError: missing attribute: address

pluck can be used to query a single column from the underlying table of a model. It accepts a column name as argument and returns an array of values of the specified column with the corresponding data type.

select returns a Model object with only :column populated
pluck only returns the values
select(:id) will return an array of Model
pluck(:id) will return an array of integers ( suppose the column id has integer type)

So migrations…yup, nice idea, keep the database in sync, provide a revision history, database vendor agnostic, fair enough.

Models….bare absolutely no resemblance to the underlying schema generated by those migrations, if you look in the class file. That’s not nice. I shouldn’t have to keep referring to the schema to understand what underlying data structure the model represents. But okay, I can live with that, I can accept the argument that having an explicit definition in every class model is redundant even if I am not fully convinced.

Data validity…is enforced entirely at the application level. Seriously? Wahhhh……wwwwww…w.aaaaaaa??!

I like data. I’ve been working with relational data models since the 80s. No, we don’t always need them. But if I’ve actually specified a relational database as my backend, specified in my “migrations and models” (in this case) the essentials to define those relationships, its not unreasonable to expect them to expect them to be honored IF I CHOOSE TO SWITCH ORMs OR FRAMEWORKS.

I guess what I am saying here is that I don’t expect to trade being database agnostic for being tied to a specific framework. Or as Ignacio Galindo writes “Also allowing your rails app database to be written by an external app or framework it’s just INSANE!”. Well, if your database schema doesn’t enforce basic constraints it definitely is.

Look, again, I do get it. I can see the trade offs, and for a lot of applications this would be a non-issue. I see the use cases for NoSQL etc. but for applications where the data IS important, I cant see myself abandoning 30+ years of wisdom when it comes to enforcing constants.

Pfft, I guess I really am a dinosaur. Or am I missing the point? Please do tell…..

Model.update_all :field=>value

It will update all of the records to the value you want.  If you want to do it for only certain records, you can use a where clause like so:

Model.where(“foo = ?”, “bar”).update_all :field=>value

Last night, however, I found myself with a little time and decided to fire up Tomb Raider.

Two things. I like the game, and I’m bored of the game.

I like the game because it’s a cool story so far, and we’re on a jungle island and jungle islands scare me…so that’s a plus. I enjoy the characters and the game looks pretty. And, like I said before, I enjoy playing a realistic female character.

But, mostly…I find myself bored.

I’m one of those people who likes to be immersed in a video game world. I love first person shooters and rpg’s. Hooray for hack and slash! I enjoy feeling like the game needs me in order to function properly. Zelda, Arkham Asylum, Fallout, Elder Scrolls, Torchlight…they all need the player’s involvement to keep the action going. I like that.

What I don’t like is hitting a few buttons and then letting the game play for me. Dragon Age: Origin (my first and only foray into that series) cemented the fact that I hate the cut scene. Like…hate. There were a few minutes of action, and then cut scene. Action…cuuuuuut sceeeeeene. Blippy action….CUT SCENE.

Fuck me sideways! I just wanna play the game please!

In Tomb Raider I feel like I have a tiny bit more control than that, but a) I can’t play first person and b) the game takes over for me at nearly every opportunity. What’s the point of me being there if the game has control like that?

The other thing I’m not a huge fan of is playing a game with overly controlling rails. DO this, then do that, then do this, we’re not going to allow you to deviate from this path. I accept that there are reasons game developers have to keep a player concentrated on the quests at hand, but games like Skyrim have spoiled me rotten with the free exploration of the world you’re in. But, I’ve played games where the story line and game play are on rails, but it didn’t feel like it. Tomb Raider feels like it. It’s a little claustrophobic.

Nonetheless, I’m going to continue to play it because, like I said, I’m enjoying the story and want to see what happens. I also want to see if I get more control as the game progresses. If so, then I think I’ll like it more.

Until then, I’ll reserve my final judgement.

Thanks to the DreamSpark account USC has, I downloaded Visual Studio 2012 to get familiar with that too. Another thing that comes with the DreamSpark account is a 90-day trial period with PluralSight, which has a huge library of tutorials written by Microsoft people. I started with the ASP.NET MVC 4 Fundamentals tutorial and watched the first module and here are the similarities and differences I saw with Rails.

First of all in terms of the basic principles, I found them to be the same. Well, that’s probably because they both use MVC and Convention over Configuration. The folder structure is pretty similar as well.

Models, Views and Controllers all have their separate folders just like the app/models, app/views and app/controllers in Rails. Configurations have their own file, just like config.

Routing

The routing seemed to be almost the same to me, at least for now. The methods in the controller correspond to a view just like in rails. Here is an example:

public class HomeController : Controller
{
    public void Index()
    {
        return View();
    }
}

So the Index method of the HomeController requires an Index.cshtml file to render the necessary html. It could be even blank, as long as it is there. By the way “cshtml” is like “erb”, you can embed C# code into html, and I will show that new.

@{
    ViewBag.title = "My Title";
}
<h3>@ViewBag.title</h3>

This code is is a little weird. Here is what I understand from this code and will try to explain in a little bit. But first let me show the Rails code for the same thing which might help those of you who are Rails developers trying to understand ASP.

class HomeController < ApplicationController
    def index
         @title = "My Title"
    end
end

The corresponding view is index.html.erb.

  <h3><%= @title %></h3>

These both do the exact same thing (I say this without actually testing so please let me know if they don’t so I can correct it). They both respond to the ../home/index url and display the same thing.

Now the differences are very apparent in terms of syntax so let me explain that a bit. In Rails I am used to passing the variables in the controller by assigning them to an instance variable like @title. However in ASP.NET you pass your variables to a ViewBag object, like so ViewBag.title = . I am assuming this is some kind of a hash with keys and values.

Now I have to just say that even though in this example we used the view of the Index method to assign the title, the same can be done in the controller and accessed in the view the same way. So we can remove the “@{}” part in the view and instead do this.

public void Index()
{
    ViewBag.title = "My Title";
    return View();
}

This without changing the html code in the view would still yield the same result and display the same page.

Database

In Rails, we are used to creating migrations and using those to create and update the database. My first impression is the way ASP.NET handles it is almost the same. I don’t know what goes on in the background and there certainly are differences but here is the overall view on that.

ASP.NET MVC uses Entity Framework 5 to manage the “code-based migrations”. When it sees a class that derives from the DbContext, it goes in and looks for DbSet declarations, and then is able to create a database (Wait! Whaat?). Here is a code example: ( This assumes that Employee, and Department have been defined)

public class DepartmentDb : DbContext
{
    public DbSet<Employee> Employees { get; set; }
    public DbSet<Department> Departments { get; set; }
}

Entity Framework is now ready to create a DB called DepartmentDb and add the Employee and Department table in it with whatever attributes they were created with. So it looks into the code and understands what you want in your database, pretty clever I have to say. You can also specify the DB name if you don’t want it to be DepartmentDb and some other configurations but this is not the place to discuss that. One other nice thing is that you can put data in the database through code. When you enable migrations, the Migrations folders gives you a Configuration file, in which there is a Seed method, which if you will with the AddOrUpdate method. Here is how that goes: (The method signature for Seed is exactly from the auto-generated code)

public override void Seed(eManager.Web.Infrastructure.DepartmentDb context)
{
    context.Departments.AddOrUpdate(d => d.name,
             new Department() { Name="Engineering" },
             new Department() { Name="Sales" }
}

This code will ensure that departments Engineering and Sales will always be in the DB.

eManager.Web.Infrastructure.DepartmentDb is just the location of the DepartmentDb file. d => d.Name tells the database to search the Departments table for names, and if there are no departments in the DB with the given name to add it. Pretty straight forward.

Conclusion

I think the first part of learning this framework has been relatively easy, since I didn’t have to wrap my head around an entirely new concept, like when I was trying to learn Rails as my first web development framework. The use of the controllers and views and models seems to be the same, which is a nice feature for a Rails developer (and I use the term loosely for my case). I will puts some ASP code on my GitHub shortly, which will be a little different version of what the tutorial is showing.