Blasted Machine!

More on Modern Version Control

2009-11-10T08:34:00.004-06:00

Lately, I've been trying to select a modern choice of VCS for personal (and freelance) work, as well as picking a recommendation for my current place of employment. I'm leaning towards Git (see my previous post), but I would still like to head off any potential arguments for the other contenders - in this case, namely Mercurial.

Here's a very detailed comparison of the top three DVCS solutions: Git, Mercurial, and Bzr (which I'm not considering). It doesn't necessarily make the choice for me, but it gives a good idea of what the advantages and disadvantages are.

One sticking point of Git, when it comes to making a recommendation at the office, is that it has very poor Windows support. It is really only available via Cygwin and doesn't really have any decent GUI tools outside of Linux. Given that I use OS X for personal and freelance work, this isn't an issue.

Mercurial (or Hg, which is its command-line executable - and the atomic symbol for Mercury -- very clever) has great support on Windows, but this isn't surpising: it's written in Python. This means that, in general, it is fairly cross-platform. There is also good a GUI tool for Windows, namely TortoiseHg.

The one thing that's not clear for me from this comparison is which tool has the better branching and merging model. Git has it's rebasing and can do complete historical merges, as well as more of a standard branch/merge model. Mercurial's model is less well known to me at this time, so perhaps the next step in this decision process is finding an equivalent of Pro Git for Mercurial.

Getting Git

2009-11-04T08:55:00.004-06:00

Pro Git is an excellent book on the Git version control system. It covers all aspects of Git from the day-to-day basics and branching to the use and setup of remote repositories. It is concisely written with excellent examples. The diagrams are particularly helpful in understanding branching, particularly in the context of merging and rebasing.

A must read for anyone considering a distributed VCS.

Double Disk Failure

2009-10-21T02:47:00.002-06:00

You'd think I'd be good at this. You'd think I'd be disciplined. I've had enough catestrophic hardware failures in my life, that you'd think I'd have a regular backup strategy of the important files on my main computer (a Macbook). You'd be right. Well, at least I did up until my back-up drive died...over a year ago.

Pretty useless strategy when your main hard-drive dies.

Normally, this wouldn't be as catastrophic as it sounds. Except that I'm in Germany, and I don't know where to go to find parts or restore the data on my drive. Nor do I even have my OS X disks (or any disks, for that matter, to even try Ubuntu) or the tools to repair the laptop. Fortunately, I have an iPod Touch, which proved invaluable for finding information and stores. I was able to try a number of steps to see about recovery, even with these obstacles.

First, I tried to install Ubuntu to a thumb-drive and boot from there. I have a thumb drive on hand, and could download Ubuntu (using my flatmate's laptop), so this was a good, free option. Following this guide, I had no problem setting up the thumb-drive. However, it turns out, that Macbooks won't boot Linux from USB drive. I haven't yet looked into whether or not it needs to have the right partition table, but looking around the web, it doesn't seem to be possible.

Second, I found an electronics store - Saturn - and bought some CD-R's^[1] and a copy of OS X: Snow Leopard. My second, less-then-free-but-still-cheaper-than-buying-a-new-hard-drive strategy was to install Snow Leopard to an external USB hard-drive, which I happen to have on hand. Following this guide, I began by formatting and repartitioning the disk. Remember when I mentioned that I'm in Germany? Well, it seems that this disk did not exactly survive the flight here in my luggage. The format failed repeatedly, using Disk Repair failed repeatedly, and even when it seemed to work, the install would fail immediately when attempting to write to disk. At least, I was able to verify that it was only the Macbook's disk was broken.

Third, I found another electronics store - Conrad - where I could buy a new hard-drive (double the size of the old one, so there's one silver lining) and the tools to replace it. 70 Euro later, and I have the parts to fix things^[2]. Thanks to iFixit and their tutorial for replacing the hard-drive, I was able to easily install a copy of Snow Leopard.

So, I'm left with a clean laptop^[3], and the task of restoring all my applications. This is a bit of a pain, since some of them don't run on Snow Leopard (I'm looking at you Microsoft Office 2004), and I don't have the disks on hand for others (Adobe Creative Suite). I'll have to find some open-source alternatives, in the mean time.

It's a relief having it back up and running. Aside from being my personal development space, it currently is my communication platform and my entertainment platform. I've lived with out a computer before, but it takes a week to get over the hole it leaves in my life. I'm glad it only took a few days to plug that whole back up.

[1] The CD's were for creating a bootable Ubuntu CD, as a backup plan.

[2] Total cost: 102.70 Euro - Not too bad really

[3] I have yet to find a place to recover the data from my old disk, but I may wait until I'm back in the States.

Twing of Jealosy

2009-08-05T13:11:00.002-06:00

It's stuff like this that makes me want to give up working in business-related applications: SIGGRAPH2009.

Frankly, there some pretty cool concepts there.

File Madness

2009-05-27T20:10:00.004-06:00

One thing that has already driving me nuts about the iPhone OS is the file system interaction. It's not necessarily something that I'll have to deal with very frequently, but the way standard directories are defined is a bit of a hodge-podge:

Getting your Application bundle directory (where all of your resources are going to be written):

NSString *resourceDir = [[NSBundle mainBundle] resourcePath];

Getting the Application's Home directory, where its documents, cache, and temporary directories are (as well as the above mentioned bundle directory):

NSString *homeDir = NSHomeDirectory();

But to get any of these other directories it get's uglier:


NSArray *paths =
 NSSearchPathForDirectoriesInDomains(
     NSDocumentDirectory, NSUserDomainMask, YES);
NSString *documentsDirectory = [paths objectAtIndex:0];

The least they could have done is given us a simple function to get that document directory, something like NSGetDocuemntDir(), for example.

Now, all this is in the documentation, but the bundle directory (where all your project resources go) are not considered files, so therefore, are only mentioned in passing in the File section of the documentation. I have been less then impressed by the developer documentation from apple. It's complete, but I just don't find the organization to be all that intuitive.

First iPhone App

2009-05-24T15:58:00.007-06:00

I finished the first pass at a working iPhone app. It's a port of the SpiderMonkey Javascript engine from Mozilla. I've put together a simple UI with an editor and output text areas. Currently it only has an alert() function and a print() function for displaying results in the output text view. It does have all of the default functions and objects for JavaScript 1.7.

Source available here. I am looking to host the project somewhere, but I haven't decided on a Mercurial hosting solution that's free and allows me to upload an existing repository.

Now, I can't actually submit this to the App Store (it uses a separate language interpreter). I did it as an exercise in porting an existing application as a first step for porting another application which uses SpiderMonkey as its scripting engine. That one has a lot more graphical and file issues, so it'll be a bit more of a challenge.

Back to Mobiles

2009-04-25T15:25:00.006-06:00

I spent a good chunk of time, early in my career, working on mobile handset programs. They were J2ME programs, and there were a tremendous amount of limitations. In order to get back into the waters of mobile development, I recently bought an iPod Touch.

Boy, times have changed.

The iPhone OS provides quite a suite of libraries: sound, animation, data, OpenGL, and a rich UI library. You also get a whopping 8 GB of space on the base models of either the phone or touch. On the earlier Motorola J2ME handsets, we had to keep our app under 150K - a real challenge with a java app as feature rich as that one.

Of course, the major difference in device development for me is that my previous experience was in business applications. Most of my ideas for getting my feet wet on the iPhone OS are small games.

Frankly, I don't know a whole lot about this sort of thing. But it's only a matter of learning some new API's and remembering how to do some simple math transforms.

I think one of the reasons I'm drawn to this platform (as well as the Wii - one at a time, people) is that it has some potentially novel input methods. The first is the multi-touch screen, while not a new idea, widens the types of interactions one can have with the device. One can build games with innovative gesture controls which may become more intuitive then using the mouse and keyboard is now.

Second (and far more interesting), the tri-axis accelerometer provides a new level of gesture-based interaction. The device itself may be used as a steering wheel, it may be shaken to clear the screen, or it may be used to perform some other intuitive physical action.

I have a lot of ideas on paper, so now it's just a matter of getting those ideas in code.

Non-Functional

2008-12-13T21:20:00.003-06:00

I've started to look at the Scala programming language. It's a very interesting language created by Martin Odersky who was responsible for addition of Generics to Java. It is both an object-oriented and a functional language. This makes it incredibly powerful, and incredible difficult at the same time.

The Awesome

It has two features that I find are incredible powerful. The first is Scala's solution to the multiple inheritance problem. A piece of functionality can be placed into a trait, which is akin to a interface, but may contain implementation. Now an object can gain pieces of functionality, without having either a polluted hierarchy or a set of interfaces with repeat of the functionality throughout the code base.

The only way to really accomplish this in Java was to use Aspects (which I do happen to like, for this very reason), but there are a variety of libraries to do this, all of which do it in their own way (AspectJ, AspectWerks, etc).

Secondly, Scala provides the ability to create your own language features. One of example of this (courtesy of Ted Neward) is with exception handling:


/ This is Scala
object Application
{
def generateException()
{
  System.out.println("Generating exception...");
  throw new Exception("Generated exception");
}

def main(args : Array[String])
{
  tryWithLogging  // This is not part of the language
  {
    generateException
  }
  System.out.println("Exiting main()");
}

def tryWithLogging (s: => Unit) {
  try {
    s
  }
  catch {
    case ex: Exception =>
      // where would you like to log this?
// I choose the console window, for now
ex.printStackTrace()
  }
}
}

We've actually created a function which takes a void function as it's argument. Due to the way Scala allows us to call functions, it can look like a part of the language. This is really powerful if you are in the business of creating Domain-Specific languages.

The Difficult

Again, Scala mixes object-oriented and functional paradigms. The functional aspect has me in a bit of an intellectual twist. I need to unwrap the OO part of my brain, and try and think like a functional coder. I was halfway there when I was doing a lot of Javascript programming, however I was busy doing what everyone else was doing: enhancing what OO capabilities are in the language.

Functional programming is different, and takes a different mindset. I'm doing some reading on the subject, but it's a struggle. I have to battle some long-set ideas in my own thinking.

Still, there has been an interesting explosion in languages, and it's a rather exiting time to be a programmer.

New Domain

2008-12-06T16:45:00.004-06:00

I've renamed this blog to Blasted Machine,as well as moving it to a custom domain. Good ol' Google has made that remarkably simple (only $10 - it's almost an impulse buy). Not sure what else will go under the Blasted Machine logo.

Heck, I even need to produce a logo, and a new template. Best get crackin' with Inkscape...

Going Native: Structures and Callbacks

2008-09-28T15:47:00.005-06:00

This is a continuation of a simple overview of the Java Native Access (JNA) library. In the first part, I looked at the basics of mapping native library functions, with simple types.

JNA provides two key elements for the mapping Java to C libraries, namely structures and callbacks. Structures are automatically mapped from the native values and may be used as a type-safe pointer to a instance of the structure. Callbacks are provided via an extension of an interface, and the appropriate method is defined on the new interface.

Structures

Mapping native structs into Java classes is fairly simple via the Structure class. This class may be extended, and and any fields may be declared as public members of the new class.

For example, let's take the following C struct


  struct {
     char* name;
     int count;
     char* desc;
   } record;

and map it into Java


  public class Record extends Structure {
     public String name;
     public int count;
     public String desc;
  }

Once we have our structure defined, we can now create mappings for functions which operate on the record struct. In C:


  int save(record* record);

and in our Java library interface:


  public int save(Record record);

What if we want to pass this struct into a function to be populated? For example,


  int load(record* record);

  // and it's usage:
  record r;
  load(&r);
  printf("record found: %s", r.name);

in which we load the record from a data store. We need a way, in Java, to pass this object to the native code, by reference. Fortunately, JNA provides a simple way of doing this.


  public class Record extends Structure {
     public class ByReference extends Record implements Structure.ByReference {}
     ...
  }

  // and it's usage:
  Record.ByReference record = new Record.ByReference();
  MyLibrary.INSTANCE.load(record);
  System.out.println("record found: " + record.name);

This tag interface provides a very simple way of giving us this functionality.

Callbacks

Callbacks are provided by the Callback interface. By extending this interface we can add a method which will be used by the C library as the call back method.

Let say we have a method in our C library which will notify the application if a record has been deleted by another process. It provides us with a method to add a callback,


  int register_delete_monitor( void* fn);

and the callback expected takes a parameter of a record.

In our Java library, we would create a Callback for this method:


  interface DeletedRecordCallback extends Callback {
    void callback (Record r);
  }
  ...
  // and in our Library Interface:
  int register_delete_monitor (DeletedRecordCallback drc);

Now we can pass in an implementation of our DeletedRecordCallback and have it registered as a callback in the C library.

There are one caveat with the use of callbacks in JNA. The callback must not be garbage collected unless it's been unregistered. This is especially true for long lived callbacks. A call to a garbage-collected callback will crash the vm. This can be simply avoided by hanging on to the instance of the callback - a singleton will work quite well in this context. Otherwise, it is important to have the callback instance deregister itself in it's finalize method.

Overall Impressions

Coupling the power of JNA's type mappings, with its structure mapping and callback access, it is a very useful library for taking the difficulty out of mapping native code to java. It makes rapid development with existing native libraries much, much easier. Java-to-native mapping has never been easier.

Going Native

2008-09-18T22:23:00.007-06:00

I have a new project (and a new work) which involves starting and interacting with a python interpreter from the JVM.

I did my requisite Google search. At first, I thought I would do this using an existing library, JPype, but this works the other way around - the JVM is embedded in Python. So I moved to the next option, JNI. JNI is a pain in the ass, so after spending half a day trying to compile the generated stubs - not even talking to the Python C library, mind you - I decided to go back to Google.

I thought that, perhaps, someone had written a way to generate JNI headers and native methods. There are a few options out there, actually, but the one I settled on is JNA. It's open source, cross-platform^[1], and surprisingly easy to use. An added benefit is that Timothy Wall, a major project contributor, is pretty responsive on the user mailing list.

It's simple to use:


package com.sun.jna.examples;

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Platform;

/** Simple example of native library declaration and usage. */
public class HelloWorld {

  public interface CLibrary extends Library {
     CLibrary INSTANCE = (CLibrary)
         Native.loadLibrary(
            (Platform.isWindows() ? "msvcrt" : "c"),
            CLibrary.class);

     void printf(String format, Object... args);
  }

  public static void main(String[] args) {
     CLibrary.INSTANCE.printf("Hello, World\n");
     for (int i=0;i < args.length;i++) {
          CLibrary.INSTANCE.printf(
             "Argument %d: %s\n", i, args[i]);
     }
  }
}

That's it. You now have native access to printf. All of the native calls are handled through a proxy generated at run time. You don't have to write all the methods in the library, either. The resolution is done on the fly. If you need to add another native call, simply add it to the interface.

The library begins to get a little hairy when dealing with pointers and references. For the most part, pointers are handled for you (it's Java, every things a pointer). But what about primitives, you ask? JNA solves this through a nice set of Pointer and PointerType classes.

So now if you have a C function like the following:


 void setSomeValue(int* retValue)

you can map it via the following:


 public interface MyNativeLibrary extends Library {
    ...

    public void setSomeValue(IntByRefrence retValue);

    ...
 }

In Java, we can now call the method like so:


 IntByReference retValue = new IntByReference();
 MyNativeLibrary.INSTANCE.setSomeValue(retValue);
 System.out.println("retValue = " + retValue.getValue());

There is also a PointerByReference, which can be used to do the same thing with pointer-based arrays, or String values.

Structures and callbacks are also very simple to map. I'll take a look at these in a followup post.

I don't know why anyone would write JNI anymore^[2]. This library has made access to native code amazingly simple, and surprisingly intuitive. I would would highly recommend it to anyone who is avoiding a solution, simply because they don't want to make native calls.

[1] Linux, Mac OS X, and Windows, for now.

[2] Ok, there is some overhead, but through clever caching of the function pointers, it's pretty fast. I'll have to find some numbers on it.

Simple SAX

2008-04-07T15:20:00.002-06:00

Greg Reimer has put together a very nice SAX parser in JavaScript. While it's preliminary, it certainly could add a much-improved way of dealing with XML.

There are certainly times when SAX parsing is a much better choice for parsing. I'm curious to see if someone expands on this idea, as well as makes some more thorough performance measurements of this implementation.

(via Ajaxian)

Another Hearder of Electric Sheep

2007-11-17T14:22:00.000-06:00

Once more there's a new library for writing applications on small devices. Android, from Google and the Open Handset Alliance, is a new OS and SDK for mobile devices (primarily for phones, by the look of the emulator).

It looks like it's built on a small Linux kernel, but, more importantly, all the functionality is accessible from a fairly full featured Java API. Depending on it's adoption, it could be a pretty serious contender for both J2ME, as well as BREW (mostly on Verizon devices).

Going forward, it might be useful to have a port of the J2ME application libraries to Android, in order to transition existing mobile apps. A good idea for a some enterprising^[1] open-source developers...

[1] Wait, are open-source developers "enterprising"? Or is the sharing of the application and source code more of an artistic action? Perhaps a philosophical discussion will have to be made.

Definitions for the Lazy

2007-08-15T08:58:00.000-06:00

This is bloody interesting (via Ajaxian). It involves creating functions at call time, where some expensive initial operation us computed and placed in a new function, which is then used to replace the original one.

For example,


function MyObject() {
    this.someFunction = function(x) {
        var a = someComplexCalculation();
        this.someFunction = function(y) {
            return a + y;
        };
        return this.someFunction(x);
    }
}

Pretty sweet.

Writing (About) Development

2007-06-27T09:05:00.001-06:00

This would be interesting for programmers. It's a journalism program through Northwestern's Medill School. Its designed around creating better technical journalists from technically minded people.

I think there is a certain about a of merit to creating a pool of developers who can communicate about technology in and around their particular disciplines. Communication not only helps people understand what is going on in software, but it also helps alleviate fears from new technologies.

One thing that seems to be on the decline is strong science and technology reporting. Things are usually over-reported or over blown. One might wonder if the whole of the Y2K scare was as a result of poor technology reporting.

This same poor understanding and fear of technology inspires such works as Cult of the Amateur: How Today's Internet is Killing Our Culture^[1]. It's premise is that sources become untrustworthy, as the ability to disseminate information essentially becomes free (via blogs, MySpace, etcetera). This undermines traditional media, which is supposedly superior through editors, publishers, marketing professions - the whole of the industry. He (at least according to critics) widely misses the mark in proving his case.

(I'm not saying that these are now unnecessary. A good editor is certainly a great value. I, for one, would like a little editorial review now and then. It would keep me from saying some of the ridiculously stupid things that happen to fall out on my keyboard - like this aside, for example).

I tend to view the current state of user-driven content (and by these, I mean blogs) as similar to the early days of the printing press. Widely available and affordable print media helped to disseminate new and powerful ideas - the Reformation, for example. The changes that came with print media brought with it an equal set of drivel and highly untrustworthy reporting - political reporting has been a biased and bile-filled subsection of the media from day. The market of readers helped to drive the quality of the publications.

Returning to the Medill program, it could help to further bridge the gap of technology savvy with excellent reporting. Trustworthy sources become so through good journalism.

[1] See this for a response.

No Such Luck

2007-05-06T13:19:00.002-06:00

I picked up the tools I needed to try and perform a little clean up of the teriyaki spill that has taken down my PowerBook. Opening up the laptop was really straight forward once I had the (ridiculously small) Torx T6 screwdriver.

Alas, all this was to no avail.

My plan had been to crack it open, spray some contact cleaner onto the now-encrusted teriyaki. Following the instructions from iFixit.com, I was able to open the laptop with much trouble. These instructions were for the model previous to the one that I own. This turns out to differ slightly from the latest model^[1].

There are a few extra screws that hide underneath the right side speaker. Not being aware of these, I tugged on the logic board a few times before poking around a bit more for those extra couple of screws. It could be one more cause for the permanent damage to the unit.

Getting the logic board out is a bit of a trick. It has to be angled just right (about 45 degrees) to pull it out. There's a little hook shaped bracket that sits over the board just to the left of the DVI connector. This is what one has to work around. This is another place where there might have been a little jostling on my part.

Looking over the board, it really looks like it was hardly touched by the teriyaki invasion. Mostly, the sauce pooled in the bottom corners, around the power connector, and a little by the DVI connector. Spraying the contact cleaner in those places seemed to clean away most of the mess. It was a bit difficult, however, as there was a considerable number of sesame seeds^[2] that got stuck in the power connector.

Putting it all back together was just a matter of reversing the process (as usual). I missed a connector or two along the way but, after a few attempts to power it up, I figured out where all the pieces go.

I pressed that button, that pretty silver button, and nothing.

All that was left was to rifle through its pockets and look for loose change. I pulled out all the useful bits and pieces - hard drive, optical drive, and the memory. I'll have to see if I can part the thing out on Ebay.

This isn't exactly a Bad Thing, of course. I'll have to get a shiny, new MacBook. The G4 was starting to show its age and those Core Duos are speedy.

Only, I'll have to wait until October. Stupid Leopard delays.

[1] And by the latest model, I mean the last model of PowerBooks. This is before the switch to the MacBook/Intel line of laptops.

[2] It's a really tasty sauce, Veri-Veri Teriyaki by Soy-Vey. I recommend using it on a nice piece of salmon - marinate the salmon for at least a half hour, broil it for ten to twelve minutes, and enjoy.

PowerBook Down

2007-04-18T16:07:00.000-06:00

I had an unfortunate incident with my PowerBook last week. It's been potentially brought to its knees. Was it a problem with the battery, a virus, chimpanzees slapping the keyboard like a bongo?

No, it was teriyaki.

My lunch, in my wonderful courier bag^[1], was not sealed. As a result, teriyaki spilled and pooled in the bottom of said bag. Not having ordered the one with the special laptop pouch^[2], it pooled into the back of my laptop.

Now, the "geniuses" at the local Apple store opened it up (for 89 bucks!) and told me that it would be 1200 simoleons to replace the logic board. First off, I might as well buy a new laptop (probably their strategy), second off, who the hell still calls it a "logic board" anyway.

I thought about this for all of thirty seconds and decided I would at least crack the thing open myself and try to clean it. With a torx driver in hand, some electrical contact cleaner and instructions from iFixit, I'm going to embark on my attempt to fix the laptop.

Pictures and discussion to follow.

...wish me luck.

[1]And, yes, on the rare occasion that I ride my bike, it actually is used for its purpose.

[2] Timbuk2 bags are great, but not compartmentalized enough for the prevention of liquid mishaps.

Perceivably Slow

2007-03-06T13:35:00.000-06:00

I installed the new version of the Java SDK, 1.6 (Mustang), at work recently and was surprised by the performance change. Looking at David Dagastine's discussion on of JDK performance, one would think that performance should and would be better.

I was grossly underwhelmed.

After installing the new SDK, I ran an install of Tomcat 5.5. My server start-up times were running between 5 and 9 seconds. Given that I start and stop the server many times in an hour[1], I really thought it would be great to reduce this time. The startup time with Mustang jumped to between 25 and 35 seconds.

Once it had started up, the performance seemed comparable to the 1.5 VM (if not better - I'm sure that it's here where Dagastine's numbers are accurate). That start up time is, however, miserable. It effects the perceived performance of the whole experience[2].

This startup performance force the designers of applications to add little things to their applications, like splash screens, startup info, etc. This will increase the perceived performance of the application by giving the illusion of things happening.

[1] This is due to the fact the file I'm using is loaded through a servlet. Due to the way that ClassLoader.getResourceAsStream() loads the stream into memory. Only restarting the VM allows me to reload the changes.

Mac on Your PC

2007-02-27T21:56:00.000-06:00

It's one of those things that a few of us in the PC world have wanted for a while: Mac OS X on our own Intel hardware. Build the machine and put whatever OS on it we wanted. What would be better than a very user-friendly UNIX variant?

Beginning with a leaked VMWare build and followed by some brilliant hacking with the Darwin kernel (the open-source core of OS X), this is now possible - albeit not entirely legally.

From what I've, err, read (right, that's it), Osx86 (as it's commonly know as) has actually reached a rather stable state. It even runs reasonably well on AMD hardware. Sure the project has a few instabilities (crashes when entering sleep mode), but it's come a long way considering it's a clever port of an closed system. Current working versions are 10.4.8, and there are experiments in progress for the latest Leopard (10.5) builds.

The Osx86 community has even put together a cobbled series of drivers for most commonly used hardware. Patched together in an hacked Mac install disk, it's possible with access to BitTorrent to try it at home.

For those who are interested in spending a little time tweaking, it's a surprisingly easy way to try before you buy. A great site for information is Insanely Mac with numerous forums, or it's older Wiki site.

For-In Issues

2007-02-09T09:54:00.000-06:00

I came across a little idiosyncrasy yesterday in JavaScript. Perhaps it still shows my ignorance to the nuances of the language, but I hadn't really thought about.

Until I got bit by it.

Look at the following snipit:


var listOfValues = new Array(1, 2, 3, 4, 5);
for(var x in listOfValues) {
   doTheThingWithTheDeal(x);
}

It seems simple and straight forward enough. Handy to use to: add some elements to an array and then use a language-level feature to evaluate them. Heck, it so useful they put it into Java.

That's great, but like Java, developers don't always want to be re-inventing the wheel with every application. Still not a problem when one is writing their own libraries. There are, however, a dearth of libraries available for use these days. With the rise of AJAX, we have people building fancy libraries to ease cross-browser development.

One of the most commonly used libraries is the Prototype library. This library provides a number of structures to improve and ease the coding of OO JavaScript. It also extends some of the native JavaScript objects, in order to add some nice methods which the developers of Prototype thought where missing from the implementation.

This is where we start to run into trouble. Array is one of these objects that is
modified with all sorts of convenient methods like indexOf, first, and each. This brings us back to that code snippet. If we now iterate over that array in the example not only will we doTheThingWithTheDeal on the integers in the array, but we'll also doTheThingWithTheDeal on all of those handy-dandy new array methods.

Prototype's (as well as any other library developer who modifies the native objects) response is to not use the for-in control. I would argue that this is a poor extension, since it forces project developers to change their own code. Some structures may rely on this control structure (hence why I'm writing about this).

Why Does It Fail (and what to do about it)

The reason this failure happens is that the properties of all JavaScript objects have attributes. These attributes consist of ReadOnly, DontEnum, DontDelete[1]. The attributes are only available for modification inside the script engine (see the Rhino JS engine, for example).

DontEnum is the attribute that controls whether or not the property shows up during the execution of a for-in structure. For-in operates over all properties of an object. For arrays, this includes the indexed properties, as well as the named properties (In fact, this is true of all objects in JavaScript, due to the languages syntax).

Current implementation of the language doesn't allow this to be modified by users.

Looking at the future of JavaScript, keywords may be added in order to modify the enumerability of properties. Until then, we'll have to either modify our code to work with Prototype, or use libraries that don't extend the native objects.

[1] See the ECMAScript Spec for more information on these attributes.

Member of the Ranks

2007-01-21T13:17:00.000-06:00

I've been writing blogs for a while now^[1], but I have yet to enter the field of technology bloggers.

Write what you know, they say.

Well, actually, I plan to use this blog for writing about learning technology I don't know very well. I'm a Java Developer by trade, dealing mostly with J2EE, and mobile Java. I've dabbled a bit with web development (AJAX being the latest bit of technology). Here, though, I'll stick to writing about subjects I'm learning.

I have quite a list of things that have begun to capture my fancy. I'm interested in learning some Mac OS programming. This may include things such as Cocoa, ObjectiveC, Dashboard widgets, and Java bindings for libraries.

There are also system related things: trying out Linux distributions, like Xubuntu for example. I'm in the process of setting up an iMac as an HTPC which, so far, has been worked out pretty well. I might need to make some tweaks which I'm certain I'll post about.

So here I am, in the ranks of technology bloggers.

[1] Schpatz Lager for essays, Vagabond Tango for travel and tango, and Ninety-Minute Shorts for fiction.