VBScript vs. Ruby - Ruby rules!

Ok came across a problem today
We have one service that runs when a user logs on that drops a flag file in a directory.
We have another service that runs that looks for those flag files and then does some work, then deletes the flag file.

Well sometimes the 2nd service dies.
So I wanted to put together a quick monitor script that will keep an eye on the folder to check for thenumber of flag files in this directory

Mind you there are about 7000 files in this directory.. and the flag files are building up so we were at about 4000 flag files when I ran it.

VBScript ~10 MINUTES
Ruby ~ 10 SECONDS

Now.. thats not all!

VBScript Code

Code:

Set objFSO = CreateObject("Scripting.FileSystemObject")
Set objFolder = objFSO.GetFolder("f:\pathto\files")
Set objFilesColl = objFolder.Files
iFlgCount = 0
For Each objFile In objFilesColl
If UCase(objFSO.GetExtensionName(objFile.Name)) = "FLG" Then
iFlgCount = iFlgCount + 1
End If
Next
WScript.Echo iFlgCount

Now note I could of wrote the vbscript a little less verbose, and the ruby a little bit more verbose.. BUT it gives me the same number!
I couldn't find a way to filter the collection in vbscript so I had to loop through each file manually taking quite a bit of time
But with Ruby I just use the grep method and WHAM done!

Awesome vass. This may or may not be a fair comparison, but I'm writing a script in Python (newbie python programmer) logs information for the user currently logged in on a *nix box, and then logs some more information on the user's way out, then puts it into a MySQL db. There are two files, each with 20 some odd lines, so 40-50 lines total. A friend of mine is writing the same program on Windows in VB (newbie VB programmer too), and his program is already over 100 lines, and he's almost got the db connection working. Mind you we're both newbie programmers in these languages, and we're programming on different operating systems. Someone who is an expert in these langs could probably accomplish this same task in fewer lines....

errr huh?
I'd still have to loop through the collection putting the data into the recordset then do a query?

or are you talking about putting the flags into a DB?
I didn't create the flag service/script but I do need to monitor it because of some stuff I added to it.
So doing the DB thign would just add more unnecessary code when this monitor will work quite fine
Especially in ruby
I just added code to email me and it was only a few more lines

Helicopters don't fly; they vibrate so much and make so much noise that the earth rejects them.

I'm still a bit leery of ruby/python because they don't use variable declaration.
But ruby does have a method that echo's all of the variables in the script so I could put that at the beginning to make sure I'm not misspelling something.
like misspelling and mispeling are two distinct variables
In VB you can put Option Explicit at the topand it requires variable declaration so the compiler will catch problems like that.
But its pretty cool

Helicopters don't fly; they vibrate so much and make so much noise that the earth rejects them.

------------------
Ruby is the interpreted scripting language for quick and easy object-oriented programming. It has many features to process text files and to do system management tasks (as in Perl). It is simple, straight-forward, extensible, and portable.

Oh, I need to mention, it's totally free, which means not only free of charge, but also freedom to use, copy, modify, and distribute it.
Features of Ruby

* Ruby has simple syntax, partially inspired by Eiffel and Ada.
* Ruby has exception handling features, like Java or Python, to make it easy to handle errors.
* Ruby's operators are syntax sugar for the methods. You can redefine them easily.
* Ruby is a complete, full, pure object oriented language: OOL. This means all data in Ruby is an object, not in the sense of Python or Perl, but in the sense of Smalltalk: no exceptions. Example: In Ruby, the number 1 is an instance of class Fixnum.
* Ruby's OO is carefully designed to be both complete and open for improvements. Example: Ruby has the ability to add methods to a class, or even to an instance during runtime. So, if needed, an instance of one class *can* behave differently from other instances of the same class.
* Ruby features single inheritance only, *on purpose*. But Ruby knows the concept of modules (called Categories in Objective-C). Modules are collections of methods. Every class can import a module and so gets all its methods for free. Some of us think that this is a much clearer way than multiple inheritance, which is complex, and not used very often compared with single inheritance (don't count C++ here, as it has often no other choice due to strong type checking!).
* Ruby features true closures. Not just unnamed function, but with present variable bindings.
* Ruby features blocks in its syntax (code surrounded by '{' ... '}' or 'do' ... 'end'). These blocks can be passed to methods, or converted into closures.
* Ruby features a true mark-and-sweep garbage collector. It works with all Ruby objects. You don't have to care about maintaining reference counts in extension libraries. This is better for your health. ;-)
* Writing C extensions in Ruby is easier than in Perl or Python, due partly to the garbage collector, and partly to the fine extension API. SWIG interface is also available.
* Integers in Ruby can (and should) be used without counting their internal representation. There *are* small integers (instances of class Fixnum) and large integers (Bignum), but you need not worry over which one is used currently. If a value is small enough, an integer is a Fixnum, otherwise it is a Bignum. Conversion occurs automatically.
* Ruby needs no variable declarations. It uses simple naming conventions to denote the scope of variables. Examples: simple 'var' = local variable, '@var' = instance variable, '$var' = global variable. So it is also not necessary to use a tiresome 'self.' prepended to every instance member.
* Ruby can load extension libraries dynamically if an OS allows.
* Ruby features OS independent threading. Thus, for all platforms on which Ruby runs, you also have multithreading, regardless of if the OS supports it or not, even on MS-DOS! ;-)
* Ruby is highly portable: it is developed mostly on Linux, but works on many types of UNIX, DOS, Windows 95/98/NT, Mac, BeOS, OS/2, etc.

Guess I've just been doing it for long
Helps me remember what type it will be holding
even if they are typeless I know what type it will be holding.

Hey Eddy, have you had any problems with UNC naming?
In this script I had to use a mapped drive because I couldnt' get a UNC name to work right.. it wouldnt' find any files in it
I thought maybe it was just glob that was messing with me which is why I switched to .entries.grep, but it turns out itwas the UNC naming that messed me up

Helicopters don't fly; they vibrate so much and make so much noise that the earth rejects them.