Find out how to break for a first chance exception here.

I had to solve 2 issues here.  First is the concept of referencing the assembly and then the concept of resolving it.  I had  couple of options for referencing.  I could refer the “log4net” assembly statically or dynamically.  I wanted to refer both the compact framework version and the full framework version of “log4net” statically.  The problem of referencing assemblies statically in Visual studio became evident once I finished adding reference to the first “log4net” assembly and started adding the second one.

It seems that Visual Studio does not allow you add reference of an assembly if the same named assembly is already added as a reference in the project.  This is probably because if you choose to copy both the references to the build folder one will be overwritten by the other.  At least Visual Studio should say so right but it doesn’t.  The work around is to either rename your assembly and add it as a reference or to go into the project file and directly add a <reference> element in it.  Of course if you choose to use the latter method you need to ensure that you don’t copy both the assemblies to same folder.

I choose the first method of renaming my “log4net” assembly and adding it as a reference to the project.  Now you would have 2 “log4net” assemblies in the reference.   If you edit the project file and add a <reference> element in the file you would be able to add a reference of the second assembly without having to rename it.  But whey you open your project file (or reload it) in Visual Studio you would see an yellow exclamation mark near your second reference.  This indicates some sort of error condition but your project will compile fine with warnings.

You need to now go back and do a couple of things before you start using these referenced assemblies.  Firstly you need to give an alias for both or one of the assemblies.  You need to do this because both assemblies have the same namespace and classes inside them.  You can give an alias to an assembly by choosing the assembly under the reference section of the project in Visual studio’s solution explorer.  Choose the assembly and go to its properties.  You would see an alias column in the assembly properties.  The default alias is “global”.  Change it to what ever you want to.  In my case I changed the alias of the full framework “log4net” to “FullFramework“.

I did not change the alias for the compact framework version of “log4net“.  Then when I wanted to use this full framework assembly I added the following lines to my code.

extern alias FullFramework; //This line goes at the top of the file ... FullFramework::log4net.Config.XmlConfigurator.Configure();  //This is call to the method from this assembly

So far you have done the first part of the process (i.e.) referencing the assembly.  The next part is resolving the assembly reference.  This is to say that you have to ensure that CLR finds and loads the assemblies correctly.  You can do this very easily by adding both the assemblies into GAC.  It wasn’t as good choice for me because the compact framework version of the “log4net” assembly is compiled out of a source that could change over a period of time and I didn’t want to put it in GAC.  To help CLR find the assembly you need to use either the “probingpath” or the “codebase” element in you app.config.  Here is the code again that got added to my app.config file.

<runtime>
 <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
 <dependentAssembly>
 <assemblyIdentity name="log4net" publicKeyToken="a1eec2f7749ea038" />
 <codeBase version="1.2.10.0" href="References/Compact Framework/log4net_for_compact.dll"/>
 </dependentAssembly>
 <dependentAssembly>
 <assemblyIdentity name="log4net" publicKeyToken="1b44e1d426115821" />
 <codeBase version="1.2.10.0" href="References/Full Framework/log4net.dll"/>
 </dependentAssembly>
 </assemblyBinding>
 </runtime>

Let me explain what the app.config contains.  The assemblyIdentify tag identifies the 2 assemblies along with their full name.  Then the codebase tag tells the relative (it could be absolute also) of the assemblies.  The base path is assumed to be the path where you can find the executable (it could be <app>\bin\debug for example).  And that’s all that needs to be done to do the side by side execution of the 2 assemblies (“log4net ” in this example).

sn – Tp <assembly>

Where <assembly> is the name of the assembly for which you want to find out public key.

I was recently looking at Microsoft Research site where I stumbled upon the “Project Tuva”.  I was impressed about the project though the concept was quite simple.  What impressed me more was the content featured in “Project Tuva”.

Tuva is a web video player with options to show related data at related intervals of playing the video.  It has also options to bookmark the video and divide it into chapters. And then there is an option to add notes to the video, search the video, expert comments etc.  That’s good right alright.  But what impressed me was not the application but the featured video of “Dr.Richard Feynman”.

Dr.Richard Feynman was a professor of physics.  He delivered a series of lectures at Cornell university in US in 1964.  These lectures were called the “Messenger Series” and were about the fundamental laws of physics.  Dr.Feynman is an exemplary teacher and that  is seen in these lectures.  His way of putting things of physics is simply amazing.  Bill Gates was really impressed by these lectures and procured the right for these videos and published them here in project Tuva. When I watched one of these videos  I was able to clearly understand some very basic physical laws and believe me it was fun.  There are totally 7 of these lectures from Dr.Feynman in project Tuva.  You can check out the application “Tuva” and the lectures from the following URL: http://research.microsoft.com/apps/tools/tuva/

Now let’s move on to the concept of ‘Multi-targeting”.  Have you ever worked on a XNA project?  If not then let me tell what it is.  XNA is a managed DirectX framework  for creating games in a PC/Xbox/Zune.  When you create a new project in XNA you have the option of targeting your game for different platforms (i.e.) you can create a game for the PC or Xbox or even a Zune player.  Let’s assume that you want to create a game targeted at both a PC and an Xbox.  The Game Studio for XNA which the IDE for XNA would let you do that in a flick.  But when you are done creating the project you would see two projects in the solutions.  One for the PC and the other is for Xbox.  Now when you start coding the different pieces of your game you would not have to do it twice as you normally assume (as there are two projects in the solution) but once.  This means the game studio will reproduce the code in both the projects.  I’m not sure of the details but I guess you get the idea.  This is multi-targeting.   It’s all about writing one code that targets multiple platforms.

Multi-targeting in the above example is achieved through linking the two projects in the game (i.e.) the one for PC and the other for Xbox.  There is project linker functionality inside the XNA Game Studio.  But what if you want to link projects in case your development environment is not XNA Game Studio. You hand code it.  Nope there is a better alternative, the Project Linker tool. The project linker tool was created by the Microsoft Patterns and Practices Composite Application team.  You can find tool in link to download the Composite Application Block. Download the tool found in the installer “MicrosoftPracticesProjectLinkerFeb2009.msi” from: http://www.microsoft.com/downloads/details.aspx?FamilyID=fa07e1ce-ca3f-4b9b-a21b-e3fa10d013dd&DisplayLang=en. You can find more information about the tool here: http://msdn.microsoft.com/en-us/library/dd458870.aspx

comment to explain why you’re doing something, not what

I totally agree with him.  Why do I agree? It’s  because when you write a self-documenting code the code lends itself to prove how it works.  When there is no comment it leaves the reader with a question as to why the code is written the way it is.  Ok!!! Let me try to give you some practical uses of a comment.

• Comments help the programmer to understand code better by explaining the purpose of a piece of code
• Comments make it easy to modify code because they make the programmer understand what is written
• Comments makes it easy to maintain the code
• Comments make it easy to review code so that the reviewer can suggest a better alternative or point out a bug in code

Are there any another uses of comments.  Well yes I have some more that I have come across in my programming experience.

• Comments can help you identify areas that require refactoring
• Comments can help you identify areas where you’ve put a work around or a temporary solution
• Comments can help you identify things that you have to do in future

I guess it may be easier for people to recognize the former set of uses of a comment that I quoted above but I don’t know if people would be able to understand the latter set of uses.  Well let me try to explain.  You can insert comments in code wherever you think you would need refactoring (may be at a later point of time).  These are areas of concern for a you as you think those pieces of code might work for now but may cause problems in future.  Comments of this type can be called as  “fix me” comments.

Many a times a you are forced to put in a work around because of limitations of the environment in which the programs work.  What do you do when you find the environment has been updated to fix the issue that it posed earlier?  You need to go back and remove your work around probably.  How do you know where your work around and what is that you did as a work around.  Comments come in handy there.  Comment of this type can be called as “work around/hack” comments.

There is no perfect software out there, every software is a good enough software.  I know people who know the software industry would agree with me.  So what do you do when you want to implement something in your software and it’s not necessarily an essential part of it to make it work right. You would have add things “to do” comments.

By the way if you ask me is there any funny comment that I’ve encountered during my career.  Yes indeed.  The funniest of them all is about a class called “LongPoll” that implemented a polling mechanism in the application.  It goes like this:

class LongPoll //often used in tent
{...}


A major version number indicates a major change in the software over its previous version.  A minor version number indicates a minor change over its previous version.  A build number indicates the version of the build that was released to QA or customer etc.  A build number in the above example ‘710’ indicates the minor features that were added in the version ‘2’ has been built over ‘710’ iterations of build. This number tends to be big in organization which employ Continuous Integration.  Finally the revision number 14 indicates the build was probably bug fixed ‘14’ times.  It could mean that “10.2.710.1” was probably released to QA and the build was thrown back and forth between QA and development ‘14’ times and hence we got a public release version of “10.2.710.14”.  All these statements above are indicate of what these version numbers could mean and vary from company to company.

Some companies follow the alpha, beta, release candidate, release to manufacturing schemes for versioning software.  For example Microsoft does use this method.

Versioning is an import aspect of software as we all know.  It is equally important to display the version of the software in the binary. Versioning source code helps reconstructing the binaries easily.  Versioning source code can be done mostly with labels found in most source control systems.  Displaying the version information in the binary helps the testers/customers identify bugs against the specific version of software.  You can find more about software versioning at: Software versioning on Wikipedia.

VS Ramachandran on your mind

David Kelley on human-centered design

Yves Behar on designing objects that tell stories

David Merrill demos Siftables

Evelyn Glennie shows how to listen

I’ll keep updating this post as I find more inspiring stuff.