I find myself looking at things I would never have found, sometimes at the detriment to my progress. There’s also been stories of people being fired because of Tweets about a new job or regarding an opinion on something in their current one. Never mind the new employer seeing their huge amount of updates during work hours.

Twitter achieved Critical Mass, earlier in the year and that’s fantastic. The main stream has embraced the technology. This isn’t new though. On average I estimate 3 or 4 websites have reached that magic Critical Mass per year for the last 10 years. Lets list a few (lists are fun, even in no particular order) until we get bored or this blog post gets too long.

Ok, bored. All of these websites are important to me and I have used most of them since they were available to me. Am I in the mainstream even though I’m a massive technophile? Lets draw a Venn diagram to illustrate what I think is happening.

Now this may seem like I’m being massively aloof. However, I think I find tools that what I perceive as the main stream of people don’t find and I also spend a lot more time online and so use more. I also think that the mainstream uses tools that I have dismissed because I’ve seen a better version or that I don’t even know about!

What I like to see is that the mainstream is moving closer to the technorati. There are more like minded people coming together.

I someday want to create something that achieves critical mass because I, like Jeff Atwood, think it is the ultimate accolade as a software developer.

Neal Stephenson explores the idea of a virus for the mind in the cyberpunk novel, “Snow Crash”. While Stephenson’s vision was extreme and fantastical it had some basis in reality, for example the use of “Glossolalia” to spread the virus. The antagonist used a mixture of technology and ancient linguistic magic in order to control the “infected”.

In my opinion a quote can really affect how you see the world and the actions you take. The use of linguistics and the turn of a phrase to influence another’s behaviour or even change their very character. I’m reminded of this quote:

Watch your thoughts, for they become words.
Watch your words, for they become actions.
Watch your actions, for they become habits.
Watch your habits, for they become character.
Watch your character, for it becomes your destiny.

Unknown Origin

Arguably you are programming your brain every time you pick up a book or article as the author hooks into your thoughts, influencing your words, your actions and ultimately your destiny. Strengthening a pathway to an action by the use of language. The spread of ideas, political or otherwise, behaves like a virus that builds society. The ideas could be good or bad but they’re still going to spread. Hate, love, knowledge, peace, war. All ideas are propagated by language. Remember that language is anything that can be used to convey information. Symbols, images, actions, gestures, and most obviously words.

An interesting trend is that some people are more apt to pick up ideas and spread them where others are wired to act on the ideas and focus on them and only them.

Nothing is more dangerous than an idea, when it’s the only one you have
Emile-Auguste Chartier

Then there are the magic individuals that can do both. I like to think these people are the entrepreneurs. Taking ideas, growing them, realising them, sharing them and then moving onto the next. That’s what I aspire to, respect and ultimately hope that I can be. The lack of fear, the bravery to put what you have made out into the world and stick two fingers up to the people who said it wasn’t possible or just a gimmick.

The entrepreneurs, the ones you can trust to stick it out, to push through the Dip, to tell you the truth, to hire and lead and inspire… that is the scarce resource.

Seth Godin

However, a fear of sharing ideas is built into our capitalist society because we have been programmed to look for opportunity and exploit it for personal gain. Which in turn gives us the fear of sharing ideas in case others do it. A social evolution of survival of the fittest instinct. It is this fear which holds us back, cages creativity and forces us into a lifetime of want. Always thinking, I could do this but what if? Entrepreneurs are the people who answer that question.

One may know how to conquer without being able to do it.
Sun Tzu, The Art of War

Traditionally an entrepreneur is a business owner, a money maker.  I’d like to expand on Seth’s definition above because I think in the age of the web this simply isn’t true anymore.

If you want to lift yourself up, lift up someone else.
Booker T. Washington

An entrepreneur is first and foremost a facilitator. Someone who’s willing to start something, be it a community, a ridiculous thread or a world changing web application.

The web is changing the face of the social landscape daily. Communities that act as a single entity for pushing ideas, building amazing products just for the sheer enjoyment of producing. Collaboration and content generation are running at an unprecedented level. Twitter is a prime example. Facebook is another. Ideas and feedback for products are flooding into the public domain. Entrepreneurs are becoming more common but on a smaller scale and of a new breed. The ones who propagate file sharing and spend countless hours ripping DVDs and music only to give it away, just for the hell of it. That is entrepreneurial.

New products surge and fall faster than most people can follow, excuse the pun. In my twisted view of the world, this is a Good Thing™.

If each of us have one object, and we exchange them, then each of us still has one object. If each of us have one idea, and we exchange them, then each of us now has two ideas. 

George Bernard Shaw

This is the real New World Order. A single community driven on communication. A community that can rise up to do great things and change the world even if it’s just in a small way, even if it’s just the simple act of naming a humpback whale “Mr Splashy Pants”.

Happiness is only real when shared. 
Chris McCandless [In the film Into The Wild]

So, concluding. If information can be used to program the mind then the internet is a giant database of code that like any code, if used correctly can do great things. I’m trying to do that everyday. My tools are Google Reader and a thirst for knowledge. My fuel is the Internet. Really I just wanted to use some quotes in a post. Thanks for reading.

So here’s a list of the new ones (and the invaluable ones you should already know). I’ve been saying “I should really learn that shortcut” but never bothered to actually do, until now.

• Ctrl+.
• Opens the auto-refactor suggestion context menu e.g. “Implement this interface”, really good one.
• Ctrl+e
• Exceptions window. This allows you to automatically break into the code when an exception is thrown and the debugger is attached. Saves a lot of F10
• Ctrl+g
• Go to line. You should know this already.
• Ctrl+k, Ctrl+c
• Comment line or selected code with the correct comment syntax.
• Ctrl-J
• List the members for statement completion while in edit mode.
• Ctrl-Shift-F9
• Remove all breakpoints in the current debugging session
• Ctrl-Shift-F5
• Rebuild and restart debugging.

For a complete list of shortcuts, see here: http://www.dofactory.com/ShortCutKeys/ShortCutKeys.aspx

I was refactoring the RSinteract source code to get rid of some duplicated classes that had over the course of a, shall we say, rigourous development schedule got disparate. Some classes were used from one set some from the other. I merged them into the common library and deleted all the old ones. This was fine until we ran an old report that had filters on it. Because the types had been serialized into the custom RDL of the report they had the old namespace stored there. Which threw an error when deserializing with the new hierarchy.

So what to do… I had a brainwave:

   1: using System;

   2: using System.Collections.Generic;

   3: using System.Text; 

   4:  

   5: namespace Ics.Reporting.Data

   6: {

   7:     [Serializable]

   8:     public class Dimension : Ics.Reporting.Common.Data.Dimension

   9:     {

  10:         //Proxy class to fix issues with old reports containing a reference to this class which has

  11:         //been moved to Ics.Reporting.Common.Data.Dimension

  12:     }

  13: } 

The empty proxy class in the old namespace that inherits from the new class. Leave a comment as to why. Et voila! No more broken old reports.

What’s your best hack imaginary readers?

Bad project top trumps. [Disclaimer: This is just a bit of fun, figures are completely arbitrary and bear no relation to real projects].

Instructions:

1. Print off this post 2 sets of these cards
2. Find a friend
3. Shuffle the cards
4. Deal the cards such that each player has the same number
5. Each player takes a card from the top of their deck
6. Each player reads out his or her Likelyhood of failure
7. The winner is the one with the highest of lowest (depending on the player’s disposition)
8. The winner takes the loser’s card and chooses the next statistic to compare on the next draw
9. The game is over when one player has taken all of the other’s cards

Cards:

So what am I doing about it. Well I have a plan. A learning plan and a structured one at that. I’ve still been reading blogs and keeping up with the newest tech as much as I can but I find this doesn’t really give me that much. The plan then, is:

1. Reduce intake of useless blog information
2. Stop procrastinating on music, cartoons, youtube
3. Make a spread sheet for each topic to learn
4. In each spreadsheet put between 1 and 10 things to learn about the topic ending in a specific goal
5. Complete at least 5 items per week.

learning spreadsheet

Simple plan, but is it going to work?

Last night I started writing a WordPress Theme for the first time, and I started getting excited again.

The first step was to mock it up and I discovered can still write a decent looking 3 column layout in pure CSS. The next step is to come up with a pretty design in Photoshop, something I’ve never done before!

Other topics I’m looking at are:

• Revisiting ASP.NET MVC
• Design
• F#
• WPF
• TDD
• PHP
• Some Misc topics that I’ve wanted to do such as writing a Ubiquity command
• Guitar
• French

There’s also a couple of side projects on the go at the moment which are helping to drive this.

Watch this space for a new theme with my name on it!

My favourites are:

2: Make hard-coded strings look ugly.

I learnt this from Joe Cooney.

Go to your favourite IDE, and set it so that literal strings stand right out — for example a yellow background with a red font. Make ‘em ugly. Damn ugly. This will encourage you to perform less hard coding, and to notice when you are embedding strings in your text.

3: Pick an ‘obscure’ keyword and master it

Do you fail to yield?. Is there a keyword you never use?

Every keyword has a purpose. Learn to master those mystery keywords and your powers will become extraordinary.

Here are lists for a few .net languages: C#, VB.net, F#.

4. Increase code-coverage by 1%

Don’t kill yourself striving for 100% coverage of code with automated unit tests. But take a few minutes to increase your coverage by 1%.

Most likely, that means going from 0% to 1%. And that’s the biggest improvement of all.

Find a particularly ghoulish regular expression. Or a critical piece of business logic. These things can’t be trusted without tests.

7. Pick an ugly method to refactor

You know the method. That method you’re particularly ashamed of. That one that’s long and ugly and horrible. And it’s crucial to the whole application.

You don’t have to polish it from a turd to a diamond, but just neaten it up a little. Rename a variable. Hoist part of it out into a separate method. Start simple. The momentum will increase. Watch out.

These are all great little things you can do in those little time pockets where you’d usually just randomly click on stuff until an email comes back or someone responds on IM. I’ve got one more to add.

Automate a process
You know that thing that takes a few minutes and you sometimes have to do twice because you miss a step? You know the ones I’m talking about! The little oddity in your build, or that annoying service/api project, editting a version number for the latest build and putting it back into source control. Well, honestly you could probably do it with a script that you could write in under 6 minutes. I just wrote one to build and install a service for debug:

   1: @ECHO OFF

   2: CALL "C:\Program Files\Microsoft Visual Studio 9.0\Common7\Tools\vsvars32.bat"

   3: msbuild "C:\Development\Solutions\Solution.sln"

   4: installutil /u "C:\Development\Solutions\Soution\bin\Debug\Soution.exe"

   5: installutil /username=IOC-DEV-UK5\Administrator /password=*** "C:\Development\Solutions\Soution\bin\Debug\Soution.exe"

Now I can get my service ready for debug in 1 click rather than openning the Visual Studio command prompt, typing in the folder structure, realising I’ve forgotten to do "Run as administrator" every bloody time!

You’ll be amazed how much time you save and the satisfaction you get from solving a little problem like this.

Finally, lots of new technology and challenges to overcome for me. One of these is dependency injection using an IoC container. I’ve worked on projects that have used it them and have understood the general principles but never have I had full control of it – it’s always been there already. This time I’m learning it properly myself. The technology that has been chosen is Microsoft’s Unity 1.2 which ships with the Enterprise Library 4.1 (Oct 2008 release). At first glance Unity appears overly complex because the documentation for it is – as Microsoft love to do – overly complicated and tries to show you everything on one page. For example:

   1: <?xml version="1.0" encoding="utf-8" ?> 

   2: configuration>

   3:  

   4: configSections>

   5:  <section name="unity"

   6:            type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,

   7:                 Microsoft.Practices.Unity.Configuration, Version=1.1.0.0,

   8:                 Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

   9: /configSections>

  10:  

  11: unity>

  12:  

  13:  <typeAliases>

  14:  

  15:    <!-- Lifetime manager types -->

  16:    <typeAlias alias="singleton"

  17:         type="Microsoft.Practices.Unity.ContainerControlledLifetimeManager,

  18:               Microsoft.Practices.Unity" />

  19:    <typeAlias alias="external"

  20:         type="Microsoft.Practices.Unity.ExternallyControlledLifetimeManager,

  21:               Microsoft.Practices.Unity" />

  22:  

  23:    <!-- User-defined type aliases -->

  24:    <typeAlias alias="IMyInterface"

  25:         type="MyApplication.MyTypes.MyInterface, MyApplication.MyTypes" />

  26:    <typeAlias alias="MyRealObject" 

  27:         type="MyApplication.MyTypes.MyRealObject, MyApplication.MyTypes" />

  28:    <typeAlias alias="IMyService"

  29:         type="MyApplication.MyTypes.MyService, MyApplication.MyTypes" />

  30:    <typeAlias alias="MyDataService"

  31:         type="MyApplication.MyTypes.MyDataService, MyApplication.MyTypes" />

  32:    <typeAlias alias="MyCustomLifetime" 

  33:         type="MyApplication.MyLifetimeManager, MyApplication.MyTypes" />

  34:  

  35:  </typeAliases>

  36:  

  37:  <containers>

  38:  

  39:    <container name="containerOne">

  40:  

  41:      <types>

  42:  

  43:        <!-- Type mapping with no lifetime – defaults to "transient" -->  

  44:        <type type="Custom.MyBaseClass" mapTo="Custom.MyConcreteClass" />

  45:  

  46:        <!-- Type mapping using aliases defined above -->  

  47:        <type type="IMyInterface" mapTo="MyRealObject" name="MyMapping" />

  48:  

  49:        <!-- Lifetime managers specified using the type aliases -->

  50:        <type type="Custom.MyBaseClass" mapTo="Custom.MyConcreteClass">

  51:          <lifetime type="singleton" /> 

  52:        </type>

  53:        <type type="IMyInterface" mapTo="MyRealObject" name="RealObject">

  54:          <lifetime type="external" />

  55:        </type>

  56:  

  57:        <!-- Lifetime manager specified using the full type name -->

  58:        <!-- Any initialization data specified for the lifetime manager -->

  59:        <!-- will be converted using the default type converter -->

  60:        <type type="Custom.MyBaseClass" mapTo="Custom.MyConcreteClass">

  61:          <lifetime value="sessionKey"

  62:                    type="MyApplication.MyTypes.MyLifetimeManager,

  63:                          MyApplication.MyTypes" />

  64:        </type>

  65:  

  66:        <!-- Lifetime manager initialization using a custom TypeConverter -->

  67:        <type type="IMyInterface" mapTo="MyRealObject" name="CustomSession">

  68:          <lifetime type="MyCustomLifetime" value="ReverseKey"

  69:                    typeConverter="MyApplication.MyTypes.MyTypeConverter,

  70:                                   MyApplication.MyTypes" />

  71:        </type>

  72:  

  73:        <!-- Object with injection parameters defined in configuration -->

  74:        <!-- Type mapping using aliases defined above -->  

  75:        <type type="IMyService" mapTo="MyDataService" name="DataService">

  76:          <typeConfig extensionType="Microsoft.Practices.Unity.Configuration.TypeInjectionElement,

  77:                                     Microsoft.Practices.Unity.Configuration">

  78:            <constructor>

  79:              <param name="connectionString" parameterType="string">

  80:                <value value="AdventureWorks"/>

  81:              </param>

  82:              <param name="logger" parameterType="ILogger">

  83:                <dependency />

  84:              </param>

  85:            </constructor> 

  86:            <property name="Logger" propertyType="ILogger" />

  87:            <method name="Initialize">

  88:              <param name="connectionString" parameterType="string">

  89:                <value value="contoso"/>

  90:              </param>

  91:              <param name="dataService" parameterType="IMyService">

  92:                <dependency />

  93:              </param>

  94:            </method>

  95:          </typeConfig>

  96:        </type>

  97:  

  98:      </types>

  99:  

 100:      <instances>

 101:        <add name="MyInstance1" type="System.String" value="Some value" />

 102:        <add name="MyInstance2" type="System.DateTime" value="2008-02-05T17:50:00"  />

 103:      </instances>

 104:  

 105:      <extensions>

 106:        <add type="MyApp.MyExtensions.SpecialOne" />

 107:      </extensions>

 108:  

 109:      <extensionConfig>

 110:        <add name="MyExtensionConfigHandler"

 111:             type="MyApp.MyExtensions.SpecialOne.ConfigHandler" />

 112:      </extensionConfig>

 113:  

 114:    </container>

 115:  

 116:    <!-- ... more containers here ... -->

 117:  

 118:  </containers>

 119:  

 120: </unity>

 121:  

 122: </configuration>

(Note this documentation is from 1.1)

Now I’m unit testing from the ground up. I don’t care about most of this stuff. I need the simplest implementation to start with. So all I really need in my config file is: the unity section declaration, a type alias and the container.  Like so:

   1: <?xml version="1.0" encoding="utf-8" ?>

   2: <configuration>

   3:   <configSections>

   4:     <section name="unity"

   5:                type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,

   6:                  Microsoft.Practices.Unity.Configuration, Version=1.2.0.0,

   7:                  Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

   8:   </configSections>

   9:   <unity>

  10:     <typeAliases>

  11:       <!--IService-->

  12:       <typeAlias alias="IService"

  13:                  type="Project.Services.Contract.IService,

  14:                  Project.Services" />

  15:       <typeAlias alias="MockService"

  16:                  type="Project.Mocks.FakeService,

  17:                  Project.Mocks" />

  18:     </typeAliases>

  19:     <containers>

  20:       <!--Service is Mocked-->

  21:       <container name="UnitTest">

  22:         <types>

  23:           <type type="IService" mapTo="MockService" />

  24:         </types>

  25:       </container>

  26:     </containers>

  27:    </unity>

  28: </configuration>

That’s it. (Obviously any types referenced here need their assemblies referenced in the unit test project). Why isn’t there a good tutorial that points this out? It seems like Microsoft tripping themselves over again. I’ve found this with other parts of the Enterprise Library too. Thank god for StackOverflow!

Now most people know about redirecting the output to a file like so:

   1: command -option arg > commandlog.txt

However, this is only handling STDOUT, most commands will put error information (which is what we’re most interested in) to the STDERR. So how do we get at that?

Well to log both do this:

   1: command -option arg > logfile.txt 2>&1

The final token there redirects STDERR to STDOUT, thus putting it all into logfile.txt.

You can also log to seperate files if you like.

   1: command -option arg 1> stdoutlog.txt 2> stderrlog.txt

That concludes today’s lesson. I hope you find this useful at some point!

Good times.