I have now secured a location and date/time for a course to be held in Regina, SK for the dates of April 23-27. The following is a description of the course with a registration link at the bottom of the page.

Overview

Nothin’ But .Net is a five day boot camp that will focus on pragmatically applying .Net within the context of developing a working N-Tiered application. Registrants will learn about advanced features of .Net (2.0/3.0) as they are applied to the task of building a complete application from the UI layer all the way down to the mapping layer.

WARNING!!!!

If you are expecting to come to this course to learn about how to have VS.Net automatically generate an “application” for you, then this course is NOT for you.

This course is all about taking control of the .Net framework and having it work the way you want. This course will place a heavy emphasis on getting back to the basics and making .Net do things the way you want it to, in a predictable and testable way.

This course will focus on a code centric view of application development vs. the typical databinding/designer magic covered by many typical .Net courses. You will walk away with a deep understanding of fundamental aspects of .Net and how these pieces can be used to develop and deliver enterprise scale applications.

Core Concepts Overview

Although the list may look rather daunting, the majority of the bullet points will be covered during the evolutionary design and construction of the sample project.

One of the main goals of the course is to show how to effectively use behavior (test) driven development, design patterns and a solid toolset to develop a portion of a non-trivial application.

The course will allow students to pragmatically apply BDD practices as well as teach people how to utilize fundamental OO concepts and techniques that will allow for them to have cleaner, more loosely coupled architectures. It will also be an opportunity for students to see what is involved in creating applications that utilize a Rich Domain Model,and the supporting infrastructure that is required to use "Plain Old Objects".

I have successfully delivered this course several times with great success. I anticipate that people who are interested will find that this is a very unique course offering, not typical of what is being delivered in the mainstream.

There are only spots for 8 people to register. The course costs $2500/US for a full 5 days. The fee covers:

If you have any questions please don't hesitate to contact me at bitwisejp@gmail.com.

Requirements

• You will be required to bring your own laptop ( VMWare / VPC images will be deployed to your machine on day 1 of the course)

To Register for the course please use the following link:

• Course Registration

Next Monday I start another iteration of the Nothin But .Net coding bootcamp. It looks like it will be a blast, but just as exciting is the trip to the course!! This past Wednesday the family and I headed out in the trusty family van, an embarked on a long drive to Richmond, VA!!!!

We have been blessed with amazing travelers, and there is quite a sense of accomplishment when you cross another state line!! It is hard to describe the awesomeness of traveling cross country with your family in tow. God is good.

The nice thing about doing a 40+ hour drive, is that you set the bar extremely high for future trips. Which means that most any other drive we make after this will be trivial in comparison.

It is definitely not something you can do all the time, but I think that everyone should take the opportunity to try it at least once. You may surprise yourself.

For those of you getting started with powershell here is a simple example for you to cut your teeth on, file copying.

I had to quickly copy some assemblies out of the gac to another location, specifically I had to copy all of the Assemblies for ActiveReports into a single directory. If you take a look at the GAC from the command line, you will notice there is a bit of a tree there. To make it simple I wrote this quick powershell script to do the heavy lifting for me :

get-childitem C:\windows\assembly\gac * -Recurse -Include act*.dll | foreach-object -process{copy-item $_FullName - destination O:\efc}

Notice how I am piping the results of the get-childitem cmdlet into the foreach-object cmdlet, the most powerful thing is that I am piping around objects, not simple strings, I love it!!

I know there are ways to do this using the plain old command promtp, but it gives me another reason to sharpen my Powershell skills. If you have not started playing with Powershell, I encourage you to give it a try.

Thanks to Guy Kawasaki, for pointing me in the direction of the Menlo Park Presbyterian Church website. Even if you are not a believer, I think that everyone can learn something by watching the sermon Jesus & Your Job.

Often I can fall into the trap of getting caught up in the politics of the environment around me, I need to remember first and foremost why I am usually brought in, in the first place : To Develop and Mentor. I love how Nancy continually stresses the point that "work is the creation of value", all of us have the capacity to influence the attitudes of the people that we work with. Some of us have the blessing of being able to completely turn around the feelings of an entire environment. The trick is to ensure that we try to maintain a positive outlook on what can sometimes be a not great situation.

Again, watch the video, I am sure that everyone can take away some learning from it.

I am not sure where he finds the time, what with home schooling 2 kids, consulting and speaking, but James Kovacs has managed to write a plugin to allow running VSTS unit tests from within ReSharper. If you happen to be one of those people who has to use the VSTS unit test, and you also have the joy of using ReSharper, head over and download it and give him some feedback!

One of the questions that came up a lot during my last developer bootcamp was : "JP, this is a lot of stuff to take in, what is a path you recommend for us to start implementing these techniques over the next little while?"

My answer to this question is twofold. The first and hardest answer to swallow is that you need to "Be Prepared To Unlearn". In my opinion, it is a lot harder for people to unlearn bad practices and ideas, as opposed to picking up potentially good and useful new ideas. The biggest unlearning comes from the fact that most developers truly believe that they are taking advantage of OO programming, when in reality the majority of their code is just procedural code utilizing objects. The shift that has supposedly happened has not truly been realized by lots of developers (this is not just applicable to the .Net world either).

Once people realize that they have not really been utilizing OO and its accompanying set of principles and practices, they want to know how they can start leveraging TDD, mock objects, ORM etc. Again, too much too soon is not necessarily a good thing. The other problem that people encounter is that once exposed to these new principles, devs want to rush back and start applying them to their existing (often bloated untested, fragile) systems. In reality, it is impractical to learn these new techniques and go back and tear the application apart (especially if it is working for the most part). The following list outlines a strategy that I suggest for blending new techniques, patterns, practices , and tools into your development environment (current project):

1. If you're not using source code control, stop reading this right now and go and get your code into an SCC, Subversion is a great free source code repository server.
2. Get a continuous build environment configured using a combination of either NAnt/MSBuild/FinalBuilder and CruiseControl .Net.
3. Set up automated scripts that can compile, and deploy your project (this will save countless time over the course of a month)
4. If you are in the camp that realizes that you are not truly sure what real OOP looks like, spend a bit of time reading up on some good material that will help you get an idea of what OOP is all about, some of my personal recommendations are:
   • Applying UML and Patterns
   • Head First Design Patterns
5. Identify hot spots in your application that cause you headache (lots of bug tickets), and make a strong effort to get some automated unit testing around those areas. Utilize frameworks like MbUnit or NUnit to accomplish this.
6. If step 5 is proving problematic because of a highly coupled system. You may need to start teasting apart dependencies and refactoring for a bit more testability. Again, only focus on the hotspots. If you are unsure about how to proceed, pick up the awesome book Working Effectively With Legacy Code which will introduce you to a host of techniques for getting yourself out of tangled messes in your application.
7. Get into the habit of unit testing new code that you write. This is not test driven development, but it will get you in the habit of ensuring that to the best of your knowledge, new functionality you are working on has a safety net of testing around it. This will serve many purposes down the road, especially if refactoring needs to take place.
8. Get some design patterns knowledge. It will allow you to speak a lot more concisely with your team members, and well as help you think about way to build more cohesive objects. If you are starting down the patterns path, beware of patternitis. In all honesty, when you are learning, you will rush to try and find a way to apply design patterns, with experiece you will realize that although you could use a pattern in a certain scenario, another solution could be simpler.
9. Start introducing the concept of interface based programming into your applications. By coding to abstractions, you will allow for systems that are far more loosely coupled as well as extremely testable.
10. By this point you should be comfortable with the concepts of unit testing and interface based programming, and all of the new development you have done, sticks out like a bright light surrounded by the darkness that is your old code. Now is the time to start getting into the habit of doing test driven development.
11. Getting into TDD is a bigger shift than the jump you will have already made to object oriented programming. The best piece of advice I can give is to stick with it. Code your tests imagining that the pieces you want to exists are already there and you can use them as you would want to, simply and easily. The nice thing about TDD is that you are designing your object from the perspective of a consumer of that object, this inherently will constrain you to keep the design as simple as possible. It is definitely beneficial if you are able to pair with someone who can help you down the TDD path (heck bring me in for a week or 2!!).
12. So you are now comforable with traditional test driven development, it is now time to add a new tool to your TDD arsenal, a mock object framework. By utilizing mock objects, you will be able to focus on writing tests for only one class at a time, while simulating any dependencies the class you are testing may have. My current favourite mock object framework is Rhino Mocks. By the time you introduce a mock object framework, you should already be comfortable with interface based programming, which will allow you to start integrating it into your tests very quickly.
13. Start playing around with some more OSS software, leverage dependency injection to acheive truly decoupled components, downlod and look at the source for existing open source projects.
14. This is the last and most important point:
    • Become a student of your profession - this is so important, most of the people who embark down this style of development do so because they have a passion to want to deliver applications that both please the user, as well as please other developers who maintain the code. Like anything else in life, if you want to excel in anything you have to be willing to sacrifice a little. What does this mean? Make a commitment to read a book a month. Take time to download a tool you have no idea about and start spiking it. Speak at a user group. Write a magazine article about your learning. Passion breeds passion, if you get infected, more often than not, others around you will want to have a "piece o dat"!!

It should be noted that the above 14 points cannot be acheived in a short amount of time, it is a proposed plan of attack for starting down a new path of development. It could take 6 months, 1 year, 2 years before you feel comfortable with all of the new techniques and practices you will be utilizing. Speaking from personal experience, it will be one of the best investments you make for your career.

Enjoy the journey!!

Yesterday Jeremy Miller asks the question : Do you use OSS tools for .Net development. My answer is an obvious and resounding Yes!!

Here are some of the tools I currently use:

• Castle Windsor - Leveraging IOC implementation
• NHibernate - Data Access
• IBatis .Net - Data Access
• log4Net - logging
• MbUnit - Unit Testing
• NUnit - Unit Testing
• Prototype - Javascript
• Script.aculo.us - Web 2.0 framework built on top of prototype
• Watir - Automated web ui testing
• NCover
• NCoverExplorer
• Boo - so many uses!!
• NAnt - Automated Build Tool
• CruiseControl .Net - Continuous Integration Server
• Rhino Mocks - mocking while practicing BDD
• NMock2 - was using this in conjunction with RhinoMocks as until recently, only NMock2 supported mocking generic method calls.
• FireFox - wicked internet browser
• Notepad++ - awesome notepad replacement
• NHQG - Strongly typed querying with NHibernate
• FileHelpers - data import/export
• iBox - overlays in HTML
• Subversion - source code repository
• TortoiseSVN - windows subversion explorer client
• MonoRail - Great MVC framework

I am sure I am missing a few, but the above list definitely covers the brunt of them!!

What OSS tools do you want to use today!!

Just a quick note to remind people who are still interested in signing up for the course that you should get over to

https://www.acteva.com/go/jboodhoo

and register. As others who have already taken the course will attest, this is not your standard fare, .Net course. You will leave this course with some crazy new ideas, as well as a new look on the way you approach software development.

If you're still interested, register and I'll see you in Richmond at the end of next month!!

I had a blast presenting at the Edmonton .Net User Group last week. With the presentation and finishing the course I neglected to upload the source code for the presentation.

It is a little rough around the edges, but the cool part was that almost all of the code was churned out during the course of the session. It was a frenzy, but I feel confident that a lot of awesome concepts got disseminated to the crowd.

Thanks Edmonton for having me, I look forward to the next time.

You can download the source code from here (you will need WinRar to extract it).