Code, coke and coins

I was recently musing over the use of ASP.NET’s viewstate, and had a quick truddle around the web to find something that explained the in and outs of it. I feel compelled to link to this article which I believe is one of the most throughout and better written articles I’ve seen in a long time.

With, what I believe is, an ever degrading quaility of Microsoft articles and help, we need more articles like this written by individuals who have used the technology.

I recently wrote about creating early bound COM objects in .NET, the object (no pun intended) of the exercise was to persuade Visual Studio 2005 to produce an early binable COM object without any ‘jiggery pokery’ after the standard build. The exercise proved successful, I could simply ‘build’ and start using my COM object from my unmanaged code.

However I did run into some issues, the first of which was caused by .NET not initialising it’s FPU control word when being called from unmanaged code. The issue occured because the unmanaged application I was calling my component from was written in Borland Delphi, which doesn’t suppress certain floating exceptions in the same was Microsoft does. If I’d had access to the Delphi source I could have recompiled turning off the exceptions, something like this.

Here is how to turn them off in C++Builder:
#include float.h
 
__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
  _control87(MCW_EM, MCW_EM);
}


Here is how to turn them off in Delphi:
const MCW_EM = DWord($133f);
  begin
    Set8087CW(MCW_EM);
  end;


Of course I’d have to produce a solution from my component, the easiest implementation I could find for this was to add something to my default constructor of my COMBase class. I started using code to explicitly set the control word, something along these lines…

[DllImport("msvcrt.dll", EntryPoint="_control87")]
public static extern UInt32 Control87(UInt32 Toggle, UInt32 Mask);
 
UInt32 OldControlWord = Control87(0, 0); // Get current value
 
Control87(0x9001f, 0xffffffff); // Set to .NET default
// Call Code Here
Control87(OldControlWord, 0xffffffff); // Restore to previous value


Although this works admirably, whilst I was working on it, a much simpler solution was offered to be from another developer, which I added to my COMBase class.

[ComVisible(false)]
    public class COMBase
    {
 
        public COMBase()
        {
            // Ensure FPU Control Word is set when called from unmanaged applications.
            try { Double.IsNaN(Double.NaN); }
            catch (ArithmeticException) { /* Intentionally empty. .NET will initialise the FPU at this point. */ }
        }
 
        /*  Snip */
    }


With this solved, the only remaining task was distribution of my COM component. For this I added a simple installer component to my code, which would be called from my setup project.

[ComVisible(false)]
    [RunInstaller(true)]
    public partial class CustomInstall : Installer
    {
        public CustomInstall()
        {
            InitializeComponent();
        }
 
        public override void Install(IDictionary stateSaver)
        {
            base.Install(stateSaver);
            RegistrationServices regSrv = new RegistrationServices();
            regSrv.RegisterAssembly(base.GetType().Assembly, AssemblyRegistrationFlags.SetCodeBase);
        }
 
        public override void Uninstall(IDictionary savedState)
        {
            base.Uninstall(savedState);
            RegistrationServices regSrv = new RegistrationServices();
            regSrv.UnregisterAssembly(base.GetType().Assembly);
        }
    }

With the project output added as ‘custom actions’ to my setup project, I could simply build my COM component, test it; then build an MSI for distribution which ensured calling of the registration functions, which in turn registered it for COM. It’s important to note that my components are not flagged for COM registration in the setup project, this is all catered for by the custom code in my installer class and COMBase class.

Ah databases, now I’m no DBA by any stretch of the imagination, but I’ve recently come across a new trend in database design which I’m pretty sure isn’t ideal.

When designing databases I’ve always taken the basic principle of using identity fields in each table and using foreign keys to ‘link’ the tables, a pretty standard affair I thought. I primarily work with SQL server, and as your average joe, I generally use an ‘int’ for my identity field. It’s never let me down and gives me a possible 2,147,483,647 (2^31 -1) indentities. The largest tables I tend to work with have about 8.5 million rows, so plenty of scope for expansion. I suppose if I were really worried I could use a bigint, which gives me a staggering 9,223,372,036,854,775,807 (2^63 – 1) possible indentities.

Back to that less than ideal design….. two databases I’ve recently worked with (both SQL server based and both ‘live’ commercial applications) have taken a different approach to indentities. In fact neither use a traditional identity field at all, both ‘maintain’ their own ids. Both shall remain nameless to protect the innocent.

The first uses a curious varchar(20) identifier, which is split into 2 parts, comma delimited no less. The first part is essentially the ‘customer identifier’ which is a number, the second part after the comma is a base36 alphanumeric. The arguments behind this are that, firstly it allows for easy merging of records from mulitiple ‘customers’ into the same table and secondly that base36 numbers are easy to read/recognise when large!!?! For example “1,BCV32J”, ah yes I know what that is, not!

The second database ‘indentifier’ design is possibly even more curious, each table has a composite key consisting of a bigint and a guid. There seems to be no logical rhyme nor reason to this, other than to make sure we have plenty of indentifiers. This we sure have, a guid has about 2^128 combinations and the bigint about 2^63, giving a possible total number of combinations of 2^191! Which is erm…. a lot. Put into perspective I could generate 1,000,000 identifiers per second and still not run out before the Sun expands and swallows planet Earth.

I suppose there is one plus side, at least they are using SQL server and not an Excel spreadsheet (where most ‘enterprise’ databases seem to get stored these days).

Many will ask why do such a daft thing as creating COM objects in .NET? Well the answer is fairly simple, at my current place of work we only have Microsoft Visual Studio 2005 and I needed to create a COM object for compatibility with an older application, which only understood early bound COM. The application is a ‘drag and drop’ business rules and workflow editor, COM can be used to provide additional custom functions otherwise not available.

I thought to myself, this can’t be that difficult, just follow the tickboxes…..

• Project Properties->Application->Assembly Information->Make Assembly COM Visible – Check
• Project Properties->Build->Register for COM Interop (automatically exports a typelibrary) – Check
• Project Properties->Signing-> Sign the assembly (make a new strong key name file) – Check

…. surely that’s enough? Wrong. The assembly was a late bound COM object only.

A few help topics and Googles later, I’m doing all sorts of tricks, adding and deleting things in the GAC and learning the wonders of regasm. However, none of it worked.

Back to basics, the type library defines the interfaces for early binding, so why couldn’t COM see the type library definitions? The answer turned out to be very simple, the C# complier didn’t add the required information into the registry during the build. Help was at hand however, in the form of the attributes [ComRegisterFunction] and [ComUnregisterFunction]. It should be noted that the C# build does add partial information to the registry, but not the required TypeLib key……


[ComVisible(false)]
public class COMBase
{
[ComRegisterFunction]
static void ComRegister(Type t)
{
  string keyName = @"CLSID\" + t.GUID.ToString("B");
  using (RegistryKey key =
     Registry.ClassesRoot.OpenSubKey(keyName, true))
  {
   using (RegistryKey subkey =
      key.CreateSubKey("TypeLib"))
   {
    Guid libid =
      Marshal.GetTypeLibGuidForAssembly(t.Assembly);
    subkey.SetValue("", libid.ToString("B"));
   }
   using (RegistryKey subkey =
        key.CreateSubKey("Version"))
   {
     Version ver = t.Assembly.GetName().Version;
     string version =
        string.Format("{0}.{1}", ver.Major, ver.Minor);
     subkey.SetValue("", version);
   }
  }
}
 
[ComUnregisterFunction]
static void ComUnregister(Type t)
{
  string keyName = @"CLSID\" + t.GUID.ToString("B");
  Registry.ClassesRoot.DeleteSubKeyTree(keyName);
}
}


Volia, derive all my ‘COM’ classes from ‘COMBase’ and I have a working early binable COM object. Should also mention, none of the GAC and regasm manual processing is needed either. Not particulary neat, I would certainly like to know if there’s a better way.

As an aside, during my time with COM in .NET I picked up a few pointers on ‘best practices’ the most useful of which is using defined interfaces, with fixed GUIDs to keep the resultant COM ‘backwards compatible’.

For example:-


[Guid("89B65A92-5CE6-4295-A6DF-9506530C7877")]
[InterfaceType(ComInterfaceType.InterfaceIsDual)]
public interface IFoo
{
int Bar();
}
 
[ProgId("MyCOMObject.Foo")]
[ClassInterface(ClassInterfaceType.None)]
public class Foo : COMBase, IFoo
{
public int Bar()
{
    return 42;
}
}


Should also be noted that explicitly specifiying the COM ‘ProgID’ makes it easier to manage also (and elminates the need to shorten namespaces and class names for COM). Specifiying ‘ClassInterfaceType.None’ for the class effectively hides it from COM, leaving only the parts you want to explicitly expose in the interface.

So the Intel QX6700 is upon us, for those not in the know, it’s not really a true ‘quad’ core processor, but a dual-dual processor. Two separate pieces of silicon (each containing an E6700 Dual core CPU) on a single physical package. But for all intensive purposes it is four physical CPUs in one drop-in LGA775 package.

The QX6700 marks the way forward to more mainstream ‘Quad’ CPUs in Q1-Q2 2007 and true Quad CPUs (one silicon slice, shared cache etc) in Q3-Q4 2007 from both Intel and AMD. If we believe everything we read we can expect up to 32 cores per processor in only a few years, which brings me to my problem…….

The software market is far from ready for multiple core CPUs on the desktop.

The crux of the problem is that the vast majority of applications are not designed to work with multiple cores. Additionally the programmers who write software are also not ‘designed to work with multiple cores’. Writing an application to use multiple CPU cores is no easy task, and based on personal experience I’d not be suprised if the vast majority of programmers today will never be able to write such an application.

There are some applications today that can take good advantage of multiple cores but these are, in the main, high-end graphics packages or specialist server software. Other applications tend to be written for a single core, with only occassional use of a second core and no more.

The popularity of dual-core is however justified, simply because it effectively allows the application you are working on to have a core to itself, whilst all those other things, such as virus-checkers can trundle along on the other core. But this doesn’t scale, you certainly don’t need a ‘whole core’ for each application, for the vast majority of people, dual-core is more than enough.

So what’s the answer? That’s the worrying thing, there is no easy answer, if there is a shortage of people capable of writing applications for multiple cores, it will be a very slow road for software….. whilst hardware races ahead.

So by all means enjoy the artificial benchmarking scores a new quad-core processor will bring you, but unless you use scare and specialised software regularly the benefits of quad and beyond will be minimal.

Like many I’m sure, I run my PC for long periods of time, on many occassions it runs 24/7 for particulary long downloads or FTP server access when I’m away. All this time the CPU is buzzing away, doing nothing for the large part, except comsuming power and generating heat.

One thing I was suprised with after my recent PC purchase, was that SpeedStep wasn’t enabled by default. SpeedStep is a technology by Intel that enables their CPUs to run at slower speeds when they aren’t so busy, laptop users may well be familiar with the technology as it’s fairly essential for long battery life. However this doesn’t seem to apply to desktop PCs, or at least it doesn’t in their default configurations as supplied by manufacturers. It should be noted that AMD support a similar technology “cool and quiet” for their CPUs.

The nice thing about SpeedStep is that the CPU changing speeds is transparent, when the power is needed i.e. by a game or other intensive processing task – the CPU automatically ramps up to a higher speed. There is no detectable performance hit whatsoever.

After a little research I found that the following Intel CPUs support SpeedStep,

• Pentium 4 (3Ghz +)
• All Pentium D
• All Core

You can verify your processor supports SpeedStep using the Intel Processor Spec Finder, which allows you to find your CPU and then ‘filter’ on SpeedStep technology.

There are other parts to the equation too, namely your motherboard must also support SpeedStep, as well as your Operating System. Those that are happy to look in their PCs BIOS settings should hunt around for “EIST” or “SpeedStep” (EIST = Enhanced Intel SpeedStep) and make sure it’s enabled. Even if you aren’t happy to delve into your BIOS you can try altering your Windows settings anyway, it may well be it’s already enabled elsewhere.

To enable SpeedStep in your OS, you simply need to change your “Power Scheme” in Control Panel – Power Options. Intel themselves explain this best and have some screenshots to show how you can verify SpeedStep is enabled, available here.

For my Intel Core 2 E6700 CPU, the speed changes from the default 2667Mhz down to 1600Mhz at the slowest speed and also 2133Mhz inbetween, depending on how much power is required. It’s completely unnoticeable in day to day use, but I’m happy in the knowledge my PC is comsuming less power and producing less heat.

I recently built a new PC and was trying to decide which anti-virus software to use on it. I’d not had this decision to make for many, many years…. since 1990, when Norton Anti-Virus was introduced.

I’ve stuck with Norton Anti-virus all that time, happily paying my subscription annually in the knowledge that I was protected from viruses. However since the 2003 release and possibly earlier I’ve noticed a sharp increase in the amount of resources and time Norton spends thrashing around on my harddrives. I believe I’m not alone, many people have complained about this, however Symantec continue to ‘bloat’ Anti-Virus with each subsequent release. Norton Anti-Virus 2006 was and probably will remain the last release of the product that I purchase.

Certainly I didn’t want to load Norton on my shiney new PC, I needed an alternative anti-virus solution. Something that harked back to the super fast and effective early releases of the Norton product.

I believe that product is NOD32 from Esnet.

NOD32 is largely written in assembly code, which shows in it’s performance. It’s throughput of files when scanning and minimal system impact has to be seen to be believed. In these early days I can’t judge it’s detection rate (I rarely encounter viruses anyway due to being very wary and diligent), however it has the lowest failure rate in tests performed by Virus Bulletin, which can’t be a bad thing. That said it did find 1 trojan on my archived data disk that Norton had never found.

It does have it’s downside, user-friendliness isn’t all it could be. Components of the product have strange 4 letter acronyms e.g. AMON, DMON, IMON, EMON (a side-effect of being an assembly language programmer I suspect!) and setup options are plentiful, maybe too plentiful? However, given a little patience and thought, it does all make sense and should be possible for most ‘computer literate’ people to setup and configure without too much pain.

After initial setup and configuration, it just works, it really is barely noticeable – especially if go for the rather good “silent mode” option. Silent mode only disturbs you if it has a reason to, no more daft “I’m great because I’ve just managed to update myself” style popups.

My trial period (one month) is about to expire, they will certainly be getting my £46 for a 1 PC, 3 year licence, worth every penny. It’s also worth noting they have student and non-profit organisation rates too.

Back in March I wrote about SFF PC’s, I’ve had my mind set on getting one for sometime. It’s taken this long for me to purchase one, as I’ve never been completely at ease with the specifications available, there always seemed to be a compromise.

Then, while trawling the net, I stumbled across Shuttle’s plans to release the SD37P2.

I suppose the compromise, if any, is it’s size. It’s not as small as some modern designs, however it is substantially smaller than my pair of Coolermaster ATC-201’s that it is replacing.

The real attraction with the SD37P2 is the Intel 975X chipset, which can take anything from a Celeron to a top end X8600 “Conroe” Core 2 Duo. This had a huge bearing on my choice, as when I upgrade, I tend to look for a substantial performance increase, otherwise what is the point?

My primary use of this machine is software development, followed by “office” type tasks and finally some gaming. Being the least important factor, gaming didn’t steer me into the scary world of ultra-high end graphics cards, however reasonable performance and a modern GPU was required.

The first decision however, was the CPU, I really had to have a new Intel “Conroe”, by all accounts the fastest CPU available by some margin and at a reasonable price. A fast CPU makes a world of difference in software development, especially with larger projects. The sensible man would have bought the E6600 flavour of Conroe, I however got the E6700 at a substantial premium. At least I didn’t go mad and get the X6800, which only really has an attraction for the ‘overclocker’, something I don’t intend to be doing.

Once the CPU decision was made, the choice of memory was an easy one. The SD37P2 supports only 533Mhz and 667Mhz variants of DDR2 RAM, unlike some of the Intel motherboards that also support 800Mhz. However, unless overclocking 533Mhz DDR2 is the obvious choice as it runs 1:1 with the CPU (CPU FSB is quad 266Mhz = 1066Mhz, DDR2 in dual configuration is 2 x 533Mhz = 1066Mhz). Even though Intel have addressed latency to some extent with pre-fetching, I choose to purchase some decent low latency RAM manufactured by OCZ. I’ve used OCZ RAM before, quite simply put, it’s faultless and fast.

The decision on graphics card took more time, I was determined to purchase the fastest possible passive card. One of the aims of this build was for the PC to be as quiet as possible, without resorting to specialist components and soundproofing. A card that caught my eye early on was the nVidia 7600GS, primarily because it’s latest generation and designed to be passive in it’s reference design. I had a nagging doubt that it might just not be fast enough to play some of the latest titles at decent settings. It is so difficult to determine from review benchmarks, many only compare to synthetic tests, which are meaningless. Other benchmarks enable daft levels of detail, thereby making cards look slower than they actually are.

I took a gamble and plumped for a XFX 7600GS, the ‘pre-overclocked’ XFX 7600GS Extreme missing out by a very small margin – I figured heat might pose a problem in such a small case. Elder Scrolls IV – Oblivion (with patch 1.1) selects “High” by default, only one notch down from the top “Ultra High” presets available – a result if ever I saw one; Oblivion has to be about the most intensive graphical games available currently, it looks fantastic and plays very smoothly.

Other choices of components were two Samsung 320GB SATA hard drives (chosen for quietness) that run in RAID 0 configuration for speed. And and LG DVD/CD -R/+R/RAM writer for optical disc duties.

The full rundown was as follows:-

• Shuttle SD37P2
• Intel “Conroe” Core 2 Duo E6700
• 2GB (2×1GB) OCZ DDR2 PC2-4200 Gold GX XTC
• 2 x Samsung 320GB SATA Hard drives
• XFX GeForce 7600GS 256MB DDR2 DUAL DVI TV
• LG GSA-H10NBAL 16x DVDRW/RAM Black Dual Layer/12x RAM/DVDRW

The whole thing was built in under an hour, OS installation (Windows XP MCE), application installation and restoration/transfer of existing data took another 4 or 5 evenings! The end result was certainly worth the expense and effort, it is lightyears ahead of my old Intel “Northwood” Pentium 4 2.53Ghz based machine.

I’ll not be posting benchmarks I think they are misleading, but Oblivion running in “High” mode and Visual Studio 2005 starting being ready to compile projects in under 3 seconds should give a rough idea. All this and very quiet with it, yes there is a “hum” from the CPU and HDD case fans, but it’s minimal.

Over the past few weeks, for the first time ever, my ADSL connection at home started to play up. Nothing major, the modem would loose synchronisation momentarily (1 or 2 seconds) every few hours and then resync – Windows remained perfectly oblivious to this activity and carried on as if nothing had occured.

Past experience with my connection had been faultless; at one point I was connected for around 4 months straight with no glitches, only disconnecting when I needed to ‘bounce’ my gateway PC for updates. This is also testament to the connection provided by my ISP, PlusNet who for all their faults provide rock solid connections for most of their customers (current trial MaxDSL issues aside!).

The answer to the ADSL issue I was experiencing came about almost by chance, the battery in my mobile phone drained after a particulary long working day. Due to this I was forced to use a landline, after finding my telephone I was dismayed to find no dialtone. I probably should say at this point that I’m part of a growing number of people with no need for a landline for day-to-day use, it is there for ADSL only.

After breathing some life back into my mobile, one of my first calls was to BT faults. I could have used the BT website to report the fault, oddly something tells me to use a phone to report a phone fault! As it happens the service is completely automated with various options such as SMS text updates etc.

Roll on Saturday morning, I get a phone call from a BT engineer who is on his way to investigate the problem with the line. Within 10 minutes of his arrival he’s identified the problem as being 15 metres down the line, which just so happens to coincide with the junction box on the wall. Outside and up the ladder he goes, almost instantly proclaiming “think I’ve found the problem!”, pointing feverishly at a single wire that is completely disconnected from the rest and sticking out at right-angles from the wall.

Reconnection of my second wire solved the ‘dialtone’ problem, a fully working phone line again, and resolved my ADSL ‘hiccups’. I queried the BT engineer as to how the ADSL continued to work at full capacity for the most part with so few problems…..

“Even we don’t understand how it works, it’s magic”

My last 2 jobs have involved a large amount of Visual Basic 6 development (amongst T_SQL, C and various script languages), but have been very different in terms of design and implementation of code.

Prior to my current role, the VB6 code was about as cutting-edge as you can get with an 8 year old development environment. Extensive use was made of collections, classes and COM to build a robust central object library that was a breeze to use.

By comparision, the product I’m working with currently has ‘history’, and a lot of it. The only time a class is used is to provide a public interface to an ActiveX control. By and large the majority of the ‘framework’ is implemented in shared modules.

Neither way is the ‘right’ way, both are valid in VB6, one being an object oriented approach and the other very much ‘procedural’. That said it is difficult moving back to procedural programming after writing so much object oriented code.

It’s the procedural code, having been around as long as VB6 itself, that threw up a few surprises for me. Along with the fact that several contributers had their roots in VB to the early versions. That said I don’t remember using some of these features, even way back in VB3…..

Multiple executions on one line of code
foo=1:bar=1

GoSubs!
Private Sub Foo()
    GoSub Bar
Exit Sub
Bar:
    MsgBox "Hello world!"
Return
End Sub

Option Compare*
Option Compare Text

…and an interesting technique to detect a VB program was running interpreted…..

Debug.Print 1/0

…I’d always for some reason used Debug.Assert to call a function and set a value. I’m sure both techniques have their pros and cons.

* Not strictly ‘forgotten’, just never used, the default binary has always suited.