While we wait for me to edit the recording we did last night and we await Glenn Block’s approval on the fantastic 2 shows we did with him, we can enjoy a smaller conversation Ryan and I had on Heroku, Azure, and a bit about Iron Ruby.

LINQ Examples

I did share how to use Sum, Select Many, and Aggregate. The code was put into my learning csharp project in my learning solution on GitHub.

I plan on writing a couple of blog posts on these LINQ items so stay tuned if you want more LINQ goodness.

http://github.com/RookieOne/Learning

Wizards of Smart Podcast – Episode 5

More rails talk on this episode. But I did share the link with the VBB. http://www.theabsentmindedcoder.com/2010/06/wizards-of-smart-episode-5_01.html

Absent Minded Coder Posts

I shared my 2 posts from the last brown bag…

Structure Map 2.6 constructing the concrete type

http://www.theabsentmindedcoder.com/2010/05/structure-map-26-constructing-concrete.html

Interface Segregation Principle

http://www.theabsentmindedcoder.com/2010/05/interface-segregation-principle-in.html

I also shared George’s comment on the Udi InfoQ article : http://www.infoq.com/presentations/Making-Roles-Explicit-Udi-Dahan

Unlocker

Claudio shared a helpful tool to get rid of an annoying Windows error. http://ccollomb.free.fr/unlocker/

VS 2010 Step into .Net Framework

Claudio also shared a blog post showing how to setup Visual Studio 2010 to allow stepping into .Net Framework code. http://weblogs.asp.net/rajbk/archive/2010/04/21/setting-up-visual-studio-2010-to-step-into-microsoft-net-source-code.aspx

Why Your Code Sucks

This might be my favorite link Claudio shared. The blog post talks about why your code sucks… yes he is talking to you. (and me…)

http://www.artima.com/weblogs/viewpost.jsp?thread=71730

Resharper and Regions

Find out how to configure Resharper to remove regions http://bit.ly/wtjK3

You can also prevent Resharper from adding regions http://bit.ly/9QgLYe

Monads

Uncle Bob uploaded a WTF is a Monad presentation : http://bit.ly/aBMIaL <- I plan to look at this tonight ;D

Revamp Your Code Review

Ryan wanted me to share a blog post by Kyle Baley discussing the code review process : http://codebetter.com/blogs/kyle.baley/archive/2010/06/01/rietveld-or-how-to-revamp-your-code-review-process.aspx

Nine Things ie9 is doing Right

Ryan also wanted me to share : http://sixrevisions.com/web-development/five-things-ie9-is-actually-doing-right/

RSA Animate – Drive: The surprising truth about what motivates us

I think @TheCodeFoundary tweet’d this link earlier this week. It is an interesting video discussing how we are actually motivated by more than money.

http://www.youtube.com/watch?v=u6XAPnuFjJc

Git + GitHub

Claudio was asking about Git so I shared some links and walked through a simple workflow into how I commit locally and then push to my GitHub repository.

Git Extensions can be found here : http://sourceforge.net/projects/gitextensions/

We also discovered this : http://learn.github.com/

Architecting TekPub

Great article on InfoQ. In the article they itnerview James Avery and Rob Conery about their experience with TekPub going from MVC to Ruby on Rails and the reasoning why.

http://www.infoq.com/articles/architecting-tekpub

Future Rails Hands-On Demo?

I tossed out the idea of having a rails hands on talk where as Claudio talks, I code the application in rails. The purpose is to showcase how rapidly we can build an application and deploy the application using rails.

What has started me thinking along these lines has been my recent readings of The Toyota Way and my re-reading of The Goal.

The Toyota Way

The Goal: A Process of Ongoing Improvement

Both readings have me re-examining my career and software development. Asking questions like, Are we focused on the right things?

Anyway here are the posts:

• Jaded .Net
• The Goal
• Estimating the Impossible

My solution is to use the decorator pattern to decorate commands with a Name that can be used as the content for the buttons.

My decorator looks like :

public class NamedCommand : ICommand{    public NamedCommand(ICommand decoratedCommand, string name)    {        _DecoratedCommand = decoratedCommand;        Name = name;    }

    readonly ICommand _DecoratedCommand;    public string Name { get; set; }

    public void Execute(object parameter)    {        _DecoratedCommand.Execute(parameter);    }

    public bool CanExecute(object parameter)    {        return _DecoratedCommand.CanExecute(parameter);    }

    public event EventHandler CanExecuteChanged;}

I then created an extension method on ICommand :

public static ICommand Name(this ICommand command, string name){    return new NamedCommand(command, name);}

So in the code I can now do:

Commands.Add(new ActionCommand(OnOpen).Name("Open"));

For my WPF visual, I have a DataTemplate :

<DataTemplate DataType="{x:Type Commands:NamedCommand}" >    <Button Content="{Binding Name}"            Command="{Binding }" /></DataTemplate>

To try and eliminate the pain, people have created some great solutions using AOP : IL weaving (PostSharp) and using a proxy (Castle Dynamic Proxy).

PostSharp has a little too much voodoo for me atm. I think I will warm up to it though and re-examine using PostSharp on my next solution. But for now, I wanted to use Castle Project’s Dynamic Proxy.

Naturally since Castle also has a very popular IoC container in Windsor, most examples marry Dynamic Proxy and Windsor to form an AOP INotifyPropertyChanged solution.

Since I am using StructureMap for this project, I endeavored to create my own solution using Dynamic Proxy.

My first attempt I shared at the Virtual Brown Bag look liked it worked but in reality I was constructing my objects twice.

Once with SM and once with the Proxy generator.

I had to go back to the drawing board and posted my problem at the SM google group. http://groups.google.com/group/structuremap-users/browse_thread/thread/1a6b19ce8152db1b?hl=en

I believe the syntax given to me was an older version of SM. For the record, I am using version 2.5.3.0

But it did direct me to the general idea on where I should start looking. I ended up needing to create an IBuildInterceptor.

public class MyBuildInterceptor : IBuildInterceptor   {       public MyBuildInterceptor(Type concreteType)       {           _ConcreteType = concreteType;       }

       readonly Type _ConcreteType;

       public object Build(BuildSession buildSession, Type pluginType, Instance instance)       {           var constructorArgs = _ConcreteType               .GetConstructors()               .FirstOrDefault()               .GetParameters()               .Select(p => buildSession.CreateInstance(p.ParameterType))               .ToArray();

           var interceptors = new List<IInterceptor>                                  {                                      new NotifyInterceptor()                                  }                                  .ToArray();

           return new ProxyGenerator().CreateClassProxy(_ConcreteType, interceptors, constructorArgs);       }

       public IBuildPolicy Clone()       {           return InnerPolicy.Clone();       }

       public void EjectAll()       {           InnerPolicy.EjectAll();       }

       public IBuildPolicy InnerPolicy { get; set; }   }

To register my ViewModels I created a convention using a TypeScanner

public class MyNotifyConvention : ITypeScanner{    public void Process(Type type, PluginGraph graph)    {

        if (type.GetInterface("IViewModel") == null)            return;

        var interfaceType = type.GetInterfaces().FirstOrDefault(i => i.Name.Contains("ViewModel")                                                            && i.Name != "IViewModel");

        if (interfaceType == null)            return;

        graph.Configure(r =>                        r.ForRequestedType(interfaceType)                        .InterceptConstructionWith(new MyBuildInterceptor(type))                        .TheDefaultIsConcreteType(type));    }}

I then used a Dynamic Proxy Interceptor that I basically copy and pasted from Serial Seb’s example.

public class NotifyInterceptor : IInterceptor{    public void Intercept(IInvocation invocation)    {        // let the original call go through first, so we can notify *after*        invocation.Proceed();

        if (invocation.Method.Name.StartsWith("set_"))        {            string propertyName = invocation.Method.Name.Substring(4);            RaisePropertyChangedEvent(invocation, propertyName, invocation.TargetType);        }    }

    void RaisePropertyChangedEvent(IInvocation invocation, string propertyName, Type type)    {        // get the field storing the delegate list that are stored by the event.        var methodInfo = type.GetMethod("RaisePropertyChanged");

        if (methodInfo == null)        {            if (type.BaseType != null)                RaisePropertyChangedEvent(invocation, propertyName, type.BaseType);        }        else // info != null        {            methodInfo.Invoke(invocation.InvocationTarget, new object[] {propertyName});        }    }}

Instead of looking for the PropertyChanged Handler, I create a RaisePropertyChanged method and use that. Although I could raise the event using the field method Seb was using, WPF wasn’t updating the binding. I didn’t really bother to investigate and just rolled with this solution.

So that’s my solution and I’ll start using it in my current solution. Naturally I will clean up the code some more etc. Feel free to use this for any of your own projects. You can also get the solution at my GitHub:

http://github.com/RookieOne/StructureMapAopNotify

I know the basic concepts of what a monad is mostly due to random discussions. I never put any solid research time into what it is… why I would use it… and where does it fit into the larger scheme of my personal development toolkit.

I started my adventure in learning where I normally start… wikipedia.

http://en.wikipedia.org/wiki/Monad_%28functional_programming%29

Whoa.. lots of new terms thrown at me. Here are some random notes and crazy thoughts I am pulling out (mostly for myself).

“a monad is a kind of abstract data type used to represent computations (instead of data in the domain model)”

That sparks some ideas. Anyone who talks to me on a regular basis knows I am a huge Greg Young CQS fan. I think I’ve always been circling around these ideas but Greg’s insights just pulled away the haze and brought into focus the essence of what always bothered me.

For more information on Greg Young’s CQS, I would suggest http://jonathan-oliver.blogspot.com/2009/03/dddd-and-cqs-getting-started.html

Jonathan has compiled a great set of links to get introduced to the ideas. I am by no means an expert, but I consider myself a CQS disciple.

Back to monads.

The idea of the ‘domain’ being a ‘computation’ or ‘action’ more than data makes me think there might be a connection to explore.

“Monads allow the programmer to chain actions together to build a pipeline, in which each action is decorated with additional processing rules provided by the monad.”

This makes me think of the ‘reconstruction’ of a domain object by processing its events. That would be a neat POC to put together.

“The return operation puts a value from a plain type into a monadic container of type M. The bind operation performs the reverse process, extracting the original value from the container and passing it to the associated next function in the pipeline.”

I am still unclear on the whole wrapping business. I think I will revisit this again after going to another location to learn about monads.

So I moved over to Channel 9 and began to watch:

http://channel9.msdn.com/shows/Going+Deep/Brian-Beckman-The-Zen-of-Expressing-State-The-State-Monad/

Here are some random notes / quotes:

“Only two types of variables. A bound variable and a free variable. Bound variable is a function argument. A free variable has to be looked up somewhere else.”

State monad takes a state and spits out a state, content pair.

“Composition is good”

“Mathematics is the art of abstraction and precision”

Is functional programming and monads a disruptive technology? Although it technically isn’t that ‘new’. I think it might be. The comments around an army of OO programmers and the difficulty for learning to think functionally just resonates with the idea that functional programming is a disruptive technology (even though functional programming isn’t new).

Ok… That was a pretty rough first day. Lots of terms and pictures and strange code thrown my way. It’s time to process the information. I’m pretty sure I will need to watch that video about 5 times in-between coding this stuff. I plan on trying Brian’s exercises along with watching ‘Don’t Fear the Monad’ (another Brian Beckman presentation).

Ryan already has completed the first exercise in C# and F#. I will work on my own version of the C# exercise and then look at his code. I don’t think I will dive into F# right now. I played with the language about 2 weeks ago but all I did was create ‘Hello World’. There is a F# user group meeting on August 27th where I ‘might’ try to code these exercises.

Until I read that book, I never thought about the importance of one sentence. A good novel writer ensures that his audience is not subjected to needless modifiers that serve to support poorly written sentences. Not only this, but he does it on a consistent basis, one sentence at a time, until the entire novel is written, all the while focusing on the overall plot of the book. The mark of quality in a novel is it’s ability to move the plot forward while avoiding unnecessary distractions. This hallmark is established with each and every sentence.

In the publishing world, there are checks and balances to ensure that before a novel is released, the quality of the novel matches up to certain standards. After the novelist writes the novel, he sends the manuscript to the publisher, who typically suggests one or many edits that the manuscript needs before it’s ready to be published. The novelist then edits his manuscript and repeats this process until the book is ready to publish.

Now, liken yourself to a novelist. You have a novel (your code) full of sentences (lines) that you’re tasked to write. The assumption is that you will not only focus on the purpose of the application, but will also focus on how that purpose is to be achieved, by paying attention to each and every line of code. I’ve heard it said recently that “it only takes one line to create a dependency”. This statement shows the power that one line of code can have. It can make or break your application.

So what is code quality? Quality code can only come from paying attention to each line you write. As I’m writing this blog, I’m paying attention to each and every sentence I write. I’m reviewing each one to verify they communicate my point clearly and concisely. The reason I’m doing this is because I know there are people who will read this post. They’ll analyze what I’m saying, and won’t want to waste their time while reading it. They expect to learn something from every sentence.

So why don’t we do this as much in our code? I think it’s because we believe that our code will never be read. It will only be used. This is a false assumption that needs rejecting. Every day I read the code I’ve read in order to modify it, or in order to hunt down a bug. The way the code is written is almost as important as what it does. Poorly written code takes longer to maintain. Well written code can be maintained almost effortlessly.

Each line of code should serve a purpose. Each set of lines should be reviewed as it’s being written, to ensure the most clear and concise expression of the concept is found. Each architectural construct should be reviewed for it’s flexibility and it’s contribution to the overall goal. This should happen not in a designated refactoring session, but during the moment-by-moment process of coding.

This takes patience, consistency and the ability to clearly adhere to and express the purpose.

Code quality, in my definition, is a well-assembled collection of well-expressed lines of code, none of them being taken for granted. This is a basic concept, but one that needs reinforcing from time to time. There are so many concepts to quality programming that it takes a lifetime to master them all (if indeed they can be mastered), but for a good start allow me to suggest SOLID principles and design patterns. Professional programmers will learn these techniques and use them to their advantage. Poor programmers will abuse the code and muddle it’s intentions.

Refactor in the small, and refactor consistently as you go. A good place to start might be to begin reading Sean Chambers’ current blog series entitled 31 Days of Refactoring. Refactoring as you go can help to prevent technical debt.

Learn these techniques and apply them as you go, not after the fact, and you’ll find at the end that your code can be as enjoyable to read as some of the world’s greatest authors, from Hemingway to King to Rowling.

Write code like it’s going to be read.

I’m glad to see Microsoft respond to the community. I find great hope in Microsoft’s future in their willingness to listen and respond. If only they would do so sooner rather than later, they would have a much better reputation with the community. Nevertheless, I’m pleased with their desire to dialogue with the community to improve their guidance.

Now, if you are an architect or developer with experience in the areas for which Microsoft is offering guidance, speak up. Help provide the response for which Microsoft is asking. This is a great opportunity for us to bridge the relationship we have with the team at Microsoft providing the tools we use daily.

Mostly its been a great exercise in BDD requirements / story construction. I’ve stumbled, made mistakes, corrected mistakes, etc

I am still excited about BDD stories. I think with DDD and BDD and insert jargon here… there is a drive to pass the infamous smell test.

There are the developers that just code. They apply a technology and just swing code around to solve a problem. Comments and best practices and solid design be damned. It works! So what’s the problem?

Then there are the developers that have that passion and instinct to know something is wrong. The idea is similar to Gladwell’s Blink principle. These developers first just code and refactor in solo. I relate it to a ronin samurai. Maybe a Luke Skywalker before his time with Yoda.

They then discover patterns and OMG.. the lights go on and you have an epiphany. There is a great book on font design by Robin Williams called The Non-Designer’s Design & Type Books. Chapter one is called The Joshua Tree Epiphany. Here is the quick summary. She picked up a tree book and the first tree was the Joshua Tree. She said to herself, “Oh, we don’t have that kind of tree in Northern California. That is a weird-looking tree. I would know if I saw that tree, and I’ve never seen one before.” She then went outside and immediately saw that her neighbors had Joshua trees. Yet she never ‘saw’ one before because she didn’t know what they were. This principle she describes simply saying :

*Once you can name something, you’re conscious of it. You have power over it. You own it. You’re in control.*

Once developers are exposed to patterns and understand patterns, a new world is opened up to them. And beyond patterns, there are principles. I recently listened to the Hansel Minutes with ‘Uncle Bob’ on the SOLID principles. I found myself saying.. exactly! a lot. The principles just resonate ‘rightness’.

Anyway, what I am trying to say is that on the road to becoming the best developer I can be, I am at the mastering DDD / BDD / TDD stage. I know they are right because when I execute them correctly, it feels right. When I mess things up, it feels wrong. In lots of ways it feels like I am on an intellectual adventure. Maybe like Lord of the Rings. Instead of the ring weighing down Frodo the closer he got to Mount Doom… the closer I get to mastery of these concepts the better I feel about development.

So anyway.. those are some random thoughts I’ve been having lately. Hence the low number of blog posts. I’ve been using the time to read (because I need to catch up!) and to practice the esoteric art of BDD stories. My current reference is Dan North’s site.

I will update Greek Fire soon with documents mostly. I want to have a readme file about setting up the database. I also want to have BDD stories to document the requirements for the domain, etc.