haslo.ch - Guido's Blog » code

SetProperty and GetProperty with C# Reflection

haslo — Sat, 12 Sep 2009 12:32:29 +0000

I’ll make a post soon, comparing Ruby on Rails to C# with ASP.NET MVC, but this here is atomic and might be of help for one or two readers.

If you want to set and get properties in C# in a type-agnostic way, these are the functions you want to put into a library class somewhere (or, as I did, into the class that uses them):

private object getProperty(object containingObject, string propertyName)
{
    return containingObject.GetType().InvokeMember(propertyName, BindingFlags.GetProperty, null, containingObject, null);
}
 
private void setProperty(object containingObject, string propertyName, object newValue)
{
    containingObject.GetType().InvokeMember(propertyName, BindingFlags.SetProperty, null, containingObject, new object[] { newValue });
}

That’s all I will say on this subject.

Creating my own little Portal Site

haslo — Wed, 22 Jul 2009 11:43:15 +0000

As you may or may not have noticed, I now have a second blog: haslos Politblog. I decided I’d want to blog about Swiss politics from time to time as well, and with this blog being English only and having a global rather than Swiss target audience, these subjects didn’t really fit in here.

Politblog

So I went and started a second blog. Finding a theme and installing WordPress was one thing, but how do you tie those things together? And while we’re at it, why not add stuff like the Twitter feed or Delicious bookmarks? And why not make a mini-tutorial out of it? (That idea actually wasn’t mine, thanks @knowLED!)

When looking at easy ways to create such a mashup for a portal site, I stumbled upon the Google AJAX Feed API, and was amazed. Essentially, it does everything we need, in a format that’s incredibly easy to style with CSS. The higher-level FeedControl class is easy to use, and does exactly what I need: display a collection of feeds in

elements.

If you want to use it as well, I suggest you sign up for an API key (although it’s not mandatory). The code that actually fetches the feeds then is simple. Add this to your HTML element…

 src="http://www.google.com/jsapi" type="text/javascript">>

…and then include bits of JavaScript that load the feeds. Since I wanted to be able to style the blog feeds a bit differently from the other feeds, I created two empty

elements that they’ll go into in the HTML body, with the ids “blogfeeds” and “otherfeeds”. Empty because they’ll be populated with the AJAX JavaScript goodness.

 id="blogfeeds">>
 id="otherfeeds">>

This is the JavaScript code, populating two FeedControl objects in an array and then rendering them to their respective

s. The feed URLs don’t have to be escaped, the escaped bits you see are what the Google API puts in as titles; I wanted those to be links to the respective feed source. Make sure you put it between tags, best in the page header:

google.load("feeds", "1");
function initialize() {
  var feedControl = new Array(new google.feeds.FeedControl(), new google.feeds.FeedControl());
 
  feedControl[0].addFeed("http://www.haslo.ch/blog/feed/", "<a href=\"http://www.haslo.ch/blog/\">Blog</a>");
  feedControl[0].addFeed("http://www.haslo.ch/politblog/feed/", "<a href=\"http://www.haslo.ch/politblog/\">Politblog</a>");
  feedControl[1].addFeed("http://feeds.backtype.com/haslo", "<a href=\"http://www.backtype.com/haslo/\">BackType</a>");
  feedControl[1].addFeed("http://twitter.com/statuses/user_timeline/14274896.rss", "<a href=\"http://twitter.com/haslo/\">Twitter</a>");
  feedControl[1].addFeed("http://feeds.delicious.com/v2/rss/haslo?count=15", "<a href=\"http://delicious.com/haslo/\">Delicious</a>");
 
  feedControl[0].setNumEntries(6);
  feedControl[1].setNumEntries(6);
 
  feedControl[0].draw(document.getElementById("blogfeeds"));
  feedControl[1].draw(document.getElementById("otherfeeds"));
}
google.setOnLoadCallback(initialize);

That’s it, that will populate the

elements with the feed data. Unstyled, this does look a bit ugly though, a mere list. So I added some CSS, and used this nice tutorial here for making the footer stick to the bottom. Go and have a look, it’s all explained nicely there. Inside that footer, I styled the elements (with Google’s classes, found easily with Firebug) like this:

.gfc-results {
  height: 460px;
  overflow: auto;
  padding-left: 3px;
}
.gfc-resultsRoot {
  height: 500px;
  float: left;
  position: inline;
}
 
#blogfeeds * .gfc-resultsRoot {
  width: 23%;
}
#otherfeeds * .gfc-resultsRoot {
  width: 18%;
}

Finally, for the title, I made an absolutely positioned

at the top, et voilà.

The last step was making Facebook aware of the fact that I now have two blogs. As you may know, you can only add one source of the type Feed/RSS for automatic updates (nice tutorial for adding RSS feeds to Facebook). Which is silly.

But anyway, the way around this involved Yahoo Pipes, or rather, just one rather simple pipe that involves a union of the two feeds, and then a descending sort by date. I made a copy of it public, have a look. They’re nice like that, you can just drag-and-drop elements that you want to use, and connect their outlets (lower end) with other element’s inputs (upper end) until you reach the “pipe output” element, creating a flow diagram that works out of the box.

Portal

That’s it already, and here’s the result. I hope you can use an element or two out of this post for your own projects

Getting MySQL 5.0 to work in Ruby 1.9.1 on Windows 7

haslo — Fri, 03 Jul 2009 00:15:59 +0000

So, I got MySQL to work for my Ruby on Rails development environment. Let’s be clear about what I actually wanted:

Ruby 1.9.1
Rails 2.3.2
Any version of MySQL whatsoever
Any way whatsoever to make my up-to-date Ruby on Rails talk to that MySQL

I don’t care what version of MySQL. I don’t care if I have to force platforms for Gems or recompile or whatever. I never did care, and I’ll happily even dig through code to make manual changes before compiling or what-have-you. What I do care about is actually getting this to work, so I can finally stop tinkering and start doing something productive.

Well, I learned a lot on my way there. I had a glimpse at how extconf.rb works (because I had to figure out correct parameters), I dug through rails sources to find errors that you don’t even want to know about, had another good look at makefiles, and generally tried to understand what exactly didn’t work.

Also, there is a more efficient way to do this, as pointed out by Luis in the comments. Thanks!

So, in the end, it now works

This tutorial blog post on Code Elite was very, very helpful. So were Luis comments here and elsewhere (although me being quite the newbie when it comes to gcc and the likes, they went a bit over my head).

The Code Elite post is not the best at being copy-paste-able though, the formatting kinda ruins that. It does point out the correct steps to getting MySQL to work in Ruby (and consequently, Rails).

Long story short, these are the steps that lead to a working MySQL integration:

Download Ruby 1.9.1 MinGW32 and the corresponding developer kit from the RubyInstaller download page. I prefer the zipped version to the one with installer, to be honest, but that’s just me.
Get the 32-bit version (not 64-bit, or linking won’t work) of MySQL 5.0 (not 5.1, or nothing will work) from the MySQL download page. Again, I prefer the zipped version.
Get the current mysql-ruby source (2.8.1, currently) from its FTP.
Put Ruby into F:\Ruby or your path of preference. Add Ruby’s \bin path to your path variable. Close and re-open the command window to update the path.
Install Rails – this is easy.
```
gem install rails
```
Put MySQL into F:\mysql (or your path, again). No adding to the path yet here.
Put the contents of the mysql-ruby package into your Ruby path (I didn’t try other paths) and point your command line there, then run this:
```
ruby extconf.rb --with-mysql-lib=f:/mysql/lib/opt --with-mysql-include=f:/mysql/include
```
Run make, then make install. Here is where 64-bit MySQL fails.
Add the following to your path variable (substituting your MySQL location): F:\mysql\lib\opt;F:\mysql\bin. Again, close and re-open the command window to update the path.
Run this to let Ruby know MySQL:
```
ruby -e 'require "mysql"'
```
Get into a command prompt as admin (you might have to right-click a command prompt and “run as admin” to get to this) to install and start the MySQL service. To do that, run these in the mysql\bin directory:
```
mysqld-nt --install
net start mysql
```
Now that the MySQL server is actually running, you can connect to it to change your root password:
```
mysqladmin -u root password topsecretpassword
```

Steps 1-3 are just downloads. Steps 4 and 5 already installs Ruby on Rails completely. Steps 6-12 then are for installing mysql (which is necessary first for the DLLs to be available to the compiler later) and then compiling the mysql-ruby package (driver?) from scratch into Ruby.

Interestingly, step 7 builds the makefile through Ruby (mostly, with some automated C mixed in), while step 8 actually compiles the C source through make and step 10 plugs this into Ruby. Steps 11 and 12 merely configure the MySQL server.

This should be it. And this time, I hope I did no forbidden or ugly things For they know not what they do and stuff.

Actually Installing Ruby on Rails, on Windows 7

haslo — Wed, 24 Jun 2009 13:32:10 +0000

OK, so I found out what it is that I have to install for my wonderful Ruby on Rails environment. It’s time to start installing.

Keep in mind that much of what I’m doing here is an experiment (and thanks Luis for being so patient with me). I don’t claim to know what works and what doesn’t, I’m just trying to find my way around here. Follow my steps at your own risk – they seem to lead to a working environment for now.

Update 2009-07-03 02:16: There’s a followup post now that does less evil and wrong things, hopefully. It also happens to result in a working Ruby on Rails plus MySQL environment, something this post doesn’t quite achieve.

Getting Ruby to run

Admittedly, I was a little surprised by how easy this was. Get Ruby and the Development kit from here. Extract them (using 7-Zip, which you should use by default anyway), and put all the contained directories where you want your Ruby. Mine resides in F:\Ruby.

Next, add the newly installed bin directory to your path. Quickest way: Open the control panel, search for “environment”, then click “edit the system environment variables”, and add the bin after a semicolon to the “Path” variable. Then, change the path in devkit/msys/1.0.11/etc/fstab to where you put your stuff – you won’t have to do this if you put Ruby into C:\Ruby.

This is what we get:

Ruby Installed

Yay. That was easy. And the greatest thing is that the One-Click installer (even if it’s not entirely one-click, currently) also already adds support for Ruby Gems.

Getting Rails

The next step is to install some gems. There is a long list on Akita on Rails, but after realizing how little stuff works with Ruby 1.9.1 and Windows 7, I chose to (nearly) only install the things I need:

gem install rails

This installs Rails and the gems it depends on.

ImageMagick, and Some More Stuff

Next, since I planned to do so and not out of some technical necessity, we install ImageMagick for Windows – get the newest Win32 Binary Gem version from RubyForge and extract it somewhere. Install the gem by going into the directory it’s extracted into and then executing this:

gem install rmagick-2.10.0-x86-mswin32.gem

Substitute the gem name with the version you’re actually using. Then install ImageMagick itself, with the .exe that you just extracted as well.

If you’re like me, you won’t be able to resist attempting to install some more gems. Here’s a nice video with some suggestions from Railsconf 2009. Personally, I installed googlecharts, twitter, cucumber and pdf-writer, but haven’t gotten to try them out properly yet.

Testing What We Have

We have Ruby on Rails now. Yep, that’s it. Rather painless so far, eh? Test it by going to the directory you want your projects in and typing this:

rails testproject

You’ll see Rails creating plenty of directories and files now. After it’s done, do this:

cd testproject
ruby script/server

Point your web browser to http://127.0.0.1:3000/, and you should see Rails, in all its glory:

Rails Installed

Not Installing MySQL

I started out by attempting to install MySQL 5.1, thinking it was stable and all. However, as it turns out, there are plenty of problems with that, and none of them stem from MySQL:

The mysql gem relies on libmySQL.dll, which has to be in the path.
The mysql gem is precompiled, there is no 64-bit Windows version, and the 32-bit version relies on msvcrt-ruby18.dll, rather than the newer msvcrt-ruby191.dll.
There is a segmentation fault that I haven’t found the cause of.

I was able to fix the first two problems by adding the mysql/bin directory to the path, and installing a Ruby 1.8.6 alongside the Ruby 1.9.1 to get the 1.8 DLL – but nevertheless, I never got rid of that segmentation fault, despite multiple reinstalls and even trying MySQL 5.0 instead of 5.1 (Google search for the exact cause, none of the proposed solutions helped).

(Do not install the 1.8 DLL, that’s apparently very evil.)

Nothing worked until I gave it a try with Ruby 1.8.6 (after all, I had that installed from attempting to get that DLL, and only needed to change the path variable and install the rails gem to have a go), and lo and behold everything worked fine.

Which convinced me not that I should use Ruby 1.8.6, there’s too many shiny new features in 1.9.1. Instead, it convinced me that I should forget about MySQL.

Installing PostgreSQL

Since Rails migrations make database dependencies a thing of the past (or at least, to a very, very large extent), I decided to install PostgreSQL instead. Their one-click Windows installer for PostgreSQL 8.3 worked a treat and installed the service and everything just fine. Next step, have Rails be able to talk to it – there are two PostgreSQL gems, only one of which (postgres-pr, not ruby-postgres) currently seems to work in Windows. So let’s get it:

gem install postgres-pr --platform=mswin32

Create Role

(Not sure if the platform is necessary, but it can’t hurt.)

Set up a database user (“login role” in PostreSQL-speak) with pgAdmin – I called mine rails – and give it a password and the ability to create databases.

Now we change the database.yml in the project’s /config/ directory. Open it with some text editor (I like EditPlus myself) and change it to fit your configuration.

This is the database.yml that makes my test project fly:

development:
 adapter: postgresql
 database: testproject
 username: rails
 password: ***
 pool: 5
 timeout: 5000
 host: localhost

Note that host:localhost (or the equivalent for your database) is important, as otherwise Rails will attempt to connect to PostgreSQL using UNIX Sockets – which obviously wouldn’t work. After that, let’s test. Go to your shiny rails project in a command window, and type or paste these:

ruby script/generate scaffold test title:string description:text
rake db:create
rake db:migrate
ruby script/server

After that, point your browser to http://127.0.0.1:3000/tests/ and poke around a bit. You should have your first Rails app running, including all four CRUD actions.

CRUD Running

I Think I’m Done Here

Done after installing aforementioned Firebug (just click “install”), Web Developer (yep, “install”) and Git for msys from Google Code (which seems to work fine so far). There’s a Ruby gem for Git, too; install with this:

gem install git

I then also got gVim 7.3 – not for the faint-hearted, I do have some experience with vim from coding Python on Linux though. I will also test how well editing works with my EditPlus, and probably some IDEs. Either way, I’ll probably make a little personal user interface evaluation post later on.

Looking back to the assessment post, I’m actually not done at all. The following things are still missing – most of them, for a reason:

ruby-debug doesn’t work with Ruby 1.9.x yet, so that falls flat. It’s merely a wrapper for the built-in debugger though, so I will be able to debug anyway.
Mongrel has “ruby script/server” produce another segmentation fault, and I don’t want to spend another 7 hours for not finding a solution to it.
Apache doesn’t make much sense in a pure development environment, particularly not if we don’t have Mongrel anyway.
Subversion has plenty of versions on their download page. I downloaded the one from Slik SVN myself, but haven’t installed it yet until I actually need it. So that’s technically missing, too.

Where To Go Now

There are some resources that can get you started with your most splendid new Ruby on Rails environment. If you have no idea what Rails is yet or why you should use it, have a look at this presentation. I found the Head First Rails book to be a very good introduction, too. Concerning Ruby, Why’s (Poignant) Guide to Ruby (available as pdf, too) is both free and great, albeit talking about Ruby 1.8.2, a tiny bit outdated. If you like it thorough, get the book only known as the Pickaxe. It is as good as they say.

Thanks for listening, and I hope I can help one or two among you out. You like it? You hate it? You found something I didn’t? Let me and all your fellow readers know in the comments!

Assessing Installing Ruby on Rails, on Windows 7

haslo — Tue, 23 Jun 2009 12:48:45 +0000

So I wanted to get up and running with a development system for Ruby on Rails, on my shiny freshly installed Windows 7 machine (so, no development stuff on it as of yet whatsoever). However, the recent Ruby update to 1.9.1 brought such big changes that apparently, many libraries don’t work with it anymore – so the installer of choice, the One-Click Ruby Installer, is (for now) stuck at supporting Ruby 1.8.6 only.

Update 2009-06-23 15:12: There seems to be a way to make the one-click installer build Ruby 1.9.1, guess I’ll have to try that out.

The One-Click Ruby Installer is not dead, and there’s even a design vote for the 1.9.1 website. But since I want my development environment bleeding edge and I want it now, I’ll just have to make do with a manual install. Since I haven’t found a tutorial detailing the steps for that, I’ll just do it from scratch and take you along the ride. Good tutorials I did find are:

The Best Environment for Rails on Windows, including a rant against IDEs
Installing Rails on Windows, including a guide for setting up MySQL
Time For A Grown-Up Server, for adding Mongrel and Apache

So, what do we need, for a full-blown environment?

Ruby 1.9.1 – obviously, can’t have Ruby without Ruby
Ruby Gems 1.3.4 – since gems are the Ruby way of distributing anything
Rails 2.3 – obviously, can’t have Ruby on Rails without Rails
MySQL 5.1 – the database we’ll use, although others would work as well
Mongrel 1.1.5 – reliable and secure webserver

That’s it for the start, but for additional tool goodness (and in order to have some of the above run properly in the first place) we need more:

Git 1.6.3.3 – the version control used by rubyists
Subversion 1.6.3 – very widespread version control (and I refuse to add CVS to this list)
MinGW and MSYS – to make sure gems can be installed and compiled if necessary
Rake 0.8.3 – the ruby version of make
Ruby-Debug 0.10.3 – who doesn’t like debuggers
ImageMagick 6.5.3 – can be used by Rails
Firebug 1.4.0b2 – for debugging web apps’ JavaScript code (requires the Firefox 3.5 beta)
Web Developer 1.1.6 – for CSS and HTML stuff
MySQL Control Center 0.9.4 – or an alternative that can admin MySQL databases
Apache 2.2.11 – front-end webserver for load balancing and whatnot

An intimidating list at first sight, but I did try to get everything I might need in there. The hard part then will be making all of them talk together. Concerning the actual development environment, I am as of yet undecided between gVim and an IDE like Aptana or RubyMine. Both have upsides and downsides.

So, is this list complete, do you see anything I’ve missed? Or do I have anything on it that you think is irrelevant? Let me know in the comments!

So much for talking the talk – the next step will be walking the walk, and I’ll make sure to give you a full tutorial afterwards.

Update 2009-06-24 16:05: Yep, Ruby on Rails is installed. Here is how I did it.

Stack Overflow: Solutions for Coders

haslo — Tue, 16 Sep 2008 12:56:35 +0000

Stack Overflow

If you’re a programmer, you know the problem of solution googlability. It’s particularly prominent in mainstream languages (and one of the things I decried in my What’s Wrong with VBA series, as VBA is particularly bad in that respect); you have a problem, you google for it, unless you’re coding in a good awesome well-designed freak language like Ruby, Python, or Haskell, all you get back is trash and spam.

So, since you’re reading blogs and a programmer (or you’d have stopped reading by now, I guess), you know Joel on Software. Now this guy and his team have done something: They took the Wiki approach of “everybody can edit”, added Digg’s “let’s vote stuff up”, and made the whole thing a generic programming Q&A site.

Behold, and witness, the rise of Stack Overflow.

From his launch post:

Here’s how it’s supposed to work. This is a community project, so I’m being careful to avoid saying this is how it will work… that’s up to the community. But this is roughly what I have in mind.

Every question in Stack Overflow is like the Wikipedia article for some extremely narrow, specific programming question. How do I enlarge a fizzbar without overwriting the user’s snibbit? [...]

Some people propose answers. Others vote on those answers. If you see the right answer, vote it up. If an answer is obviously wrong (or inferior in some way), you vote it down. Very quickly, the best answers bubble to the top. The person who asked the question in the first place also has the ability to designate one answer as the “accepted” answer, but this isn’t required. The accepted answer floats above all the other answers.

Sounds great! It has tags, it’s not restricted to one programming language, it could provide the framework for thousands of programmers collaborating. And the best thing: They plan to “keep it ad-free and open to the public forever”.

You’ll need an OpenID to log in – I got one at myOpenID myself. Too bad it’s not possible to log in without, but whatever – I guess this approach has more promise than the closed one that Microsoft tried to force upon us with that whole Live ID crap, but still shares the same weaknesses (which are, mainly, another party involved and a central point of failure).

Nevertheless, I do think this could be awesome. Let’s see where it goes.

What’s Wrong With VBA? (3/3)

haslo — Mon, 08 Sep 2008 17:27:48 +0000

part 1 – part 2 – part 3

This is the third part of a three-part series, have a look at part 1 and part 2 first.

So let’s go on ahead and jump into the final bits of my troubles with MS Access and VBA as environment for medium and larger IT projects – basically, anything having 2 and up users.

Syntax

There are quite a few things that bother me about the VBA syntax. First of all: it’s inconsistent, even more so than the one of php (where mainly method signatures are inconsistent), in several places. The most prominent of them are functions. Take these lines:

Dim answer As VbMsgBoxResult
MsgBox "Hello World!", vbOKOnly
answer = MsgBox("Hello World?", vbYesNo)

Did you notice anything? Yes, indeed. Take note, the parentheses are forbidden in the first case, and mandatory in the second. Now assume that you have a function call that you suddenly need the answer from, whereas you didn’t need it earlier. Not only do you now have to write the assignment, but you also have to add parentheses to the function call. Way to spend productive time.

The same goes for “Set” and assignments to native data types and Objects: For Objects, it’s mandatory, for native types it’s forbidden. That goes even for Objects stored in a Variant variable – all Variants are not made equal, some will throw runtime errors when you assign stuff to them.

Another annoying syntax bit is this one:

' Won't work!
Dim someNumber As Integer = 5
' Will work :-/
Dim someNumber As Integer
someNumber = 5

Yay, more lines of code, how great. But wait, I have more! What do you think this produces?

Dim firstVar, secondVar As Double
Dim thirdVar, fourthVar As Object

Yep, you guessed it. “firstVar” is a Variant, “secondVar” a Double, “thirdVar” a Variant, “fourthVar” an Object. Oh, you got it wrong? Don’t worry, it’s just that silly.

My final pet peeve with the syntax is its capitalization (and thus technically the IDE and not VBA itself). VBA is not per se case sensitive – and it expresses that through simple means: Whenever it encounters a variable, it tries to capitalize it the way it’s supposed to be, to make it clear that it’s the same.

Now, enter scoping, and intuitively named API bits. So you have a local variable called “currentItem” … what happens if you try to access the property “CurrentItem” in, say, an Inspector Object? Right, it’s capitalized “currentItem”. It has nothing at all to do with my local variable, but the IDE is too stupid to notice.

Of course there’s other things amiss or strange, like the lack of a side effect free ternary operator, or the (nearly syntax) VBA developer gospel for the redundant Hungarian notation taken to wrong extremes, but I’ll just stop here.

MS Access

I won’t even go into how I find Access 2007 to be much worse than its predecessors when it comes to usability, with longer mouse paths and more clicks per action, the developer tab not showing by default, and shortcuts no longer easily visible. Just so much: it’s annoying. I guess I still haven’t gotten used to the new, less quick, way of displaying shortcuts, and often, object placements aren’t intuitive for me and I’m looking for things in the wrong tab.

What really bothers though is that Access has stability issues. Access is the only program so far that managed to crash on my development system. Dreamweaver MX 04 is quite an old make and has huge problems with Vista’s UAC, but it doesn’t crash. Nor does any other tool. But Access, which happens to often corrupt databases when it does.

Even crashes aside, occasionally the database just corrupts like that, without any visible reason. Or it keeps code that you deleted, and keeps spitting error messages how that code isn’t valid – without you having any possibility to do anything about it, not even overwriting helps.

I hope you make backups every couple minutes, I certainly learned to. I haven’t found another reliable way to get those databases back into stable conditions.

Then, what’s one of the many responsibilities of a proper DBMS? Housekeeping! What does Access do? Provide you with “compact and repair”, which is user-initiated only. Well, I guess with huge databases that Access couldn’t handle anymore anyway, that would make sense, not having that an automated regular task.

Furthermore, every single user needs MS Access installed on his computer. Potentially a security risk, certainly not something that should be necessary. You don’t go and install an MS SQL Server on everybody’s machine. At least Microsoft consequently follows through, and their Access security FAQ is all about how you can protect your computer from malicious Access macros, and not how you can secure your Access databases.

By the way, Access doesn’t scale – what else is new. Multiple users are a problem, for larger databases (>2GB, but you’re hitting performance bottlenecks way before that) you have to move to a proper backend – essentially, lugging around the whole DBMS part of your GUI windowing toolkit for naught afterwards.

It does at least have proper locking, quite refined permissions, and with Access 2007, database encryption (without which all the permission structures in the world are worth naught) as well.

Other Things

There’s a few other small things that I found incredibly annoying, coming from other languages like Java, Python and my personal favourite, Ruby.

For one, Null comparisons work in odd ways, VBA uses ternary logic (although admittedly, this is consistent with the way SQL handles Nulls).

The next minor thing are silly defaults – there are two lines every halfway serious programmer adds as a very first thing to every single bit of VBA code they write (and this goes so far that there’s option settings to add it automatically to every source bit):

Option Explicit
Option Compare Database

The reason for this is simple: backwards compatibility. While VB6 (maybe earlier?) changed the default to the need for explicit variable declaration, VBA never did, and thus it’s still possible to mistype a simple variable and never find the error later on. And as for Compare Database … yeah sure, let’s compare stuff everywhere a bit differently, to make sure the database behaves completely unforeseeable.

Another one: No external source file support. If you want to use any library or other cool thingy you found on the net or elsewhere, you have to copy-paste the code into Access. Where it’s needed, that is, which of course means that if it’s needed anywhere else, you have to copy-paste it again. The only way around this are Access databases that allow you to copy-paste (oh, look, a pattern) the respective classes or modules as a whole. No, you can’t just link (with very limited exceptions). Hooray?

We’re not done yet: You can’t return an array! If you want a Function that returns an array, you have to define it as returning a Variant. If you do that, you can return arrays (since they’re a subtype of Variant), but will lose all meta information: Data type, size, everything. So if you want to return an array and its size, you have to do it via separate functions, or with a stateful returning object, or with a custom ADT.

Something that was rightfully pointed out to me (thanks Ste!) – why is it that VBA (and VB.NET, for that matter) distinguishes between Functions and Subs? There’s no fundamental difference, one returns something, the other doesn’t (so, essentially returns Nothing), but that’s it. Visual Studio goes so far to automatically change the keyword from Sub to Function when you return something.

Conclusion

I guess it’s apparent by now: I do think that it’s justifiable to say that VBA is outdated and should be dumped right now.

For Microsoft: There are good replacements, there’s no reasonable reason beyond “it was easier” to have Office 2007 use VBA still, and there’s certainly no reason to make the next version of MS Office still have VBA support – particularly if that means that there still won’t be native VB.NET support inside MS Office.

How delusional of me to think they’ll actually see this, though

For anybody considering Access and VBA for their projects: Well, if you still want to, you can of course. Or get the free Visual Studio Express for VB.NET plus SQL Server Express, and stick to a Microsoft environment with a very similar but much more mature language, and a more performant database, for less money.

I still do work with VBA, when I really have to, but I think I laid out here why it’s a fact that I really only do so when there is no other way.

part 1 – part 2 – part 3

What’s Wrong With VBA? (2/3)

haslo — Sun, 07 Sep 2008 11:08:11 +0000

part 1 – part 2 – part 3

This is the second part of a three-part series, have a look at part 1 first if you haven’t read it yet.

Let’s just jump right in and continue the list of problems I have with VBA as a programming language for medium and larger MS Access projects.

Error Handling

The modern paradigm for error handling is exception handling, but to VBA that doesn’t apply for a simple reason: VBA doesn’t have exceptions. Instead, it has this:

On Error GoTo ErrorHandler

Yes, that’s a GoTo, and we all know those are evil. Even worse than GoTo though is this line:

On Error Resume Next

Basically, “just ignore all the errors that happen now, they’re not important”. Ah, right. We can still check for error codes, so even this evil construct (never ever use this as default!) is occasionally necessary to avoid the spaghetti code that the GoTo alternative would produce, while providing reasonable feedback instead of the techy default Access warnings:

DoCmd.SetWarnings False
On Error Resume Next
doSomethingUseful
If Not Err.Number = 0 Then
    MsgBox "Descriptive error message", vbCritical, "Error"
End If
On Error GoTo 0
DoCmd.SetWarnings True

What a silly contraption. In VB.NET, it’d look like this, and be way more flexible and expandable:

Try
    doSomethingUseful()
Catch ex As Exception
    MsgBox("Descriptive error message", MsgBoxStyle.Critical, "Error")
End Try

The current consensus among programmers is that GoTo isn’t necessarily evil, but it has to be used the right way. Myself, I have yet to see a case where I find GoTo to be better than its alternatives, but that’s subjective I guess. Excursus: I couldn’t resist solving the Last Example – Nontrivial Gotos from that last link, with less C code and no GoTo and, in my opinion, clearer:

int parse()
{
    while (Token tok = gettoken() != END) {
        while (!shift(tok)) {
            if (!reduce(tok)) {
                return ERROR;
    }}}
    return ACCEPT;
}

Anyway. VBA provides a GoTo, which is neutral, and it forces that GoTo upon programmers for error handling due to lack of alternatives, which is bad. Only C gets away with that.

The IDE

The Access VBA IDE basically consists of two parts (and thus technically isn’t really integrated, but we’ll let that slide): The in-Access editor (or layouter) for forms and reports, and the code editor for actual programming.

The layouter works quite well really, except that the one even in the free Visual Studio Express (which isn’t even the central part of that IDE, unlike in Access) is lightyears ahead, be it concerning auto-snaps or ease of use or number of clicks for anything. Microsoft doesn’t seem to use its internal synergies all that well.

The same then goes for the code editor, just worse: It hasn’t gotten an update in recent years, the one that shipped in Office 2007 is exactly the same as the one from Office 2003. Grievances are…

Whenever you have a half-finished line, and switch line to write something somewhere else, you have an error message box pop up that you have to click away first – because it only checks errors when you leave a line, and has no other way to display them.
Class lookup is shaky, with new custom classes it often it only works after you exit and restart Access.
Even if it works it’s not completely reliable, working autocompletion is a rare positive surprise.
Debugging is pretty limited, often when there’s an error the IDE doesn’t even stop at the point where the error actually occurred but at some point further up the call stack.

I can live with those shortcomings of course, but I really don’t see why Microsoft didn’t just use the Visual Studio IDE instead – it would not only have fixed those problems, but also have gained better searching capabilities, snippets, refactoring and wizards to go with it.

Object Orientation

VBA is object oriented! Yeah, to some extent: You can make classes, and there’s even properties. However, yet again there’s a bullet list of things that should be better:

You can’t have parameters for your class constructors (the Class_Initialize Sub), so initializing a class must be either with default values or through a separate “init” function that’s called after instantiation with “New”.
No real inheritance, you can just implement interfaces (and thus inherit method signatures, but no content or properties or anything) – considering there’s no compile time type checking anyway, I don’t see much purpose in that.
No overloading. Yes, you can have optional parameters, but the same function name with different signatures won’t work (the language does support encapsulation though, so you can override functions in narrower namespaces, but that’s not really overloading).
Objects are handled different from native data types. Not just “they are different”, but they have differing syntax too – an assignment to an object needs “Set”, one to a Variant must not have “Set”. So even though you can store an Object in a Variant, you’ll run into runtime errors if you do. Admittedly, Java shares similar problems, but at least it has autoboxing meanwhile.

Some people also have a problem with VBA having both modules and classes – myself, I see that more pragmatically: There are cases when you’d make just static functions in a class anyway, or work just with a singleton, so why not pack those in a module instead? You can always change to a class structure later if it becomes necessary.

The Community

Now this one is certainly controversial, and even more subjective than the rest of this post series. First off, there are quite a few great community sites full of dedicated and knowledgable authors, like the MS VB forums, databasedev.co.uk, VB Helper, The Access Web, FreeVBCode, the TekTips VBA section and the FMS tips section.

But what I’m talking about is the “Googlability” of problems.

If I don’t find a solution in a site I know (or sometimes while looking in one of those sites, with “site:foobar.com”), I just Google it (of course) – problems do occur, and others must have had the same ones before. Now what happens if I do that for VBA problems?

I find trash.

This is for these three reasons, I guess:

There isn’t so much a VBA community as 4 VBA communities: ASP VBA, Excel VBA, Word VBA, and finally also Access VBA (about in that order of prominence) – and then there’s the VB6 and VB.NET community too, with solutions that often don’t apply to VBA.
So the search queries have to get more and more elaborate, adding “-asp” and “-excel” is common if you want to find anything – thus it takes longer until you find your solutions.
There are plenty of solution providers that might provide reasonable solutions, but cost money. Now, that’s a problem of mine I guess, but I don’t like giving my credit card info to some obscure website for a solution that might or might not work for me. Luckily, CustomizeGoogle filters those out quite reliably, after I tell it to.
There are plenty of inexperienced users when it comes to VBA, way more so than with most other programming languages and other technologies I used so far (well, Python and Ruby tend to have geeky target audiences anyway, but the same applies to Java). This means two things:
- Often, questions are answered less than optimal by only slightly more knowledgable users than the ones asking the question, meaning the solution is either just wrong or not generic and thus doesn’t work in a slightly altered context.
- Even more often, questions aren’t answered at all. The favourites here are the people later writing “nevermind, I found the solution”, without providing what that solution was that I could use now as well…

Keep in mind that I don’t have any problems with inexperienced users whatsoever, I’m regularly a newbie in yet another programming language I’m learning myself. And asking questions is a good thing anyway – it’s just that it seems like more experienced VBA programmers move on to VB.NET or something and thus VBA queries often disappear in the void, because there’s nobody experienced around to answer them.

That’s all for now, stay tuned for part 3 with syntax, MS Access, other things and a conclusion.

part 1 – part 2 – part 3

What’s Wrong With VBA? (1/3)

haslo — Sat, 06 Sep 2008 13:56:11 +0000

part 1 – part 2 – part 3

Visual Basic for Applications – the legacy language that Microsoft apparently still won’t drop even in future Office updates, although they’re working on it, and certainly hasn’t dropped in Office 2007. The plague with a lobby. Why is it so bad, is it so bad at all?

This very subject here was, in fact, one of the things that made me think “I have to get a blog again” over those years when I didn’t have one – I so wanted to write it whenever I was forced to work with applications coded inside MS Access, or when I coded them myself from scratch. I decided to make what started as a single post into a three part series, simply because there was so much content that one blog post couldn’t hold it all.

I won’t go into VBA for the rest of the Office suite too much, for tiny macro things it might even fit, what I’m talking about is medium (and larger) applications. And I will use the term “database” for the course of this article series for something it technically doesn’t strictly apply to, which is a MS Access application and actually an entire DBMS, plus GUI stuff and application logic, all mashed together.

So, what are all those things that bug me so much?

Language Updates

That’s possibly the biggest gripe of them all. Quoting the very Microsoft VBA site, at least MS makes their stance towards VBA perfectly clear:

[...] As previously announced, Microsoft does not expect to make significant enhancements to VBA. [...]

As of July 1, 2007, Microsoft will no longer offer VBA distribution licenses to new customers. Existing VBA customers can still purchase additional VBA licenses from Summit Software and Microsoft for existing solutions.

In other words, “we’re desparately trying to get rid of this mess”. Well, why wouldn’t they: VBA wasn’t updated for nearly 10 years now – while programming languages evolved around it, some very well-designed behemoths (for the time they were designed at) like C++ still stand their ground, many others have vanished and were replaced.

Yes, of course there’s always a demand for coders for older languages, just look at COBOL. If you like VBA, there’s plenty of legacy Access applications, and places where Access makes sense, so you won’t be out of a job any time soon.

That doesn’t change that the language would be in desparate need of an update, wouldn’t the update already exist in the form of VB.NET and, to a lesser extent, in C#. Why Microsoft hasn’t at least added support for those inside MS Access in the course of introducing .NET is beyond me.

The API

What clearly does belong to the VBA API, particularly in our context of developing MS Access applications, is the windowing framework. While it has its very own problems that I’ll describe in the IDE chapter, it does what it’s supposed to do rather well: Forms, reports and components, with a nice drag-and-drop interface for tinkering interfaces. It doesn’t have the best performance out there, but for database applications that work, who makes that their top priority.

Beyond those widgets and happy drag-and-drop things, for the most part, the Application Programmer Interface of VBA can be described with a few simple words: It doesn’t exist. While VBA does make use of DAO and ADO (not the way better ADO.NET, mind you), and the Office object model (which is actually more comfortable to use in VBA than in C#), everything that goes beyond that is out of bounds.

Let me illustrate by means of a symptomatic example.

Let’s assume you want a dynamically sized array, a Vector or ArrayList, that grows and shrinks as you add and remove items, preferrably useable as a stack or queue too by means of simple procedures. Now, in every other language that’s as simple as importing a bit of the API and then using said dynamic array. Not so in VBA, that bit of the API doesn’t exist (except if you count the Collection that has whooping 4 methods). There are “dynamically sized arrays” through lines like this one:

ReDim Preserve myArray(0 To arraySize)

This does mean though that all the automatic growing and shrinking has to be added by hand, and push and pop don’t work at all. In short, you have to do everything yourself.

Which I did by the way, you can download my classes here.

Mangled Tiers

Every non-trivial application, particularly multi-user applications, is best handled with multiple tiers: A database tier, a client/presentation tier, maybe an application server in between, that’s usually enough but can be extended. Less is bad, more is more complicated but depending on the application, necessary.

In MS Access, everything is “in the database” by default. Now,what does this mean? Basically, it’s a mess, and sorting things out properly is nearly impossible, whenever you update the database you also update the application and extending the user circle beyond, say, 1-2 users inevitably leads to problems (more on this later).

It is worth noting that these tiers can be somewhat simulated by using multiple databases for different purposes: You can easily have an “application” database that just does frontend work, and a “data” database. You can then create links from the “application” database to the “data” database, and have the frontend update independendly of the backend.

That’s common practice and makes sense, and comes close to true multi tier programming, although it still makes a mess of things because those links are hardcoded file paths and aren’t as easy to manage as they should be; the “data” database’s location has to be known on a file share, and every user needs write access to that share, which leads to obvious security inconsistencies and further problems that we’ll explore in the course of part 3.

The problem about paths being hardcoded can of course be solved by writing libraries that update paths, and the tier problem as a whole can to some extent be resolved by having data reside in an MS SQL (or other, through the rather dated ODBC) database.

What’s MVC?

This problem is very similar to the last one concerning mangled tiers. Modern applications often use, for maintenance and development reasons, a Model-View-Controller approach. Some languages and frameworks, like Ruby on Rails, even make it really hard not to (which is good, considering the approach makes sense). Now, if you want to create a program that’s cleanly using that paradigm in VBA, you basically have to ignore all the structure there is and make a new one. The good news is that you can actually do that, of course, and VBA doesn’t stop you from doing it – it just doesn’t help you a bit.

It all starts out so nicely:

The model is the database, tables and views can be accessed via DAO or ADO
The view is WYSIWYG-edited and stashed in Reports and Forms
Every Frame has its own class, akin to its very own controller

Regarding models: Yes, in theory it’s nice like that. However, as soon as we start having things that go beyond tables and views, we’re screwed. That goes for simple things like tree view models (that are stored inside the tree view and not really accessible from the outside). You can make stand-alone recordsets (aka RAM tables), you can even disconnect recordsets from their source, that’s good. But overall, the model is in the view and vice versa, splitting the two is hard and in some places impossible.

The view only in the WYSIWYG editor is a nice thought for simple things, but when you want to start exchanging components on the fly, you have to write your own view classes (or end in chaos, as many VBA projects do) anyway. Or, the alternative many VBA projects take, have invisible components that you make visible or visible depending on the mode the form currently is in – a maintenance nightmare. The best approach here is having subforms and exchanging those, that actually works really well too and is my favourite approach. It’s just not the way VBA and Access make easy, and it can yet again very easily lead to duplicated bits (code or UI components).

Finally, the controller – you can avoid duplicated code and make pretty good controllers if you completely ignore the Frame’s default classes and only use those for proxying your own controller classes that you write in addition to them. Works well, it’s just, again, not the way VBA and Access makes easy.

That’s all for now, we’re warming up. Stay tuned for…

part 1 – part 2 – part 3

VBA Vector Classes

haslo — Tue, 02 Sep 2008 15:36:25 +0000

If you’re anything like me and ever had to code anything in Visual Basic for Applications, you must have felt the need for a proper API with some very basic common ADTs. The most basic of them being, in my opinion, the dynamic array (Vector, ArrayList, List and Collection are often used more or rather less synonymous). So what would it feel like to be able to write this and have it work?

Dim primitiveVector As clsVector
Set primitiveVector = New clsVector
Dim myInt As Integer
myInt = 3
 
primitiveVector.AddItem myInt

There are of course other people who have made such a thing, and there’s the VBA Collection, but none of them quite fit what I wanted. I wanted a Vector that had random access, was able to handle LIFO and FIFO (and thus act as stack and queue), addition and insertion and deletion, could check for item existence, and had dynamic resizing. So I went and coded my own. I did this while working at Promino AG and thus the code is technically theirs, so thanks to Paul Moser for the nod for publishing this under the GNU Lesser General Public License.

You can download both classes (two? more below), together with a tiny trivial testing framework, as Access 2002-2003 .mdb.

This here is the vector class for Variants. It goes into a new class module, I called mine “clsVector”:

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see .

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Variant
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Variant
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Variant)
    CheckDimensions
    itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Variant
    GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Variant
    PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Variant
    GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Variant) As Boolean
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i) = item Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Variant)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        itemBuffer(i + 1) = itemBuffer(i)
    Next i
    itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

Now, it would be nice if we would be done. But, we’re not done yet, obviously, after all there’s plenty more code below this break. The reason for that is simple: In VBA, a Variant is not an Object, and an Object is not a Variant, consequently functions that take Objects don’t take Variants and vice versa (although you can technically store an Object in a Variant, this will lead to problems). Objects also happen to have “Set” mandatory in places where it isn’t allowed for Variants.

What this means is that there is no way to have the same Vector class for both your custom ADTs and the primitive data types. So basically, we have another class that has exactly the same functions and exactly the same algorithms, but takes Objects instead of Variants. I called mine “clsObjectVector”. Here is the source for the class module:

Option Compare Database
Option Explicit
 
' Copyright 2007, 2008 by Promino AG
' Author: Guido Gloor
'
' This program is free software: you can redistribute it and/or modify
' it under the terms of the GNU Lesser General Public License as published by
' the Free Software Foundation, either version 3 of the License, or
' (at your option) any later version.
'
' This program is distributed in the hope that it will be useful,
' but WITHOUT ANY WARRANTY; without even the implied warranty of
' MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
' GNU Lesser General Public License for more details.
'
' You should have received a copy of the GNU Lesser General Public License
' along with this program.  If not, see .

Private itemCount As Integer
Private itemBufferSize As Integer
Private itemBuffer() As Object
 
Private Sub Class_Initialize()
    itemCount = 0
    itemBufferSize = 100
    NewDimensions
End Sub
 
Private Sub NewDimensions()
    ReDim Preserve itemBuffer(itemBufferSize) As Object
End Sub
 
Private Sub CheckDimensions()
    If itemCount > itemBufferSize - 2 Then
        itemBufferSize = itemBufferSize * 2
        NewDimensions
    End If
End Sub
 
Public Sub ShrinkDimensions()
    itemCount = itemBufferSize + 10
    NewDimensions
End Sub
 
Public Function GetSize() As Integer
    GetSize = itemCount
End Function
 
Public Sub AddItem(item As Object)
    CheckDimensions
    Set itemBuffer(itemCount) = item
    itemCount = itemCount + 1
End Sub
 
Public Function GetItem(index As Integer) As Object
    Set GetItem = itemBuffer(index)
End Function
 
Public Function PopItem() As Object
    Set PopItem = itemBuffer(itemCount - 1)
    DeleteItem itemCount - 1
End Function
 
Public Function GetNextQueueItem() As Object
    Set GetNextQueueItem = itemBuffer(0)
    DeleteItem 0
End Function
 
Public Function ContainsItem(item As Object) As Boolean
    ' The used ADTs need to have an Equals function for this to work
    Dim i As Integer
    ContainsItem = False
 
    For i = 0 To itemCount - 1
        If itemBuffer(i).Equals(item) Then ContainsItem = True
    Next i
End Function
 
Public Sub InsertItem(index As Integer, item As Object)
    Dim i As Integer
 
    CheckDimensions
    For i = itemCount - 1 To index Step -1
        Set itemBuffer(i + 1) = itemBuffer(i)
    Next i
    Set itemBuffer(index) = item
    itemCount = itemCount + 1
End Sub
 
Public Sub DeleteItem(index As Integer)
    Dim i As Integer
 
    For i = index + 1 To itemCount - 1
        Set itemBuffer(i - 1) = itemBuffer(i)
    Next i
    itemCount = itemCount - 1
End Sub
 
Public Function IsEmpty() As Boolean
    IsEmpty = itemCount <= 0
End Function

This is it, have fun As much as you can have if you’re forced to work with VBA, that is.

Oh, and if you can use it – comments are appreciated