Rinat Abdullin

Google is entering the browser battlefield

Speaking of the browsers. This news story is making the day around the world: Google is releasing new browser called Google Chrome.

Highlights are:

• Streamlined UI
• Isolated tabs (using a process per tab…)
• New Javascript engine
• Extensibility
• Orientation towards the web applications

Users generally tend to win in browser wars. Developers, at the same time, tend to loose.

I’m definitely glad I’m out of the pure web development.

This error has just made my day

This is the error that I get in Firefox 3.0.1 (Windows XP) while trying to navigate page on the Microsoft site about Office servers

Internet Explorer does not say a word on the same machine.

Blog upgraded

Ok, now this web log should be a little bit faster (upgraded the engine, dropped K2) and more accessible (RSS feeds display full posts with basic formatting).

Please, feel free to drop a line about any issues you might encounter.

Commit Monitor for Subversion

Last night I’ve got really nice tool into my autorun - Commit Monitor.

It is small, simple and completely replaces SVN notification emails.

Inversion of Control happens to…

Title of the latest post by Jeffrey Palermo (Inversion of Control is NOT about testability) has got into really nice loose coupling with the .NET development I’ve been doing these days. This inspired me to compose this small list of some positive side effects of the Inversion of Control:

• Inversion of Control (just like Test Driven Development) happens to enforce good logical organization of the code (some call it Separation of Concerns, but this SoC term is more specific). IoC does not guarantee that your code will have the optimal distribution of the folding lines, extensibility and flexibility joints, but at least it will be better than the code without IoC (in 80% of the cases).
• IoC happens to improve functional testability of the code, by allowing to swap in wrapper and logger objects to examine interactions between the components (obviously, these unit test coverage points become more meaningful as well).
• IoC happens to increase code reusability – properly coded component becomes a syntax element of its own. After that it could be used in multiple scenarios or sub-solutions to save development and maintenance time.
• It is a pure coincidence, that the mind of the developer happens to change as well – it starts seeking implementation paths that create such component reusability.
• Proper IoC obviously increases the configurability of the code (xml/DSL configs, interceptors, Aspect Oriented Programming - all these can play really well with the IoC environment); more than that – it becomes possible to implement some business functionality simply by changing the component properties and interactions, rather than resorting to write the code.

PS: It does not matter that much, what IoC Container to pick for your .NET project (Autofac, Castle MicroKernel / Windsor, ObjectBuilder, StructureMap, Unity or something else), when you are starting to IoC. But as soon as you get the gut feeling that you are constrained by the IoC tool, I encourage you to explore the other implementations.

I’ve been working with all the containers mentioned above and, at the present, Autofac is the best one for me.

Tags: autofac, Castle, IoC

VS 2008 SP1 and some other upgrades

Today has been the day of some upgrades.

Upgrade 1: development environment has been updated with Visual Studio 2008 SP1 and ReSharper # build 4.0.919.10. Both have been running smoothly on Windows Server 2008 64 bit for me so far.

However, there are some notes:

• This VS 2008 SP1 brings along updates to the .NET framework 3.5 that have been known to break the existing code.
• After installing the update I’ve noticed that Mozilla Firefox 3.0 has got “Microsoft .NET Assistant” add-in. Although this is nice (and is supposed to deal with the ClickOnce+Firefox compatibility issues) the intrusive approach itself has felt a little bit uncomfortable.
  
• Updates like this affect comment headers in auto-generated files (i.e.: ASPX designer files). So expect some meaningless changes to be going into your version control repository (unless you check every single file before commits). This usually tends to get even more exciting in distributed projects without enforced development environment policies.

Upgrade 2: personal development server has finally been upgraded to 4Gb of RAM (2 pieces of 2GB@800 in paired mode). Hyper-V just needs some memory.

NB: Running Memory Test (you can find this one in the boot loader menu of Windows Server 2008) is always a good idea, since sometimes RAMs could be corrupt and will need to be exchanged.

Upgrade 3: I’ve upgraded firmware on the home wireless router and have got small performance boost.

NB: for some strange reason number of defects related to the firmware upgrades is significantly smaller than when software upgrades take place. It looks like software development still has a long way to go from art to engineering (while hardware-related development is already there).

Development server meets virtualization

Never host any services critical for the customer on your development server “just till he gets the new server”. You would not be able to easily move them off your back, even when you leave the project.

Finally, today I’ll be able to stop my dev server, upgrade it to Windows Server 2008 64 bit with Hyper-V and get going. This means:

• Ability to set up CruiseControl.NET 1.4 on a separate virtual machine, clean up existing integration projects and finally add the continuous integration support for the Autofac Contrib (Nick, sorry for the delay).
  BTW, running integration server for any open source project inside virtual machine is important, since the build process itself is a huge security vulnerability. Although this approach does not eliminate it completely, it does reduce the threat (and the potential damage) quite a bit.
• Ability to set up separate virtual environments to test the infrastructure of the current development project, run deployment and integration scenarios on this local sandbox etc.
• Ease and flexibility of deploying, saving, copying and migrating different deployment and development scenarios (think of the logical encapsulation of some development or production subsystem at the OS image level)
• Ability to leverage continuous integration, testing and auto-deployment under different OSes and software configurations (not that I expect to need this ability in the next 6 months)
• Valuable experience of structuring and managing development workflows in the environment where VM is a cheap resource that could be created, deployed and deleted within a single integration build (we are not there yet, but that’s where the technology goes).

All-in-all, virtualization is going to be a big hit next years. Especially, with the Hyper-V by Microsoft (kernel-level virtualization technology built into Windows Server 2008) that comes at the cost of peanuts (VMWare has got some decent competition in their market niche). Just check out this great podcast for the details and some inspiration.

PS: I wonder, when .NET will finally get this construct (captures all details of the exception in VMI with the debugger attached):

catch (Exception ex)
{
	get new VirtualMachineImage(ex);
}

PPS: VMWare has just made their move on the market by rolling out free hypervisor.

Tags: thoughts, virtualization