Podcasts are a great way to get exposed to these new things: if you commute, jog, travel, you can easily use that time away from the computer to get better informed and reflect about our field.

I have a 20 minute walk between home and my office. That’s more than 3h of free time per week that I can spend thinking, listening to music or getting entertained and educated through relevant podcasts.

These are my preferred shows so far:

Hanselminutes
A 30 minute or so podcast about technologies, usually closely or distantly related to Microsoft development. Scott is an excellent interviewer and his blog is a must read too.

Herding Code
A 60 minute show with a bunch of well-known developers, K. Scott Allen, Kevin Dente, Scott Koon (Lazycoder), and Jon Galloway discussing wide-ranging topics with their guests.

.Net Rocks
The unavoidable 60 minute grand-father or all .Net podcasts. Funny and always informative. Also check out the related DnrTV for on-topic screencasts, excellent for getting started on a new technology.

The Polymorphic podcast
A nice podcast, the host, Craig Shoemaker, is a great inteviewer. Only drawback is that shows are not regularly produced.

The StackExchange podcast
Sometimes random, mildly irritating at times (guests sound quality, audio sync between guest, ramblings about Stackoverflow’s principles) but usually both enlightenning and funny. Topics revolve around Stackoverflow and the various StackExchange sites. It’s always worth listenting to Joel Spolsky, he tends to see clearly in an industry that often borders on the BS.

This Developer’s Life
Last but not least, a beautifully produced podcast that covers more philosophical topics through interviews and real-life experiences. It’s not about technology, it’s about the human aspect of being a coder, and what it means to be one.

Whichever you choose, any of these podcasts are bound to expand your knowledge, educate and entertain you!

After upgrading my development machine (Win7 x64) and a few clients (Windows 2008R2 x64) to SP1 (x86), I started to get strange issues:

• I use .Net libraries from my Access application and suddenly, even when not instantiating any .Net objects, Access would crash, usually on startup, but sometimes when opening the VBE.
  Decompiling and re-compacting the database would be OK, usually once, but the problem would reappear the next time I would restart the application.
  
• In the Runtime, I would get strange errors, such as The setting your entered isn’t valid for this property, or Action Failed Error Number: 2950, or Runtime Error 3270 Property not found.
  The strange thing about these errors is that they would occur in places that had not been modified for many releases of our application, parts that have been running without problem until now.
  
• Another weird issue was the systematic reset of our custom ribbon to its first tab. this could happen randomly, but most it could also be reproduced by simply opening a report as a tab page (that fill-in the whole MDI window). When closing that form, the first tab of the ribbon would select itself automatically. This wasn’t happening when closing pop-up windows.

After removing the Office and Runtime Service Pack 1, everything went back to normal.

A fix, finally!

A good 6 months after SP1 was released, Microsoft finally issued hotfix for the issue!
So, read about it on the MS Forums and get your KB2596585 hotfix, then decompile your database to clean it out.

The problem is that testing for “blankness” can mean many different things to different types:

• For an Object type, the variable can be Nothing.
• For a String type, the string can have no content at all: "", vbNullString.
• For a Variant type, the string can have any of the following attributes or values:
  • it can be Missing if the variable is an unused optional parameter,
  • it can be Empty if it was never assigned,
  • it can be Null if, for instance it’s bound to a nullable field or unbound with no value,
  • it can be an empty string "", vbNullString.

When having to check these variables in code, it can be tiresome to have to go through testing some of these possibilities just to find out that your variable does or not not contains something useful, regardless of the type of variable you are using.

To avoid having to do all these tests, make the code a bit more tidy and allow me to move on to more important things, I use this small utility function quite often:

'----------------------------------------------------------------------------- ' True if the argument is Nothing, Null, Empty, Missing or an empty string . '----------------------------------------------------------------------------- Public Function IsBlank(arg As Variant) As Boolean Select Case VarType(arg) Case vbEmpty IsBlank = True Case vbNull IsBlank = True Case vbString IsBlank = (arg = vbNullString) Case vbObject IsBlank = (arg Is Nothing) Case Else IsBlank = IsMissing(arg) End Select End Function

So now I don’t have to worry so much about the type of the variable I’m testing when I want to know if it contains useful data: ... ' Here assume that CustomerReference is a control on a form. ' By using IsBlank() we avoid having to test both for Null and empty string. If IsBlank(CustomerReference) Then MsgBox "Customer Reference cannot be left blank." End If ...

Obviously, IsBlank() doesn’t replace the other tests but I found it to be more straightforward to use in most cases.

Run-time Error '3155' ODBC--insert on a linked table  failed

It was driving me mad.
I could insert a simple record using SQL Server Management Studio, I could add new records to the table in datasheet mode within Access, but as soon as I tried to insert a record from code, whether using DAO recordset or executing the same SQL INSERT, it would miserably fail.

After a fair bit of investigation and tests, of which you can read the full account on the question I asked on StackOverflow, it turns out that this is a long-standing bug in the ODBC Driver (or Access).

Memo fields in Access are usually translated into nvarchar(MAX) in SQL Server by tools like SSMA.
Unfortunately, when you link tables having these fields using the SQL Server Client driver, these fields get incorrectly interpreted as string, even though they appear ok from the table design view.
It’s only if you try to insert something into the field, either text larger than 255 chars or NULL, that you get the error message.

So, the solution, at least in this case, is to revert to the older SQL Server ODBC driver instead, or use varchar() instead of nvarchar(), but if you’re dealing with Unicode, you have to stick with nvarchar().

References

• My question Inserting NULL in an nvarchar fails in MSAccess on StackOverflow.
• A reference I found on this issue: Ms Access linking table with nvarchar(max).

My problem is that currently, the Access application uses autoincrement numbers as surrogate Primary Keys (PK). Since I will need to synchronise the data over multiple remote sites, including occasionally disconnected clients, I can’t use the current autoincrement PK and will need to change to GUID.

To see for myself what could be the impact, I made a series of benchmarks.
This first part is fairly simple:

• Populate a Product table that contains 3 fields: ID, SKU and Designation with 1,000,000 records.
• Test natively on SQL Server and Access 2007.
• The records are inserted in transactions batches of 1000 records.
• I collect the time taken for each of these transactions and plot it.

Test setup

Nothing much to say about that:

All tests are performed on a dedicated Windows Server 2008 x64 rack running Access 2007 and SQL Server 2008 Standard (SP1) x64.

Test database

In SQL Server, we created a database with two tables ProductGUID and ProductInt:

CREATE TABLE ProductGUID ( ID UNIQUEIDENTIFIER DEFAULT NEWSEQUENTIALID(), SKU NVARCHAR(32) NOT NULL, Description NVARCHAR(255) NULL ); CREATE CLUSTERED INDEX ProdGUIDix ON ProductGUID(ID); GO CREATE TABLE ProductINT ( ID INT IDENTITY(1,1), SKU NVARCHAR(32) NOT NULL, Description NVARCHAR(255) NULL ); CREATE CLUSTERED INDEX ProdINTix ON ProductINT(ID); GO

For the table using a GUID, we use the NewSequentialID() instead of NewID() to create new keys. This is supposed to offer much better performance as the generated GUIDs are guaranteed to be sequential rather than random, resulting in better index performance on insertion.

For the Access version of the tables, we basically use the same definition, except that we used 4 tables:

• ProductINT: let Jet/ACE autonumbering create the sequential integer Primary Key.
• ProductINTRandom: let Jet/ACE autonumbering create the random integer Primary Key.
• ProductGUIDRandom: let Jet/ACE use its own internal GenGUID() for the key which generates random GUIDs instead of sequential ones.
• ProdcutGUIDSequential: call the Windows API (UuidCreateSequential) to create sequential ID instead.

SQL Server Test code

Using the SQL Server Management Studio, we performed the following test once for each table (resetting the database in-between): SET NOCOUNT ON; GO DECLARE @i INT = 1; WHILE (@i <= 1000) BEGIN DECLARE @tstart DATETIME2 = SYSDATETIME(); BEGIN TRAN DECLARE @a INT = 1; WHILE (@a <= 1000) BEGIN INSERT INTO ProductGUID (SKU,Description) VALUES ('PROD' + CONVERT(CHAR,@a), 'Product number ' + CONVERT(CHAR,@a)); SELECT @a = @a + 1; END; COMMIT TRAN; SELECT DATEDIFF(MILLISECOND, @tstart, SYSDATETIME()) AS timespan; SELECT @i = @i + 1; END; GO

Basically, we perform 1000 transactions each inserting 1000 records into the table ProductGUID or ProductINT.

Access 2007 Test code

To duplicate the same conditions, the following VBA code will perform 1000 transactions each inserting 1000 records.
Note that the recordset is opened in Append mode only.
The importance of this will be discussed in another article.

' Run this to inset 1,000,000 products in batches of 1000 ' In the given table Public Sub Benchmark(TableName as String, InsertSeqGUID as Boolean) Dim i As Integer For i = 1 To 1000 Insert1000Products TableName, InsertSeqGUID Next i End Sub ' Insert 1000 products in a table Public Sub Insert1000Products(TableName as String, InsertSeqGUID as boolean) Dim i As Long Dim db As DAO.Database Dim rs As DAO.Recordset Dim ws As DAO.Workspace Dim starttime As Long Dim timespan As Long Set ws = DBEngine.Workspaces(0) DoEvents starttime = GetClock ' Get the current time in ms ws.BeginTrans Set db = CurrentDb Set rs = db.OpenRecordset(TableName, dbOpenDynaset, dbAppendOnly) With rs For i = 1 To 1000 .AddNew If InsertSeqGUID Then !ID = "{guid {" & CreateStringUUIDSeq() & "}" !SKU = "PROD" & i !Description = "Product number " & i .Update Next i End With ws.CommitTrans rs.Close timespan = GetClock() - CDbl(starttime) Set rs = Nothing Set db = Nothing ' Print Elapsed time in milliseconds Debug.Print timespan DoEvents End Sub

We call this code to perform inserts on each of our Access tables:

• ProductINT table: we just insert data in the ProductINT table, letting Access create autonumber IDs.
• ProductINTRandom table: we just insert data in the ProductINTRandom table, letting Access create random autonumber IDs.
• ProductGUIDRandom table: we let Access create the Random GUID for the primary key.
• ProductGUIDSequential: we use the Windows API to create a sequential ID that we insert ourselves.

Test results

Without further ado, here are the raw results, showing the number of inserted record per second that we achieve for each test over the growing size of the database (here are only shown tests comapring Sequantial GUID and Autoincrement on SQL Server and Access, see next sections for the other results):

What we clearly see here is that performance when using autoincrement and Sequential GUID stays pretty much constant over the whole test.
That’s good new as it means that using Sequential GUIDs do not degrade performance over time.

As a side note, in this particular test, Access offers much better raw performance than SQL Server. In more complex scenarios it’s very likely that Access’ performance would degrade more than SQL Server, but it’s nice to see that Access isn’t a sloth.

Using Sequential GUID vs Autoincrement in Access

The results show that we do take a performance hit of about 30% when inserting Sequential GUID vs just using autonumbers.
We’re still getting good results, but that’s something to keep in mind.

In terms of CPU consumption, here is what we get:

Random PK, whether they are simple integer or GUID do consume substantially more CPU resources.

Using Sequential GUID vs Identity in SQL Server

Out-of-the box, SQL Server performs quite well and there is not much difference whether you’re using Sequential GUIDs or autoincrement PK.

There is however a surprising result: using Sequential GUIDs is actually slightly faster than using autoincrement!

There is obviously an explanation for this but I’m not sure what it is so please enlighten me :-)

CPU Consumption:

Using Random GUID vs Sequential GUID vs Random Autonumber in Access

So, what is the impact of choosing a Sequential GUID as opposed to letting Access create its own random GUIDs?

It’s clear that random GUIDs have a substantial performance impact: their randomness basically messes up indexing, resulting in the database engine having to do a lot more work to re-index the data on each insertion.
The good thing is that this degradation is pretty logarithmic so while it degrades over time, the overall performance remains pretty decent.
While GUIDs are larger than Random Integers (16 bytes vs 4 bytes) the actual performance of inserting records whose PK is a random integrer is actually worse than random GUID…

Provisional conclusions

Here we’ve check the baseline for our performance tests. In the next article, we’ll look exclusively at the performance of inserting data from a remote Access 2007 front end using our VBA code.

Having this baseline will allow us to check the performance overhead of using ODBC and letting Jet/ACE manage the dialogue with the SQL Server backend.

Feel free to leave your comments below, especially if you have any resources or information that would be useful.

Updates

• 16APR2009: added test of random autonumber as PK in Access.
• 13APR2009: Original Article

I’ve got this Dell R300 rack server that runs Windows Server 2008 that I dedicate to running IIS and SQL Server 2008, mostly for development purposes.

In my previous blog entry, I was trying some benchmark to compare the performance of Access and SQL Server using INT and GUID and getting some strange results.

Here are the results I was getting from inserting large amounts of data in SQL Server:

On the server, not using transactions makes the query run more than 8 seconds, at least an order of magnitude slower than it should!

I initially thought there was something wrong with my server setup but since I couldn’t find anything, I just spend the day re-installing the OS and SQL server, applying all patches and updates so the server is basically brand new, nothing else on the box, no other services, basically all the power is left for SQL Server…

Despair

When I saw the results for the first time after spending my Easter Sunday rebuilding the machine I felt dread and despair.
The gods were being unfair, it had to be a hardware issue and it had to be related to either memory or hard disk, although I couldn’t understand really why but these were the only things that I could see have such an impact on performance.

I started to look in the hardware settings:

And then I noticed this in the Policies tab of the Disk Device Properties :

Just for the lulz of it, I ticked the box, close the properties

And then tried my query again:

A nearly 35 fold increase in performance!

Moral of the story

If you are getting strange and inconsistent performance results from SQL Server, make sure you check that Enable advanced performance option.
Even if you’re not getting strange results, you may not be aware of the issue, only that some operations may be much slower than they should.

Before taking your machine apart and re-installing everything on it, check your hardware settings, there may be options made available by the manufacturer or the OS that you’re not aware of…

Lesson learnt.

While there are tools like SSMA that can help you move an Access database to SQL Server, a lot of the problems you’ll encounter can be solved before you even have to think about upsizing.
Abiding by a few simple rules will cost you nothing when creating your Access application but will save you a lot of headache if -when- the time comes to upsize.

So here are a few things to keep in mind.

Naming conventions

Access is pretty liberal about naming conventions and it will let you freely name your tables, columns indexes and queries. When these get moved to another database you’ll most probably be faced with having to rename them.
In some cases, you could actually create subtle bugs because something that used to work fine in Access may be tolerated in the new database but be interpreted differently.

• Do not use spaces or special characters in your data object names.
  Stick to characters in the range A through Z, 0 to 9 with maybe underscores _ somewhere in between (but not at the start or the end).
  Also try to respect casing wherever you reference this name (especially for databases like MySQL which are case-sensitive if the hosted on a Linux platform for instance).
  eg:
  Customer Order Lines (archive) should be CustomerOrderLines_Archive.
  Query for last Year's Turnover should be QueryLastYearTurnover.
  Index ID+OrderDate should become instead ID_OrderDate.

• Do not use keywords that are reserved or might mean something else whether they are SQL keywords or functions names:
  A column called Date could be renamed PurchaseDate for instance.
  Similarly, OrderBy could be renamed SortBy or PurchaseBy instead, depending on the context of Order.
  Failing to do so may not generate errors but could result in weird and difficult to debug behaviour.

• Do not prefix tables with Sys, USys, MSys or a tilde ~.
  Access has its own internal system tables starting with these prefixes and it’s best to stay away from these.
  When a table is deleted, Access will often keep it around temporarily and it will have a tilde as its prefix.

• Do not prefix Queries with a tilde ~.
  Access use the tilde to prefix the hidden queries kept internally as recordsource for controls and forms.

Database design

• Always use Primary keys.
  Always have a non-null primary key column in every table.
  All my tables have an autonumber column called ID. Using an automatically generated column ID guarantees that each record in a table can be uniquely identified.
  It’s a painless way to ensure a minimum level of data integrity.

• Do not use complex multivalue columns.
  Access 2007 introduced complex columns that can record multiple values.
  They are in fact fields that return whole recordset objects instead of simple scalar values. Of course, this being an Access 2007 only feature, it’s not compatible with any other database. Just don’t use it, however tempting and convenient it might be.
  Instead use a table to record Many-To-Many relationships between 2 tables or use a simple lookup to record lists of choices in a text field itself if you’re only dealing with a very limited range of multivalues that do not change.

• Do not use the Hyperlink data type.
  Another Access exclusive that isn’t available in other databases.

• Be careful about field lookups.
  When you create Table columns, Access allows you to define lookup values from other tables or lists of values.
  If you manually input a list of values to be presented to the user, these won’t get transferred when upsizing to SQL Server.
  To avoid having to maintain these lookup lists all over your app, you could create small tables for them and use them as lookup instead; that way you only need to maintain a single list of lookup values.

• Be careful about your dates.
  Access date range is much larger than SQL Server.
  This has 2 side-effects:
  1) if your software has to deal with dates outside the range, you’ll end-up with errors.
  2) if your users are entering dates manually, they could have made mistakes when entering the year (like 09 instead of 2009).
  Ensure that user-entered dates are valid for your application.

VBA

While most of your code will work fine, there are a few traps that will bomb your application or result in weird errors:

• Always explicitly specify options when opening recordsets or executing SQL.
  With SQL Server, the dbSeeChange is mandatory whenever you open a recordset for update.
  I recommend using dbFailOnError as well as it will ensure that the changes are rolled back if an error occurs. Dim rs as DAO.RecordSet ' Open for read/write set rs = db.OpenRecordSet("Stock", dbOpenDynaset, dbSeechanges + dbFailOnError) ' Open for read only set rs = db.OpenRecordSet("Stock", dbOpenSnapshot) ' Direct SQL execution CurrentDB.Execute "INSERT INTO ...", dbSeeChanges + dbFailOnError

• Get the new autonumbered ID after updating the record.
  In Access, autonumbered fields are set as soon as the record is added even if it hasn’t been saved yet.
  That doesn’t work for SQL Server as autonumbered IDs are only visible after the records have been saved. ' Works for Access tables only ' We can get the new autonumber ID as soon as the record is inserted rs.AddNew mynewid = rs!ID ... rs.Update ' Works for ODBC and Access tables alike ' We get the new autonumber ID after the record has been updated rs.AddNew ... rs.Update rs.Move 0, rs.LastModified mynewid = rs!ID

• Never rely on the type of your primary key.
  This is more of a recommendation but if you use an autonumbered ID as your primary key, don’t rely in your code or you queries on the fact that it is a long integer.
  This can become important if you ever need to upsize to a replicated database and need to transform your number IDs into GUID.
  Just use a Variant instead.

Parting thoughts

These simple rules will not solve all your problems but they will certainly reduce the number of issues you’ll be faced with when upsizing you Access application.
Using a tool like SSMA to upsize will then be fairly painless.

If you have other recommendations, please don’t hesitate to leave them in the comments, I’ll regularly update this article to included them.

References

• You will find lots of other bits of wisdom on this page: My random thoughts on SQL Server Upsizing from Microsoft Access by Tony, from Granite Consulting.
• Martin Green’s Office tips has a series of articles on Access to SQL Server migration.

One of the challenges is to upsize the current MS Access 2007 backend database to SQL Server 2008. If you try it from Access itself using the Upsizing Wizard, you may end up getting this error message:

The Upsizing Wizard only works with Microsoft SQL Server (Versions 6.50 SP5 or higher). Please log in to a SQL Server data source.

After spending some time fiddling around with SQL Server settings I couldn’t understand why I was still getting this error.
Turns out that the upsizing wizard is apparently sensitive to the version of SQL Server you’re using and it doesn’t consider SQL Server v10 (2008) as being later than v6.50…

This issue is in fact a blessing.
Microsoft provides a migration tool for upsizing MS Access database to SQL Server 2008 that’s orders of magnitude better than anything the basic wizard can do: the SQL Migration Assistant for Access, or SSMA.

SSMA lets you take a bunch of Access databases and move the tables and queries you choose to SQL Server, automatically linking them in your original database if you want.
It’s not just a one-off thing either: SSMA keeps track of the objects that where transferred and allows you to synchronise both schema and data as often as you need.

So here you are: do not use the basic MS Access Upsizing Wizard, download and use SSMA instead.

Strange COM Error

While SSMA works perfectly fine on my Windows 2008 x64 laptop, on my main Windows XP desktop it throws an exception when trying to load an Access database:

Unable to cast COM object of type ‘Microsoft.Office.Interop.Access.Dao.DBEngineClass’ to interface type ‘Microsoft.Office.Interop.Access.Dao._DBEngine’
… {00000021-0000-0010-8000-00AA006D2EA4}…

It was a COM error saying that the library for DAO couldn’t be loaded.

I couldn’t find any relevant information on the web.
After a while, I had a look at the DAO driver in
C:\Program Files\Common Files\Microsoft Shared\DAO\dao360.dll
and I noticed that the filename was in blue: that reminded me that I had set compression on the filesystem.

I disabled compression for the file and, magically, SSMA worked again…

Moral of the story: be careful about compressing your filesystem, some registered libraries and system files may work in unpredictable ways…

References

• SQL Server Migration Assistant for Access main page.
• SQL Server Migration Assistant download. Note that you will have to register to get a license file that you need to save on your PC before you can use this free tool.
• “Access 2007 Upsizing to SQL Server 2008 Express in SQL Upsizing” discussion on Microsoft groups.
• “KB838594: Error message when you try to upsize your Access database by using the Upsizing Wizard” is not the problem here, but some may find the reference useful if you’re trying to upsize your MS Access database to a SQL Server database on a network.
• My random thoughts on SQL Server Upsizing from Microsoft Access from Tony’s Access MVP website, and his list of links to other resources.

Updates

• 17MAR2009: Added section on the strange COM error.
• 14MAR2009 : Added links to Tony’s Access MVP website.
• 05JAN2009 : Original publication.

With OpenOffice 3, things got trickier and applications that used to work will now fail. I’ve just spend nearly a day trying to get a mail-merge application I built to work again with the new version of OO.

Changes and limitations

Developing .Net applications with OpenOffice 3 now requires that the .Net framework 3.5 be installed.
Only one version of OpenOffice/StarOffice must be installed.

Getting the CLI assemblies in your project

OpenOffice used to ship with a bunch of CLI DLLs for manipulating Open Documents from .Net. With OpenOffice version 3, these DLLs are directly installed in the GAC and not available in the Program installation folder any longer, making them unavailable when you need to add them as references to your Visual Studio project.

The trick is to extract the DLLs from the installation CAB, then reference those and make sure you exclude them in your setup file so only the latest version installed on the user’s computer’s GAC will get used.

1. Open the installation folder where the installation files are extracted (usually left on your desktop under a folder like OpenOffice.org 3.0 (en-US) Installation Files during the OO installation process.
2. Open the openofficeorg1.cab file (using a utility like 7zip if necessary) and extract the files matching cli_*.dl.
3. Add the ones you need to your VS Project’s references and make sure the properties of these references have their Copy Local and Specific Version properties set to false.
4. If you have a setup project that added these references to the list of files, right-click each of them and select Exclude to make sure they won’t be packaged.

The reason for not deploying the DLLs is that they are very specific to a given OpenOffice version and the latest assemblies relevant to the user’s OpenOffice installation will already be deployed to the target machine’s GAC.
When .Net loads assemblies, if they are not included in the path of the application being launched, they will be loaded from the GAC if they can be found there.

Path and environment setup

Before being able to call OpenOffice from your application you now must set your application’s environment variables to the correct paths so the assemblies can find the actual OpenOffice library and program files.

Basically, you need to add to your PATH the path to the folder where the UNO java libraries reside. You also need to add a UNO_PATH environment variable that points to the program folder of OpenOffice. Basically, before any call to OpenOffice functions you must:

• Append to PATH something like C:\Program Files\OpenOffice.org 3\URE\bin.
• Create a UNO_PATH variable set to C:\Program Files\OpenOffice.org 3\program.

Because there is no guarantee that these paths will not change or are valid for all systems you must get them from specific keys located in the Registry:

• PATH is appended with the vaue of HKLM\SOFTWARE\OpenOffice.org\Layers\URE\1\UREINSTALLLOCATION to which you must append the bin directory.
• UNO_PATH is set to the content of the HKLM\SOFTWARE\OpenOffice.org\UNO\InstallPath key.

See the C# and VB.Net code below for working examples.

Special Considerations for x64 systems

My development machine runs Windows Server 2008 x64 and I’ve ran into some specific issues that you’re likely to encounter when deploying to a 64 bits OS.

OpenOffice is 32 bits only
That means that your .Net project must be set to target x86 systems only:
Open your Solution’s Configuration Manager and under Active solution platform click New… then:

Make sure you repeat this for both the Debug and Release configurations.

Registry keys are elsewhere
32 bit applications see their registry keys normally expected under:
HKEY_LOCAL_MACHINE\Software moved to:
HKEY_LOCAL_MACHINE\Software\Wow6432Node instead.
This of course creates issues when you’re trying to read a registry key that’s not where it should be…

The Code

The code below will allow you to correctly connect to OpenOffice 3 under 32 or 64 bit systems.
It reads the registry to find the proper paths and appends the PATH and creates the UNO_PATH environment variables expected by the the bootstrapper to find the OpenOffice program and libraries.

The code is built upon information and a test program made available by Marten Feldtmann on his blog (more information, in English, is available on OOoForum ).

Please let me know if this works for you or if you have any corrections. private void InitOpenOfficeEnvironment() { string baseKey; // OpenOffice being a 32 bit app, its registry location is different in a 64 bit OS if (Marshal.SizeOf(typeof(IntPtr)) == 8) baseKey = @"SOFTWARE\Wow6432Node\OpenOffice.org\"; else baseKey = @"SOFTWARE\OpenOffice.org\"; // Get the URE directory string key = baseKey + @"Layers\URE\1"; RegistryKey reg = Registry.CurrentUser.OpenSubKey(key); if (reg==null) reg = Registry.LocalMachine.OpenSubKey(key); string urePath = reg.GetValue("UREINSTALLLOCATION") as string; reg.Close(); urePath = Path.Combine(urePath, "bin"); // Get the UNO Path key = baseKey + @"UNO\InstallPath"; reg = Registry.CurrentUser.OpenSubKey(key); if (reg==null) reg = Registry.LocalMachine.OpenSubKey(key); string unoPath = reg.GetValue(null) as string; reg.Close(); string path; path = string.Format ("{0};{1}", System.Environment.GetEnvironmentVariable("PATH"), urePath); System.Environment.SetEnvironmentVariable("PATH", path); System.Environment.SetEnvironmentVariable("UNO_PATH", unoPath); }

In VB.Net: Private Sub InitOpenOfficeEnvironment() Dim baseKey As String ' OpenOffice being a 32 bit app, its registry location is different in a 64 bit OS If (Marshal.SizeOf(GetType(IntPtr)) = 8) Then baseKey = "SOFTWARE\Wow6432Node\OpenOffice.org\" Else baseKey = "SOFTWARE\OpenOffice.org\" End If ' Get the URE directory Dim key As String = (baseKey + "Layers\URE\1") Dim reg As RegistryKey = Microsoft.Win32.egistry.CurrentUser.OpenSubKey(key) If (reg Is Nothing) Then reg = Registry.LocalMachine.OpenSubKey(key) End If Dim urePath As String = CType(reg.GetValue("UREINSTALLLOCATION"),String) reg.Close urePath = Path.Combine(urePath, "bin") ' Get the UNO Path key = (baseKey + "UNO\InstallPath") reg = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(key) If (reg Is Nothing) Then reg = Microsoft.Win32.Registry.LocalMachine.OpenSubKey(key) End If Dim unoPath As String = CType(reg.GetValue(Nothing),String) reg.Close Dim path As String path = String.Format ("{0};{1}",System.Environment.GetEnvironmentVariable("PATH"),urePath) System.Environment.SetEnvironmentVariable("PATH", path) System.Environment.SetEnvironmentVariable("UNO_PATH", unoPath) End Sub

Updates

07MAY2009 -- Added reference link to OOo documentation.
03DEC2008 -- Added VB.Net translation. Thanks to Stefan for suggesting it.
30JAN2009 -- Added reference to Aleksandr Sazonov’s article on CodeProject (thanks for the the article).

References

• CLI Language Binding
• OOoForum thread on getting sample C# code to work with OpenOffice 3
• OOoForum thread on upgrading code from OpenOffice 2.4 to 3
• Programming with .Net quick start guide.
• CLI UNO bridge not working
• Cross-compatible spreadsheet processor in .Net for Excel and OOo Calc, article from Aleksandr Sazonov on CodeProject.
• Writing client programs -- from the OOo documentation

The ‘Microsoft.Jet.OLEDB.4.0′ provider is not registered on the local machine:

It may look otherwise, but this error is generally due to either of two thing:

• you don’t have Office 2007/2010 Jet drivers installed
• or you are running a 32 bit application in a default x64 environment.

The first issue is easy to solve, just download the Access 2010 Database Engine from Microsoft (works with Access 2007 databases as well).

For the second one, the fix is also easy enough:

• For Windows 2008: Navigate to Server Manager > Roles > Web Server (IIS) > Internet Information Services (IIS) Manager, then look under your machine name > Application Pool.
• For Windows 7: Navigate to Programs > Administrative Tools > Internet Information Services (IIS) Manager, then look under your machine name > Application Pool.

Under there you can call the DefaultAppPool’s advanced settings to change Enable 32-Bits Applications to True:

You may have to restart the service for it to take effect but it should work.

References

• Scott Hanselman’s blog entry about undestanding 64 vs. 32 bitness in .Net.
• Access 2010 Database Engine driver

Updates

• 10DEC2011: Updated driver link to use the Access 2010 engine.
• 03APR2010: Added instructions for Windows 7
• 12FEB2009: Added reference to Scott’s article.
• 28OCT2008: Original version

I use VMware on my main desktop to keep multiple OS setups that match typical configurations of my customer’s machines.
This allows me to test my software before deployment and make sure everything works as expected. It saved me many times from strange bugs and I would consider these final tests to be a mandatory step before deployment.
My old trusty vaio would be hard pressed to run any of these without slowing down to a crawl.

I looked at some possible replacements. Initially I checked Lenovo’s offerings but they don’t seem to offer anything in large screen size (WUXGA 1920×1200) (Note, actually, they have, but not really for me).
Dito for Dell, not counting their humongous XPS M1730 luggable gaming machine that was wayyy over the top as a work computer, not to mention probably heavier than its volume in pure gold.

On a hint from a friend I checked out Apple’s online store and saw they had a nice Macbook Pro configuration. I went to check it out in the retail store close to my office and they had that exact specification in stock, so, in what must have been the highest rated expense/time-to-think ratio of any decision I ever took, well, I bought it…

The spec, some bragging rights:

• Macbook Pro 17″
• Core Duo T9500 2.6GHz processor
• nVidia 8600M GT 512MB graphics card
• 200GB 7200rpm drive
• Kingston 4GB DDR2 667MHz RAM
• Hi Resolution 17″ 1920×1200 glossy screen

It’s a very nice machine, Apple knows how to make nice hardware, there is no question there.
OSX has some cool features, some of them still a bit foreign to me and some minor annoyances are creeping up, like Thunderbird’s not picking up my system date and time settings and displaying the date in the wrong format (a pet peeve of me), probably not Apple’s fault but annoying nonetheless.
So far so good and while I don’t mind using OSX for my browsing, email and creative stuff, that machine is meant to be running Windows Server 2008 x64 as a development platform.

Why Windows Server 2008 x64?

Well, it has some excellent features, a smaller footprint than Vista, all the aero eye candy, is apparently noticeably faster than Vista and has none of the nagging security prompt (you are considered administrator though, so keeping safe is entirely up to you).
The 64 bit version can also address the full 4GB of RAM without limitation and all server features are optionally installable.
By default, the installation is actually pretty minimal and you have to set services and options to get Windows configured as a proper workstation. It is after all, meant to be a server.
Oh, I almost forgot that there is also support for HyperV, although you must make sure you download the right version (if you list all available downloads in your MSDN subscription, you’ll see some that are explicitly without that technology).

Installing Windows Server 2008 x64 is remarkably easy.

• Get your hands on the ISO from your MSDN subscription or an install DVD from somewhere else (like a MS event, or even as a free 240 days download from Microsoft).
• You’ll need to repackage the ISO as it won’t work properly (something to do with non-standard file naming options).
  It’s fairly easy if you follow the instructions from Jowie’s website (cached version): you can get the ImgBurn software for free as well, which is a good find in itself. It should’t take more than 30 minutes to repackage the DVD.
• In OSX, go to Applications > Utilities > Boot camp and follow the instructions on screen.
  You will be able to resize the default partition by just moving the slider. I left 60GB for OSX and allocated the rest to Windows. The good thing is that OSX can read Windows partitions, so you can always store data there. Windows however, can’t read the HFS+ mac file system, although there are some third-party tools that can do it [1] [2] [3].
• Insert your repackaged DVD and Bootcamp will have rebooted the machine.
  After a few minutes of blank screen (and no HDD activity light to let you know something is happening), windows setup launches.
• You will be then prompted with the choice of partition to install to.
  Select the one named BOOTCAMP, then click the advanced options button and click format. From there one, windows will install everything, then reboot, then carry on installing, then reboot one last time.
• Now, insert your OSX recovery CD 1. It should automatically launch the driver installation.
  Once done, you’ll reboot to a nice, full-resolution windows prompt.
• All drivers will have been installed correctly except the one for Bluetooth. To easily solve that issue, just go to Spencer Harbar’s website and read how to install the Bluetooth drivers. Takes 5 minutes tops.

The final touches

A few notes to quickly get things running as expected.

• Get the most of your configuration by following the list of tweaks from Vijayshinva Karnure from Microsoft India.
• There are more tweaks, and even more tweaks available as well (don’t forget to enable Superfetch).
• Microsoft has a whole KB entry on enabling user experience.
• In the Control Panel > System > Advanced System Settings > Advanced > Settings > Advanced > Processor scheduling, set to Programs instead of Background services.
• Activate your copy of Windows using Control Panel > System.
  I was getting an error code 0x8007232B DNS name does not exist error. To force activation, just click on the Change Product Key button and re-enter the same key you used during install.
  Windows will activate straight away.
• When booting your Macbook, press the Option key and you will be presented a list of boot choices.
• You can check on Apple’s Bootcamp webpage other information about how to use the track pad, keyboard layouts etc,

References

• http://stuartd.blogspot.com/2008/04/windows-server-2008-boot-camp-and.html
• http://burnetts.homeserver.com/post/Windows-Server-2008-on-the-Mac.aspx
• http://csaborio.wordpress.com/2008/03/28/installing-windows-server-2008-on-a-mac-book-pro/
• http://exo-blog.blogspot.com/2008/03/windows-2008-vista-done-right.html
• http://www.sturmnet.org/blog/archives/2008/10/02/stuff-i-use-on-the-mac/ Lots of software recommendations for someone switching from Windows to the Mac.

The Linux server-based application would scan the vast (100,000s of CAD drawings) and, depending on their format, attempt to create thumbnails and extract textual information from them and populate a database so we could easily find related drawings through a simple web-interface.

The software would present thumbnails of the drawings; when the drawing was in DWG or DXF format, the thumbnail would be an SVG vector representation of the original drawing instead of an image. That made the preview much more useful as you could zoom in and still retain enough detail to ascertain if the drawings was actually what you were looking for.

Other file formats (TIFF, HPGL plots, etc) were transformed into PNG image previews that were saved into 2 size: a small thumbnail, good enough to be displayed in a list, and a larger one that would show more details.

The server software was written in Perl, with some of the converters in C. Every night, the server would go through the whole tree of drawings on the filesystem, looking for drawings it hadn’t seen before and it would pass them to the appropriate plug-in for extracting text -where possible- and create thumbnails.

Memories of fun projects…

Download links:

• cad2svg: http://etc.nkadesign.com/Download/Cad2svg
• cad2text: http://etc.nkadesign.com/Download/Cad2text

Checking for the existence of network paths

Checking for the existence of network paths (directories or files) is one of these issues that can freeze an application for 30 seconds or more if the folder is not accessible.

This is a type of problem that benefits greatly from running in a separate thread: it can take such a long time that the best way to check for these remote paths is to launch the verification for their existence outside of Access and somehow get the result back and cache it for the current session so we don’t have to suffer these delays again every time we check for that path’s existence.

One easy way to do achieve that goal is to create plain DOS batch files that execute hidden from view, create a result file when they complete their task and delete themselves automatically when they are finished.

How to use it

Download the sample database below then just add the FileUtilities, HashTable and MD5 modules to your project and you can use the code as such:

Dim status As AsyncDirectoryStatus status = FileUtilities.PathExistAsync("\\123.45.67.89\shared folder") The status variable will return either of the following values:

• AsyncDirectoryStatus.OK if the path was found.
• AsyncDirectoryStatus.NotFound if the path was not found (either because it doesn’t exist or you don’t have the rights to access it).
• AsyncDirectoryStatus.Checking if the verification is in progress and we haven’t received a definite answer yet.
  It’s up to you to decide how you want to handle that case. You could periodically check it, like I did in the example database, or you could disable the controls until you’re getting a confirmed result (by checking every time the user performs some action, like moving from record to record in a datasheet for instance).

You can call PathExistAsync as often as you want to check the status: it will not slow down your application (read the optional arguments section below though).
The result of the verification is cached, so querying the existence of the path is actually only done once; the result of subsequent queries for the same path is just instantly retrieved from memory.

Optional arguments

If you want to force the actual re-checking of a path without using the cached value, you can simply pass the ForceCheck optional parameter: Dim status As AsyncDirectoryStatus status = FileUtilities.PathExistAsync("\\123.45.67.89\shared folder", ForceCheck:=true) The first time you query for a path (or force it to be rechecked) there will be a short 150ms delay to give a chance to the function to return its result straight away (in case the path can be resolved quickly).
This may not be desirable if you’re checking a bunch of directories at a time. For instance, this is what I do when my application launches: ' Check a bunch of paths in parallel PathExistAsync strPathToQualityDocuments, NoDelay:=true PathExistAsync strPathToFinancialDocuments, NoDelay:=true PathExistAsync strPathToShippingDocuments, NoDelay:=true PathExistAsync strPathToPurchasingDocuments, NoDelay:=true By querying the existence of all these paths as soon as my application launches, I am starting the verification process without introducing delays in the application itself: each verification will start in its own process, in parallel to the main application.
Later in the application, when I need to actually use these paths, their result is likely to be known.

How it works

The FileUtilities module contains the main code.
In it, the PathExistAsync function works in slightly different ways depending on whether it’s the first time it is being called for a particular path or not.

The first time
The first time the function is called for a given path, we create in the user’s temporary folder the small batch file whose name is simply a MD5 hash (see below) of the path with .bat appended to it.
This batch file simply checks for the existence of the path and will create a small file (whose name is the MD5 hash of the path) with either 0 or 1 in it depending on the result of the verification.
We initially cache the status of the verification for the Path into the AsyncDirectories hashtable (see below) as Checking.

Example of batch file automatically created to verify a path: IF NOT EXIST "\\123.56.78.9\going nowhere" GOTO NOTEXIST echo 1 > "C:\DOCUME~1\Renaud\LOCALS~1\Temp\463C7367D8329BD6209A65A70A7DA08C" GOTO END :NOTEXIST echo 0 > "C:\DOCUME~1\Renaud\LOCALS~1\Temp\463C7367D8329BD6209A65A70A7DA08C" :END DEL %0 The Batch file name is 463C7367D8329BD6209A65A70A7DA08C.bat where the long number is actually the MD5 hash of the path we’re checking \\123.56.78.9\going nowhere.

Getting back the result
Whenever the PathExistAsync function is called, we check the currently cached result from the AsyncDirectories hastable.
If it is still Checking then we try to verify if we the result file has been created from the running batch. If not, we just return the same status, if yes, we read the result from the file, save it in the hashtable and delete the result file.

Useful libraries

The code makes use of 2 extremely useful libraries that I end up using quite often:

• a HashTable implementation.
  It makes it easy to create hashtable objects (otherwise known as Associative Arrays) to store and retrieve key/value pairs quickly.
  Hashtables are often used to cache data and can be thought of arrays where the index is a string value instead of an number.
  Here I use a hashtable to keep track of the paths we’ve checked and their result.

• a MD5 hash implementation.
  MD5 is a way to get a somewhat unique fixed-length value from a chunk of data.
  It’s a mathematical function that guarantees that a small change in input (say a single bit in the input data) has a large effect on the output value (a totally different number will be generated) and that you can’t reverse the function (you can’t obtain the input just by looking at the output).
  It is often used in security applications to transform sensitive data like passwords into unique values that can be (somewhat) safely stored because you can’t easily reverse a md5.
  Well, MD5 are not that secure any longer but here we just use their ability to transform our path into a unique number that we can easily use as a filename and a key for our hash to retrieve the current status of the path being checked.

Sample database

Download the PathExistAsync01.zip (67KB) containing the Access 2007 ACCDB database.

Download the PathExistAsync02b.zip (121KB) containing the MDB database¹ (untested as I only have Access 2007).

License

Please refer to the source code in the database for the exact licensing terms.
Note that the license only refers to code by me. When code from other sources is used, you will have to conform to their own licensing terms.

This work is licensed under a Creative Commons Attribution 3.0 Unported License.

References

• Hashtable implementation in VB
• Cryptography Software Code (for the MD5 hash implementation in VB)

Here is the absolute proof:

He calls himself Erik Meijer now and apparently solved his skin issue but you only need to listen to them to know it’s the same person.

Yes, they are both Dutch, which in itself is already proof enough of their evilness and further confirms they are one and the same.

There is some talk that Microsoft has been the refuge of all that is Bad, and some even say that Steve Ballmer may be none other than Dr Evil himself…

That being said, you should check out videos on Channel 9 where Erik Meijer appears. Despite his obvious evilness, he is actually one of the very bright and interesting characters at Microsoft and always has fascinating things to say about programming languages:

• Expert to Expert: Erik Meijer and Bertrand Meyer -- Objects, Contracts, Concurrency, Sleeping Barbers
• Tier Splitting Volta: Who. What. How. Why -- Part 1 and Part 2
• Erik Meijer: Functional Programming
• Erik Meijer, Gilad Bracha, Mads Torgersen: Perspectives on Programming Language Design and Evolution
• Paul Vick and Erik Meijer -- Dynamic Programming in Visual Basic
• Erik Meijer: Democratizing the Cloud
• Anders Hejlsberg, Herb Sutter, Erik Meijer, Brian Beckman: Software Composability and the Future of the CLR
• JAOO 2007: Joe Armstrong -- On Erlang, OO, Concurrency, Shared State and the Future, Part 1 and Part 2
• CLR Team Tour -- The Future of Languages (PDC panel preview) -- Part 1 and Part 2

What’s wrong with the default MsgBox

The default message box in Access is sometimes useful to warn, inform or ask confirmation from the user.

It has, however, a few drawbacks:

• It is bland: the standard message box does not even follow the currently selected Office 2007 scheme.
• The amount of text it can display is limited: if you try to display too much text it will be truncated.
• You can’t copy or save the content of the message.
• Because popup boxes are viewed as intrusive, people tend not to read them and end-up closing message boxes before they realize they may have contained useful information.
• They only displays plain text: you cannot format the message to draw attention to the key points.
• They are blocking, meaning that nothing can happen in the main application while the box is displayed (it can’t even shut down).

Sometimes you need to display an important message or require users to make take a decision.
Message boxes are not to be abused but they serve a useful purpose.

An enhanced message box

Rather than using the bland standard message box you can now have something a bit more customized.

Plain Text version of the enhanced custom message box under the Office Blue Colour Scheme:

RichText version of the enhanced custom message box under the Office Black Colour Scheme:

Here are the features of the enhanced message box:

• It is entirely compatible with the standard one: just change MsgBox to Box using find and replace should be enough (see tip below to avoid getting strange errors).
• It allows the user to simply click on a button to copy the content of the message to the clipboard or save it to a text file to a configurable default location.
• It looks and feels like it belongs to the main application, following its colour scheme.
• It attempts to prevent users from blindly closing the modal box reading the message: buttons will first be inactive for a configurable amount of time. It’s not a perfect solution, but it is quite effective.
• There is a RichBox version that can display rich HTML content, not just plain text, so important parts of the message can be formatted in a useful way.
• It is able to display large amount of data. While it’s not something you usually want, it may be useful for the message box to display more text in some situations (log or tracing information, legal documentation, etc).
• Rather than sprinkling your code with “& vbCrLf & _” uglies, you can embed newlines in the text itself by using C-style “\n” escape sequences that will automatically be transformed into the appropriate newlines. Makes for clearer code and less typing.
• Because you get the source, you can easily customise the message box with new icons and colours to better match your overall application’s personality.
• It is non-blocking: if your application forces users to log-off after a certain amount of inactivity, the enhanced message box will just close rather than prevent Access from shutting down like the standard MsgBox does. Of course, it’s up to you to decide how to handle that gracefully, if at all.
• It properly displays the expected button captions based on the language of the operating system, so it behaves very much like the default MsgBox (for instance, it will properly display “Cancel” on English systems and “Annuler” on French ones).
• It also properly plays the system sounds associated with the type of message. You can also enable or disable the sound effect as needed.

How to use it

Download the demo below and copy (drag & drop) the following into your application:

• the FormDialog form,
• the API_GetTextMetrics module,
• the Dialog module.

If you rename the FormDialog, make sure you replace any occurrence to it in the code, in particular in the Dialog module.

Since the enhanced message box is just a replacement for the standard one, you just use it like you would use the MsgBox.
'----------------------------------------------------------------------------- ' Simple use of the Plaintext box ' Note the use of n that will be converted into a newline Dialog.Box "This is a plaintext message.\nClick OK to dismiss", vbOKOnly+vbinformation, _ "Message Title" '----------------------------------------------------------------------------- ' Getting the result back Dim dr as vbMsgBoxresult dr = Dialog.Box("Are you sure you want to delete?", _ vbYesNoCancel+vbQuestion, "Confirm action") if (dr = vbYes) then DeleteRecords '----------------------------------------------------------------------------- ' Using named parameters Dialog.Box Prompt:="All your bases are belong to us", _ Buttons:=(vbOkOnly+vbCritical), _ Title:="Bad error" '----------------------------------------------------------------------------- ' Using the RichBox to display simple HTML ' The first line will be bold, then the word 'button' will be printed in red ' Here the n will be escaped to '<br/>' tags to simulate newlines. Dialog.RichBox "<strong>This is a bold message</strong>.\n" & _ "Click the <font color=""#FF0000"">button</font> to dismiss.", vbOKOnly+vbinformation, _ "RichText Message Title" There are a few additional settings that can be used to change the behaviour of the enhanced message boxes.
One is that you can adjust the delay before the buttons become activated.
'----------------------------------------------------------------------------- ' Use the ButtonDelay to specify the time in seconds before the buttons become activated ' The default is 2s. Use 0 to activate the buttons immediately. Dialog.Box Prompt:="All your bases are belong to us", _ Buttons:=(vbOkOnly+vbCritical), _ Title:="Bad error", ButtonDelay:=1 '----------------------------------------------------------------------------- ' Change the default delay value. ' To disable the activation delay Dialog.DefaultButtonDelay = 0 ' To make the user wait 3 seconds before they can press any button Dialog.DefaultButtonDelay = 3 Another one is that you can enable or disable whether beeps should be played or not.
'----------------------------------------------------------------------------- ' Use AllowBeep to specify whether beeps should be played when the message box opens ' By default, they are. Dialog.Box Prompt:="All your bases are belong to us", _ Buttons:=(vbOkOnly+vbCritical), _ Title:="Bad error", AllowBeep:=false '----------------------------------------------------------------------------- ' Change the default behaviour. This is true by default. Dialog.DefaultAllowBeep = false The last settings is the folder where we should save the content of the message when the user clicks the Save button on the message box.
'----------------------------------------------------------------------------- ' Change the save folder. ' By default, the text messages will be saved in the same directory as the database. ' Here we want them to be saved to a temp directory Dialog.DefaultSavedTextFileFolder= "C:temp" These few settings make the enhanced message box more customizable.

Large text

The standard MsgBox cannot display much text. On the other hand, there is no real limitation to the amount of text the Box and RichBox can display.
When the amount of information is too much to fit the maximum allowed size for the message box the text will overflow and can be scrolled up/down as necessary.

Limitations of the RichBox

The RichBox version relies on the normal TextBox control’s ability under Access 2007 to display RichText wich is nothing more than lightweight HTML.
Because font size may be varying a lot in the message, it becomes very difficult to accurately predict the size of the box needed to display the whole message.
Short of implementing a complete HTML engine, we have to rely on some assumptions to display HTML.
The risk is that sometimes the content may not properly fit the TextBox control in some circumstances.
If you use the RichBox, thoroughly try displaying your messages and tweak the HTML as necessary to include additional lines or non-breaking spaces to ensure that the result looks good.
If you don’t overuse font size and don’t display in multiple fonts the RichBox should do the right thing most of the time.
Don’t overuse the RichBox to display colourful messages. There is a fine line between being informative and tasteless. Keep colours and formatting where it is useful.
I think that in most cases, the plain text version Box is more than enough.

Replacing MsgBox in existing code

As I said above, replacing the standard MsgBox is easy but you need to make sure your search and replace parameters are configured correctly:

If you’re getting strange compile errors, it may be because you forgot to tick the Find Whole Word Only and some of the strings containing the letter sequence “msgbox” were replaced in the process.

If that’s the case, you can revert the damage by simply doing a search and replace across the whole project on:
- VbboxStyle or VbDialog.BoxStyle to be replaced with VbMsgBoxStyle
- VbboxResult or VbDialog.BoxResultto be replaced with VbMsgBoxResult

How it works

The code makes extensive use of Win32 API calls.
Most of the hard work is done in the FomDialog class form. There is too much there to really go into the details but you are welcome to have a look at the commented code.
The code relies also on a utility function from Stephen Lebans used to calculate the size of of text. I have made some minor modification to that code so I would refer you to his original implementation if you are interested in calculating TextBox sizes for forms or reports.

In the code for the FormDialog, I re-implement some of the expected functionalities of the MsgBox: proper arrangement of the buttons, displaying of the appropriate icon, etc.
Once this is done, we calculate the size of the textbox needed to display the whole of the message.
In the case of RichText, we first use Application.PlainText() to convert the HTML into properly formatted plain text. We then calculate the Textbox size using a slightly larger font than needed as a way to ensure that the content of the RichText message will fit the box in most cases.
Once we know the size of the TextBox, we can easily resize the form to properly display the TextBox.
If there is too much text, we resize the form to its maximum permissible (70% or screen width and 90% of screen height) and change some of the visual cues to let the user know the text is overflowing.

One thing of note is the way the form is kept modal.
Rather than using DoCmd.OpenForm and DoCmd.Close I use the form as a class and create an instance manually (see the code in Dialog.Box and Dialog.Richbox). I keep this instance alive until I got the form’s result back.
If you are interested in knowing how the form is made modal, this is the code in FormDialog.ShowModal() what keeps the form open until the user clicks a button:
Public Function ShowModal() As VbMsgBoxResult ... ' Here we reset the result for the clicked button such as vbOK, vbYes, etc ' This is set in each Button's Click event m_Result = -1 ' Wait for the user to click a button Do While (m_Result = -1) DoEvents Sleep 50 Loop ShowModal = m_Result End Function The Sleep() function is a Win32 API that stops the current process for the given number of milliseconds. This in effects hands back the control to the Operating System for a short time. That way the system is still responsive and does not consume resources when it’s just waiting for user input.

Sample database

You can download a sample database containing all the necessary code as well as a number of tests.
This version only contains the database in Microsoft Access 2007 accdb format.

Download the EnhancedMsgBox01.zip (116KB), v1.3 containing the ACCDB database.

Code Updates

v1.3: 17MAR2009
Thanks to Henry of Access-Pro.de for proposing a correction to the default buttons behaviour.

• Updated behaviour for the default buttons. They are now focused in a way that matches that of the standard msgbox.
• Reversed the naming of the buttons on the form to make it a bit more consistent with the standard box.

v1.2: 07SEP2008
Thanks to Andy Colonna (http://www.pcesoft.com) for uncovering the following bugs (check out his free Spell Checker with source code!):

• Corrected bug in Form_FormDialog.FilenameSanitize() function that would fail to remove all invalid characters for a file name.
• File name for the saved text message will be truncated to first 32 characters of message box title in Form_FormDialog.MakeFriendlyFileName().
• Changed the use of FollowHyperlink to ShellExecute to avoid security warning in some instances in Form_FormDialog.btCopyToFile_Click()
• Corrected twips to pixel conversion bug in API_GetTextMetrics.fTextWidthOrHeight() that would result in an improperly sized dialog box when the text message was too wide.

v1.1: 08AUG2008

• Corrected code for DefaultButtonDelay (thanks to Geoffrey) (was referencing wrong variable, causing self-referencing code).
• Corrected code for Box and RichBox to take the DefaultSavedTextFileFolder into account (the path was previously not passed onto the dialog boxes and the text file would always be created in the application folder instead of the one specified by DefaultSavedTextFileFolder)
• Added license notice at top of source code.

v1.0: 20MAY2008

• Original version

Resources

• Dissecting the MessageBox article on CodeProject
• XMessageBox -- A reverse-engineered MessageBox() article on CodeProject
• TextWidth-Height code demo from Stephen Lebans (great resource, check it out!).
• Pixel to Twips conversion from MSDN.
• Copy Text to Clipboard from the excellent site The Access Web.
• Getting Resource Strings and more from DLLs.

This work is licensed under a Creative Commons Attribution 3.0 Unported License.
Free for re-use in any application or tutorial providing clear credit is made about the origin of the code and a link to this site is prominently displayed where end-users can easily access it.

Being able to cleanly restart and compact the application is also useful in other instances:

• Changes made to the environment
• Recovering from errors (for instance after a network disconnection)
• Forcing the user to re-log cleanly into the application
• Automatically restarting a long-running application (for instance so that it may automatically compact on close and restart afresh with or without user intervention).

The problem is that you cannot -to the best of my knowledge- close and open again the same database from within MS Access itself.
Most executables cannot do that and the way to solve the issue is usually to pass the control to another boostrap programme, close the main application and let the bootstrap programme re-open the main application again.
I wanted a simple and clean way of using it. One that would not require shipping external programmes.

How to use it

Download the sample database below, copy the Utilities module or just the Restart sub defined in it into your own application.

To use it, just call the Restart sub and the application will close and re-open.
If you supply the optional Compact:=true parameter, the database will also be compacted during the restart process.
This will work for normal databases (mdb/accdb) and also compiled (mde/accde) and runtime (accdr) databases as well.

Important note

If you want to use this code do not enable the Compact on Close option in Access for your database as the code doesn’t pick that up yet.
Instead, you can either simply call restart Compact:=true on user action (for instance from a menu) or on other triggers, for instance when the database is being open and hasn’t been compacted for more than a week.

How it works

If you’re curious about the technical details, here is how it was put together.
The main idea is that the MS Access database application has to be self-sufficient and restart itself by performing these steps:

• create a small batch file
• run the batch file, passing the path and extension of our database
• close the main application
• the running batch file would wait for the MS Access lock file to be removed
• once the lock file disappears, we open the database after compacting it if required.

The key point here is that the batch file cannot just reopen the database right away: if the application is big or if it’s compacting on close for instance, it may take several seconds to actually close.
The only moment we can be pretty sure that the database is effectively closed is when the lock file is deleted by MS Access.

The batch file is hard-wired in the Restart sub that does all the work:
SETLOCAL ENABLEDELAYEDEXPANSION SET /a counter=0 :CHECKLOCKFILE ping 0.0.0.255 -n 1 -w 100 > nul SET /a counter+=1 IF "!counter!"=="60" GOTO CLEANUP IF EXIST "%~f2.%4" GOTO CHECKLOCKFILE "%~f1" "%~f2.%3" /compact start " " "%~f2.%3" :CLEANUP del %0 When the application runs the batch file, it passes 4 arguments:

• the full path to the MSAccess.exe executable (used for compacting the database)
• the full path to the database without the extension
• the database file extension without the leading “.”
• the appropriate database lock file extension (laccdb or ldb).

This allows us to easily construct the path to either the database or the lock file at line 07 and 09.
Line 08 is actually only inserted if we need to compact the database: it simply launches MSAccess.exe with the /compact command line switch.

The funny use of PING is actually a simple way to wait for some time before we check if the lock file is still there or not. There is not SLEEP or WAIT function provided by default in Windows so we have to be a bit creative and use the time-out option of the PING command trying to ping an inexistent, but valid, IP address.
Once the lock file has disappeared, we open the database at line 09 and then delete the batch file itself so we leave no leftovers.

The other thing of note is that we now use a counter to keep track of the number of times we checked the existence of the lock file.
Once this counter reaches a pre-determined amount (60 by default, ~ 45 seconds) we consider that there is a problem and the database application didn’t close, so we just exit and delete the batch file.

Download the DatabaseRestart.zip (48KB) containing both an Access 2007 ACCDB and Access 2000 MDB test databases.

Other implementations

• Roger’s Access Library (MVP) has a different implementation on offer.

Code Updates

v1.2: 13FEB2009

• Added optional parameter to compact the database during restart.

v1.1: 09AUG2008

• Now a separate test database (used to be bundled with the Colour Scheme sample).
• Added support for older Access versions (an Access2000 MDB is now included).
• Corrected wrong lock file extension for accd* files.
• Added a time-out feature after which the batch file will delete itself after a while if the Access lock file wasn’t released (for instance following a crash).
• Added checks to delete the batch file if it has not deleted itself for some reason (for instance after a reboot).
• The batch file now has a unique name based on the name of the database, allowing multiple databases to be restarted from the same directory.
• Added license notice at top of source code.
• Updated the article to reflect the changes.

v1.0: 06MAY2008

• Original version

This work is licensed under a Creative Commons Attribution 3.0 Unported License.

Luckily for us, Office 2007 stores the global colour scheme setting in the registry under:
HKEY_CURRENT_USER\Software\Microsoft\Office\12.0\Common\Theme
and Office 2010 in:
HKEY_CURRENT_USER\Software\Microsoft\Office\14.0\Common\Theme

The values being stored under that key are:

1. Blue scheme
2. Silver scheme
3. Black scheme

With this information, we can easily both read and set the colour scheme. The only caveat is that I could not find a way to notify Access to reload the setting automatically once it is changed, so users will have to restart the application before the change becomes active. A small price to pay but if anyone has a better idea, please let me know.

To write the new value to the registry I use a set of WIN 32 APIs that are more flexible than the default ones provided in VBA.

You can download the sample database as it contains all necessary files, including the definition for the Win32 API functions.

Download the ColorSchemeV1.3.zip (31KB) containing the ACCDB database.

The sample also contains some code to restart the database. This is the subject of another post: Restarting and compacting the database programmatically.

Improvements/uses:

• Find a way for Access to reload the settings without having to restart the application.
• Use the knowledge about the current scheme to change the other colour settings in the application (or even adapt the form’s theme).

Updates:

• 31MAY2011: added support for Office 2010.

References:

• Setting the BackColor to match the Office 2007 color scheme
• API Get / Set Registry functions from http://www.arcatapet.net/.

The trick is to use some WIN 32 API calls to modify the transparency of a standard MS Access form made to cover the screen.

The effect is quite neat and I thought I would try it and make a sample database for others to tinker with it.
My version allows you to chose between covering the whole screen or just the main Access window and it will test if it’s running under a Remote Desktop Terminal and disable the layer in that case.

Update 07MAY2008

Following Rob’s improvements I made another sample database that incorporates his code with a few improvements:

• I added the LightBoxForm.LayerToFullScreen property so users can choose explicitly how they want the layer to be shown.
• I moved the code to hide the layer into a Hide() sub so you can just show/hide the layer using LightboxForm.Show and LightboxForm.Hide.
• I changed the Form’s Resize event code in the LightBoxForm class to avoid flickering: resizing the form within its Resize event actually trigger the Resize event again a second time which causes flickering.
  I simply modified the code to make the form totally transparent (opacity of 0) the first time the event is fired and assign it the expected opacity when the event handler in re-entered.

'----------------------------------------------------------------------------- ' Handle the Layer Form Resize event '----------------------------------------------------------------------------- Private Sub m_objForm_Resize() Static busyResizing As Boolean Dim lngStyle As Long Dim r As RECT ' disable screen updates m_objForm.Painting = False ' When the form opens initially, we make it totally transparent to avoid flickering lngStyle = GetWindowLong(m_objForm.hWnd, GWL_EXSTYLE) SetWindowLong m_objForm.hWnd, GWL_EXSTYLE, lngStyle Or WS_EX_LAYERED SetLayeredWindowAttributes m_objForm.hWnd, 0, 0, LWA_ALPHA ' If the Access window is maximized, then maximize the lightbox form. ' If the Access window is not maximized, then ' position the lightbox form so that it covers the Access window If IsZoomed(hWndAccessApp()) Or m_bLayerToFullScreen Then DoCmd.Maximize Else GetWindowRect Application.hWndAccessApp(), r MoveWindow m_objForm.hWnd, r.x1, r.y1, (r.x2 - r.x1), (r.y2 - r.y1), True End If If busyResizing Then ' Get the current window style, then set transparency lngStyle = GetWindowLong(m_objForm.hWnd, GWL_EXSTYLE) SetWindowLong m_objForm.hWnd, GWL_EXSTYLE, lngStyle Or WS_EX_LAYERED SetLayeredWindowAttributes m_objForm.hWnd, 0, (m_sngOpacity * 255), LWA_ALPHA ' enable screen updates m_objForm.Painting = True ' Back to normal busyResizing = False Else busyResizing = True End If End Sub

Samples

There are now 2 sample databases. Ech zip contains a Microsoft Access 2007 ACCDB file and its conversion to Access 2000¹ and Access 2002-2003 MDB but please note that I have not been been able to test those in older version of Access and that form transparency doesn’t work in Operating Systems older than Windows 2000.

Download TransparentLayer02b.zip (138KB), recommended version
(improved, more flexible version, based on Rob’s updated article).

Download TransparentLayer01b.zip (122KB), original version
(simple code, based Rob’s original article).

Troubleshooting

• If you are getting security warnings: make sure that you open the database from a Trusted Location or you will receive a security prompt. If you don’t know how to do that, check these steps.
• If the layer appears on top of the login form instead of behind: make sure that the top-most form has ist Modal properties set to Yes and the frmLightBox form has its modal property set to No.
  If you improve on it, please let me know and I’ll post it here for all to find.

Good graphic designers who work on User Interfaces are too few and far between, and large organisations will take time to get staff with a sufficient level of expertise to be useful in developing meaningful WPF/Silverlight applications.
Until now, the bulk of the development effort was done by developers. Most ISV only have developers onboard.

As far as I can tell, it seems that main reason behind this slow adoption is that WPF/Silverlight has only been noticed by developers and they don’t know what to make with it.
WPF/Silverlight are not really developer-friendly: the development infrastructure is there but we’re left with a blank canvas and nothing to drag and drop onto it.

There will be a great gap, probably lasting a few years, before there are enough experiments in these new user interfaces that some useful lowest common denominator can be exploited by non-designers.
We’ll have to wait for tool vendors to provide the bulk of user interface blocks and for a few new patterns to appear before all the designer-challenged developers like me can make decent interfaces without requiring a professional graphic designer in their midst.
In the mean time, we’ll probably have useless, but pretty, applications, some useful, but ugly ones and a lot of people scratching their head trying to couple the designers and the developers in a working relationship.

Here are some reasons why SQL Server Express may be a good choice:

You’re upsizing an Access database

SQL Server is the natural extension of upsizing an existing Access database. It work automagically with minimum effort providing that you followed some simple good-design rules from the start.

You’re future-proofing your needs

Because SQL Server comes in many flavours, you know you -or your customers- can upgrade to a more capable (albeit more expensive) version in the future if needed.

Very flexible

As usual with a lot of Microsoft development tools, SQL Server will happily let you shoot yourself in the foot by providing you with a fairly easy way to treat your database as a complete development platform.
It’s good in the sense that you have interesting tools and capabilities included in the server, and it’s bad for the exact same reasons.
I tend to prefer database servers to be just that: data repositories, and I’m not too fond of relying on specific, non-standard features of a particular database system, but what do I know.

Excellent out-of-the-box development support

Deep integration with .Net and Visual Studio, without any effort, Microsoft saw to that of course.
In some cases, such as LINQ to SQL, it’s almost the only real choice, although the other database vendors are working hard at the necessary providers, so that lead should be short-lived.
There is something to be said about developer productivity: you have to give credit to Microsoft for making their tools well integrated and usable from each-other. What it means is that for small developer shops there is much to gain in surrendering to this “ease of the default”.
Of course, it’s a double-edged sword, but having a complete development infrastructure work out of the box is certainly a big help, and if you don’t like it, you’re still free to chose something else.

Lots of tools

With SQL Server Advanced Services, you also get Server Management and Reporting Services. These are great tools made available for free.
The only missing one for SQL Server is the Reporting designer. While the reporting service means that you can use existing reports, only SQL Server Standard and Enterprise have it.
There is an option for developers though: the (nearly free) SQL Server Developer edition is in fact the same as SQL Server Enterprise, without the license to use in non-developer or tester environment. This means that as a developer, you can create and distribute your reports to be used by your customers who will be using SQL Server Express.

Did I mention it’s free?

All this is free, as in beer, not as in liberty though.
For commercial applications targeted at small businesses, SQL Server Express is a really good choice: you can distribute it without problem, the customer gets all the tools, can easily find outside support, and they can always migrate to a more beefy version if their needs grow, all that without having to depend on you.
So it sort of offers customers a kind of freedom that they wouldn’t have with other choices.

Of course you can get that with other database systems, although you have to be careful which Open Source one you choose: I recently decided not to use MySQL any longer for the simple reason that it’s too expensive and restrictive in a business environment, at least for the kind of work I do.

Why would you not want to use SQL Server Express?

You don’t want to depend on Microsoft

That can be a good reason enough sometimes. There is nothing preventing Microsoft from crippling SQL Server Express in the future to force users to move to a paying version early.
I suppose that whatever database system you use, even Open Source ones, there is always the possibility that the company supporting its development goes bankrupt, the Open Source projects goes dead or decides to go in a direction that doesn’t suit you..

It’s only supported on Microsoft OS

True, and that’s a good reason to chose something else.
There is a hidden cost in SQL Server Express: it needs to run on a Windows machine, and that’s not free, although SQL Server will work on older Windows 2000 machines and Windows XP which are arguably not expensive.

Your database needs will exceed SQL Server Express specifications

If you think any of your databases will grow beyond 4GB or that it will get busy and you need all the RAM and CPU you can get, then SQL Server Express is probably not for you as it will only use 1 CPU and 1GB of RAM at most.
If your needs go beyond that, then you’ll have to move to a paying version.

Upgrading can be expensive

It’s true that moving to the next cheapest upgrade of SQL Server Workgroup will cost you about US$700 for a 5 user license. The limits imposed on the database are much higher (2 processors, 3GB RAM and no size limit) but if you need more clients / or higher limits, then the expense will grow quite fast, and you’ll have to manage those hateful client access licenses.

Your needs are more modest

We haven’t talked here about single-file/single-user database systems. These databases don’t user resident services and are usually meant for more limited needs, sometimes allowing only a single user to be connected.
The footprint of these non-server databases is a lot smaller, typically only requiring a single dll or a handful of files to be installed.
They are extremely useful for desktop application that do not really require multi-user support or advanced security features.
Here again, Microsoft offers SQL Server Compact, which, despite the name, doesn’t have much to do with the other SQL Server editions. This one is also free, but has a limited feature set and only allow single-user access as it is meant to be a lightweight database and works well in limited memory environments such as those found on mobile devices.
Of course, here again there is a lot of competition: Thunderbird, SQLite, MS Access and VistaDB (for embedding into .Net applications, not free) to name a few.

These are pretty good times when it comes to databases: we get more choices now than we ever had.
As usual, choosing a database as a back-end for your products isn’t easy: you need to consider cost, licensing, support and the future.
There isn’t a single database system that will meet everyone’s needs for all types of use, so choose carefully.
SQL Server Express is a very good contender in that market. It should not be dismissed out of hand because it’s from Microsoft, in the same way that PostgreSQL shouldn’t be dismissed because it’s Open Source.
Just use the tool that best answers your needs for your particular circumstances.

References:

• SQL Server Express main page
  www.microsoft.com/sql/editions/express/
• Compare SQL Server editions
  www.microsoft.com/sql/prodinfo/features/compare-features.mspx
• System Requirements for SQL Server Express
  www.microsoft.com/sql/editions/express/sysreqs.mspx
• SQL Server Compact (single-user, small footprint database)
  www.microsoft.com/sql/editions/compact/
• The VistaDB database, commercial embeddable database for .Net applications
  www.vistadb.net/
• SQLite database, public domain, flexible file-database system
  www.sqlite.org/
• The Firebird DB (based on Interbase 6 from Borland)
  http://www.firebirdsql.org/
• PostgreSQL Open Source database server
  http://www.postgresql.org/

If you are from North America and a handful other countries 04/05/01 would mean 5th of April 2001.
If you’re in Asia or some eastern countries, if could be 1st of May 2004.
For the rest of the world, it would look like 4th of May 2001.

We cannot ignore any longer the importance of writing dates in a format that is understandable by everyone.
Still too often, web sites -even big companies- with a global audience state dates in a format that is probably obvious where they live but not consistently so to everyone else.

Developers are sometimes guilty of this sin, as can be seen in the format chosen to specify dates in Microsoft Access SQL, which requires that hard-coded dates be formatted in the US rather than the more neutral ISO8601 format.
I wonder how many bugs that little egocentric feature caused in business applications that where developed by foreign coders…
I know it also happened to me at least once…

The worst thing is that when you write 04/05/06, you may very well have thought about the rest of the world and meant DD/MM/YY; alas, unless the context grants us some clarification or the actual date is unequivocal, there is sometimes no way for a lot of us to know for sure what you really meant.

We should ban the use of the short date format in communications that may be read by more than 3 people, in today’s world, that’s pretty much all communication.

Instead a simple format such as 05MAY2006 is clear an unequivocal: it’s easy to read and understand, regardless of where you live.
You’re free to add spaces, dashes, dots, comas or slashes to it if you want, you can use 2006MAY05 if you prefer or even MAY05,2006, whatever pleases you: it still remains readable.

The rule is simple:write the year in full and never write the month as a two-digit number, that’s reserved for the day

The point is that you, me and the rest of the world can read it and understand exactly what was meant; it’s an easy problem to solve.
Surely that means something to you?

References

• http://en.wikipedia.org/wiki/Date_format
• Does you code pass the Turkey test?

Install the client-side highlighter

Download dp.SyntaxHighlighter. Uncompress its content under a new /skins/common/SyntaxHighlighter folder in your MediaWiki installation (don’t forget to make sure the files can be read by the web server; for instance, on Linux you may use chown apache.apache -R *).

In the skin template you are using for your MediaWiki site, insert the necessary code as required. In my example, I use the default /skins/MonoBook.php template into which I added the following:

Just before the closing </head> tag:
<!-- http://www.dreamprojections.com/syntaxhighlighter/ --> <link type="text/css" rel="stylesheet" href="/skins/common/SyntaxHighlighter/Styles/SyntaxHighlighter.css"></link>Just before the closing </body> tag:<!-- http://www.dreamprojections.com/syntaxhighlighter/ --> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shCore.js"></script> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shBrushCSharp.js"></script> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shBrushXml.js"></script> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shBrushSql.js"></script> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shBrushJScript.js"></script> <script language="javascript" src="/skins/common/SyntaxHighlighter/Scripts/shBrushPhp.js"></script> <script language="javascript"> dp.SyntaxHighlighter.HighlightAll('code'); </script>

Note that you must include a reference to each source file corresponding to the type of programming language you want to highlight.
Have a look under the /skins/common/SyntaxHighlighter/Scripts/ folder to see which languages you can highlight; there are a lot more than the few I use on my site.

Install the WikiMedia extension

I’ve created a small extension to WikiMedia to allow us to enclose any source code in a new <codesyntax> tag. Click on the View Plain option below and copy-paste the following code into a new file that you will save under /extensions/syntaxhighlighter.php (again, make sure this is readable by the webserver).
<?php /************************************************************ ** Simple WikiMedia extension to create a new <codesyntax> tag that renders ** syntax highlighted through the dp.SyntaxHighlighter javascript helper ** See http://www.dreamprojections.com/syntaxhighlighter/ ** See http://meta.wikimedia.org/wiki/Extending_wiki_markup ** (c) Renaud Bompuis, 2007 ** ------------------------------------------------------------------------------ ** v1.0 - 20EFB2007 : first version. Uses the <pre> tag to ensure that the content of ** the <textarea> containing the source code will not be messed up by WikiMedia. ** There are certainly better ways to do this, but they seem more complicated than this ** (registering hooks, recording content before it is expanded and then replacing ** messed up content with the original) ************************************************************/ $wgExtensionFunctions[] = "wfSyntaxHighlighterExtension"; function wfSyntaxHighlighterExtension() { global $wgParser; $wgParser->setHook( "codesyntax", "renderCodeSyntax" ); } // The callback function for converting the input text to HTML output function renderCodeSyntax( $input, $argv, &$parser ) { $output = "<pre style='border:0;padding:0;margin:0;'>" ."<textarea name='code' class='".$argv["lang"]."'>" .Xml::escapeTagsOnly($input) ."</textarea></pre>" ; return $output; } ?>
Add the following line to the end of your LocalSettings.php file, right before the closing ?> tag.
require_once 'extensions/syntaxhighlighter.php';

Usage

To highlight code in your MediaWiki pages, just enclose your source code with the new <codesyntax> tag. This tag takes a lang attribute to specify the options that normally would be listed in the class attribute in the dp.SyntaxHighlighter documentation.

For example:
<codesyntax lang="c#"> string url = "<a href=\"" + someObj.getUrl() + "\" target=\"_blank\">l;"; // single line comments // second single line override protected void OnLoad(EventArgs e) { if(Attributes["class"] != null) { //_year.CssClass = Attributes["class"]; } // base.OnLoad(e); } </codesyntax>
Will display as:
string url = "<a href=\"" + someObj.getUrl() + "\" target=\"_blank\">"; // single line comments // second single line override protected void OnLoad(EventArgs e) { if(Attributes["class"] != null) { //_year.CssClass = Attributes["class"]; } // base.OnLoad(e); }

For more information on using dp.SyntaxHighlighter see:
http://www.dreamprojections.com/syntaxhighlighter/Usage.aspx

When you start looking into all these platforms you can be blown away by the ease of implementation and elegance of some; your head spins at all the features and claims being made and it becomes hard to achieve a rational decision.

I’ve been faced with that very issue recently and it sucks. Actually, the time spent investigating all these possibilities is really what is being sucked away.
Of course, learning about new technologies is not just fun, it’s also essential: you have to keep on top of what’s new and decide if you want to join in on the fun or just stay comfortably where you are.

I also realized that you need to get away from the coolness factor of each these much touted technologies and actually try to be objective.
During my investigation, I tried to decide what were the really important factors that I should consider to make a rational choice.

I came up with the list of the following 10 questions that I think everyone should ask themselves when choosing a platform for an important project.

1- Is the platform wide enough?

New technologies that can show amazing productivity get all the buzz. After all, that’s what we developer want: enough with the nuts & bolts! Give us a toolbox with all new shinny power tools! The problem is that often these technologies are impressive, but looking beyond the sample projects into what actual users get confronted to, you start noticing discussion threads that should obviously signal that the platform is not wide enough.
Choosing a technology that hasn’t achieved its goals can be a huge problem down the line: you implement 80% of your project in record time, only to realise that the platform you chose doesn’t support proper cross-browser detection, or that its implementation of security is way too lax, or that it only support XML for data storage and now you actually need a real database for performance reasons…
In those cases, you can of course develop those areas yourself and contribute to the project, but doing so supposes that you planed it all along and you factored that in your schedule, both in time and in cost.

2- Is it popular?

In other words: are other professional people actually using that platform in real life? I’m not talking about Joe Developer using it for his local community church website. I’m talking about businesses or large organisations actually using that software platform successfully.
If all you need is a simple 3 page website, then professional popularity amongst the Top 500 business companies is probably not that important. On the other hand, if you plan to build a large project, or you know that your project could grow large in the future, then you probably want to ensure that others have taken it there before you.

3- Is it mature?

Has the platform existed for long enough that it went through enough abuse to withstand almost anything you can throw at it?
A technology that is only a couple year old may be too young to have evolved to the point where it actually can solve most common and not-so-common problems. Technology evolves through iterations: each one is a good long hard look at what didn’t work and tries to fix, improve and extend.
A young technology may be more cutting-edge and exciting, but when you need to commit to it for a big project, its age may quickly come as an issue; its shinny surface may blind you to the black holes waiting below…

4- Are local developers available?

Always think about the future. When you’re gone from the project, who is going to look after it? Getting a web project entirely in Rebol may be cool and fun, but how many people in your city actually use that thing anyway?
Aren’t you creating a liability if you’re dead-set on choosing a platform that cannot be maintained?

5- Is it scalable?

Most projects start small but dream of ending-up big.
It’s usually fine at the beginning when the number of users and visitors is manageable, but what happens when you start to be successful?
After all, that’s why we craft our projects: we want them to succeed, we want the world to see them. When the world starts coming though, will the terrific platform we’ve chosen break at the seams?
How much overhead does the platform create? It is flexible in its database support? Is there a way to implement clustering or persisting sessions accross multiple servers?
What’s the cost in memory and CPU resources? How many simultaneous connections can you get? What are the bottlenecks? What do you need to do to compensate for them? How much would it cost?

6- Do you have control?

Some frameworks work hard for you and can make you really productive. Sometime though, they try too hard and hide too much from you.
When a feature doesn’t exactly work the way you want you have to dig deep into the entrails of the beast to make sense of it and change its behaviour.
A platform that was all nice and pretty can get very dirty and complex inside, making it difficult to adapt to your needs.
A platform should do most of the hard work but still allow you to redefine its default behaviour without much hassle. It should be built with extensibility in mind, making easy thing easy and difficult things possible.
A case in point are 4G development platforms: they usually have a fairly narrow field of expertise and tend to use graphics and nice simple paradigms to quickly build complex tasks but when you are faced with a specific issue that hasn’t been solved by the platform, you often have to resort to ugly hacks to get around their limitations.

7- Does it satisfies the essential constraints for your project?

When being blinded by something cool, we often become skewed in our judgement and guilty of lowering the importance of constraints that are actually critical for our project.
In all honesty, I really wanted to use Ruby on Rail, and I liked the principle and elegance of it so much that I came to seriously consider it, that is, until I came to my senses and looked into something that is critical to my project: support for complex Asian languages.
Ruby is being developed in Japan, so you could think that it should be able to handle complex ideographic characters well.
Turns out that the Japanese are not terribly fond of Unicode and, unless I’m mistaken, prefer to use Code Pages instead. The result is that Ruby doesn’t have great support for Unicode, and that sucks.
That’s why Unicode was created: to attempt to simplify all this patchwork of implementations that are not compatible with each other.
Because I needed to be able to handle English, Mandarin, Cantonese and probably any other language out there, Unicode is the only viable option to abstract the issue of language enough that it becomes manageable.
So because of Ruby’s poor support for Unicode, it would not be rational to use Ruby on Rails for my particular project as it would probably greatly increase the complexity and hacks necessary to manage complex Asian languages in a unified and simple way.

8- Documentation?

All framework have a more or less steep learning curve: you need to think differently to adapt to the particular framework’s frame of mind, so to speak.
Make sure that the framework has a lively community, that it has more documentation than you can swallow and that documentation is well organised.
Make sure also that there are samples, tutorials, webcasts, videos or whatever that cover the principle aspects of it.
A beautiful framework no-one talks about means that no-one will answer when you have a question. A beautiful framework without documentation is useless. A beautiful framework with lots of disorganised docs means that you’re going to waste a lot of time experimenting instead of building your project.

9- Support?

Here I mean support in the wide sense of the word: who is behind the framework. Are they likely to stay in business long after your project has been completed?
Are they commercial or Open Source? In either case there are issues for and against: a commercial venture backed by a small company may falter and disappear overnight. Similarly, an exciting open source project managed by only 2 people can suffer the same fate when they decide to move on. Support also includes what help is available to you when you encounter issues. Is there any guarantee that you could have your important technical questions answered?
If you encounter a large issue, is there someone to help you?
I would contend that the best and most serious projects should have professional help available: you can always fall back on paying someone to help you through, whether it’s the original developers, a paid-for support hotline or a third-party specialist, it’s important that you know you can get your answers when you’re stuck.
Developing for an important project without safety net is dangerous: you can waste a lot of time and effort, endangering the very project you are undertaking, if you stumble on a problem you cannot solve yourself.
Large frameworks like .Net or big Open Source projects usually have enough users and support groups and specialists that it’s likely any question you may have has already been answered somewhere or that you can pay someone to help you out when you need it most.

10- What do you know best?

Every framework is based around a particular data-management model. Every framework is built with a particular programming language in mind. Every framework demands that you learn something new. How comfortable are you with the requirements? how long is it going to take you to start to get really productive?
Like their real-world counterpart, it can take very little time to learn a new language’s words and syntax but it takes years to become proficient in it. A framework adds another layer of abstraction that you will need to get experienced at.
If you need to both learn a new language and a new framework, chances are that you are at best months away from being able to churn code without having to look into the documentation every 5 minutes.
Learning new languages and concepts is necessary, but again, if you chose that route you must be sure that your project has that learning curve built-in, otherwise you’re going to move at the pace of a turtle when in fact you chose that particular framework because you though you would be more productive and faster than a sparrow.
If you chose a new framework, make sure that you already possess most of the knowledge it requires: in my particular instance, I chose .Net and C# because I have already worked in that framework and I know it can tackle the project without me having to waste too much time on learning the platform rather than implementing the project.

We all should seize any opportunity to learn something new. Learning is often more exciting than doing the same old thing over and over again and it’s a necessary part of staying in business. Curiosity is an excellent quality that must be nurtured and indulged.
The issue is when to do it.

Choosing a new development framework is not easy. The best way to tackle the problem is to pose it as a risk analysis study.

The framework you chose should simply be the one that poses the least risk to you succeeding your project.

The only thing I really dislike about Microsoft is its marketing, its pricing, its Genuine (Dis)Advantage that nags me every time I need to install something and its lack of openness when it comes to inter-operability with other competing implementations (here I’m particularly thinking about its network protocols that the Samba team tries to decipher and re-implement as an Open Source platform).
On the other hand, Microsoft is made of great programmers, great minds that you can watch on Channel 9 and read on their insightful blogs.

Microsoft is really (I mean REALLY) pro-developer: they understand that the Operating System alone is nothing without lots of applications sitting on top of it, and they offer developers a lot of goodies.
One such useful programme is +Microsoft Empower for ISV_. It’s a simple membership that allows a small software company (ISV meaning Independent Software Developer) to own a number of licenses for its internal use at a fraction of the price it would normally cost.
What you get is pretty wide for a small business: 5 licenses for Windows XP (whatever version), 5 licenses for Microsoft Office, 1 license for Windows 2003 Server and Exchange, SQL Server, SharePoint Portal, a MSDN Premium Subscription that covers almost anything else, including 5 licenses for Visual Studio 2005 Pro.
You also get access to MSDN downloads, beta software and tons of libraries, SDK, etc. A MSDN subscription alone is about US$2000…
The Empower ISV programme is quite cheap and depend on the country you are in.
I paid mine HK$4,260 about US$530.

To get all this you need to register as a Microsoft Partner (that’s free), then apply for the Empower for ISV programme by making a promise to release a commercial software within 2 year at most. You need to give some details and pay your due. After a few days, you get confirmation if your application is accepted or not.
As far as I know, you need to be a company and have a company website, but that may not be mandatory in all regions.
The software you get is the normal US version plus whatever local version there are for your region. My bunch of DVD came in Japanese, Cantonese, Mandarin, some in Korea and Thai too.
At least, the English version is supplied. For some software, you also get the multilingual version that include European languages as well.
You manage your licenses by login under your MSDN account.

Really, it’s a nice touch from Microsoft to give us poor developers access to all this for such a reasonable price. I can only encourage other small software companies and independent developers to do the same.

Using PropertyInfo you get enough information about a particular property to decide if you want to display it or recurse into it if it’s a complex type that contain other properties.

The only big issue I faced was when dealing with indexers.

The issue with Indexers

Indexers are defined in code like that:
using System; using System.Collections; public class DayPlanner { // We store our indexer values in here Hashtable _meetings = new System.Collections.Hashtable(); // First indexer public string this[DateTime date] { get { return _meetings[date] as string; } set { _meetings[date] = value; } } // Second indexer, overloads the first public string this[string datestr] { get { return this[DateTime.Parse(datestr)] as string; } set { this[DateTime.Parse(datestr)] = value; } } } We’ve defined an overloaded indexer: one takes a DateTime, the other just a string representation of a date.

We could use them like that for instance:
DayPlanner myDay = new DayPlanner(); myDay[DateTime.Parse("2006/02/03")] = "Lunch"; ... string whatNow = myDay["2006/06/26"]; Now, let’s say we want to print all property names and their values for an arbitrary object.
Let’s try on our myDay intance:
Type type = myDay.GetType(); PropertyInfo[] picoll; picoll = type.GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static); foreach (PropertyInfo pi in picoll) { object val; val = pi.GetValue(myDay, null); Debug.WriteLine(pi.Name+"="+val) ); } So, that part is easy: we iterate through all properties of myDay and print their Name and they value.
Problem is, when we reach the indexer property, we get a TargetParameterCountException on line 8.

We need to detect the indexer before attempting to get its value.
To do that, we need to modify our foreach loop to:
foreach (PropertyInfo pi in picoll) { object val; ParameterInfo[] parcoll = pi.GetIndexParameters(); if (parcoll.Length == 0) { val = pi.GetValue(o, null); Debug.WriteLine(pi.Name+"="+val) ); } } Here we attempt to get the indexer parameters for every property. If we’re dealing with an indexer, the parcoll array will contain a list of ParameterInfo related to that particular indexer.

So what really is this parcoll and its ParameterInfos?

A ParameterInfo contain information about the parameter of an indexer property.
The parcoll array will contain one entry for each overloaded indexer.
In our concrete example this is what we get:

• pi.Name will be Items, this is standard for all indexer properties.
• pi.PropertyType is the type of the returned class of our indexer, in our case, a System.String.
• parcoll.Length will be equal to 2 because we have 2 overloaded indexers.
• parcoll[0].Name will be date.
• parcoll[1].Name will be datestr.
• parcoll[0].ParameterType will be System.DateTime.
• parcoll[1].ParameterType System.String.
• parcoll[0].Member and parcoll[1].Member are in fact references to pi itself

That’s a lot of nice information about our indexer, but what if we want to get a value from it? Consider the definition for GetValue:
PropertyInfo.GetValue(object o, object[]{} index). That second parameter is used to get a value from the indexer.

So, how do we use it?

If you know valid keys that you can feed to the indexer, then you just do that (assuming that pi is the PropertyInfo for the indexer).
string meeting; meeting = pi.GetValue(myDay, new string[]{"2006/02/25"}) as string; Or, if you prefer to use a DateTime: string meeting; meeting = pi.GetValue(myDay, new DateTime[]{DateTime.Now}) as string; But what if you don’t know anything about the values contained by the indexer?
Well, unless you use attributes to decorate the indexer or the underlying storage field with specific custom information, you’re basically screwed.

To understand why, just consider how the indexer is implemented:
When you pass it a DateTime or a string as a parameter, it just passes it on to the getter/setter as the value.
What is done with that is up to the implementer.
If you want to maintain a collection of some kind, then you need to use private fields to hold the keys and their values.
.Net doesn’t store the values passed to the indexer or the values returned by it anywhere.

Consider how .Net doesn’t give you any means of iterating through the keys and values of an indexer.
You can’t do a for(;;) or a foreach() loop, you can’t even know how many items are maintained through the indexer by directly questioning it.
So, it certainly is normal that you cannot get anything out of the indexer without knowing exactly how to access it.

The Observer Effect

In many fields of science, the act of measuring something, whether it’s an electronic circuit or a psychological experiment, can actually influence the observed phenomenon.
This is unsurprisingly called the Observer Effect.

In .Net, Reflecting on object can be very much the same.

Consider the use of Reflection when it comes to getting information about an object:
You use metadata describing the object to get more meta data information about its members You can use that meta data to direcly query the state of an object.

If you limit yourself to getting metada, then no harm is done: you’re not querying the object instance itself but the metadata about its class.

If you start querying an actual object instance for its values then you are actively interacting with it.
In most cases, if you’re just getting the value of Fields or Properties defined as follow, then it’s fine:
class GetMe { private string _meeting; public string Meeting { get { return _meeting; } set { _meeting = value; } } } Using reflection, we can get the values of both _meeting and Meeting without any side-effect to the object.

Now consider this:
class GetMeNot { private int _collection = null; public int Collection { get { if ( _collection == null ) { OpenDatabaseConnection(); _collection = FetchAllData(); } return _collection; } } } Now what we’ve got here is a case of lazy loading or lazy initialization.
The consequence is that by querying the Collection property we’re actually creating it, with a potential for a lot of side-effects, like the change of other properties, here maybe related to opening the database connection for instance.

So, when getting values of the properties of an object instance, we can actually completely change its state.
Whether this is a concern or not really depends on what you’re trying to achieve: you may not be able to achieve being a passive observer using Reflection unless you know about the construction of the particular class you’re dealing with.
Using Attributes, you could give hints about which Property not to query and which Field to get instead. In our case, we could add a custom attribute like [ImplementedBy("_collection")] to our Collection property for instance.

If you want to do something generic, then you’re out of luck it and have to deal with that fact.
One possible way to minimize the effect would be to not query Properties that only have a getter and no setter, but that’s not a guarantee that all properties that implement a getter/setter are going to play nice.
Then there is also the -probably rarer- case of the Property that only has a setter.
Then there is also the case of the property getter that has some in-build security and will return different things depending on who’s calling…

All this seems pretty obvious once you understand the whole picture but it’s easy to get so impressed and dazzled by the power of Reflection that you don’t realise its natural limits.

There is an impedance mismatch between the usual programming technology and the database worlds. The mismatch occurs because most development is object-oriented and most database systems are query-based.
Getting data from the database into your objects and back is tricky and difficult to maintain: any modification in either camp needs to be reflected to the other.

One solution is to use an intermediate layer to take care of the impedance mismatch for us: that’s the job of he ORM.

When I initially took the decision to use an ORM I tried and reviewed a few. Each have a different way of doing their job and place emphasis on different things, depending on the school of thought they belong to.
Most still require a database-centric view and either abstract the whole and let you deal with meta-data that used to modify both code and database or they just let you modify the database and then update automatically the code.
Then there was XPO.
This one was a bit different: it really completely abstracted the database. It would create and update it automatically (whenever possible) without you having to ever deal with how the data is stored: it would work in the exact same way regardless of the underlying chosen database.
You could even use it on an already existing database and it would be happy to talk to it.

So I chose XPO.
It didn’t have fancy designers but it offers a simple, reliable and flexible way to persist my objects in the database of my choosing.
One thing to note too is that you can get it with full source code (not commented though).
I find it reassuring when a company doesn’t mind its code to be scrutinised by its customers. It’s also proven invaluable in finding out XPO’s inner working (not that I understand a lot though).

I’ll be blogging a few articles in the future on various aspects of XPO that I think may be of interest to those already working with it. I’m not going to re-state what’s in the documentation or on the Developer Express (DX) community website and official pages, there is a lot of information available out there, it’s just sometimes hard to get to know the fundamentals because it’s sometime buried deep. Whenever possible (depending on time and complexity) I’ll make a sample project. I’m even thinking about building a repository of samples showcasing various aspects of XPO.

Let’s see if I can hold the load for long…. I’ve also committed myself to DXCore recently… but that’s something for another post altogether…

References:

• Official XPO product page
  http://www.devexpress.com/Products/NET/XPO/
• XPO articles on the DX Community blog
  http://community.devexpress.com/blogs/xpo/
• DX Peer Support newsgroups
  http://www.devexpress.com/Support/Newsgroups.xml
• DX Knowledge base articles
  http://devexpress.com/Support/KnowledgeBase/
• DX Support center where additional information, tips and bug reports can be found.
  https://www.devexpress.com/support/center/
• An extensive list and description of available ORM for .Net
  http://www.howtoselectguides.com/dotnet/ormapping/

One self-inflicting problem I’ve often been confronted to is over-engineering: I tend to over-think, over-design and over-anticipate.
Sometimes it’s good to just spend time trying to make your code more modular and as future-proof as you can, but often, it leads to code that has no real use right-now, and that ends up having to be modified because when you need it, it’s not in the form you’ve implemented it originally.
This is an Extreme Programming practice aptly named You Aren’t Gonna Need It.

A classic example of YagNi that I am paying dearly is a large application I’m working on at the moment (at least large from the perspective a single developer).
It’s a fairly complex database application with an equally demanding winform GUI layer in C# on top.
I built the GUI in a very modular fashion: each bit of information that could be grouped has its own User Control, sealing its particularities.
Then each of these controls is used in panels that embody another layer of functionality.
Each panel is then loaded as needed into a form that display the panels on demand.
The issue is that I now have to make major changes to the application and there are too many layers in these controls, making code hard to change.
I had built it this way for re-use, thinking that it could be useful to have independent specialized controls, say for entering addresses, or customer details, etc.

Well, each of these controls took me a lot of time to craft, trying to make them as independent upon my particular implementation as I could. It turns out though that I’ve used each control no more than once -maybe twice for a couple- in the whole of the application, and I now realize that it’s unlikely that I would get another job that would require the exact same user-interface broken down the exact same way.
So my uber-GUI controls are mostly a waste of time and complexity.

I should have simply created the forms directly, using partial classes (a new .Net 2 feature) to separate each logical part into something manageable.
My application would have been faster to develop and faster to run, with a lot less of unnecessary layers of abstraction.

I’m having a hard time with that, but I’m getting better, hopefully…