I recently had a conversation with someone who is looking to make a fresh start and become a developer (coming from other IT positions).  The question they had was:

What should I learn to get started in .NET and web development?

Now this question was starting from a position of “I’d like to get started with .NET and the web. How do I do that?” So please hold your “No, choose Ruby (or NodeJS or … )” comments. That’s another blog post. :)

Here’s my advice along with a bunch of courses you can use to accomplish this efficiently and affordably.

To go from “zero to web dev in .NET” I think you should start on these topics, in an iterative fashion:

What’s great about taking these classes on LearningLine is there is zero duplication. If a lesson (task) happens to be shared across courses, you’ll see it already marked as completed for you and you can just skip to the next.

Hope this has help give you some guidance on getting serious about becoming a .NET developer.

Here is a short screencast which shows you the stark contrast in simplicity between an application using a relational database and one using a document database such as MongoDB, CouchDB, or RavenDB.

This is an excerpt from my upcoming online MongoDB course for DevelopMentor. You can take the first 1 1/2 hours for free here:

Early access: MongoDB and NoSQL for .NET developers

Cheers,
@mkennedy

These are both excerpts from my upcoming online MongoDB course for DevelopMentor. You can take the first 1 1/2 hours for free here:

Early access: MongoDB and NoSQL for .NET developers

Windows:

OS X:

Feedback welcome.

cheers
@mkennedy

The news is good. There are many different options to choose depending on your platform and use-cases.

1. Robomongo, price: $0 / open-source, platforms: Windows, OS X, Linux
http://robomongo.org/

Robomongo — is a shell-centric cross-platform open source MongoDB management tool (i.e. Admin GUI). Robomongo embeds the same JavaScript engine that powers MongoDB’s mongo shell. Everything you can write in mongo shell — you can write in Robomongo!

Key features:

• Full power of MongoDB shell with the ease of a GUI
• Multiple shells
• Multiple results
• Autocompletion
• View your MongoDB database as a hierarchical tree consisting of databases, collections, indexes and users
• User management

My take: Robomongo is definitely my current favorite management tool for MongoDB. It beautifully blends the power of the mongo shell and JavaScript API with a classy and intuitive user interface. Basically every rich UI can be driven by shell commands and then further manipulated with the UI. Brilliant. The fact that it’s free and works on all platforms is nice too.

The shell, price: $0 / open-source, platforms: Windows, OS X, Linux
No url, comes with MongoDB itself.

The mongo shell is an interactive JavaScript shell for MongoDB, and is part of all MongoDB distributions.

Key features:

• Complete (albeit command-line only) access to MongoDB
• Comes with MongoDB

My take: While the mongo shell might not be your favorite way work with MongoDB, it is very powerful and it’s always available. So you should take the time to learn it properly. Especially since you’ll need to know most of the features to take advantage of Robomongo above anyway.

Mongovue, price: $0 / $35 / $up, platforms: Windows

MongoVUE is an innovative MongoDB desktop application for Windows OS that gives you an elegant and highly usable GUI interface to work with MongoDB. Now there is one less worry in managing your web-scale data.

Key features:

• Gain a quick and effective overview of your database (size, usage, doc count, etc).
• Easily build indexes – either specify Json or use the point and click (visual) interface
• Run Map-Reduce operations easily. Get syntax highlighting for your Javascript functions while typing
• View your MongoDB database as a hierarchical tree consisting of databases, collections, indexes and users
• Import relational data from MySQL or SQLServer into MongoDB automatically and start building your applications right away
• User Managment
• Special GridFS interface
• Limited shell support
• Copy collections from a database to another database

My take: Mongovue has been around for awhile and is solid and affordable. I really like the “overview” view for a given database to see just how much space everything is using and how your data is growing.

LINQPad, price: $0 / $39, platforms: Windows
http://www.linqpad.net/
http://www.thinqlinq.com/default/Using-LINQPad-with-MongoDb-and-NoRM.aspx

LINQPad lets you interactively query databases in a modern query language: LINQ. Kiss goodbye to SQL Management Studio! LINQPad supports everything in C# 5.0 and Framework 4.5

Key features:

C# “shell” rather than JavaScript shell.
Can leverage utility functions from your library
Directly work in the objects and classes of your application

My take: If you are writing .NET apps to talk to MongoDB do not overlook LINQPad. You can take your classes and queries directly from your app and test and view the results in this GUI. Follow Jim Wooley’s blog post link above to see how to put your classes in LINQPad to get started (you might not be using NoRM, so adjust accordingly).

REST view, price: $0 / open-source, platforms: Windows, OS X, Linux
http://localhost:28017/

Key features:

• View contents and status of server with your browser
• Check on performance and statistics
• View the log file

My take: While this is just the basic REST API of MongoDB, you can monitor your log files, run commands using the REST API, and otherwise check in on your server. Not bad. Just requires the –rest command-line to mongod.

Genghis, price: $0 / open-source, platforms: Windows, OS X, Linux
http://genghisapp.com/

Key features:

• Basic database status, CRUD, etc.
• Installs into your web app (provided you’re using Ruby or PHP)
• View contents and status of server with your browser

My take: This is a very interesting web monitoring app. Just drop a single .RB or .PHP file on your server and you get a well rounded management tool. Only requires that you can run Ruby or PHP on your server.

MongoDB Monitoring Service, price: $0 / open-source, platforms: Windows, OS X, Linux

MMS (MongoDB Monitoring Service) is a service for monitoring MongoDB infrastructure. MMS was created by 10gen and is provided for all users of MongoDB. Designed with security and ease of use, MMS collects statistics on all key server and hardware indicators and then presents the data in a powerful web console. The data is a great asset when optimizing applications during development and potentially invaluable when diagnosing production issues. For sharded clusters consisting of dozens of nodes, MMS is particularly useful because it provides a holistic overview of MongoDB deployments so that administrators can asses quickly the health clusters.

Key features:

• Allows secure access to your server’s stats and errors remotely
• Great graphical dashboards about server usage
• Error reports and logs
• Alerts for server issues

My take: MMS is an interesting, free service from 10gen, the makers of MongoDB. It’s pretty easy and quick to setup.

Conclusion:

Hopefully you’ve found something new or interesting that can help you get started or keep going with MongoDB. The lack of management tools was hurting MongoDB’s adoption in the early days. I think those days are past.

Cheers,
@mkennedy

This article demonstrates a technique and supporting library for adding optimistic concurrency control to NoSQL databases and MongoDB in particular.

Watch a video walk-through using this library:

Quickly, what is optimistic concurrency control?

Ideally, all databases that allow concurrent access or disconnected access need to implement some form of concurrency control. This usually comes in two flavors:

1. Pessimistic concurrency control
   
2. Optimistic concurrency control

Pessimistic concurrency control is usually used when working heavily within transactions. That may be fine for bank transfers, but it typically falls down in the face of disconnected models used by almost all ORMs such as Entity Framework. Moreover, it is entirely inappropriate for NoSQL databases.

Frameworks such as Entity Framework have optimistic concurrency control built in (although it may be turned off). It’s instructive to quickly see how it works. Basically there are three steps:

1. Get an entity from the DB and disconnect.
2. Edit in memory.
3. Update the db with changes using a special update clause. Something like: “Update this row WHERE the current values are same as original values”.

If that update returns “0 rows modified” then we know it was changed since we loaded it and are about to overwrite someone’s changes. This results in a concurrency exception and not changes go through.

Optimistic concurrency control for MongoDB

By carefully constructing update commands in C# with the official 10gen C# driver, we can achieve almost exactly the same flow. At the end of this article is a simple C# class (data context) which has save and delete methods which internally are safe via optimistic concurrency control.

The only thing you need to do to use this library in your apps is to implement this interface on all top-level MongoDB entities and use a class derived from ConcurrentDataContext (in library below) for your data access.

Using this interface, the data context will manage a unique ID for you named _accessId per save. If someone else edits this object after you have gotten it but before saving it, you’ll get a concurrency exception, just like EF, and no changes will go through. All you do is call save and access entities via LINQ queries. Nice huh?

Here is an example of your entities with this interface in the db:

Here is an example of an app running end to end with only one editor on the document. See, no errors:

And here is simulating a concurrent edit, which results in an error.

Conclusion

There you have it! For all of you who want to adopt MongoDB and .NET but are concerned about concurrency issues, you now have the same level of concurrency safety as Entity Framework. That should be quite reassuring.

Here’s the download for the source, library with the concurrent data context, and the sample app:

MongoDB.Kennedy.zip

Cheers,
@mkennedy

We believe that LearningLine is the most effective online training for developers, period. Today it gets even better. We are announcing the ability to preview any of our online courses, for free without entering any payment information.

This is not a trial that becomes a subscription or a silly 5 minute preview like other company’s offer.  You can now study approximately the first hour of any one of our courses. And you can spend as much time as you like doing so.

To get started, just head over to our schedule page, click on any course title you’d like and choose “Preview course for free“:

This means there is now a lot of content available to you right now. At a typical student speed working for an hour a day, it would take over a month to complete all the content that is available for preview.

Do you want to learn how to build rich input forms and avoid security holes in your ASP.NET MVC applications? Just head over to Accepting user input in ASP.NET MVC  and click preview:

https://learninglineapp.com/courses/11/accepting-user-input-in-aspnet-mvc

Are you getting back into C++? Learning it for the first time? The try Developing C++ Applications:

https://learninglineapp.com/courses/36/develop-cplusplus-applications

Are all your cool, hip friends talking about HTML5? Check out HTML5 In-depth:

https://learninglineapp.com/courses/8/hmtl5-in-depth

You get the idea. At the time of this writing, there are 27 courses which run between 4 and 15 days in length. There is definitely something out there for your to try.  So head on over to the schedule page and find a course that is right for you:

https://learninglineapp.com/schedule

Cheers,
@mkennedy

PS – No this is not an April fools joke. :)

I had a great time discussing these topics with everyone at DevWeek 2013. Thanks to all who attended my sessions. Here are the slides:

Getting Serious About The Cloud For Developers
Slides: Getting serious about the Cloud (DevWeek).pdf
Demos: CloudDriverS3SecureFiles-Demo-DevWeek-Kennedy.zip

18 Ways Your Brand-New MVC Web Application Can Be Better
Slides:More Ways MVC Better (DevWeek) – Kennedy.pdf
Demos: 18WaysMvcNewProjectBetterDemo-DevWeek-Kennedy.zip

Building Rich Forms in ASP.NET MVC (important - see note below)
Slides: Rich Forms with ASP.NET MVC (DevWeek).pdf
Demos: Rich-ASPNET-Forms-Demos-Michael-Kennedy.zip

Applied NoSQL in .NET (important – see note below)
Slides: Applied NoSQL in .NET (DevWeek).pdf
Demos: Applied-NoSQL-in-dotNET-Demos-Michael-Kennedy.zip

Important note: In order to run this demo, you must download MongoDB and start it on your local machine. You do not need to initialize a database or anything like that but the db will be empty so use the admin feature to create categories and books. Running MongoDB as a Windows Service is not required.

Cheers,
@mkennedy

http://www.learninglineapp.com

At DevelopMentor we have been thinking deeply about online training. We wanted to create an environment that combines the best parts of online learning and classroom training, the best parts of self-directed exploration and expert-led mentoring. We believe we have created just such an environment and I am thrilled to publicly announce it today.

Here’s a short 2-minute video which will give you a quick overview. You can get more details at http://www.learninglineapp.com.

Online training today

There are many shortcomings in how developers learn online today.

Some developers choose online video libraries. Many of these are well done by highly qualified people. However, software development is a contact sport. We learn by doing, not just watching. Did you happen to watch the (American Football) Superbowl this year? If so, you’re probably more knowledgeable about football. You can have great conversations about football and seem (and feel) connected and current. But can you play football any better because of it? Some things in life are learned through participation - software development is one of them.

Some developers are self-starters and just piece together the knowledge they need. With blogs, YouTube, social media, Channel 9, and a plethora of other sources, motivated and skilled peopled can learn on their own, and many do. This process is definitely hit and miss, and it’s inefficient. You spend a lot of time separating the wheat from the chaff – and there is a lot of chaff out there.

Some developers choose instructor-led classroom training. DevelopMentor has long been known as an industry leader in classroom training. While we think classroom training is great for teams that have the time, schedule, and budget that is an increasingly less common situation for many developers. Online training (of any variety) offers a clear alternative to classroom training and it provides immediate on-demand learning.

World, meet something better

While there are benefits to all the above styles of learning, there are many drawbacks too. In creating LearningLine, we have carefully studied over 30 online learning offerings (both higher education and professional training) and have selected some of the best elements from each. We think the unique blend of the features that we have rolled into LearningLine address many of the shortcomings of online training head-on.

1.  LearningLine is online, and self-paced. You learn when and what you need. Our dependency engine provides the means to “back up the bus” and allow you to fill in any missing prerequisites or immediately see what you can do just after a given lesson.
2. Our lessons are comprised of learning activities which come in multiple modalities. Everyone learns in a unique way. This is why LearningLine uses multiple learning modalities including videos, articles, code demos, and exercises.
3. We learn by doing. LearningLine is not a passive experience. It is intense learning where you write code and submit work at every turn. The harder you work, the more you learn. LearningLine is all about creating developers who can ship software.
4. LearningLine is instructor supported. With LearningLine, you won’t get stuck. When you submit work, your instructors will review your code and suggest improvements. They will answer any question you have for your class. LearningLine instructors are professional software developers with real-world experience building applications with the technology you are learning right now.
5. Modern software development is a social activity. Why should learning be different? On LearningLine you can talk with your instructor and other students, see who is ahead of you, and you learn as a team. With LearningLine’s reputation system, you can show your teammates just how smart you are as you compete for the #1 ranking.
6. LearningLine is built around your team. You have full access to our content, and platform, to create your own custom learning that suits your team and project. You can annotate our content and add your own internal learning material to make learning directly relevant for your team. Your own experts can also be instructors using the same tools we have built for ourselves.

Go forth and learn

I encourage you to check out LearningLine at:

http://www.learninglineapp.com

You should also follow us on social media. We’ll be announcing some free classes and subscriptions to celebrate our launch.

Twitter – @LearningLine
YouTube (featuring some  of our content freely available)
Google+
LinkedIn
Facebook

Check out our class schedule and pricing options. If you are used to classroom instructor-led classes, I think you’ll be blown away at how affordable instructor-led learning can be.

Do you believe in us?

If you believe that online learning can be more than it is today, and if you believe LearningLine is a step forward, I encourage you to spread the word. Tell your co-workers, tell you boss, talk about us on social media, email a friend and so on.

This is the beginning of a bold adventure. I look forward to sharing it with you all.

Cheers,
@mkennedy

Validating ASP.NET MVC Forms with DataAnnotations

In this short screencast, I will show you how to leverage ASP.NET MVC’s excellent model binding as well as the DataAnnotations attributes to easily add both server-side and client-side validation for MVC websites.

Here’s a quick ASP.NET MVC tip to help you be more productive and write cleaner code. We will see how to leverage C# 4′s optional and default parameters in our action methods for greatly simplifying our code while keeping it fully functional and error free.

Often you want to pass data to your controllers based on URL parameters. This can either be part of the URL itself in the case of route data or it can be part of the query string. In fact, this tip even works for input forms.

Let’s take a basic method which shows some census data, potentially filtered and sorted if that information is passed along, otherwise we’ll just show everything with a default sort.

This looks great, right? If you had a URL such as

    /census/detailsvaltype/1?sortAscending=false

It would work perfectly. But what if we omit sortAscending? Well, bool is a value type and doesn’t like missing data much:

I’m just guessing, but most users don’t love this page.

So we can make the parameters strings (no MVC conversion required, missing data can be detected, etc.) like this. But notice how ugly and complex the code becomes

Yikes, we went from 1 line of code to many! However, (here’s the point of this post), let’s try that again with optional parameters:

Almost as simple as the naive version. However, you see making the request with and without data works perfectly! In fact, the data passed to GetDataAndResult are the same here as for the complex variant.

With Data (filtered and ordered):
/census/detailsoptionaldefault/1?sortAscending=false

Without Data (unfiltered and default order):
/census/detailsoptionaldefault

How about that? Hope you find that useful! You can download the code and try it for yourself here: OptionalParamsKennedy.zip

Cheers,
@mkennedy

First, if you’re unfamiliar with NuGet, it’s basically “add reference” to external software projects (typically open source ones such as jQuery, but also for Microsoft ones such as Entity Framework). You definitely need to check out David Ebbo’s post introducing it. NuGet will change the way you develop.

Now when using NuGet it maintains a packages folder near your solution file. For things like ASP.NET MVC that heavily leverage NuGet, you’ll see this folder is very large. It’s usually much larger than your project itself in the beginning.

If you write small projects and share them out as compressed files (e.g. zip’s), and size matters to you, you might want to consider enabling NuGet package restore (off by default) for those projects and delete the packages folder before zipping and sending it out.

As an example, with a typical MVC 4 project, the “raw” content is 680 KB. After doing a build and counting the packages folder you’ll see it jumps to 16.9 MB. If that helps you significantly, then it’s probably a good idea to use package restore.

Three things have to happen to use NuGet package restore.

First, you’ll need to make sure everyone who downloads your zip file has “Allow NuGet to download packages during build” enabled in Visual Studio under Tools>Options>Package Manager.

The next set of steps are only done by the you – the one sharing the code. Right-click on the solution file and choose enable package restore:

After doing this, you’ll see 3 new files in your solution:

Finally, when you zip and share your code, be sure to include the .nuget folder but not the packages folder (and maybe not the bin and obj either).

Now I did say at the beginning why to consider this, not just you should use it as a blanket statement. This whole workflow was introduced for simplifying source code management. Two reasons that come to mind right away to not use package restore are:

1. If not many of your users / readers / downloaders have package restore enabled globally it might be more effort than its worth.
2. In the source code scenario, you are dependent on NuGet keeping the right version around forever. Suppose you want to roll-back to the way the code was 2 years ago (some time in the future). It might be safer to have the packages folder just checked in so you’re sure it gets versioned and labeled exactly right.

Hope that’s useful to you!

Cheers,
@mkennedy

Sessions:

Building Rich Input Forms in ASP.NET MVC

ASP.NET MVC has gained broad adoption over the last year. This is in part due to it’s clean and simple design. However, one aspect that new-comers typically get hung up on is building pages that accept user input in various manners. In this talk we will explore the powerful features of ASP.NET MVC that allow us to build rich forms that accept user input. We’ll begin by discussing the built-in HTML Helpers and Model Binding. Next we’ll add validation and show how we can do both client- and server-side validation using DataAnnotations. We’ll see that sometimes using domain models as our form-bound objects doesn’t make sense and so we will cover more advanced scenarios using View Models. Finally, time permitting, we’ll see how client-side programming with JavaScript and jQuery can take this even farther.

Applied NoSQL in .NET

Perhaps you’ve heard about the next generation of databases roughly classified as NoSQL databases? These databases are generally much better than RDBMS at scaling, performance, and easy-of-development (i.e. in NoSQL the object-relational impedance mismatch usually disappears). Unfortunately, many talks on NoSQL are very academic and general. Not this one.

In this talk, we’ll explore the NoSQL landscape and look at the the various options out there. Then we’ll learn how to leverage MongoDB (a popular NoSQL DB) to build .NET applications using LINQ as the data access language. From there we will build out a .NET application using LINQ and MongoDB in a series of interactive demos using Visual Studio 2012 and C#.

Getting Serious About The Cloud – For Developers

You’ve been hearing all about “the cloud” for several years now. Maybe now is the time to take the leap and get started developing for this next-generation platform. That’s what this talk is all about. Learn what options you have for cloud hosting (and the related trade-offs). See how to create and host applications in the cloud. And learn about the tricks the pros use to achieve the scalability and durability promised by all the hype.

(At Least) 9 Ways Your Brand New ASP.NET MVC Project Can Be Better

So you’re ready to start that new and ambitious ASP.NET MVC project. Maybe you’re kicking off a new startup or just finally moving that old-and-crusty webforms project into modern development world. Either way, this talk will give you some easy things you can do immediately after creating that new MVC project that you will thank yourself for as your project grows in complexity.

Cheers,
@mkennedy

In this short screencast, I’ll show you everything you need to know to get started with ASP.NET MVC routing. You’ll see how default routes in MVC map to controllers and actions. Next you’ll see how to map additional data from query-strings in addition to simple route data. Finally, we’ll create a custom route to pass additional data in a clean, URL based manor.

You can download the code if you’re interested.

Download the code: Kennedy.Mvc.StronglyTypedViews.zip

Download the code: Code-Kennedy.Mvc.ViewBagsAndViewData.zip

Cheers,
@mkennedy

What happens if you link to a js file twice in your page?

Here is a contrived example.

Notice that we are including bad-example.js twice. Do modern browsers somehow realize they loaded this file already and skip this? Not yet, as we’ll see!

Imagine bad-example.js had this code in it.

Is jQuery smart enough to know it should only hook this event once per file? Will that div be appended as many times as the file was included when the button named nameIt is clicked?

I’ve created a simple jsFiddle for you to explore this problem before we get to the solution.

Accidentally Included Script Three Times
http://jsfiddle.net/mkennedy/6AHCZ/

In the bottom-right pane, you’ll see the web page running. Enter your name and click the button. You’ll see that you get this output, repeated 3 times per click!

Now, the old saying “I said, doctor it hurts when I do this with my arm. Doctor said, then don’t do that!” comes to mine. Maybe we should just try hard to not include a js file multiple times. In real web apps, it’s not that simple.

I’ve been working on a JavaScript-heavy web application recently. There are a lot of ASP.NET MVC views and layouts as well as a lot of JavaScript files. Currently, a little dir /s reports there are 1,200 razor views and 50 JavaScript files. Many of these are views nested within views which are nested within layouts, and so on. It’s not simple to be certain you’re only including a file once.

So what do you do? Give up and proclaim that JavaScript sucks. It was never meant for building large applications. No, of course not.

The web is awesome and the fix is simple enough.

Let’s look at another example. If we could simply write code like this, we would be in business.

We call fileAlreadyLoaded and bail out if it’s true. You’ll see that by using namespaces (you should do this anyway!) and a simple method which embraces JavaScript’s dynamic nature, we can pull this off easily.

First, for your project, define a global namespace. Let’s assume I’m writing a blog app. So maybe blog is a good base namespace. You see, in JavaScript it’s as simple as this:

This might be good for your main JS file. But you do not want to have just one huge JS file. Breaking things up for maintainability is good. So suppose we have a commets.js file. In there, we’d have:

Notice, it’s not var blog.comments.We’re adding a sub-namespace (object) to the global namespace blog. With namespaces in place, we can add methods to them and get intellisense to boot! Here’s an example of adding a method to the blog.comments namespace.

We can set values such as blog.comments.debugMode = false. And your code becomes much more navigable in Visual Studio with intellisense by leveraging namespaces:

So namespaces are great and all. But the question is…

How do we leverage namespaces for checking whether a file is loading more than once?

Well, if we use one namespace per file and recall that namespaces are just objects we can write that method to check for a double load like this:

We take a namespace and see if it has a firstLoad property. The first time, firstLoad has never been set, so it comes back as undefined. Hence, isFirst is true. We add a little logging to let us know there is trouble if it’s a second load. Then we just return the status.

Anywhere in your js file you need check (only ask once per file!) you can do:

See how we pass the namespace blog.comments which is in the comments.js file?

There you have it. We prevented the execution of a JS file the second, third, etc times it’s included. You even get a diagnostic output to boot.

So for the final part of this post, check out a new jsFiddle which uses the improved script with this testing and with namespaces.

Scripts only once (block multiple)
http://jsfiddle.net/mkennedy/eEBZh/

Now you see, we get just the output we want. Our script was included 3 times and yet it only ran once.

We even got some nice output in the F12 tools!

Hope this is useful or helpful to you!

Cheers,
@mkennedy

Early November I’ll be co-teaching DevelopMentor’s biggest .NET developer event of the year in Los Angeles: Guerrilla .NET. If you haven’t been to Guerrilla .NET, it’s a very unique and memorable event – it’s unlike almost any other training class you’ve seen. We’ve just updated the outline with the most important current and upcoming technologies (see below).

I hope to see you there! Feel free to contact me with any questions.
@mkennedy

Guerrilla .NET provides a deep exploration of .NET design philosophy and practical advice. You learn a myriad of patterns and best practices, and you get hands-on experience developing applications using Visual Studio 2012 and Windows 8. Learn to write code using new .NET class libraries like Entity Framework 5, MVC 4, and even the new Windows Runtime (WinRT).

Course Topic Highlights:

• Windows 8 For The Developer
• LINQ and Entity Framework 5
• XAML-based Programming
• ASP.NET MVC 4.0: Beyond the Basics
• Introduction to jQuery
• Model-View-ViewModel for WPF and Metro
• Building RESTful Services with The ASP.NET Web API
• Programming Win8 Apps: Metro / WinRT
• Entity Framework 5 and Code First
• PFx: Task: a Unified Threading API
• PFx: The Parallel Class and Concurrent Data Structures
• C# 5.0
• What’s New in .NET 4.5
• Cloud Computing for the .NET Developer: IaaS, PaaS, and Patterns
• Applied NoSQL with LINQ, and MongoDB
• KnockoutJS
• Power Debugging
• Design Patterns for Testable Applications
• Topic X

I just added a download link for the source code:

WebAppsHaveHotKeysTooSample-MichaelKennedy-v1.zip

It’s an ASP.NET MVC 3 web app. Hope you find it useful!

Cheers,
@mkennedy

Enjoy!
@mkennedy

PS – Be sure to watch it in 720p quality.

Interested in a blog post on this? Take it to the comments section.

Cheers,
@mkennedy

Want to get ready for this class or a class like it or just get a quick-start on .NET? Here’s what I would recommend. There are many books covering the topics (but no small list covering most). Instead of trying to read them all in-depth (a fairly unattainable goal), I would suggest that you read the first 2 – 3 chapters from all of these books listed below. This would cost about $250 if they buy them all, but they are all available on Safari Books Online.

http://my.safaribooksonline.com/

You can get the free trial for 10 days and if you like it you can then pay $19 / month and have access to all these books (see the coupon at the bottom of the trial page on safari online).

CLR via C#, Third Edition (foundational knowledge)
http://my.safaribooksonline.com/book/programming/csharp/9780735640467

WPF 4 Unleashed
http://my.safaribooksonline.com/book/programming/microsoft-wpf/9780132174367

Silverlight 4 in Action
http://my.safaribooksonline.com/book/web-development/silverlight/9781935182375

Pro ASP.NET MVC 3 Framework, Third Edition:
http://my.safaribooksonline.com/9781430234043

Programming Entity Framework
http://my.safaribooksonline.com/book/software-engineering-and-development/9780596807276

RESTful .NET
http://my.safaribooksonline.com/book/programming/microsoft-dotnet/9780596155025

Learning WCF
http://my.safaribooksonline.com/book/programming/microsoft-wcf/9780596101626

C# in Depth
http://my.safaribooksonline.com/book/-/9781935182474

jQuery in Action
http://my.safaribooksonline.com/book/web-development/jquery/9781935182320

Host Your Web Site in the Cloud
http://my.safaribooksonline.com/book/web-development/9780980576832

MongoDB: The Definitive Guide
http://my.safaribooksonline.com/book/databases/mongodb/9781449381578

Agile Principles, Patterns, and Practices in C#
http://my.safaribooksonline.com/book/programming/csharp/0131857258

Debugging Applications for Microsoft .NET (sections on WinDBG)
http://my.safaribooksonline.com/book/programming/microsoft-dotnet/9780735645349

Cheers,
@mkennedy

Slides: Kennedy-Rich-Forms-with-ASP.NET-MVC-Slides.zip
Demo Application: Kennedy-MVC-Forms-Demo.zip

Video Recording:

Remember, you’ll need to run MongoDB to make the web app work. Read the readme in the zip file for details (it’s easy!).

Cheers,
@mkennedy

Want to learn more about building great forms in MVC? Attend my free DevelopMentor webcast this Tuesday.

Webcast: Building Rich Input Forms in ASP.NET MVC

https://www3.gotomeeting.com/register/559059054

In this webcast we will explore the powerful features of ASP.NET MVC that allow us to build rich forms that accept user input. We’ll begin by discussing the built-in HTML Helpers and Model Binding. Next we’ll add validation and show how we can do both client- and server-side validation using DataAnnotations. Finally, we’ll see that sometimes using domain models as our form-bound objects doesn’t make sense. We’ll look at more advanced scenarios using View Models.

Cheers,
@mkennedy

Let me give you one less reason choose the rocky-road of desktop apps today. You’ll hear people tell you that if you build applications for business users (so-called LOB apps) that are input heavy or have complex navigation, your only choice is to build a Windows application.

Why? Because your power users will want hot-keys. They don’t want to use the mouse and navigation and all that stuff that makes the web less usable. They’ll just want to hit a few keystrokes and jump from place to place and do that quick look-up or data entry.

If you haven’t looked carefully around the web lately, here’s a revelation:

Real web apps have hot-keys too.

Just look at Twitter, GMail, GitHub, Hotmail, and many more. They all have rich hot-key support (although with GMail you’ll have to turn it on). Scott Hanselman has a great article on this: Are you using the Web’s Keyboard Shortcuts and Hotkeys?

So if Scott’s is so good, why write this one? His post is meant to open your eyes to how web apps can be. I want to show you, Mr. / Ms. Software Person, how easy it is to get there. You might be thinking to yourself, “Sure Google & Twitter can do this because they have millions of dollars and a bunch of developers. My project has 2 people and a 1 month deadline.”

It turns out, adding hot-keys to a web app is crazy easy. Especially with the jQuery plugin jQuery.hotKeyMap.js which I recently wrote. Here’s the blog post I did on it. You should check out the sample application I built to see it in action.

So give hot-keys in your web apps a try. Feel free to use my jQuery plugin and sample application as a starting point. Once you get over the hurtle of teaching your users to use them, you’ll hear a whole lot less clamoring for desktop apps. All the pain from weird errors on certain versions of Windows, installers, patches, admin rights, .NET Framework versions and other unpleasantries that you’ve gotten used to, because you had to, will be distant memories.

Cheers,
@mkennedy

Of course, you can do this by adding target=”_blank” to all your external links, but that’s tedious to say the least. So here is a simple jQuery plugin I created to do the trick. (Yes I know there are others, but none seem quite right, so here is yet another.)

Download: Query.externalLinks

The usage is pretty easy. Pick a section to scan for external links and say go:

Here is a simple example (from my previous post on hotkeys). Click on the title or the twitter icon in the lower right to see it in action.

Currently, it works by adding target=”_blank” to all fully-qualified links. For example, the first link will be a new window, the second won’t:

<a href=”http://www.google.com”>google</a&gt;
<a href=”/contact”>contact me</a>

Hope you find it helpful.

Cheers,
@mkennedy

Expect a more general blog post on the topic soon. For now, I’d like to share my jQuery plugin that enables this capability with you.

Announcing jQuery.hotKeyMap.js: A jQuery plugin that allows you to add complex hot-key functionality and navigation to your web apps with very little effort.

You can download it here:

jQuery.hotKeyMap

It’s built on top of John Resig’s jQuery.hotKeys. His plugin is great (as you’d expect), but as far as I know doesn’t support complex series of keys. For example, if you want to GMail style navigation (press ‘g’ then press ‘t’ to go to sent mail), that’s fairly difficult using his plugin. Here’s how you accomplish this with my plugin:

In the code above, we’re assigning three immediate key actions (e.g. ctrl+z executes undo). We are also adding one complex sequence: g, h => navigates to the home page (calls navTo, not shown, passing ‘h’).

Want to see it in action? Check out my sample application:

Web Apps Have Hot Keys Too!
http://www.michaelckennedy.net/Samples/blog/HotKeys/

It even comes with Visual Studio intellisense:

I hope you find it useful!

Cheers,
@mkennedy

   Kennedy-Demo-Amazoon-Sound-Sound-Usergroup.zip

The topic will be:

BUILDING WEB APPS WITH ASP.NET MVC AND NOSQL

This talk guides you through building modern web applications using ASP.NET MVC and MongoDB, one of the most popular NoSQL databases.

You will learn some best practices for getting started with MVC. We’ll cover building rich-forms to accept user input. And if time permits, we might even add some client-side techniques using jQuery and MVC.

All of this will be built upon the powerful non-relational database MongoDB. We will discuss the origins of the so-called NoSQL movement and why you might choose a non-relational database over SQL Server. You’ll also see our data access layer will be built using LINQ to MongoDB.

Of course, you won’t be in for a night of PowerPoint. This talk is a series of interactive demos using Visual Studio 11, Windows 8, and C#.

I hope to see you there! There is a chance I’ll have some prizes from DevelopMentor to hand out while I’m there too.

Cheers,
@mkennedy

Apple touts 4G as finally giving you the ability to watch HD video streaming on the go. They’re implying that finally you are free of 3G slowness and now you have high-speed Internet. You can do normal high-speed Internet things on the go. You can even tether up to 5 devices to that connection.

But I wouldn’t do too much of that if I were you! You see, this capability (while awesome) reminds me of that Prince Bride quote:

You keep using that word.
I do not think it means what you think it means.

Yes, you can watch HD video. But only 3 hours of it, per month. And that’s it. At the highest premium plan ($50/month). The starter plan gives you maybe 30 minutes / month. That had better be pretty good video, because it’s not cheap.

Here’s the relevant excerpt from the apple order page:

Yikes! Don’t despair though. There are other options. I’m currently using Clear.net. For $40/month they give you UNLIMITED data plans.

Here’s my recent usage graph. I usually do not use my clear at home, but do use it when I’m working out at Starbucks or elsewhere. Keep in mind, this graph is PER DAY USAGE and only counts 8 days of this period. I’ve also highlighted where the MONTHLY iPad 4G plans would land:

You can see several days of normal usage would bust the monthly limit of the premium plans. Most days that I have used the device all day would bust the mid-grade plan (not the cheapest, which is 250 MB, but the 3 GB plan).

Yes, there is the draw-back of carrying an extra device (even though it’s very small – credit card sized). But you get 4G and you get to use the Internet as if you really had high-speed Internet. Plus, you get a wireless network supporting up to 8 devices at once (maybe 9 with a hack).

Here’s a speed test from a random day on clear 4G. You can see it’s pretty speedy, but I have seen it above 10 Mbps.

So like many of you, I’m eagerly awaiting March 16th when the new iPad ships. But I’m just as happy it comes with WiFi and not 4G. I already have the covered.

Cheers!
@mkennedy

1. First of all, even MVC 3 has old-and-crusty aspects lurking in its projects. There are old MicrosoftMvc*.js AJAX and validation libraries that have be replaced with new jQuery hotness. These *.js files aren’t used so just delete them.

2. Many of the dependencies of your MVC project are out-of-date as soon as you create your project. You have an old version of jQuery, Entity Framework, etc. Luckily Phil Haack and crew had the brilliant insight to link these to NuGet. So the next thing you do is just run NuGet and choose the Updates tab.

What’s that, you don’t have NuGet? Oh, you need to fix that right now!

Here’s what you can expect under the NuGet updates page:

3. Speaking of NuGet, by default all the external, NuGet-based JavaScript files get mixed in with your few JS files you always need to go back to for editing. So this is what you do:

Create a separate folder called js and put your JavaScript files in there.

Don’t forget to import site.js into your _Layout.cshtml file.

4. You like intellisense, yes? You also like fast-loading pages yes? So on one hand, you want to use jquery-1.7.1-vsdoc.js for intellisense, but you want jquery-1.7.1.min.js for performance. Here’s what you do. Import the minified version into your layout page (see later in the article) but add a “reference” to the vsdoc version in your site.js file. See the /// <reference> at the top? See intellisense? Good!

BTW, you are using namespaces or the prototype pattern or something besides just importing junk into the global namespace aren’t you? I thought so.

5. Next, unless you are planning on using jQueryUI you should remove it via NuGet. It has so many files under the content folder that unless you plan on using it. They are just mental weight. Everything in your project should earn its keep. You can always add jQuery UI back via NuGet if you want it.

6. Web programming is awesome, except when it’s not. That usual happens when you find your page looks different in IE vs Chrome vs Safari. You can avoid some of these issues just by referencing Eric Meyer’s reset.css. Be sure to put reset.css as the *very* first CSS file.

7. In ASP.NET MVC, there are models, then there are models. In MVC, there are domain models that are usually UI independent. Then there are models specifically meant to be tied to views. These view-oriented models are called View Models. I recommend you put view models in their own folder to make this dead-obvious.

Stephen Walther has more on View Models if this is the first you’re hearing of them.

8. You said you like fast pages before right? Well MVC is “doing it wrong” in order to allow you to inline JS which you should not do. Put the JS imports at the bottom of the page.

Be careful though, modernizr.js needs to stay at the top to work.

9. There are times you need to conditionally import JavaScript files from pages. The technique above in #8 makes this adhoc importing difficult. We can easily fix this by adding a layout section called AdditionalJsImports and make it optional (see above). This lets pages add more JS *after* jQuery.js and site.js.

Conclusion

If you do these 9 things at the start of your project, you’ll be on a good path to a well-architected system with some key advantages: It doesn’t have files in the wrong places, it doesn’t have unused or outdated files, and it is built for performance.

Hope you find these tips useful! If you have your own, please add them to the comments below.

Cheers!
@mkennedy

Usually, these view files are organized into sections by controller which keeps this manageable. For example, your solution might look like:

• Controllers
• Models
• Views
  • Home
    • Index.cshtml
    • About.cshtml
  • Products
    • All.cshtml
    • Show.cshtml
    • New.cshtml
  • Shared
    • …
  • etc…

So that any one folder might only have 10 cshtml files. But there is one folder that is disproportionately crowed, that Shared folder where all the common partial views and layouts are kept. A quick look at one of my recent MVC projects shows 113 files in that shared folder!

A 113 files tossed into a single folder is painful to manage and difficult to find what you’re looking for at a glance. If they could be categorized into subfolders, say things like Shared/Navigation, Shared/Accounts, Shared/Users, things would be good again.

Presently MVC doesn’t look into subfolders of the shared views folder. But with a little open-source library I wrote and a few clicks on NuGet, it will!

Introducing Enhanced View Locations for MVC

To address this issue, I’ve created a project over at CodePlex:

Enhanced View Locations for MVC

http://mvcviews.codeplex.com/

With this library added to your project (via NuGet), your massive Shared folder can look like this:

Here’s how you use it (from the codeplex project documentation):

Enhanced View Locations for MVC allows you to further organize your ASP.NET MVC views without your action methods or Html.RenderPartial / Html.RenderAction elements knowing or caring about how they are organized or re-organized.

1. Begin by adding a reference to EnhancedViewLocations.dll to your ASP.NET MVC project via NuGet (http://nuget.org/List/Packages/EnhancedViewLocations) or by directly downloading and referencing it.

2. Next, define and register custom view locations in the form partial Uri’s from within the Global.asax file:

protected void Application_Start()
{
    AreaRegistration.RegisterAllAreas();
    RegisterGlobalFilters( GlobalFilters.Filters );
    RegisterRoutes( RouteTable.Routes );

    // Register the extra locations for views.
    RegisterCustomViewLocations();
}

private static void RegisterCustomViewLocations()
{
   // We can optionally enable the standard Razor view CS
   // (or VB) locations so we don't always search our
   // extra / custom areas first when searching for a view.
   // EnhancedViewLocator.EnableStandardRazorCSLocations();

   // Next, add two extra locations to store / arrange our views.

   // 1. in the templates folder under the standard shared view
   // folder.
   EnhancedViewLocator.AddFolder( "views/shared/templates" );

   // 2. in the navigation folder under the standard
   // shared view folder.
   EnhancedViewLocator.AddFolder( "views/shared/navigation" );

   // Finally, have the locator install a custom view
   // engine to manage the lookups.
   EnhancedViewLocator.Install( ControllerBuilder.Current );
}

I’ve recently signed up as an INETA speaker. If you would like me to speak at your user group or event, check out my INETA Speaker Profile or simply contact me directly.

I typically speak on NoSQL, MongoDB, ASP.NET MVC, Modern Web Applications (whatever that means!) and design patterns but I’m also open for other requests.

Cheers!
@mkennedy 

Enjoy!
@mkennedy

PS – Yeah, it’s from last year. I forgot to publish it on my blog so here it is…

In this second installment, we’ll be covering exactly that. How do we manage having Visual Studio and associated tools and servers universally accessible in the cloud, even on mobile devices such as iPads?

We’ll start with the king of the cloud:

Amazon Elastic Compute Cloud (Amazon EC2)
http://aws.amazon.com/ec2/

At EC2 we can create a variety of Windows instances, get full admin access via remote desktop, and install anything we want (Visual Studio, SQL Server, MongoDB, etc). We can also run these for just 30 minutes here, 2 hours there and we’ll only be charge for the time we use it.

We are going to setup a Windows Server in EC2 which we can access from our Cloud OS, or any other machine or mobile device, and deck it out with all the developer tools we want. You have to choose your server type based on what you’re planning on doing as well as how much you want to pay. Here are the available options and pricing. You can roughly expect to pay $0.50/hr for a good workstation, or $0.12/hr for an acceptable but small one.

Amazon EC2 Instance Types: http://aws.amazon.com/ec2/instance-types/
Amazon EC2 Pricing: http://aws.amazon.com/ec2/pricing/

I’m currently using a Micro Instance for an SVN server which is always running as well as High-Memory Extra Large Instance for my development machine that I start and stop on-demand when I need to get some programming done. Here are the specs for the developer workstation:

High-Memory Extra Large Instance

17.1 GB of memory
6.5 EC2 Compute Units (2 virtual cores with 3.25 EC2 Compute Units each)
420 GB of instance storage
64-bit platform
I/O Performance: Moderate
API name: m2.xlarge

You have to admit, that’s a pretty killer workstation. It’s a overkill on the memory, but has better processors than the cheaper ones which also have decent memory.

The price of the dev machine is $0.69 / hour. I’ve also built some tools which help shut down the machine in case I get distracted. So far I’ve been using it pretty heavily this past few weeks and have spent probably $13 on it. That’s not bad for the possibility of being anywhere in the world (with an Internet connection) and getting my workstation running in an instant. OK, maybe it takes longer than an instant. To be fair, it usually it’s 10-15 seconds :).

Take the Free Lunch

One thing you should do straight away if you’re going to try this is sign up for the EC2 Free Tier:

AWS Free Usage Tier
http://aws.amazon.com/free/

This won’t cover the EC2 CPU time (that’s Linux only), but it will cover storage, bandwidth, S3 snapshots, etc. You also get a free Linux machine to play with if you like.

Setting up Windows in the Cloud

OK, so if you’re chosen an instance type and are ready to start, you should do the EC2 walk-through I put together here to get your machine up and running and login for the first time.

Building Windows Machines in Amazon EC2
http://www.michaelckennedy.net/blog/2010/01/31/BuildingWindowsMachinesInAmazonEC2.aspx

I’d guess that takes about 15 minutes. When you’re done, come back here…

Installing Software in EC2 and Windows

So you’ve logged in and you want to install Visual Studio, SQL Server, and other MSDN goodies. The easiest way to get them is to use the ISO DVD images from the MSDN download site. In order to mount them on your EC2 machine (which has no DVD drive), you should install

Virtual CloneDrive
http://www.slysoft.com/en/virtual-clonedrive.html

which lets you mount ISO images as if they were proper DVD drives. Then you can download and install all the MSDN files you need. A good place to start is with Visual Studio:

Microsoft Visual Studio 2010 Premium Trial – ISO
http://www.microsoft.com/downloads/en/details.aspx?FamilyID=f81412a2-d48e-4040-9b32-27eaf771c5db&displaylang=en

One word of warning here: I’ve noticed that Chrome can freak out and fail to download very large files inside your EC2 instance. Don’t know why, but it does. So be sure to use IE or Firefox to do the downloads for the ISOs.

Syncing your Files Between your Local Machine and Dev EC2 Machine

There are two techniques we can use to sync files, depending on what category of files we’re sharing and how. For the source files, you can always setup an SVN Server (that’s what my micro instance is about). I’m a fan of Visual SVN. It’s free and easy to setup and admin.

VISUALSVN SERVER
http://www.visualsvn.com/server/

Then on your EC2 dev machine (and your others you may have) setup:

TortoiseSVN
http://tortoisesvn.net/

and

AnkhSVN for Visual Studio Integration
http://ankhsvn.open.collab.net/

Then you have super easy, reliable, and secure sharing of your source files.

For everything else, you can just setup a Dropbox share between your Cloud OS and you EC2 Dev Machine:

If you don’t have Dropbox and want to try it, use this link to create an account

http://db.tt/Qo7m9PA

and you’ll get me some extra free space which I always appreciate. :) Then if you have a file on your local computer you want accessible on your cloud dev machine, just drop it in your Dropbox folder on the originating computer and it’ll be there as soon as it uploads.

Waste Not, Want Not

Now here is a problem you will encounter:

You’re working on your dev machine in EC2, something comes up and you get distracted and forget about it for the rest of the day. When you come back the next day you see your EC2 system is still running and you’ve wasted $12 by leaving it running idle overnight. That sucks. If it happens on Friday, it might run the whole weekend which is even worse.

To avoid this, I wrote a little tray utility that watches for extended idle times and will shutdown your EC2 instance if it’s idle for too long.

Below is how you configure it. Simple, right?

Add it to your startup menu to make sure it starts when you log in.

You can download it here. I may blog about this app in greater detail later, for now feel free to use it.

Shutdown on Idle
http://www.michaelckennedy.com/Downloads/Tools/ShutdownAfterIdle.zip

Reliable Access to EC2

One annoyance in EC2 is that every time you turn off your EC2 computer, it will take on a new random public DNS name. If you really want to access to your EC2 machine from anywhere, you probably want a reliable DNS name / IP address. That’s where Elastic IPs come into play in EC2:

Feature Guide: Amazon EC2 Elastic IP Addresses
http://aws.amazon.com/articles/1346

If you create an elastic IP, then you can map it to a sub-domain in your domain and always use that. For example I could register it for cloud-developer.michaelckennedy.net. Then as long as I have a way to start my machine and re-associate the IP, all my config on my various machines (such as remembered RDP settings and passwords and such) will “stick”.

Be aware that while your EC2 machine is off, you’ll be charged a small fee (few dollars / month) for the address. You can decide whether it’s worth the trouble to save the few dollars.

Mobile / iPad Access

I’m sure when you think of accessing your EC2 dev machines, you’re thinking of doing that form Windows or maybe a Mac (using  http://www.microsoft.com/mac/remote-desktop-client). But the iPad (and even the iPhone) has apps to allow you to use Remote Desktop to EC2. For example, here’s editing the code for http://chatpast.com in Visual Studio via my iPad:

(click for full size image)

And you can even bring up the keyboard or attach a Bluetooth keyboard.

(click for full size image)

The app I was using is called “Jump”, and you can find it here:

Jump for iPad
http://jumpdesktop.com/

Summary

I hope that gives you some inspiration to try a new way to work in the cloud. You saw that we can create fairly serious EC2 Windows computers which can serve as developer workstations. We can share files via source control and Dropbox and we can access the computers from Windows, from Macs, and even mobile devices like an iPad.

Good luck!
@mkennedy

I’ve been fascinated with what Google is doing with Chrome OS. I think finding a way to fully “live in the cloud” has a lot of promise. However, in practice Chrome OS is entirely unappealing to me. It’s just a single browser window, maximized. Yuck. I don’t mind doing most things in the browser, but I’d like multiple non-maximized browser windows and a desktop to organize things like shortcuts. That’s OK though because Chromebooks aren’t the only option. We have decent operating systems right now that can function largely in the same way if we set them up with discipline.

What we’re going to do is take a pristine Windows 7 instance and deck it out for the cloud. Even with all the choices these days, Windows 7 is still my favorite OS. I do have a Mac, several iOS devices, and I could always install Linux. Nevertheless, it’s Windows 7 for me so that’s where we’ll start.

Creating a Fresh Windows 7 Instance – Gently

I want to start from the very beginning. I don’t want old apps I’ve already installed encouraging me to “cheat” and work outside of the cloud more than necessary. At the same time I need to be able to fire up Visual Studio and do some work with an unreliable or nonexistent Internet connection So I’m keeping my current “full” Windows system intact. We’ll install a secondary instance of Windows using the awesome Boot to VHD feature in Windows 7 Ultimate. If you haven’t heard of it, I did a video walk-through here:

   Boot to VHD Screencast:
   http://www.michaelckennedy.net/blog/2009/10/20/BootToVHDScreencast.aspx

Scott Hanselman’s write up is very helpful too.

   Less Virtual, More Machine – Windows 7 and the magic of Boot to VHD:
   http://www.hanselman.com/blog/LessVirtualMoreMachineWindows7AndTheMagicOfBootToVHD.aspx

This process takes about 15 minutes. Once you’ve got everything setup, I recommend you activate and then snapshot that VHD file (from your main OS) so you can always get back to “clean”. If you’re really living the cloud lifestyle, than paving your system is much easier than before. I always keep a secondary partition around for data files anyway so that can be shared across OSes.

Now that you’ve got a truly fresh Windows 7 copy, it’s time to install just a few apps needed to set you free (and a few you’d rather not live without).

Installing “The Cloud”

While your fresh copy of Windows 7 does have IE 8 installed, that browser is entirely not up to the task of being where you spend 90% of your time. I strongly encourage you to give the latest Chrome beta a shot as your main browser. The “application shortcuts” feature of Chrome makes it much more immersive than anything IE 9 or FireFox 4 are doing (yes, I know they have pinned sites, that’s not even close).

   Chrome Beta
http://www.google.com/intl/en/landing/chrome/beta/

Got Chrome installed and set as your default browser? Good. Don’t forget to install all your Windows updates and Windows 7 SP1 while you’re at it.

What about Visual Studio?

You may be thinking, “I *NEED* Visual Studio 2010”. Yes, we do need it for sure, but stick with me here. We are NOT installing that beast on our fresh Windows 7 system. Remember, this is your Cloud OS. I even named mine Cloud OS in my boot loader to keep that focused in my mind.

We’ll talk about Visual Studio soon.

Installing Your Web Applications

You may think that you do not need to install your web apps cloud apps. There are a few installers we’ll be running such as DropBox and ChatPast, but even the plain vanilla websites such as GMail are better if you install them. That’s why Chrome is way better than the other browsers.

Let’s suppose you’ll want to use Google Docs to work with documents, presentations, Excel worksheets and so on (you will want this!). Visit https://docs.google.com, then choose “Create application shortcut” in Chrome (see image):

This not only gives you start menu items and desktop shortcuts, but it makes your taskbar truly useful and your web apps behave as regular Windows apps.

In addition, you get the true feel of your websites being applications without all the browser toolbars and other junk around it. For example, here’s how this article (barely written) looks in Google Docs right now. Notice, how it looks like an app rather than a tab buried in a busy browser. It remembers its window size and position. In short, it’s more application-like.

What Cloud Apps Should I Install?

OK, so I hope I convinced you that treating your web apps as true applications is worthwhile. Now which ones do I install? Here are a few I recommend. You may have your own favorite sites. We’ll also need a few apps that do cloudy stuff but run MSI installers on our system.

- GMail: https://mail.google.com/ (obviously :) )
- Google Docs: https://docs.google.com (good Microsoft Office replacement)
- Google Calendar: https://www.google.com/calendar/
- Google Contacts: http://mail.google.com/mail/contacts/u/0/ui/ContactManager
- 37 Signals LaunchPad: https://launchpad.37signals.com (Great web apps for projects)
- Amazon Web Service: https://console.aws.amazon.com/ec2/ (You’ll see why soon)
- Twitter: http://twitter.com/
- Office Online: http://office.live.com (for when Google docs fail you)
- Pandora: http://www.pandora.com/

Here are a few proper apps that are cloud-based in some way or another that require installers.

- Skype (obviously :) http://www.skype.com
- DropBox: https://www.dropbox.com
- ChatPast Sync Client: https://chatpast.com/

By using GMail, Google Contacts, and Google Calendar, you obviously get portability from the web. But if you have a modern phone or tablet, chances are you can keep them 100% in sync using Google’s Exchange support. I do that for both my iPhone and iPad.

There are also a couple of light-weight apps that I just didn’t want to do without and still have a solid use in a Cloud OS. I needed a good image editing app (for writing blog posts like this) and one for screen captures. So we have

- Paint.NET: http://download.cnet.com/Paint-NET/3000-2192_4-10338146.html
- Window Clippings: http://www.windowclippings.com/

Finally, there are a couple that I use to just keep an eye on my system such as

- Process Explorer: http://technet.microsoft.com/en-us/sysinternals/bb896653

Here is the full list of *everything* I have installed on my system. Just 11 applications installed. Note that I’ve hidden some that Windows installs without asking. For example, using my Microsoft Mouse forces an install of Microsoft’s Intellipoint software when I plug it in. Similarly for the touch-pad on my laptop. To me, those don’t count so I edited them out.

Escape from Outlook

You may be thinking that because you still use your company’s email that you’ll need to install Microsoft Office and the 800-lbs gorilla that is Outlook. Chances are you will not need Outlook. I have several “regular” email accounts I have to check that don’t have reasonable web options.

You can setup your GMail account to automatically pull from your other email accounts as if GMail itself was a POP3 client like Outlook. Just go to Gmail > Settings >  Accounts and Import > and configure “Check mail using POP3” as well as “Send mail as”. Here you see my other accounts have recently been checked and received mail.

Sometimes having a “Send and Receive” button for these accounts is handy. Visit the Labs section of GMail and install the “Refresh POP accounts” add-on to make the refresh button propagate a refresh off to your other accounts as well.

While you are in there, you should turn on the keyboard shortcuts and take 5 minutes to learn the important ones. For example, / will take you to search, i to the inbox, e archives, -c composes an email in a separate window, etc.

Where Are the Developer Tools?

You probably didn’t see Visual Studio in that list, because it wasn’t there! In the next blog post, I’ll take you through setting up an Visual Studio 2010 instance in the cloud along with all the other developer tools and servers you might need such as SQL Server, and MongoDB, and LINQPad, and so on. Stay tuned.

When I have that post online, I’ll be sure to add a link here. If you just can’t wait, here’s a hint of where we’re going next.

[Update: Read Part 2 Now]

Good luck!
@mkennedy

Here’s an article about Getting Things Done and how I use Backpack from 37Signals to make it happen.

I’ve recently taken on some roles where I have a lot more loose-ends in my life and adopting Getting Things Done (GTD) has really helped manage everything. I’m also a huge fan of the 37Signals suite of products (Backpack, Basecamp, etc). That should be obvious from what we’re doing over at ChatPast with integrating instant messaging and 37Signals applications.

So using 37Signals to implement Getting Things Done (GTD) was the obvious choice for me. After looking at both Backpack and Basecamp, it seems that Backpack is the clear winner for implementing GTD. You’ll see why shortly.

There have been some articles already written about Backpack + GTD. Brett Kelly wrote a nice one over at Getting Things Done with 37signals’ Backpack – Why I’m Switching Back. However, while this was helpful in showing me that I *could* implement GTD in Backpack, it didn’t show me how to do it.

How should I organize my pages? Do I use reminders, the calendar, both or neither? There will be TODO lists, but how do I correlate them to my actual work? What about check lists? Can I have templates for repeated ones? Answering these questions is the purpose of this article.

A Step-by-step guide to implementing GTD in Backpack

In this article we’ll look at the major pieces of GTD and how to fit them into Backpack.

First, A Quick Review on GTD

I’m not going to give you full summary of GTD. If you haven’t started using GTD yet, I recommend that you read the book. Don’t like reading? Listen to Scott Hanselman interview Lane Newsom about it or watch David Allen speak about it at Google.

Here’s enough to start seeing GTD manifest itself in Backpack. First a definition, what is
Getting Things Done:

GTD is a work / life management technique which encourages you to make sure you have absolutely zero open items and actions that you are tracking in your head. You get everything that you are working on or waiting for written down. This frees your mind to be fully “in the moment” and focused on what you chose to do now as well as keeps you from forgetting anything you committed to doing.

At the heart of GTD is this decision-tree model:

[image credit Graham King]

In our GTD in Backpack world, the 8 items ringing the workflow will mostly land in Backpack. The “Do It” one just gets done and saved nowhere – although I sometimes track these just for my personal record.

GTD in Backpack – The Basic Layout

In Backpack, I have 5 pages dedicated to GTD, which is convenient because as you see, you get 5 for free. (note: if you aren’t familiar with Backpack yet, watch these
short videos before going on.)

You can see that each page corresponded to a major component of GTD. They are further partitioned inside each page – more on that below.

1. Inboxes

With inboxes, I’m not talking about just your email inbox – although that’s probably the biggest one for most people. GTD inboxes represent places that stuff that is new shows up and is waiting to be processed through the decision-tree model above. I think you’d be surprised to see how many inboxes you truly have if you took a full

account of them. GTD encourages you to do this for all sorts of things – take a full account and get them out of your mind.

That’s one of the great uses of check lists in GTD + Backpack.

2. Check Lists

A check list is any set of steps you need to remember. Sometimes it’s for one-off situations, others it’s repeating. Processing all the new stuff in your varied inboxes is a repetitive action. So I made a check list for that. Check lists, as you can see below, are TODO lists in backpack. When they are repeated, I make a template like the actual list but with the title prefix [template]. Then I make a copy to “do” the check list each time.

Here is the check list I use several times a week to make sure that I don’t forget to “process” one of my inboxes, which then feeds the other 8 types of containers ringing the workflow diagram.

You would see a very similar looking TODO list at the bottom of the [GTD] Check Lists page with the title ‘[template] Processing “in” Checklist’.

3. Next Action Lists

The Next Action Lists are pretty straight forward. As you saw above, there is a page entitled “[GTD] Next Actions”. Here I track my next action for each item or project I have open. Again the page is partition internally:

Notice that I have a personal and business one (actually several). One rule of GTD is that if your home life is a mess, it’ll affect your business life and visa versa. So manage it all here. Note also that you can add comments and attach files to the items to track additional info you might need.

If the next action came from an ongoing project (see below), then I’ve tried to put the name of the project as a prefix, for example House: in my personal items.

Finally, you’ll see that I don’t use the GTD contexts as most people might. In my world there is so much overlap for the contexts that they become meaningless. Traditional contexts might include calls, at computer, errands, at office, at home, agendas, read / review. However, I work at home with internet always on and a computer at my desk. I also do reading here. So those contexts basically all mean the same thing and thus I don’t use them.

4. Projects

As you saw in the basic structure, projects get their own page (internally partitioned). Thus I have a page entitled ‘[GTD] Projects’. This one is pretty simple. I keep track of all the ‘open-loops’ that require 2 or more actions to complete. Each one gets its own TODO list within Backpack and those lists are partitioned by work and personal.

5. Reminders

By far, the biggest GTD “bang for the buck” that you get from Backpack come in the form of reminders. However, their effect takes some exploring to see their full potential. First, let’s look at the reminders I have upcoming. Usually I have more than this, but they seem to have thinned out for the weekend.

In my reminders, you’ll see I need to finalize the home inspection details for a house I’m buying on Feb 4th. By putting it into my reminders, I can rest assured that I’ll remember it on the day that I can do something about it.

What about calendars? I make extremely heavy use of calendars for GTD. But not within Backpack. I use Google calendar, which then I sync to Outlook, my iPhone, my iPad, and I can also access via the web. If this had been an appointment, I would have skipped the reminders and just put it on my calendar. But it’s an action with a date, so it goes in the reminders.

Getting Notified of Reminders

The first place to leverage reminders is to have them show up as text messages on your phone. To do this, go to “My Info” in backpack, in the section “Mobile phone reminders”, check the checkbox for “Send text message reminders to my mobile phone”.

Next, you’ll want to see these reminders in your calendar (but not as appointments!).
That’s where the crazy URL starting with iCalendar:     webcal://domain.backpackit.com/ical/…
comes in. You can subscribe to this in Outlook or, as in my case, in Google calendar.

In my calendar, then have all these actions + dates show up alongside my day.

I think I had to replace ‘webcal:’ with ‘http:’ in order to add this to Google Calendar though.

6. Waiting-For Lists

Waiting lists are for situations where I know I’ll need to follow up on something but no necessarily by any particular date – in that case a reminder doesn’t make sense for me. But several times a week, I’ll scan the list and close those loops if they other person hasn’t responded by then. Here’s how that looks in Backpack:

Note that the dates I manually typed in are not the due dates. They are the creation dates (Backpack doesn’t track this). So I know how long I’ve been waiting.

7. Reference Material

One of the huge advantages that Basecamp has over other systems that are just simple TODO lists is the ability to attach rich reference material and additional information to the TODO item that represents a next action, or waiting item, and so on.

You can add comments to any TODO item. For basic information, this can be simple text. For example, if you needed to renew your insurance, you could attach the phone number and policy number to the TODO item so you don’t have to look it up.

For non-textual information, you can also attach files (pictures, word docs, whatever) to the TODO item. Note that file attachments are a paid feature, so you can’t use this option
if you’re on the free version of Backpack.

8. Taking it with you

One of the key tenants of GTD is that you should have your info with you nearly all the time. You might be thinking that using Backpack means you will only be able to get to it when you’re on the web.

If you have an iPhone, iPad (or even iPod touch), you can always have an offline copy available using an app called Satchel found in the Extras section.

Here’s a few screenshots from the iPhone:

Here’s a few screenshots from the iPad (click to enlarge):

9. What about Basecamp?

Some projects are either shared by a team of people or are truly massive with many steps, artifacts, milestones, and files. These projects are better managed outside of Backpack. In that case I use the paid version of Basecamp and simply add a note to the project entry page as you can see here.

Conclusion

If you’ve been thinking of using Backpack for GTD, I hope this has given you something to work with. I certainly don’t promise to be a GTD expert. But this setup works well for me and I think it will for you too.

Thanks!
@mkennedy

What I want to talk about is all the cool open source projects I found just by flipping through the pages of the NuGet directory in the Visual Studio “Add Library Package Reference” dialog.

1. RazorEngine at  http://razorengine.codeplex.com/

RazorEngine is templating engine built upon Microsoft’s Razor parsing technology. The Razor Templating Engine allows you to use Razor syntax to build robust templates No need to learn a custom clunky API for generating things like HTML and emails and so on. Just use the hot new @Razor syntax from ASP.NET MVC 3.

2. YUI Compressor for .Net at http://yuicompressor.codeplex.com/

YUI Compressor for .Net is is a .NET port of the Yahoo! UI Library’s YUI Compressor Java project. Do you have a bunch of CSS and JavaScript files and you want your page to load faster. This is a great way to do it from ASP.NET.

3. 51degrees.mobi at http://51degrees.codeplex.com/

Want to build an ASP.NET MVC website that has both a desktop and mobile version from the same project? 51degrees.mobi Foundation is an ASP.NET open source module which detects mobile devices and browsers, enhancing the information available to ASP.NET. Mobile handsets can optionally be redirected to a home page designed for mobile phones. Smart phone and feature phones are all supported.

4. Lucene.Net at  http://lucene.apache.org/lucene.net/

Lucene.Net is a source code, class-per-class, API-per-API and algorithmatic port of the Java Lucene search engine to the C# and .NET platform utilizing Microsoft .NET Framework. Want indexed full-text search from .NET? Here you go.

5. MvcMailer at  http://www.codeproject.com/KB/aspnet/MvcMailerNuGet.aspx

Send a professional looking HTML email from your ASP.NET MVC simply by pointing at a particular view.

6. DotNetZip at http://dotnetzip.codeplex.com/

DotNetZip is an easy-to-use, FAST, FREE class library and toolset for manipulating zip files or folders. Zip and Unzip is easy: with DotNetZip, .NET applications written in VB, C# – any .NET language – can easily create, read, extract, or update zip files. For Mono or MS .NET.

7. FileDB at http://filedb.codeplex.com/

Ever wanted to have a single, simple file that you can access as a basic database without the fuss? FileDB is a free, fast, lightweight C# (v3.5) DLL project to store, retrieve and delete files using a single archive file as a container on disk. It’s ideal for storing files (all kind, all sizes) without databases and keeping them organized on a single disk file.

8. Chargify.NET at http://chargify.codeplex.com/

If you need to do recurring billing, like I need to over at  http://chatpast.com, then  Chargify.NET is super handy. It’s comprehensive C# API wrapper library for accessing http://chargify.com, using XML or JSON to read/write.

9. Facebook C# SDK at  http://facebooksdk.codeplex.com/

Facebook is all the rage these days, and python, well… Here’s a .NET SDK for Facebook. The Facebook C# SDK helps .Net developers build web, desktop, Silverlight, and  Windows Phone 7 applications that integrate with Facebook.

10. OpenSearch Toolkit at  http://opensearchtoolkit.codeplex.com/

OpenSearch is a great way to “light-up” the search features of your site. For example, if you visit http://chatpast.com with Firefox and pull down the search engine selector, you’ll see “Add ChatPast Search”. Do the same in Chrome and then type chatpast.com in the omnibox and hit tab then you’re searching directly into your chat history (even when you’re not on chatpast.com). So obviously OpenSearch is awesome. This toolkit makes that easier. The OpenSearch Toolkit provides ASP.NET developers with drop-in support for OpenSearch. This lets you quickly and easily publish valid search suggestions to all the major browsers.

11. NoRM at http://normproject.org/

LINQ, NoSQL and MongoDB, what more could you want? NoRM is how you make it happen. NoRM is a .Net library for connecting to the document-oriented database, MongoDB.

11.5. Simple MVVM for WPF, SL, and WP7 at http://simplemvvmtoolkit.codeplex.com/ (added after original post, hence the .5)

Simple MVVM Toolkit makes it easier to develop Silverlight, WPF and WP7 applications using the Model-View-ViewModel design pattern. The purpose of the toolkit is to provide a simple framework and set of tools for getting up to speed quickly with Silverlight applications based on the MVVM design pattern. The emphasis is on simplicity, but it should contain everything you need to implement MVVM for real-world line of business applications.

Keep in mind, that to get the latest version of any of these projects, you can just use the Visual Studio ”Add Library Package Reference” dialog because of all the NuGet goodness. No need to download and manage these project references at a low level.

Enjoy!
@mkennedy

Thanks to everyone who came to my two sessions at the Portland CodeCamp this weekend.

The NoSQL Movement, LINQ, and MongoDB – Oh My!

Panel Discussion: NoSQL vs. RDBMS

You can download the slides, demo code, and the mongoctx code snippet for Visual Studio here:

NoSQL + MongoDB + LINQ:
http://www.michaelckennedy.com/Talks/Downloads/PortlandCodeCamp/Kennedy-PdxCodeCamp-2010-MongoDB-NoRM-LINQ.zip

NoSQL vs. RDBMS Panel:
http://www.michaelckennedy.com/Talks/Downloads/PortlandCodeCamp/Kennedy-PdxCodeCamp-2010-NoSQL-vs-RDBMS-Panel.zip

If you missed the sessions and want to see some MongoDB + LINQ or if you would like to recommend this session to a friend, I’ll be doing a webcast on a very similar talk tomorrow:

NoSQL + MongoDB + LINQ Webcast

Cheers!
@mkennedy

[Update: This webcast is in the past, but you can download the video and audio recordings.]

Download Video (WMV)
Download Audio (MP3)

I’m happy to announce I’ll be doing a free webcast in the DevelopMentor webcast series on MongoDB, .NET, LINQ, and NoRM.

NoSQL Movement, LINQ, and MongoDB 
Tuesday May 25th – 11AM PST
Register here

I hope to see you there. We’ll be building out a website in ASP.NET MVC with MongoDB as the back-end using LINQ. There will be plenty of code so it should be fun and educational.

Cheers!
@mkennedy

This article is a follow up one I wrote last week entitled “The NoSQL Movement, LINQ, and MongoDB – Oh My!”. In that article I introduced the NoSQL movement, MongoDB, and showed you how to program against it in .NET using LINQ and NoRM. You can also watch my conference presentation at MongoDB Seattle 2011 or this DevelopMentor webcast.

I highlighted two cornerstone reasons why you might ditch your SQL Server for the NoSQL world of MongoDB. Those were

1. Ease-of-use and deployment
2. Performance

For ease-of-use, you’ll want to read the original article.

This article is about the performance argument for MongoDB over SQL Server (or MySql or Oracle). In the first article, I threw out a potentially controversial graph showing MongoDB performing 100 *times* better than SQL Server for inserts.

“A potentially controversial graph showing MongoDB performing 100 times better than SQL Server”

We’ll see source code, downloadable and executable examples and you can verify all of this for yourselves. But first, here’s a new twist on an old proverb:

“Data is money”

If your application is data intensive and stores lots of data, queries lots of data, and generally lives and breathes by its data, then you’d better do that efficiently or have resources (i.e. money) to burn.

Let’s imagine you’re creating a website that is for-pay and data intensive. If you were to attempt to plan out your operating costs per user to help guide the pricing of your product then the cost of storing, querying, and managing your data will likely be a significant part of that calculation.

If there is a database that is 100 times faster than SQL Server, free, easy to administer and you program it with LINQ just as you would with SQL Server then that is a very compelling choice.

When you have such a database, it means you can run your system on commodity hardware rather than high-end servers. It means you can have fewer servers to maintain and purchase or lease. It means you can charge a lot less per user of your application and get the same revenue. Think about it.

“It means you can charge a lot less per user of your application and get the same revenue. Think about it.”

One more story before we see the statistics. Kristina Chodorow from 10Gen gave a talk a few weeks ago at San Francisco’s MySQL Meetup entitled “Dropping ACID with MongoDB”. You can watch the recording here:

http://www.ustream.tv/recorded/6146875

[The audio and video isn’t too hot, but the content is. Skip the first minute without
audio.]

During this talk, Kristina describes SourceForge’s experience moving from MySql to MongoDB. On MySql, SourceForge was reaching its limits of performance at its current user load. Using some of the easy scale-out options in MongoDB, they fully replaced MySQL and found MongoDB could handle the current user load easily. In fact, after some testing, they found their site can now handle 100 times the number of users it currently supports.

Not convinced of this NoSQL thing yet? Fair enough. Here are some graphs, some stats, and some code.

The scenario:

Model a data intensive web application aiming to support as many concurrent users
as possible. There will be users from the web application itself. But there will also be users from an API and external applications. Users will interact with the data by having nearly as many inserts as they do queries. Their inserts are all small pieces of data and are all independent of each other.

Let me just get this out of the way and I mean the following in the nicest of ways: I don’t care about your scenario or use-case. The scenario above is what I’m trying to model. I’m not trying to do bulk-inserts or loading large files into databases or anything like that. MongoDB may be great for these. SQL Server may have specialized features around your use-case, etc. They don’t apply in my scenario. So please don’t wonder why I’m not using bulk inserts or anything like that in the examples below.

Insert Speed Comparison

It’s the inserts where the differences are most obvious between MongoDB and SQL Server.

These inserts were performed by inserting 50,000 independent objects using NoRM for MongoDB and LINQ to SQL for SQL Server 2008. Here are the data models:

MongoDB basic class

SQL Server basic class

I ran five concurrent clients hammering the databases with inserts. Here’s the  screenshots for  running against MongoDB and  against SQL Server. Let’s zoom into the most important result with the output from one of five concurrent clients:

MongoDB:

SQL Server:

That’s right. It’s 2 seconds verses 3 1/2 minutes!

Now to be fair, this was using LINQ to SQL on the SQL side which is slow on the inserts. After discussing these results with some friends, I re-ran the tests using raw ADO.NET style programming and saw a 1.5x-3x performance improvement for SQL. That still leaves MongoDB 30x-50x faster than SQL.

Query Speed Comparison

Now let’s see about getting the data out using the same objects above on the indexed Id field for each database.

Here MongoDB still kicks some SQL butt with almost 3x performance. If we were to leverage the mad scale-out options that MongoDB affords then we could kick that up to many times more.

“If we were to leverage the mad scale-out options that MongoDB affords then we could kick that up to many times more.”

Complex Data and the Real World

Feel like that was an overly simplified example? Here’s some real world data with foreign keys and joins. Below is the complex data model.

MongoDB:

SQL Server:

It shouldn’t surprise you that MongoDB does even better here without its joins.

The Hardware

All of these tests were run on a Lenovo T61 on Windows 7 64-bit with a dual-core 2.8 GHz processor using the 64-bit versions of both SQL Server 2008 Standard and MongoDB 1.4.1. You can even see a picture of the computer here: http://twitpic.com/hywa8

Your Turn

If you want to see the entire set of data above as an Excel spreadsheet, you can download that here:

http://www.michaelckennedy.com/Downloads/sql-vs-mongo.xlsx

You can also download the sample code. Before you do, realize I haven’t done a bunch of work to make it super easy to run. But you should be able to figure it out. Just turn the knobs on the PerfConstants class for the number of inserts and queries. Then comment or uncomment sections of the code in the clients for your scenarios.

The expected use is that you’ll start the launcher application then use it to launch five concurrent clients at exactly the same time.

Download Sample:

http://www.michaelckennedy.com/Samples/SpeedOfSqlVsMongoDBAnddotNetSample.zip

Got feedback? Write a comment or contact me on Twitter:  @mkennedy or find me in
any of these other ways.

Thanks!

Some thanks are in order for all the help I got bouncing around ideas as well as trying different scenarios. Thanks to

Eric Cain @arcain
Jim Lehmer@dullroar
Karl Seguin @karlseguin

Cheers!
@mkennedy 

Maybe you’ve heard people talking about ditching their SQL Servers and other RDBMS entirely. There is a movement out in the software development world called the “NoSQL” movement and it’s taking the web application world by storm.

“Insanity!” you may cry, “for where will people put their data if not in a database? Flat files? Tell me we aren’t going back to flat files.”

No, but in the relational model, something does has to give. The NoSQL movement is about re-evaluating the constraints and scalability of data storage systems in the light of the way modern web applications generate and consume data.

The outcry about flat files above is meant to highlight an assumption developers often have about building data-driven applications: Data goes in the database (SQL Server, Oracle, or MySql). Just maybe, if we are really cutting-edge, we might consider storing our data in the cloud, but the choices generally stop there.

The NoSQL movement asks the question:

“Is the relational database (RDBMS) always the right tool for data storage and data access?”

Starting from an RDBMS is virtually an axiom of software development. However, those of us who are excited about NoSQL believe that relational databases are not always the answer. I think this highlights one of the reasons this NoSQL thing is called a movement. People are realizing they have a choice where they thought they had none.

The converse is, of course, also true. The NoSQL databases are also not always the right choice either. If you look carefully however, you will find that they are a good choice much of the time. Don’t take my word on it. Ask Facebook, Twitter, Digg, SourceForge, WebEx, Reddit and a bunch of other companies here and here that are using NoSQL databases.

This move towards NoSQL is driven by pressure from two angles in the web application
world:

• Ease-of-use and deployment
• Performance - especially when there are many writers as compared to the number of readers (think Twitter or Facebook).

Choosing NoSQL for Ease-of-Use and Deployment

I cover the programming model in detail as well as introduce the actual database
server below. For some vague motivation, let me just give you a quick look at how
you define the data model and maintain it.

Why, in the name of all that is right, do we have to model our system twice? Once in the database and once, in parallel, in code? With NoSQL, you have one place to do that – in your C# classes.

* You may have to run a transformation tool if you’re making radical data changes, but that’s true in SQL systems as well.

Choosing NoSQL for Performance

When the number of concurrent clients using your application – and thus your database - is reasonably small (let’s say 500 users as a baseline) RDBMS can work great. But what if that number grows? And if you are writing a web app, you definitely want that number to grow. At 50,000 users, can you still run on a single instance of SQL Server or MySql? How powerful does your hardware have to be to handle that? What about at 500,000 or 5,000,000 users, still good?

I’m sure there are some of you out there thinking, “What a minute now! There are plenty of systems with tons of users built upon relational databases.”

It’s true, there are. But how much expensive hardware and software do these require? How easy is it to leverage *commodity* hardware and free software? A basic SQL Server  cluster might run you $100,000 just to get it up and running on decent hardware. Rather than leveraging crazy scaling-up options, the NoSQL databases let you scale-out. They make this possible (dare I say easy?) by dropping the relational aspects of a database. Some NoSQL systems such as MongoDB get even better scalability by loosening some of the durability guarantees – which they backfill somewhat with redundancy (more on MongoDB shortly).

“Ok, ok. So it’s cheaper and simpler,” you say. “How much faster than the finely tune system that is SQL Server 2008 can these open source NoSQL systems be?”

The answer is: MUCH MUCH FASTER. Here’s a simple comparison of running a bunch of concurrent inserts into SQL Server 2008 and MongoDB on the same computer.

Looks like under heavy load, I’d say it’s about 100 times faster. I’m sure there going to be tons of second guessing this graph and so on. Hold your comments please! I’ll be posting a full performance comparison with source code soon. Let me just say that I think the comparison was fair – I’ll back that up in a later post.

NoSQL and a New Programming Model

If we do not have joins and primary / foreign key relationships, how do we associate related data? In NoSQL, there is a way to mimic foreign keys for certain relationships. However the main answer is that you do not disassociate your data in the first place.

I’m sure that you’ve all heard of the object-relational impedance mismatch. A large part
of that mismatch comes from the fact that we normalize the data in our database to the extreme and then use joins to reassemble that data. Not only does that cause this so-called impedance mismatch, but those joins can be really slow and they can be the death of any scale-out solution. The key to many of the NoSQL databases’ scalability is that they do not use joins. You simply save large swaths of your data as a single blob (which in MongoDB’s case, is still deeply queriable).

Shortly we’ll look at an example where we build out a disconnected, offline RSS reader that uses MongoDB and LINQ to store its data. But just think about how you might structure your data storage if you could save entire object graphs and still query them? Your “row” might be a Blog object which has an array of BlogEntries which contain the entry text, link, date, etc. Then your *entire* query to pull all the details of a single blog would hit a single “table” in the database. That might look like this query which has one result:

var blog =
       (from b in ctx.Blogs
       where b.Id == requestedBlogId
       select b).FirstOrDefault();

There are no joins or anything like that because you’re saving objects not columns and those objects contain their collections already (e.g. RssEntries). There is an important distinction to make here. These NoSQL databases generally are *not* the same as object databases. They are what are known as document databases. There’s actually a
big difference between the two.

Introducing MongoDB

The NoSQL database we are using in this example is MongoDB. This is free, open-source database which runs on Windows, Linux, and Mac OS X systems. You can access it from many platforms including .NET, Ruby, Java, PHP, and so on.

We’ll be using .NET and C# of course. You have several options when choosing how to access MongoDB from .NET but generally that means using LINQ and a light-weight object-mapper on top of MongoDB itself. Note that common terminology might categorize the object mapper that moves objects into and out of the database as an ORM. While that’s OK, there is technically no “R” in this ORM because MongoDB is not relational. Hence I’m calling simply an Object-Mapper (OM).

In MongoDB nomenclature, theses libraries are called drivers. My favorite .NET driver
is called NoRM. It’s being actively developed and was created by Karl Seguin, Andrew Theken, Rob Conery, James Avery, and Jason Alexander. You can find NoRM on GitHub and discuss it in its related Google Group.

If you want to learn more about MongoDB you should listen to these Podcast interviews:

Michael Dirolf also has a great book in the works. You can catch a preview of it on
Safari Books Online. Here’s the amazon page:

MongoDB: The Definitive Guide.

NoSQL in Action

Let’s write some code. The first step typically in a data-driven application is to spec out the database. Then we’d use LINQ to SQL or Entity Framework to generate the ORM classes. MongoDB is different. MongoDB has no schema or rather its schema is flexible and defined via usage rather than being predefined in the database. So our first step is to define the classes we’d be storing in the DB via NoRM.

We’re going to define 3 classes: Blog, RssEntry, and RssDetail. The Blog object will contain a collection of RssEntry objects. In practice you might just go with the Blog and RssEntry classes. But I wanted to model both the embedded case (Blog + RssEntry) and the loosely defined foreign key style relationship that mimic joins (RssEntry + RssDetail). That way we can demonstrate both use-cases.

Here’s a taste of the Blog class:

public class Blog
{
	public ObjectId _id { get; set; }
	public string Name { get; set; }
	public string Url { get; set; }
	public string RssUrl { get; set; }
	public List Entries { get; set; }
      // ...
}

Notice that it contains a collection (Listreally) of RssEntry objects. That’s the relationship supported by nesting. The Blog class just has this collection as part of its data model.

The RssEntry class has the summary info for a blog entry:

public class RssEntry
{
	public ObjectId _id { get; set; }

	public Guid UniqueId { get; set; }
	public DateTime PostedDate { get; set; }
	public string Title { get; set; }
	public string RssGuid { get; set; }
}

And the larger data is stored in the RssDetails class (for example the text of the post):

public class RssDetails
{
	public ObjectId _id { get; set; }

	// this is kinda like the foreign key.
	public Guid RssEntryId { get; set; }

	public List Categories { get; set; }
	public string Link { get; set; }
	public string Text { get; set; }
	// ...
}

Let’s see how we insert an entire set of Blog data into the database. We begin by generating the objects (Blog, RssEntry, etc) in memory and then serializing them via NoRM to MongoDB much as you would in LINQ to SQL. The difference is this will actually generate the collections (analogous to tables) if they don’t already exist and it will define the implicit schema to match our objects:

void SaveBlogToMongoDb(
	string rssUrl, XElement root, RssDataContext ctx)
{
	Blog blog = new Blog();
	blog.RssUrl = rssUrl;
	blog.Name = GetBlogName(root);
	blog.Url = GetBlogUrl(root);

	blog.Entries = ParseEntries(root);
	IEnumerable details
		= GetDetails(blog.Entries, root);

	foreach (RssDetails detail in details)
	{
		ctx.Add(detail);
	}

	ctx.Add(blog);
}

Here we are using a class called RssDataContext which we wrote manually. It is very similar to what LINQ to SQL and Entity Framework use to do the object-relational mapping. Want to do a query? Do you know LINQ? Well then you’re all set:

var results =
    from b in ctx.Blog
    where b.Name.Contains( "MongoDB" )
    select b;

How do you add a new entry to an existing blog and update it in the database?

void AddEntry(Blog blog, RssEntry entry)
{
	blog.Entries.Add(entry);
	ctx.Save(blog);
}

We leverage the fact that the blog.Entries collection is a List and just add to it. Then save will update the record in the DB.

All this works great and is highly performant. But do be careful as not all the LINQ operations are fully implemented yet in NoRM and some (like join) may never be added because MongoDB doesn’t support it.

To get started, download MongoDB the tools and server here:

http://www.mongodb.org

You unzip the zip file and run the mongod.exe program. Be sure that you have created the C:\data\db folder. It appears at first that you have to run MongoDB in a console window. But you can register it as a Windows Service:

Here’s some helpful advice on installing MongoDB as a Windows Service (there is
a small bug you have to work around):

http://www.deltasdevelopers.com/post/Running-MongoDB-as-a-Windows-Service.aspx

There’s also a management console (and I mean “console”):

It’s a little different. You’ll get used to it. The means of interaction with the server is through JavaScript rather than T-SQL and the storage format is a binary form of JSON as you can see.

For a project I’m working on I’ve built a Windows Forms UI that lets me manage the database easily by just adding an object data source and doing some drag-drop magic in Visual Studio. Generally I look down upon that sort of development, but for an admin tool it’s just fine.

Now It’s Your Turn!

Try it out for yourself. Download MongoDB and the NoRM driver and build some apps. You may also want to check out the source code for my demo app:

Download Sample: RssMongoSample-Kennedy.zip

Got feedback? Write a comment or contact me on Twitter where I’m @mkennedy or find me in any of these other ways.

Recommended Reading:

Here are some other blogs on this subject.

I came across what I think is an awesome technique for seeing how your web page will look as you edit it. This is WAY beyond WYSIWIG:

1. Load the page you’re working on in ALL the browser you care about. I’m using Chrome 4, FireFox 3.6, and IE 8.
2. If you have the monitor space, cascade these browsers side-by-side.
3. Add a meta-refresh tag to the header of that HTML file you’re working on (or which consumes the CSS you’re building)
4. Now here’s the sweet part:Edit the page in Visual Studio, notepad, whatever. When you press save all  Browsers reload their view in a few seconds!
5. Now you get real WYSIWIG on real browsers.

That’s it. The technique is totally low tech and would have worked for years. But I found it really helpful. Hope you do too.

Be sure to keep watching here. I promise a cool site will be announced soon!

Cheers!
Michael
@mkennedy