Upcoming Topics:

Setting up the Bootstrapper and Global.asax
Creating Models, Views, and Controllers with FubuMVC
Adding database connectivity
Using HTML helpers

I will most likely cross post these to the FubuMVC wiki once they are refined and final, so if any of you have comments, ways to do things better, or find things I should explain or do differently, please leave me a comment.

Before You Begin

Before you start your setup, head over to the FubuMVC website, grab the latest version of the source and compile it. This way you will have the references I am using below.

Project Setup

The first thing you need to do is go setup your project and folder structure. I am not going to detail the process here, because most people have thier own preferences and naming conventions but for my sampl I will be using the following folder structure:

• FubuSample
• lib
• src
• FubuSample.Core
• FubuSample.Web
• FubuSample.Tests
• FubuSample.sln

You may have noticed above that I am using three different projects: FubuSample.Core (class library), FubuSample.Web (Web Application) and FubuSample.Tests (class library). Setup these projects and we will move on, mine look like this:

Got it, great. Next thing I am going to do is add references required for FubuMVC to work. I added the following references to my projects:

1. FubuSample.Core
   1. FubuMVC.Core
   2. FubuMVC.Container.StructureMap
   3. StructureMap
   4. Microsoft.Practices.ServiceLocation
2. FubuSample.Web
   1. FubuSample.Core
   2. FubuMVC.Core
   3. FubuMVC.Container.StructureMap
   4. StructureMap
   5. Microsoft.Practices.ServiceLocation
3. FubuSample.Tests
   1. FubuSample.Core
   2. FubuSample.Web
   3. FubuMVC.Core
   4. FubuMVC.Container.StructureMap
   5. NUnit.Framework
   6. Rhino.Mocks
   7. StructureMap

Once all the references are are in your 3 projects, you are almost ready to get going. The next thing to do is to setup a basic folder structure inside your projects. In the web project I added a Views folder and a Content folder; under the content folder I added seperate folders for images, scripts and stylesheets. Moving on to the Core project I added top level folders for  Config, Domain, and Web. Under the Web folder I also added folders named Controllers, DisplayModels, Html, and WebForms. My folder structure now looks like this for my projects:

Next up, setting up the Bootstrapper, Global.asax and Web.config for FubuMVC

I can tell you this though, I am going to be managing and developing the software development side of a company that is in startup mode. We will be primarily doing Asp.Net Web Apps, MVC style. This is a little scary for me as I have been doing Win Forms development for the past 5 years, but I have kept my fingers in a lot of web stuff. I am also thinking we are going to build on top of FubuMVC vs. Asp.Net MVC . This is primarily because I am wanting to get involved with the development of FubuMVC as an Open Source Project this year. I have several pages of documentation on getting started with FubuMVC from scratch, I am sanitizing and creating posts / articles out of them as I have time.

I am really excited about this new job, I have a good feeling that it is going to open up lots of new opportunities for me to stay involved with the Alt.Net community, and maybe I will get to see more of you more often.

p.s. I will post more details if/when I am able.

Personally I think that university Computer Science programs are a
joke (at least in the U.S., can’t speak for other countries). In my 4
years at the U. of Toledo I think I had 5 classes that taught me
something relevant to real world software development. The words
"unit test" were never uttered in my classrooms <shudder>. College
grads take this education into workplace and have no idea how to
practically use the skills that they have learned.

 

As far as I know there is nowhere you can go to get a formal education
on advanced software development topics. User groups and conferences
are great, but there are tons of devs that don’t go to those things.
I’m talking about classes that teach you software development
principles like what unit testing is, how to do test-driven
development, what SOLID is, domain driven design, etc., or maybe more
technology specific things like how to use NHibernate, how to optimize
ASP .NET applications, etc.

I have to say that I wholeheartedly agree with this statement. In my 7 years in college I had never heard of Unit Testing, SOLID principles, etc. It wasn’t until I began to use the basic building blocks I was taught in daily software development that I realized, “Hey, there is a better way to do this stuff.” Then I found the Alt.Net community and began further educating myself on these topics. The most important part of what I just discussed is, “I educated myself.” In large part this is the one single thing that separates a great developer from a programmer, initiative. You have to want to continuously improve and hone your skills in order to become a great developer.

Why does this education breakdown exist?

I have my opinions on why this education breakdown exists and I would love to hear yours as well. I think one of the biggest reasons this happens is because Computer Science programs tend grow from within themselves. I mean obviously if you have been in college for 12 years and have a PhD in Computer Science then you are an expert software developer, right? I say WRONG; It becomes the blind leading the blind in a redundant cycle over and over. Most PhD Computer Science professors are what I would call “Research Oriented.” They go through their entire educational career never writing any real business software. They focus on research projects, and exercises that are only important in school. They are not forced into dealing with the pain and struggle that full-time normal developers encounter each and every day. The dynamics of developing software with a team and a boss, and their bosses boss, not to mention timelines and financial constraints. These “Expert” professors hold the students well being (grades) in their hands, and mandate that you do it their way or you fail. Nobody wants to fail so they do it their way, and the cycle continues.

Some professors may actually come from the industry, but many only join academia in retirement. More likely than not, they were not a developer when they retired, they had become “successful” and moved into management. Either way, it has probably been a while since they were in the trenches developing software on a daily basis. Compounding the problem are advances in language, methods, and principles. The software they wrote a long time ago was in different languages than what is taught at colleges and universities today. They are now learning new languages so they can teach them to students. They are so focused on the new languages that they neglect the principles that are language independent like Unit Testing, SOLID principles, ORM’s, TDD, etc.

What can we do to stop the cycle?

I believe we have to take action as individuals inside the community to change the path that our future team members are on as soon as possible. Each year, the cycle perpetuates itself.

One of the ways we can do this within our own teams is to have “The Way”. Inside our development team we have “The Way”, which is the way we develop software. We practice TDD, Unit Testing, DDD, we adhere to SOLID principles, we use NHibernate. That is “The Way” we develop software. Now this puts a burden on the company, and on the seasoned developers to spend time with new team members and teach them how to do these things. This does two things: it helps develop a team working environment and hopefully instills in them personal initiative to continuously improve their software skills.

Another way that I am currently doing is to get involved with your local college, community college, or University and teach some classes. Remember, the professor’s way is the students way. I currently teach classes at our local university and these are the exact things I want to engrain in the minds of these students. Next week I begin teaching an upper level Systems Analysis and Design class. During the semester we will design and begin developing an Open Source Learning Management System,will make the students learn and practice concepts such as pairing, unit testing, SOLID principles and practice using an ORM. They will create this project in C#, as that is my language of choice, but will understand that these tools and concepts are not tied to one language.

You may or may not be able to teach a class at your local university but I would be highly surprised if you could not, at the very least, give a talk at a “Computer Science Club” meeting about these things in an evening.

I know I do not have all the answers, but this is the best way for me to make a difference. I would like to hear opinions and other things we can do to help alleviate this breakdown in education of our future employees and teammates.

-Ryan

Met new People

I was able to meet a ton of new people in 2008, both online through blogs and other communities, and at KaizenConf in Austin. This is probably the single most important thing that happened to me in 2008 because it helped put me into circle of people that share the same thoughts and values about software development that I do.

Alt.Net Introduction

I was also introduced to the Alt.Net movement during 2008. I have been developing software for several years and some of the things I had been doing just didn’t seem quite right, they worked, but they had a smell to them. Enter Alt.Net, this stuff just makes sense. It is smart software development, that revolves around creating highly testable, highly maintainable code that follows the SOLID design principles. I have come to realize that if you just ask yourself “How does this proposed solution adhere to the SOLID principles” you will write much more elegant code.

KaizenConf Open Spaces Conference

This was my first open spaces conference and I didn’t know what to expect but I came away with the feeling that this was the best conference I had ever been to. KaizenConf helped fuel my fire for continuing with more Alt.Net stuff, working on Lean Software Development and KanBan methods, and staying involved with the community. It even spurred me to start blogging more frequently about these topics.

Some 2009 Resolutions

I have a few resolutions I am going to make for the new year, some are computer related, some are not.

• Blog More – I am targeting 52 blog posts in 2009, that is a little more than double from 2008 and is only 1 per week.
• Fish more, I love fly fishing, just need to make more time

  - Fly Fish for Bass – talk about fun!

• Write Elegant Code – I am staying committed to SOLID principles, testability and maintainable code.
• Learn more about Asp.Net – Especially MVC stuff, I have been doing WinForms development for the past 4 years, so I am looking forward to this one.
• Learn a new Programming Language – Everybody should do this every year.

I am going to stop there, I don’t want to set any unrealistic expectations for myself during the year. I think all of these are very attainable and I hope that my list has spurred some inner resolution making within you to go out and commit to something new in 2009.

Here is the error: Test(s) failed. System.Runtime.InteropServices.COMException : The program issued a command but the command length is incorrect. (Exception from HRESULT: 0×80070018)

So I did some googling around and found there is a bug in the .NET Framework 3.5 SP1 regarding this issue. So a little more work and I found a work around. I believe this bug only pertains to WPF stuff.

Workaround

On the build agent do the following:

1. Stop the TeamCity Build Agent service (Start –> Run –> services.msc –> TeamCity Build Agent –> Right Click –> Stop)
2. Browse to the service file (C:\TeamCity\BuildAgent\launcher\bin)
   
3. Right click TeamCityAgentService-windows-x86-32.exe and click Properties
4. Go to the Compatibility Tab
   
5. Click Show settings for all users
6. Change the Compatibility mode to be Windows XP (Service Pack 2)
   
7. Click OK a few times to close all the windows
8. Start the TeamCity Build Agent service.

You should now have a working build with WPF unit tests. Hope this helps somebody out as I was banging my head on the wall trying to figure it out.

The shock on their faces at the collective “I’m Sorry” was a bit much. They knew some people have very differing opinions about different frameworks and tools, but hearing it confessed out loud was a breath of fresh air.

Recently our development team decided to stop developing with the CSLA framework. Before I get into specifics, I want to be very clear about something up front. I have no problem with people that continue to use CSLA. We used CSLA for nearly 4 years and it has worked in way it was designed.

While Hiren and I were at KaizenConf in Austin we made sure to find a few minutes each evening before getting caught up with a large group, to recap the day and share some new things we each learned. One of these nights while relaxing and evaluating what we’d been learning we came to the conclusion that it was time for us to step away from new development with CSLA and migrate existing codebases as well. Over the past week we have been outlining and discussing these ideas and why we have made the decision to move away from CSLA.

It all started a few months ago when we first started getting introduced to the Alt.Net ways of developing software. What I mean by the Alt.Net ways are things like S.O.L.I.D. principles, ORM use, unit testing, Domain Driven Design, Mocking, TDD, etc… All of this has really changed the way we think about and develop software. Even before this though Hiren and I made a very dangerous combination of developers because we are never satisfied with a piece of code once it is written, we usually have to talk one another into just leaving it alone because it works and is as good as it needs to be to get the job done.

There are several driving forces behind this decision, but the primary one is that our CSLA business objects just leave a bad taste in our mouth. Our systems are moderately complex and it is not uncommon at all to have a class with 1500 – 2500 lines of code, in fact that is probably an average line count in most business objects. The other thing that really smells to us is that the “model” contains a lot of stuff that is not directly related to the model, namely data access.

I would like to take a minute to point out some of the things I really like and will miss about CSLA, and some of the other reasons for making the switch.

CSLA, I will miss some of you:

• Validation Rules System
• Data binding Support
• Combo of these == reach UI validation for user
• Good set of guiding principles and samples to get started with.
• Rocky’s Books!

I won’t miss these parts though:

• Data Access code in business object
• Difficult to mock out data access in mocking
• N-Level undo – I never, ever used this but had to contend with it, like it or not
• “Super” Classes

These are purely my opinion so take them as they are. I still think CSLA has a place for some people and unlike others I have run into on the internet, I will not bash you or think you are stupid for using it. CSLA was an excellent stepping stone for us; it introduced and really engrained the Object-Oriented Programming style of thinking into our minds. I/we just feel like we have matured to a new level of development through better understanding of our software development process and how apply those skills to our situation.

We are still learning and don’t yet know exactly what our development style is going to be end-to-end on this project. We have a long way to go before we are completely comfortable with all these new tools. Luckily, the Alt.Net community seems to be an open and accepting group and nearly everyone is willing to help us out along the way.

What I do know is that no team can just take what one person or one book says and do it that way. It won’t work. What we are doing is educating ourselves on different practices and tools and using what works for us, we do a lot of spikes right now. We are also building our domain model with POCO’s which gives us a great amount of flexibility in the infrastructure and presentation layers of our system. As we continue this process I will post successes and failures here on my blog.

Lean is the Process, Kanban the Tool

I personally think that a lot of people equate Kanban as being the methodology or even worse an equivalent replacement to Agile or Scrum. This is absolutely not the case, KanBan is not even a methodology like the others. This is a very important point that is often overlooked, especially when new people are trying to learn and apply Lean practices in their software process. Kanban is a Japanese word meaning literally “Signal Card” or “Signal Board”. A Kanban board is just a visual tool used to signal flow and show limits of the process and to create the signal for the pull flow of the system. Derick Bailey has a great easy to understand example of a Kanban in the shape of a grocery store over on his blog. I work for a Lean Manufacturer and we don’t use a “Kanban” in the traditional sense per say because we do not pass cards around the manufacturing floor, we do however use signaling and that is what KanBan is really all about. We refer to our signaling system as our “Supermarkets”, what these supermarkets are actually physical spaces in the production area that are designated for certain types and variations of product.  When a supermarket has an empty space, somebody up the process builds the product to refill that supermarket. To the right is a picture of one of our actual supermarkets, this is a bed supermarket.

Whether you are using cards, boards or supermarket’s the most important thing is that it is creating a signal in the pull system, and this enables flow. The two other really important pieces that Derick does a good job explaining are Order Points and Limits with his grocery store example so I won’t go to far in depth on this. These are two very basic items that every inventory management system has or should have at least. You obviously wouldn’t waste money shipping one box of cereal from General Mills every time a custom took one off the shelf. These just provide a way for the store or the development team to manage the amount of inventory they carry.

I kind of got carried away on what a Kanban was so let me get back on topic. A KanBan could be useful for various methodologies I think but it really shines if you are doing Lean Software Engineering. Lean is the methodology and I think there is a fear rising up within the software community that a lot of teams are just going to “Cargo Cult” this stuff and it really doesn’t work that way. Lean is a way of thinking, just like many of the Alt.Net principles. There are no hard and fast guidelines to implement Lean in 14 days, it is a process and takes time. Even then if you are practicing lean you will never stop implementing lean. I will get off my soap box but I just want people to know the difference between the tools and the methodologies.

Lean comes in Different Sizes

This is what I am really excited about right now. I know of 3 people currently implementing (or hoping to) Lean in their teams right now. The best part of this is that we are sharing the processes that we are following to make this as open as possible for other teams to follow along with. This is great because we are all in different teams, sizes, makeup, skill level, etc… So we should see some very different yet exciting results come out of all this. I committed to documenting my implementation at KaizenConf and have started with a few posts on what I have done so far. Louis Salin also has a series of great articles on his blog that are a recap of several sessions from KaizenConf combined with his own thoughts on this implementation and guess what, It isn’t that much different from the rest of us, only it is his way, which is awsome!

Louis Salin – The bag and the Kanban:

1. The bag and the Kanban, part 1
2. The bag and the Kanban, part 2
3. Activity Modeling and the bag

Louis has got some great ideas here, especially the bag idea. This is something very similar to what I have been thinking of / calling my “To-do” list. I will expand on this topic in a few days, we are currently re-working the way we deal with items before they make it on the backlog.

Derick Bailey – Adventures in Lean

Derick Bailey has just started his series, “Adventures in Lean”, and I think this will be very interesting to follow as well. Derick’s team is a larger team that I have for sure, and I think larger that Louis’ team too.

Ryan Kelley – Lean in Small Teams

I am documenting the Lean implementation in our team as we go along. I will continue to write about this, good things and bad so hopefully other people can learn from what we are doing. That said, we are a very small team, in fact if we were any smaller we wouldn’t be a team. Some may think that for a 2 – 4 person team you don’t need to do Lean but I say that is Bull****. One of the main reasons we are “Going Lean” is to bring some formality into a process that hasn’t ever had any before. We are probably the most disciplined department in the company with regards to how we work, so we need to share the discipline around a little and off-load more responsibility to the customer.

Until next time, I hope this as whet your appetite for more Lean / Kanban discussions.

What is going on here you ask? Order is the primary object type, but it is abstract. I have maybe 7 different types of orders, service order, make order, repair order, etc… each order has several attributes that are always present on every order. What makes each order unique is the attributes that are not shared between all orders. This is why I have decided to use inheritance.

One of the items that are common between all types of orders is that they all have many parts. However, I want the base Order class to have a collection of base OrderPart objects. OrderPart is the mapping object in between Order and Part for the Many To Many relationship, I am using an object because this association has state of it’s own. Now to complicate matters even more, each concrete Order can have a different concrete type of Part and OrderPart assigned to it.

I have the model all setup and Have written some tests against it as I wrote it, not really test first but hey, I am spiking here. So below is one of the tests that shows most of this in action.

public void CanCreateOrderWithCustomerAndParts()
{
var order = new CustomOrder();
order.Customer = new Customer
{
Name = "John Smith",
Address =
new Address
{
Street = "45623 Easy",
State = "TX",
City = "Dalals",
ZipCode = "73884"
}
};
order.OrderNumber = "Y984939";
order.Amount = (decimal) 1234.33;
order.CustomOrderDescription = "Testing adlkfjl 123";
order.Parts =
new List
{
new CustomOrderPart
{
Part =
new CustomPart
{
PartNumber = "Part456sdf34",
Description = "Test Partasd 87",
CustomPartText = "TEST",
},
Quantity = 12
},
new CustomOrderPart
{
Part =
new CustomPart
{
PartNumber = "PARTWITHNULLPULLLOCATION",
Description = "Test Part 848sasd8243",
CustomPartText = "TEST",
},
Quantity = 251
}
};

With.Transaction(() => Repository.Save(order));

Order createdOrder = Repository.Get(order.Id);

Assert.IsNotNull(createdOrder);
Assert.AreEqual(2, createdOrder.Parts.Count);
}

Don’t make fun of my test code, like I said, it’s a spike. But when I create a CustomOrder I am creating Parts as a new List<OrderPart> which is how it is implemented. But then I had new CustomOrderParts and CustomParts into that collection. NHibernate will persist this information correctly into the database and will retrieve it correclty from the DB. So seemingly all works fine right, sure I guess. Maybe it is just because I have been in Csla land so long that I don’t know any different but what I am really missing is being able for the concrete order object to know what concrete type of  OrderPart is contained in the parts collection. As I wrote that I just kicked myself, if that isn’t a violation of Seperation of Concerns I don’t know what is, or is it? I mean Order or a concrete Order is basically an Aggregate Root in DDD terms so it is the responsible entry point into the chain/web of objects that make up the aggregate.

So, for my real question which I am not sure of now, How would you tackle this design problem? How do you handle child collections? Am I just way off the reservation?