Given the domain we’ve created in the last post, I’ve got to wrap the base amount of information I want stored in the database we’re using that will be familiar across all objects.  The base “Entity” object will contain Id, Version, CreateDate and LastModified properties in order to place nice with our ORM. The Id, CreateDate and LastModified should be obvious, the Version is a field we will use to manage concurrency issues. My next move is to define how NHibernate maps our domain to the database.  As I briefly mentioned above, the newest version of NHibernate (3.2) integrated convention and configuration based mappings that rely on strongly-typed code instead of xml for transforms.  Unfortunately this is a relatively new feature and finding documentation on best practices can be difficult.  Most of what I’ve done can be referenced through Fabio Maulo’s 3.2 series of articles. To leverage this convention based power, I can define a class for our default mapping configurations.

Pretty simple eh?  This configuration should take care of 80% of what we need out of our ORM. You’ll notice there is one reference to an explicit map around line 39, that’s because we’re defining a ManyToMany for Restaurants to Tags but don’t really care or have the domain Tag class knowing about our restaurants.  Otherwise, we could probably map a convention for ManyToMany and be done with the whole process.

Once configuration is done, I write a test to create and export the schema which should verify that our domain matches the database and will detect whenever we’ve mapped something improperly.

Before this test can run, I have to define the configuration for NHibernate and this is vastly different (re: way simpler) to do than previous incarnations.  Again, though, there isn’t a ton of documentation at this time on getting configuration up and running.  Instead of configuration individual variables on the configuration object, we interact we an object called DatabaseIntegration on the Configuration to specify the db dialect and connection string.  The final step is to add the mapping files to the configuration and, BOOM, we’re ready to go.  You can still specify configuration parameters via Configuration.SetProperty(Key,Value) by why would you when half of the work is already done?  (Note though, we’ll likely need to make some changes once we get into a web environment).

That’s that.  We have enough to generate our database and have our system not die. Also at the bottom notice I’ve created a function to export our xml mapping files should we feel the need to confirm any mapping issues. If anyone out there knows a native way of doing this in NHibernate 3.2 please do tell.  We’ve made our UI decisions so we’ll now start scaffolding up the site’s layout and UI interaction in order to get some of the back-end work come together.

There are two main points that need to be addressed. One is the number of assemblies should be kept to an minimum. Two is proper naming of namespaces and classes.
In my experience improper seperation of projects and namespaces is one of the biggest downfalls of any project. As the number of projects grows, two negative consequences inexplicably happen. One, compilation times shoot up to 2 to 5 minutes per build. Plus the just in time compilation of ASP.NET adds another 2 – 5 minutes. Thus if a developer compiles code 50 times in a day, then you are looking at a 100 to 250 minute time waste. Two, traversal and searching for classes becomes a burden. Sure with the lovely “Ctrl-T” in ReSharper I can quickly go to the class, but find usages becomes a 2 minute wait of checking every project. And if you are just browsing the code to get familiar with the application, well good luck and bring a lot of patience.

Minimize the number of assemblies!
Shrinking the number of assemblies down to one or two is the best thing you can do! There a few WEAK arguments for multiple assemblies, but they all fall short when inquiring more deeply about application of such methods. Don’t tell me about your hypothetical situation where monkeys rule the world.

Don’t use IRepository!
Raise your hand if you understand what Repository really means. Now put them down if you ever have a Repository with any kind of load planning. Repositories do not have load planning! Repository from P of EAA and Repository from DDD have nothing in them about load plans and the depth of objects loaded. By my interpretation the object returned is a fully hydrated object plan that does not need further database query. Using ORM tools such as NHibernate we can remove the full hydration by having lazy loading. But when you start going down that path, remember that it leads to hundreds of database queries just for a single action. I bring up the Repository naming because of its misuse, and:

You must have a Common Language!
Just like we agree on the meaning of English words, we must also agree on the meanings of what we name classes and namespaces. Also if you do have a Repository feel free to use the name, and be ready to accept the consequences of following the pattern whatever it entails. Design patterns are one part of the whole of common language for programming. This common language is programming language agnostic and spans operating systems and ignores syntax. This language is also rooted in good programming practices, SOLID principles, and design patterns.

Starting an application with a proper naming structure and organization will save you time and sanity in the long run. If you don’t have the luxury of starting from scratch, then bring your solution up to date, spend some time organizing and cleaning up, you will not regret it!

Lunchage is a small application to showcase latest development practices in .NET in a real world application. Lunchage will use a variety of technologies for its front end and back end processing.

The Tech

NHibernate 3.2

Backbone.js

Handlebars

ASP.NET MVC 3.0

Facebook Authentication

Balsamiq

Progress can be found on our blog series about Lunchage.

Code can be found on Git Hub.

Following and caring about standards is a trait of a mature and detail oriented developer. When thousands and hundreds of thousands of lines of code follow the same standard, it is easier to read through the code and easier to find bugs and inconsistencies. Combine that with architectural patterns, name conventions and proper namespace separation, the code becomes a joy to work with and the job becomes much more interesting and exciting.

That was my rant, here is the how. Get ReSharper (need help selling, check the benefits out). I and everyone I know, LOVES ReSharper. No, we are not sponsored by ReSharper. My instructions are for ReSharper. I’m sure there are open source, read free, alternatives that do the code formatting, and if anyone would like to do a post on that please let me know.

The shortcut for ReSharper clean up is “Ctrl – E – C” for Visual Studio scheme and “Ctrl – Alt – F” for IDEA scheme. For silent clean up, “Ctrl – E – F”.

Starting with Code Style Sharing, ReSharper allows for code sharing per solution or not sharing, under “ReSharper -> Options -> Languages -> Common -> Code Style Sharing”. You can also export and import settings to share with your friends.

One of the overlooked features is the “Type Member Layout”, it is also one of the most useful. A consistent member placement makes code easier to navigate to and browse. At the time of this writing, ReSharper does not support “Type Member Layout” import from the settings file, but here is our type member layout. The xml file is pretty straightforward, so by reading it you will get some idea what each node is responsible for.

Another invaluable tool is StyleCop. The documentation is full and rich, so I won’t waste time explaining how it works. What makes StyleCop better is the ReSharper integration. Since the feedback is instant it is easy to follow the standards and quick to notice inconsistencies. StyleCop/ReSharper integration will also run during code clean up fixing most issues. Note when installing StyleCop, make sure you WANT the “Visual Studio Templates” replacement option. While it is possible to revert, it is a pain to do so.

You can either use the default code cleanup profiles or set up your own. To set one up go to “ReSharper -> Options -> Code Cleanup”.  It is a must with the StyleCop ReSharper extension, since most likely you are not following all the default StyleCop rules. Unfortunately the Code Cleanup options cannot be exported.

Grab the standards for Lunchage, use “Import…” under code style sharing to implement our standards.

There are also formatting options part of Visual Studio “Tools -> Options -> Text Editor -> YOUR LANGUAGE -> Formatting”, that has the basic formatting options. You can run default formatting with “Ctrl – K – D” to clean up the current file. It’s a simple and built in formatter, that can do the job for a more disciplined team.

One last pet peeve of mine is Tabs! Use Tabs. Tab is a standard character with a standard width of 4 spaces, but the excellent people behind Visual Studio actually allow you to set the number of spaces to what ever your heart desires. Leaving my preference of 4 spaces up to me and 4 up to you. To change go to “Tools -> Options -> Text Editor -> All Languages -> Tabs”, I prefer the indenting to be “Smart”, “Tab Size” and “Indent Size” to be 4, and most important “Keep Tabs” selected. The Fix Mixed Tabs extension is also helpful for those of us with OCD.

Our tools should make code style standards easy to enforce and easy to follow. There are no excuses not to have standards or enforce them, and if you don’t care about code style standards, then why care about anything in code at all? Naming, Principles and Code Style standards are part of any well seasoned programmer tool belt.

Those were quick to do and got my ideas on paper and out of my head.
Now to focus on something more easily modifiable and that can be shared with the rest of the team. We use Balsamiq Mockups because it’s feature rich, easy to use and quick to get started with. As with any tool the more you use it the better and faster you get with it. Another awesome reason is Mockups To Go, which has even more mock up goodness for download. I spent about 30 mins on this homepage mock up, after a quick discussion over the hand drawn ones.

Now that we got our general plan for homepage we can get started with design and getting some pages out quickly. We will come back to Balsamiq Mockups in the future for other pages, for now we need to focus on showing progress to our product owners and getting their input. Since our product owners are everyone, feel free to post your ideas in the comments.

Release often, release quickly, and try to minimize the bugs!

• Intro
• Domain Model

Part of my enthusiasm in creating the Lunchage application is the prospect of new beginnings.  Every new project requires significant amounts of thought into my favorite activity, modeling out a domain.  I believe the single most important aspect of a software engineer’s tool belt is the ability to translate real-world requirements into a set of classes that:

• Properly represents the problem that the software aims to solve
• Are capable of being modified with as little resistance as possible

So, with these lofty goals in mind, we’re going to be keeping a very strict sense of Object Oriented Design in mind when developing and writing out the classes in our main domain model.  I’ve dealt with plenty of DTO/Domain model hybrids in the past with feature envy and am looking to this project to display exactly how easy life can be when we allow our domain to properly encapsulate logic instead of merely providing an interface into our database as is the case with many other systems.

In you’re interested at all in following along with the code base, feel free to download it from github.

Instead of listing every property and field on all our our domain models, I’ll simply say that if a property is necessary for an object to exist, we make sure that it is passed into a constructor to force on instantiation.  In addition, we’re going to try and force all List types to be only mutable by the parent.  This means no public getter on lists, we’ll supply a public getter in the form of IEnumerable  so no other classes can modify the list.

Since our requirements dictate that users need to be able to log in and create an account with Lunchage we’re going to create a, wait for it, Account class.  I want to try an avoid having a needless amount of properties on the class so naturally my first instinct is to simply add first name, last name and email as the only identifiers of a user that I need.  Further down the line we’ll add avatar support but, in keeping in line with light requirements, that stuff is fluff so it’s out for now.  Email is the one property an account needs to be created, so we’ll force that dependency in the constructor and only have a getter backing a private property to allow field access.  In the future if we (read: when) want to allow changing the email we can add a setter with some null checking logic, but for the time being we’re creating a contract with a property that always needs to be there, so let’s make sure that it is.

Our Account class is also going to need a list of properties to track when they choose a place to have lunch.  I’ll then create a LunchSelection class, which is largely immutable, to store the relationship between a Restaurant selected, an Account and the time the lunch is supposed to take place.  After the lunch we’ll allow the user to submit series of reviews on the service, food quality etc….

The Restaurant class is just as simple as our Account class.  We need an Address to store it’s location for geo-targeting, a name, a list of descriptive Tag objects and a list of LunchSelection objects that were created in conjunction with the Restaurant.

You’ll notice we have a list of Reviews attached to the LunchSelection, this may seem a little silly at the moment, I’ll explain this decision after describing the Review class properly.  A Review is made up of a user’s Vote (Great, Ok, Bad), the Question they answered (How was the service?  How did the food taste? etc…) and the LunchSelection for bi-directional reference.  All properties on this class are immutable, largely because once you review something, you really can’t take it back.  The premise is that we want multiple mini-reviews for a LunchSelection that describe fully the experience they had.  Restaurants can be crappy some days because of service and excellent simply because of the atmosphere.  We want to capture the flowing nature of this information.

Voting in our Lunchage system is designed to be hyper-simple to the point of almost Yes-No question answer pairs.  We have to assume most people don’t want to spend the time on diatribes about the quality of their lunch, we need to capture their experience though in order to properly recommend other restaurants.  So we can ask brief questions like “How was the service?” with Netflix style emails to hopefully garner a response.  Vote is then only going to have a VoteValue, which is an enum for Great, Ok or Bad, comments should the user want to provide them and the LunchSelection it is tied to.

The last major class in our system (as per our initial requirements) is going to be the Tag.  A Tag is a name describing the type of food a restaurant serves.  Tags can range from Chinese or Italian to simply Spicy.  Our goal is to create a really dumb selection process that invites the user to blindly click buttons of words they like.  Next thing you know they’re eating lunch at a restaurant they love and have never eaten at and thanking us for making suggestions.

That’s the whole shebang.

From here the real work on the application begins.  We need to get rolling on our storage mechanism implementation and, from there, whatever testing framework we’re going to use to make sure this code-base doesn’t become a mess.  We may have to slightly alter our model once we choose ORM solutions, but we’ll get to that next time.

Again, if you want to check out the codebase, feel free to download it here.

1. Intro
2. Creating New Items

Creating New Items!

Lets start with an empty MVC shell. If you don’t have MVC 3.0 installed yet, you probably should, since we will be referencing it a lot.

The age old right click on folder in the solution explorer  “Add-> New Item…” is not for the Keyboard Ninja! Same for the “File ->New -> File”. It takes far too long and way too much clicking and scrolling with the mouse.

Of course some may say, could it be that “Ctrl – N” maybe of service, but I say no! Try it yourself, first we get the select file type screen, of course what we usually use is not the default highlight. After selecting the “Visual C# Class”, we get a clean class called “Class1″. But no file in sight, and the cursor at the top of the file, things are not much better than with a mouse click. (the second time with “Ctrl – N” did save the last file type used)

And then there is “Ctrl – Shift – A”, add new item shortcut. It’s not a bad choice if you don’t have ReSharper and you can control the Visual Studio default templates. You can locate and organize project templates, easily edit, and create item templates. It’s a lot easier if you have ReSharper and use the Live Templates feature.

Now lets try my favorite way,” Ctrl – Shift – Ins”. The ReSharper insert template, awful to remember, but we will remap “Ctrl – N” to the this command later on. First press “Ctrl – W – S”, which will either show or focus on the solution explorer, easy way to remember is “W” -> window, “S” -> solution explorer. Select the folder “Controllers” and “Ctrl – Shift – Ins”. Select the “Class” as the template. You can also hit the underlined letter key to insert the template without having to navigate to it, in this case “l”. I am naming mine as “AccountController”. Extend the “Controller”, which will result in a blue pop up to add a reference with “Alt -Enter”.

“Alt – Enter” will be the most used shortcut in the process of programming. This brings up the smart ReSharper options, which officially stands for “ReShaper_ForceCompleteItem”. The short cut works whenever there is a ReSharper menu icon pops up on the left hand side of the code.

Let’s remap “Ctrl – Alt -Ins” to an easier to remember and use “Ctrl – N”. Open the “Tools -> Options -> Keyboard”, and find out what the command for the ReSharper insert template, go to the “Press shortcut keys:” and the command will show up in the “Shortcut currently used by:” dropdown. There is a dropdown because the same keystroke can do different things in different scopes. “Global” applies to shortcuts at any level, “Text Editor” only in text edit mode. The command is “ReSharper.ReSharper_GenerateFileBesides”, lets find it and reassign “Ctrl – N” to that. Go to “Show commands containing:” and start typing in “GenerateFile” the command will become highlighted. The search box is an auto search and its an insensitive contains, so you don’t have to know the exact command to find it. In the “Shortcuts for selected command:” dropdown you will find all the current shortcuts assigned to the command. We are going to add a new one. Go back to “Press shortcut keys:” and “Ctrl – N”, you may get the double shortcut of “Ctrl – Alt – Ins, Ctrl – N”, press “Ctrl – N” again to reset the dialog. Keep “Global” in the scope dropdown and click “Assign”.

Check if the “Ctrl – N” is the right shortcut, by pressing the shortcut keys in “Press shortcut keys:” and checking the currently used by dropdown. There are two items in my list, one is the global ReSharper generate file and the other “SqlEditorNewQuery”  in the “Transact-SQL Editor” scope. Since that will not interfere with the new command I will not remove the assignment. If you wanted to remove the command, then you would have to search for it, and select the shortcut you would like to remove in the dropdown menu and click “Remove”.

Most of the time I am in the middle of class creation when I run across the need for a new class or interface. For our example lets create “AccountService”, that will implement the “IAccountService” interface. Instead of using our newly created shortcut we will just start typing the new interface in as a constructor dependency for our Controller.

“pu” “Tab” will autofill “public”, “Accou” “Tab” will autofill “AccountController”, “(IAccountService accountService)” “Enter” “{“, the auto fill will put in our closing curly brace. The “IAccountService” will appear red, since we do not have that class, navigate  to the “IAccountService” and you will see the red ReSharper can do something about this box, press “Alt – Enter”.

Select create interface(notice the underlined characters), the interface is created at the bottom of the file. Put cursor on the name of the new interface, a new box will appear, a purple pyramid. “Alt – Enter” and select “Move to another file and match type name”. Now you have  a new file, and can be done quickly and efficiently. The only downside, the new file probably does not belong in the same folder. And so far I have not discovered a way to move the file without drag and drop. Once in the right folder, you will have an option to adjust the namespace by “Alt – Enter” on the namespace.

Next: Refactor Options

When I first began using ASP.NET MVC as a web development framework, I found the Nerd Dinner application from Microsoft helped to learn the ropes.  The app though never really went far enough into an application’s development cycle to answer a lot of questions I had when starting a new project (to it’s credit though, that really wasn’t the point of the sample application at all).  Trying to find decent help on how to make design decisions can be found in the classic books (Patterns and DDD) but real-world examples are often made into smaller chunks without the big picture on display.  In light of this, we wanted to focus our energies to coming up with requirements for a brand new open source app and take anyone willing along for the ride.  Our open source application will function as a medium to present design decisions and challenges that we can publicly solve for the greater good.

Introducing :  Lunchage

We decided that since we like eating lunch so much and are indecisive, why wouldn’t we create an application that presented us with choices for lunch?  Ok, so right now you might be saying “Why are you making Urban Spoon?”, “Doesn’t Yelp do this?” or “You idiots really have nothing better to do huh?”.  To that, you’re probably right, but we have a few requirements that those apps don’t quite have.

So, over the next few weeks we’re going to be outlining the requirements, software stack, front-end necessities and design for the full Lunchage application.  I want to detail every thought and plan we have to show exactly how fast an app can be spun up using convention, agile methods and good design practices.  Through the programming process our range of blogs will cover object oriented design principles, modern front-end javascript frameworks, front end design and usage of HTML5, usability and maybe even mobile considerations.  The point being that we’re tackling a full scale operation and documenting the entire thing.

Requirements

Before we can get to coding anything, I’m taking the liberty of documenting the basic requirements for the team so we can all work off a unified idea.  Keeping with the Agile methodology, our requirements are going to change as we build and play around with our application so we try to keep any ideas we have loose so we can drop, defer or re-prioritize them at any time.  In my experience, creating a gigantic set of software requirements and sticking to every crossed t is a fast way to create an expensive, complicated and bloated piece of you know what.  Agile aims to keep not only the software cycle lean, but the requirements themselves.

The basic idea of our application is this: I want to log into the Lunchage application, select one to a few descriptors of food I want to eat and I want places in the area to show up.  That is all.  Any other details we add is just fluff.  Our software is going to be designed to perform one very specific task very well.

Now that we have our basic concept, other details we know we want are the ability to log-in using at least two major authentication providers (Facebook and Google for starters) and we want to be able to connect with other people in our application to share where we are having lunch for others to tag along.

The other implementation details (i.e. where we get restaurant data, do we want reviews?) will be discovered as the application is built and discovered.  The main point is that we don’t want to spent a significant amount of time and money on features that we don’t end up using.  Remember the 80/20 rule!

To finalize then, I want an application that:

1. Let’s me sign up with Facebook or Google
2. Let’s me pick food types like “Chinese” or “Spicy”
3. Gives me local places to have lunch.
4. Allows me to share that lunch choice with friends.

As software developers, more often than not we’re able to think ahead to a problem’s solution well before we can write the code, the only thing getting in our way is a mouse and keyboard.  Fortunately for the .NET development community, there are wonderful tools out there combined with Visual Studio to make our lives easier.

This series of blogs is going to focus on utilizing keystrokes and keeping our grubby fingers off of our mouse as it only serves to slow us down and annoy co-workers.  Once we’re all finished, you will sworn into the secret society of keyboard ninjas. We will also try to train ourselves to be more effective by taking advantage of advanced ReSharper commands and features.

You want to make sure that you use any command you learn right away. Try to use as many shortcuts as you can. Consciously recognize often used button clicks and find keyboard alternatives. One last thing, make sure your keyboard shortcuts are consistent across applications that you use.

To start here is my set up of the keyboard shortcuts and screen layout.

My screen layout is simple, I do not use toolbars. So every toolbar is turned off. On the right hand side I have my Solution explorer always open. That also acts like a tabbed pane for any other narrow windows that can fit there like the Team Explorer and Properties. On the bottom, always minimized are any wide panes like Error lists.

My keyboard shortcuts are set to “Visual C# 2005″ settings, visible in the Tools -> Options -> Environment-> Keyboard(Keyboard Options).

My ReSharper shortcuts are set to “Visual Studio” scheme, visible under ReSharper -> Options -> Visual Studio Integration.

To use the shortcuts we will introduce you should have your settings match ours. If a shortcut doesn’t work you can check what if anything is mapped to that shortcut key stroke. To check it go to the Keyboard Options and go to the “Press Shortcut Keys”, and check which commands are mapped to the shortcut.

We will be back to that screen plenty of times to assign and reassign shortcuts. I will provide the exact commands where I can, feel free to ask clarifications on any that are not straightforward in the comments.

Next: How to create a new file.

Need to talk to us?