Also while I was at it – I added a second argument to sizeOf() and deepSizeOf() named ignoreFlyweights. That refers back to the last section of part II – it enables you to define if the (what we have defined as well-known) flyweights are going to be counted for the total memory usage or not.

This is the modified internalSizeOf() method, that’s being used to “filter” for the the two well-known “troublemakers” in CF as discussed in part II. When I was doing some further testing, I came across a few more scenarios that could cause the memory sizing to drift off, those have been added as well:

 private static long internalSizeOf(Object obj, Stack stack, Map visited, 
   boolean ignoreFlyweights) 
  {
    if (skipObject(obj, visited, ignoreFlyweights)) 
    {	
      return 0;
    }
 
    Class clazz = obj.getClass();  
 
    if (clazz.isArray()) 
    {
      addArrayElementsToStack(clazz, obj, stack);
    } 
    else 
    {
      // add all non-primitive fields, non-CF memory tracker objects and non-SessionContext objects to the stack
      while (clazz != null) 
      {
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) 
        {
          if (!Modifier.isStatic(field.getModifiers()) && !field.getType().isPrimitive() && 
            field.getType().getName() != "coldfusion.runtime.NeoPageContext" && 
            field.getType().getName() != "coldfusion.runtime.CfJspPage" && 
            field.getType().getName() != "coldfusion.monitor.memory.MemoryTrackable" && 
            field.getType().getName() != "coldfusion.monitor.sql.QueryStat" && 
            field.getType().getName() != "coldfusion.monitor.memory.MemoryTrackerProxy" && 
            field.getType().getName() != "javax.servlet.ServletContext") 
          {
            field.setAccessible(true);
            try 
          	{
              stack.add(field.get(obj));        
            } 
            catch (IllegalAccessException ex) 
            {
              throw new RuntimeException(ex);
            }
          }
        }
        clazz = clazz.getSuperclass();
      }
    }
    visited.put(obj, null);
 
    return sizeOf(obj, ignoreFlyweights);
  }

I’ve provided a .zip file (version 0.1.1) containing the source. If you don’t want to compile it yourself, just grab the CFMemoryCounterAgent.jar and apply it to your CF instance as described in part I. The .zip also contains a memorytest.cfm that should be self-explanatory and will give you an idea how it’s supposed to be used. If you want to compile it, the build file for Ant should do the trick – please note that there is a copy task in there that copies the file into the location of my CF installation’s lib folder. You pretty much would want to change that to copy the .jar file to a different location OR remove that copy task in the first place. Also – I’ve build and tested this on CF 8.0.1 on OS X. You need Java 5 or newer to run this in the first place and YMMV with other CF versions. If you try it and get weird results, let me know.

Edit: The .jar file is compiled with Java 6 and the Ant file targets Java 6 as well. Make sure that you potentially recompile the source and change the Ant file if you try to run this on Java 5.

Please keep in mind that all results you’re getting from this are JVM-based estimations and sort-of right. Also, I would strongly discourage you to build totally messed-up code for the sake of saving 250 bytes or similar. Don’t forget that the JVM has a reasonably well-working garbage collection and the GC will collect most variables that you create on a page very quickly in the first place. The techniques shown here are more for information and to raise the behind-the-scenes awareness. Besides that, it’s just interesting to see how CF deals with the different variable types. The next (and final) post of this series will have a look at some results and try to explain those. Stay tuned.

How much memory does my ColdFusion variable really use? – Part III is a post from: Blog in Black

How does it work?

This post is geared towards the problems the out-of-the-box Java solution runs into. Let’s first have a look into two different ways of calculating the memory usage of a CF variable with the approach described so far.: sizeOf() vs. deepSizeOf() respectively shallow vs. deep. If you’ve done any work structs in ColdFusion this concept should be somewhat familiar (there are shallow copies/references as well as deep copies). In our use of the terminology shallow will refer to measuring the memory usage of the object itself and deep will refer to measuring the memory usage of the object as well as its fields (members) as well as the parent class(es) and their fields up the object hierarchy.

How does the code do this? Basically it’s using a stack and a hash map to keep track of what do to and what already has been measured. First step is to grab the CF variable (which is a Java object), check a few things (more below) and then throw all members of the object onto the stack for further processing. After that, the superclass gets processed the same way, more stuff gets thrown onto the stack and popped off the stack again when we’re running out of things to process and measure.

Ignoring types

This fact alone contains a few interesting surprises. When I started measuring slightly more complex CF variables than simple Strings or Numbers, I got crazy figures of several MB for a simple struct. That obviously couldn’t be right. Using Java reflection on a few CF variables, such as structs or arrays, I easily found the “culprit”: reference(s) to coldfusion.monitor.memory.MemoryTrackerProxy. Sounds like the CF 8+ server monitor subsystem to me, but I might be wrong. But anyway – following this reference along up the object hierarchy creates the outrages figures for a struct and other variables. The Java class behind a CF struct is coldfusion.runtime.Struct and it actually contains a getter and a setter (getMemoryTrackerProxy() etc) to work with the MemoryTrackerProxy. For our purpose of measuring the memory used for the struct and its content, we certainly don’t need to follow the links to MemoryTrackerProxy when the instrumentation works itself through the object stack. What that basically means is that we have to ignore all members of type coldfusion.monitor.memory.MemoryTrackerProxy when we trace the object tree.

Just in case you’re interested, the inheritance structure for a CF structs from a Java point of view looks like this:

After having “fixed” the MemoryTrackerProxy issue, common CF variables worked fine. I still ran into issues with some persistent scopes. Further testing showed that some of those contain members of type javax.servlet.ServletContext. Now – following those when tracing memory usage also creates huge amounts of memory being used because you’re pretty much including a lot of the overall Java API. That particular happens when dealing with measuring the application scope. Therefore javax.servlet.ServletContext is another class I’m filtering for and ignore when measuring memory usage.

Important: Both decisions are made sort of arbitrary. One can argue that following the references and including javax.servlet.ServletContext for the application scope for instance would create the “real” amount of memory used for the application scope. My answer to that would be: yes, that’s fair enough and it might be a valid point. I’ve made the decision not to include it because it’s not what I want to measure here.

Flyweights

Just a few quick word on flyweights or the Flyweight Pattern. I don’t want to dive into the specifics of this pattern, just follow the linked explanations if that’s of interest for you. But – I want to give you a plain language description of what it is (from 30,000 ft): Basically the Flyweight pattern is a way to manage memory very efficiently by sharing and pooling objects whenever possible. That’s pretty much you’d need to know for the purpose of this exercise. Ah – no, hang on. What again does this have to do with Instrumentation and tracking memory usage?

Well – think of a pool of Integer objects or internalized Strings. For us, it’s pretty much impossible to say if a particular object of such characteristics is used for solely our case or if it’s reused in a lot of other places in the app. Maybe we have our own instance of an Integer xyz and therefore the memory usage of it should be counted towards the use of our complex ColdFusion variable. But maybe we just borrowed an Integer abc for the fraction of a blink that was somewhere in the pool anyway and therefore just quickly using it didn’t do any “harm”. We don’t know and that’s why we check. For Integers we would basically do: obj == Integer.valueOf((Integer) obj). If that returns true, we know it’s a shared flyweight and shouldn’t contribute to the overall memory usage. For Strings it means to check the .intern() method (as described and linked above). There are a few more types for which such testing makes sense.

Still, one can argue that one’d want to see the memory usage ignoring any flyweight/JVM concerns, so I made that configurable with a switch. I personally think it’d be better not to include them, but both will possible.

That’s it for now – part III will comprise the actual Java code and .jar file to be used in ColdFusion and some examples. I should actually write another post giving a few more explanations on using Java reflection in ColdFusion and what it can be good for (basically tinkering with undocumented features .

How much memory does my ColdFusion variable really use? – Part II is a post from: Blog in Black

All that’s good information, but it didn’t provide the information I wanted in this case. I literally wanted to be able to create an array or a structure in CF and see how much memory the instantiation of this variable will take. I don’t see a way to get this information from ColdFusion itself, but here’s a nice feature of the underlying Java platform to the rescue: JVM instrumentation (available from Java 5 onwards).

If you followed the link above you would have seen the getObjectSize(Object) method and its description “Returns an implementation-specific approximation of the amount of storage consumed by the specified object.”. Ah, cool. That sounds about what we want, right. Take an object – throw it into that method and get back the amount of storage used, doesn’t it?

Notice the following restrictions:

• implementation-specific and
• approximation

What does that mean for us? Well – basically what it comes down to is: You get an approximation, it  might not be correct to the last byte. The JVM will try hard, but it might just not be 100% exact. Also, speaking of the JVM – the number it returns will be correct for your hardware, operating system and JVM used. To give you an example – the figures I get on my 64-bit OS X 10.6.2 with JVM 1.6.0_17 might be different from someone on 32-bit Windows with a Java 5 JVM or even a JVM 1.6.0_16. So – to sum it up: YMMV.

I started playing with instrumentation a bit and then found issue 142 of Heinz Kabutz’s JavaSpecialists newsletter. In there, he provides a JVM-instrumentation based memory counter that seemed to do exactly what I wanted to do. The idea is that you have a MemoryCounterAgent class that provides two static methods: sizeOf() and deepSizeOf().

The way to use his code is rather straight forward. Compile the MemoryCounterAgent.java provided there – either with a tool of your choice or use the ANT scripts Heinz has provided. The result should be a .jar file that you’d best put into the lib folder of CF respectively Java. I’ve done all this on CF 8.0.1 / OS X 64-bit installed in a JRUN4-based J2EE installation. The folder I place the .jar file in this case is /Applications/JRun4/lib.

To hook your JVM into the instrumentation agent, you need to modify the JVM arguments. You find those usually in the jvm.config file in the bin-folder of your CF or JRun installation. The idea is to add a -javaagent argument in front of the other, existing arguments that points to the .jar file you’ve created and placed in lib before.

java.args=-javaagent:/Applications/JRun4/lib/MemoryCounterAgent.jar

Restart ColdFusion and after that you’ve got the instrumentation available for ColdFusion code. Put the Java object in your CF code (it’s static, so don’t instantiate it) and call a method of it:

<cfscript>
	oObjectSize = CreateObject("java","eu.javaspecialists.tjsn.memory.MemoryCounterAgent");
	myText = "This is a string";
	WriteOutput(oObjectSize.sizeOf(myText));
</cfscript>

“What’s the catch?”, you might ask. Well, there are a few. First of all – the unmodified code works for a variety of different CF variables, but it pretty much provides weird results for some others. The reason for this is that a CF variable is basically a Java variable. Strings in CF are of type java.lang.String – easy. Arrays in CF are of type coldfusion.runtime.Array and most complex CF types have such a non-trivial representation in the Java world. Those Java classes contain CF-specific implementation details and hooks into other parts of the ColdFusion infrastructure that really blow out and misshape the memory estimations the JVM instrumentation provides. There are ways around that (by using reflection on CF variables to find out how they are constructed, but that will be covered in part II of this series of blog posts).

The second issue are flyweights. For all those of you who have no idea of what that means – the flyweight pattern is a way to manage memory that is used for certain types in Java and its JVMs. Using (and including) flyweights in memory calculations can produce significantly different results from not using them. Also – that will be covered in more detail in part II or III.

Anyway – there are reasonable solutions for both issues, I believe. I’m currently building a CFMemoryCounterAgent class that provides memory tracking on CF variables as close as it gets – stay tuned, more on this here in the next few days.

How much memory does my ColdFusion variable really use? – Part I is a post from: Blog in Black

BTW: Did everyone realise that the registration for webDU 2010 is open and that the Early Bird price (AU$ 695 is really a bargain for the two days) runs out on March 7? Register now, but latest on March 7 please.

My topic will be: “It doesn’t always have to be relational – Introduction into CouchDB”. Although this session is going to cover a lot of content specific to CouchDB, you can bet that you’re going to get a whole lot of information on how to use Couch with ColdFusion and Flex.

Here’s the full session abstract:

—
Web developers have grown into the habit of pretty much solely relying on relational data base management systems to store the data of web applications. But besides the well-known RDBMS there is a huge community of supporters of alternative database systems out there: Object-oriented database management systems, hybrids between OO- and relational DBMS and many more. And then there’s CouchDB (subtitled: “relax”) – a document-oriented database that recently got promoted from the Apache incubator to becoming a full-blown Apache-supported open source project. CouchDB is fundamentally different from what you’re used to, but it offers a refreshing and different approach for storing data in your web application and it actually scales tremendously well in large web apps.

In this session, you’ll get an introduction into CouchDB, its API and the mechanisms behind the API and we’re going to look into hooking CouchDB into technologies like Flex and ColdFusion.
—

Speaking at webDU 2010 (May 6 and 7 2010, Bondi Beach) is a post from: Blog in Black

Additional to the simulators, the building caters for a quite a bit of crew training, it has theory and computer-based-training classrooms as well as crew briefing and -debriefing rooms. In preparation for the day, I had a look at the 777 flight manual and some checklists (for Flight Sim X etc) to get an idea of the cockpit and instrument layout and how things roughly work. On arrival at the sim centre, we were greeted by Joy, one of the instructors. She showed us around and then we went to the 777-200 simulator and I took control of the plane *g*. Diane jumped into the first officer’s seat and Joy started to explain the cockpit and what we’re going to do. The photo shows my side of the cockpit: Flight director to the left (it’s basically a combined artificial horizon, airspeed indicator, direction indication and also shows the altitude) then the navigation display, 3 individual instruments in a column, the Flight management computer below it and the engine displays towards the right (they’re not running yet as you can see)

The autostart feature of the 777 is pretty cool. What it comes roughly down to – make sure breaks are set, engine is in autostart mode and provide fuel to the engine and off you go. Same for shutting it down (and that’s very similar to the type of planes I fly) – cut the fuel flow into the engine and it will shutdown. The next image shows the controls below the FMC – the big lever is thrust and to the right you can see the settings for flaps – from 1 to 30 degrees.

When the simulation launched we found ourselves at gate 3 of NZAA international, scheduled to take-off from Runway 23L. First interesting challenge (after starting the engines and being pushed back) – finding the correct taxiways, keep the plane on the yellow line to avoid hitting any building, car or other plane along the way and line up correctly. It was quite amazing how real those simulators feel. It takes quite a while for the 777 to overcome the intertia but after I got it rolling once, it hardly wanted to stop.

Lined up correctly, the takeoff was initiated, auto-thrust took over and soon after we reached the rotation speed of (I think) some 150 knots and off we went. We took off from 23L climbed out quite straight ahead for a short moment and then banked into a right turn for a Peeha One Alfa departure from NZAA. I found the flight director instrument helping a lot with that – awesome little thing I’d love to have in my 172 Below is the ILS departure chart, having reached 3000 feet, Auckland city was already clearly coming in sight and we did a few turns and basic maneuverers to get grip of the plane.

Luckily Diane took videos (yay!) – here’s a video of the take off (you can also hear/see her raising the gears after takeoff):

We then programmed an ILS approach for runway 23L via the navigation point EMRAG into the flight computer and the navigation display started to show me the approach pattern (basically an arc that leads into finals for 23L) to follow. The idea of such a pattern is that the pilots ends up being on a 3-dimensional glide slope that leads directly to the touchdown point. You’re given vertical and horizontal indicators in the Flight Director screen, which is very helpful.

When we entered the approach, we disconnected the autopilot and I flew the plane through the arc and on finals. My first approach became slightly wobbly at about 1000 feet – not badly though, but I had issues keeping the wings perfectly level because I lost the glide slope a few times and tried to catch up with it. When you approach the ground, the plane will very clearly call out the altitude (as in “one hundred!!!!! … fifty!!!! … thirty!!!! etc) so that the pilot is def. aware of the fact that a landing is to be expected very soon. As a consequence of my wobbly approach my first touchdown was a bit too hard, but still came in reasonably straight on the centreline and when the thrust reversers and auto-break kicked in we got to a quite quick stop.

Joy then asked me if I wanted to do another one (WHAT A QUESTION!) – sure I wanted. Actually it ended up being two more and my second and third approach were so much nicer and smother and particularly in the third I got the hang of it. The picture below is a (slighty blurry) shot of the navigation display and you can see that the turn is not a perfect arc. That’s because we started that particular approach closer to EMRAG and then it became some sort of a short-cut approach into 23L.

I’m flying an AirNZ 777-200 is a post from: Blog in Black

We went over to the Engineering Base in Auckland which is pretty much an operation that works around the clock. We got a temporary Aviation Security ID (in form of a sticker) and met Ian Parkes, Communications Manager for Air NZ Tech Ops who gave us a tour through the different workshops and a few maintenance hangars.

The engineering crews at the base are not just taking care of Air NZ’s own planes but also contract out their services to airline partners and in some cases direct competitors. The project with Hawaiian Airlines I mentioned above for instance comprises Air NZ Engineering taking over an Hawaiian Airlines Boeing 767 plane that flies into Sydney and comes to Auckland for maintenance. After the maintenance work is done, an Air New Zealand crew takes control and ferries the plane back to Hawaii on an NZ flight number (not as a codeshare flight number). Customers might therefore get a bit of an unusual experience traveling with Air NZ pilots and cabin crew on Hawaiian metal. The cabin crew needs to be particularly trained and licensed to work on such a plane and that requires alterations to normal crew scheduling etc.

When we walked through the maintenance hangars there were an A320, a Hawaiian B767 and an AirNZ 777 around. The amount of people working on such a plane at the same time (depending on the type of maintenance) is enormous. Logistically there is also a tremendous pile of paperwork to deal with as work instructions, defects and the proper action have to be documented, done, signed-off and quality controlled. Ian said that they tried to experiment with introducing PDAs for those processes but that a paper-driven documentation with humans actually signing documents still seems to be the best option in such an environment.

In the 777 hangar I stood under ZK-OKC, the one currently being on maintenance. It’s massive. That’s already keeping in mind that other planes such as the B747 or the A380 are even larger – but it’s still massive. Actually the A380 is literally a monster against the “tiny” 777. There are quite a few interesting details to look at when you’re close to such a plane. The picture below shows one of the Rolls-Royce engines. It’s probably hard to see, but there’s a little rubber cone on top of the centre of the turbine. That’s being put in there to avoid icing – very clever engineering from Rolls Royce’s team according to Ian. An equivalent engine model from a US manufacturer just has a power-consuming heating plate in there.

It’s quite amazing to learn about the amount of stuff Air NZ can take care of themselves when it comes to repairing parts or crafting new parts. Diane pretty much fell in love with the fact that and how they create the nose cones for the planes. In the avionics lab Air NZ has setup a joint venture with one of the vendors of a lot of avionic devices and parts to again provide services for a lot of other airlines as well. There’s a quite amazing huge $6 million computer system in there that comes with a wardrobe-size section of interface bays where all sorts of devices from a variety of planes can be plugged in to simulate and replay faults.

From a business point of view, Air NZ’s Tech Ops is highly profitable. Because Air NZ is a rather small airline (and some maintenance for domestic planes is done in Christchurch and/or in the engineering bases of the smaller subsidies like Air Nelson or Eagle) the Auckland base works for pretty much all other airlines flying into Auckland international. In a lot of cases that might just mean smaller maintenance jobs and checks before a plane is returning back overseas to wherever it came from, but in some instances as above it could mean that some airlines also get major works done in Auckland.

Very awesome start of the day, but stay tuned – way more to come!

A visit at Air New Zealand’s Engineering Base in Auckland is a post from: Blog in Black

So – what happened? Let me briefly introduce you to the events that lead into yesterday’s trip to Auckland with and to Air New Zealand. As you all know, I’m flying quite a bit and that pretty much exclusively (well, at least to the destinations they offer) on Air New Zealand. Among being actually a really nice and friendly airline, their marketing and communications team is absolutely on top of their game and is leveraging all sorts of online and social media services. Among those is a twitter account named @airpointsfairy. She wears a cute dress, lives in a beautiful fairy land and fulfils wishes of members of Air NZ’s frequent flyer program Airpoints.

Normally members wish for an access pass for a lounge, a top up of their Airpoints$ to being able to spend them on a particular flight reward an similar thing. But before Xmas last year, the Airpointsfairy was doing a “12 days of Xmas”-themed giveaway of larger gifts. One Saturday morning, Diane woke me up saying the Airpointsfairy was giving away 2 simulator rides in Air NZ’s 777-200 simulator in Auckland. So Diane thought she actually had a good reason to wish that I got one because due to our wonderful Wellington weather it was clear that I wasn’t going to go flying in a Cessna 172 on that day (as originally planned). To fast-forward the story – I won it. Including a trip to Auckland with @blauerpunto and including a tour of Air NZ’s Engineering base in Auckland and Hangar 9 (where they secretly developed the new seats and cabins for the 777-300 and the 787 Dreamliner) in the city.

Diane already posted about the overall experience of the trip (which was just awesome) last night (make sure you scroll further down for English). So, I won’t go into all those details again, but the next few posts will be for the aviation geeks among you – more coming tonight! Just one thing in advance: Flying a jet in a simulator is freakin’ awesome. It feels quite real and flying a real jet must be even more awesome. Anyone wants to pay for my training?

An awesome day with Air New Zealand is a post from: Blog in Black

The Friday sessions:

Eric Ries – The Lean Startup

My personal highlight of Webstock 2010, very interesting and enlightening talk about startups and how to potentially avoid failure. A lot of Eric’s points make a lot of sense and I came across some of them myself doing work for startup-up type companies. He’s recently published a book titled “Startup Lessons Learned” (if it just was available as an .epub ebook – I would right away buy it).

Daniel Burka – Iterative Design Strategies

David worked on the design-side of things at Digg and Mozilla.org. He discussed how iterative design can drive communities, very interesting session (even for me coming from a back end point-of-view).

Amy Hoy – Shift+Cmd+R: Hard Refresh Your Design

Very entertaining and interesting session covering a variety of uncommon and “weird” stuff. Fun to watch!

Mike Davidson – When Your Idea Doesn’t Suck: How to stop working for clients and launch a startup

A good talk with a lot of truth in it. Mike presented without any slides and I noticed that quite a few people lost interest after a while. Very unfortunate though, because what he had to say about launching a startup, shareholder setups, acquisition, ideas etc was very interesting. I’m not quite sure why he asked for his session not to be blogged or tweeted about though. It’s a bit of wishful thinking at a web conference I suppose.

Thomas Fuchs – I Can’t Believe It’s not Flash!

Thomas’ session was interesting and he showed a lot of cool stuff one can do with JavaScript nowadays for instance animation (performing quite well), using WebGL etc. Really impressive and I hadn’t seen a lot of that stuff before. In good tradition he also had to punch Flash by providing some figures on Flash’s video performance vs HTML 5 video. As much as I agree that there are issues with Flash Video on OS X for a variety of reasons his 10% vs. 100% CPU load comparison was just purely FUD. Even now after the talk and discussions on Twitter and Ajaxian he hasn’t provided any sample video(s) and codecs he used to make his point.

Jeff Veen – How the Web Works and Mark Pesce – Dense and Thick

The closing session block was actually quite awesome. Both speakers talked about the past, present and future of the web – I guess for a lot of people in their early 20s, quite a few things of the past might have been new to them Also we got an interesting insight into how W3C committees work and make their decisions… The big next thing to come is supposedly AR but who knows when and where and in which flavour it’s going to take off.

All in all Webstock 2010 was very well worth my time and the money spent on the conference ticket. Same is true for the pre-conference workshops, keeping my feedback in consideration. On a scale from 1 to 10 with 10 being the best I would give it an 8.5 – missing a 9 or better mainly because most of the content is not directly applicable and convertible (in)to my work. Leaving that (very personal situation) aside, Webstock should really be seen as a must for anyone working with/in/on the web in New Zealand. Seriously. Thanks a lot to all the people behind it – you’ve done a great job and I look forward to Webstock 2011.

My personal review of Webstock 2010 – (part III: conference proper Friday) is a post from: Blog in Black

So – we ticked off the venue, food was fine and vegetarian and other special dietary requirements were tucked away from the main food stations. The latter is particular important from my point of view as I strongly disklike it when carnivores do not “book” veggie food at events in advance and all of a sudden on the day prefer the (often limited) vegetarian option. Also – not to forget the tremendous amounts of Kapiti ice cream throughout the day (yay!) and free proper coffee provide by People’s coffee!

Some impressions from Thursday’s sessions:

Scott Thomas – Web design that grabs people

Scott talked about his role in the web team of the Obama campaign and explained how design decisions and experiments drove online collaboration and engaged a community of volunteers and supporters around Obama. Very interesting and a lot of insights into the structure of the Obama campaign web team.

Brian Fling – Brian does the Andrew Sisters

Brian’s message seem to have been hidden or invisible for parts of the audience. To be fair, his style of presentation was quite unusual and comprised a lot of talking about what he’s not going to talk about and I can understand why some people had some issues with that. I found his presentation quite entertaining to be honest – also his thoughts on monetizing mobile content appealed to me.

Lisa Herrod – Designing for Diversity – Inclusive Design & the User Experience

Lisa is well known in AU/NZ for good thoughts and a deep knowledge of accessibility and user experience. In her talk she raised the question why a lot of user experience consultants still ignore diversity and what needs to happen to change that. Not directly related to what I’m doing most of the time, but still very interesting knowledge to have.

John Resig – How jQuery Makes Hard Things Simple

Very good presentation (as somewhat expected after the brilliant workshop on Tuesday afternoon), partly based on some elements I already knew but John also covered a few things I hadn’t known before this talk.

Chris Shiflett – Security-Centered Design: Exploring the Impact of Human Behavior

Amazing talk, seriously amazing. Chris presented a lot of examples and observations how design drives human behaviour – both web- and RL-based, from Twitter and Facebook hacks to people’s behaviour on Japanese subway trains.

Shelley Bernstein – Fostering Personal Connection to Place

Shelley talked about how the Brooklyn Museum in New York fosters community and interacts with its visitors. Her presentation was another awesome peek into leveraging design, communities, experimenting and other typical “social network” features in an offline scenario.

Jeff Atwood – Stack Overflow: Building Social Software for the Anti-Social

Jeff’s presentation was very good! Lot’s of “lessons-learned-from-building-stack-overflow”-type of content discussed in his session. The session title actually really held what it had promised – how to build a social site for us nerdy developers – well done! (Both stackoverflow.com as well as the talk )

Regine deBatty – Please, don’t let it be interactive

Maybe it was because I was getting tired towards the end of the day, but I couldn’t really connect to Regine and her presentation.

Rives – The Word Wild Web

Yeah, well. Rives. Apparently he’s somewhat famous (I had never heard of him before Webstock) as an online poet. I think his presentation (well, rather “gig”) had some interesting and actually really funny elements, I personally didn’t really get some other bits and pieces of his on-stage show.

My personal review of Webstock 2010 – (part II: conference proper Thursday) is a post from: Blog in Black

There’s something else that makes Webstock reasonably special compared to other web conferences: It’s a lot about inspiration, ideas and the future. You won’t find many talks with titles such as “Using framework X with technology Y in situations in which the development team just wants to work when the 29th of February falls on a Monday” but rather things like Jeff Atwood’s ”Building Social Software for the Anti-Social” or Eric Ries’ “The Lean Startup“.

Webstock also comes with a bag (full with really cool stuff) – rumor says some people are just attending the conference to get the awesome bags each and every year After last year’s trading card game, some people were keen on having another game and so there was the Twitter-based Webstockbingo and a social challenge-/task-based Webstock Game. Both very interesting and it’s quite amazing that Kat Hardisty won the game the second year in a row!

Workshops

I’ve booked two of the pre-conferece workshops on Tuesday. Jeff Atwood’s “Getting started with ASP.NET MVC” and John Resig’s “Introduction to jQuery and jQuery UI“, both pretty much for the reason that they cover technologies that interested me for the one or the other reason and that 3.5 hrs of compressed information usually provide enough information and potentially inspiration to later on dig deeper. The workshops on Tuesday were organised very smoothly and without any obvious problems by the Webstock crew in Wellington’s Town Hall and the adjacent Michael Fowler Centre.

Jeff’s session covered ASP.NET MVC (mostly in version 1) and its integration in Visual Studio 2008. The idea of the workshop was to build parts of the NerdDinner.com application (available as a free walkthrough on Scott Gu’s site) and to explain/talk about some specifics along the way. Although there’s nothing wrong with that, Jeff didn’t have any slides along the workshop and the session was pretty much based on live coding. Again – there’s nothing wrong with that (and all participants were asked to have VS 2008 installed on their machines if they wanted to follow along), what I found a problem though was that due to his speed Jeff basically lost most of the participants (including myself) after 45-60 minutes (it was quite obvious by looking around and by comments made in the morning tea break). The presentation setup with having a second (non-mirrored) screen from where stuff was copied and pasted into the visible VS 2008 window didn’t help to actually follow along either. But hang on – not everything was bad: Jeff obviously knows his stuff very well and is a very good presenter and speaker. He was able to provide a lot of real-world experience with the ASP.NET MVC framework from their work on http://stackoverflow.com, so that there was def. quite a significant amount of added value on top of the rather straight forward tutorial walkthrough. I’d still have preferred him to have used something that’s not available as a free tutorial on the web – but that might be my personal expectation from attending a somewhat “commercial” workshop as well as from offering similar workshops on (different) technologies myself.

The afternoon session on jQuery and jQuery UI was of particular interest to me because one of my clients is going to move from a vast collection of JS/AJAX-frameworks and handcrafted JavaScript code to jQuery as their main JS framework for HTML-based front ends. Having John Resig, the author of the framework himself present it was another bonus. Due to some weird weather in the US, John just made it to Webstock and his workshop 1 hour before it actually was supposed to start (to make things worse his luggage was delayed as well). Nevertheless it was a great session covering a lot of content starting with the basics of jQuery, building complex expressions and modifying page content and structure as well as looking into some more advanced topic and new features of the jQuery 1.4(.2) release. The session was a very well balanced mixture of (interactive) slides to introduce concepts and hands-on exercises to try out features in a jQuery coding sandbox on John’s server (I love that idea).

Overall, I’m very happy with having attended both. Just to let everyone know – I’ve provided all this feedback (more detailed where due) right away after the workshops to the team around Mike and Tash (who run Webstock), don’t think this is a public bitching session behind people’s backs or something

My personal review of Webstock 2010 – (part I: workshops) is a post from: Blog in Black

Search: parameterExists\(([^)]*)\)
Replace: isDefined(“\1″)

That saved me at least 2 hours

ParameterExists => isDefined is a post from: Blog in Black

Unfortunately, it’s impossible to perform a sitewide search/replace, so I have to open every single file containing CFQUERY tags. To get a list of all the files containing “<cfquery…”, I did a quick

grep -rli “\<cfquery ” > cfqueryfiles.txt

Then, I wrote two tiny regular expressions that make the manual replacing a lot faster:

Step 1: Strings => Varchar
Replace ‘#([^#]*)#’ by <cfqueryparam cfsqltype=”CF_SQL_VARCHAR” maxlength=”50″ value=”#\1#”>

Step 2: Numbers => Big
Replace #([^#]*)# by <cfqueryparam cfsqltype=”CF_SQL_BIGINT” value=”#\1#”>
(Careful! This replaces ANY variable, but does its job inside CFQUERY. Do NOT “replace all”.)

After that, you only have to set the correct sqltypes and/or maxlengths.

cfqueryparam / regular expression is a post from: Blog in Black

The next (and first meeting in 2010) will be held at Natcoll Design Technology in Wellington (thanks to Brett Taylor, who’s the head of department for Interactive Design and Web Development at Natcoll and helped a lot to set this up). Topics will be Stratus, Adobe’s peer-to-peer framework for RTMP communication and Skinning in Styling in Flex 4. Both will be 30 min-ish long introductory presentations, no previous knowledge of either topic will be required.

This is the agenda:

• Introduction in Stratus (Ross Phillips)
  Stratus: http://labs.adobe.com/technologies/stratus/
• The basics of skinning and styling in Flex 4 (Kai Koenig)
  Flex 4: http://opensource.adobe.com/wiki/display/flexsdk/Download+Flex+4

Date, Time, Address:

Tuesday, February 16 2010 – 5:30 pm for a 5:45 pm presentation start. Anticipated end at 6:45pm-ish.

Natcoll House
2/20 Kent Terrace
Wellington
New Zealand

If you’re attending, please make sure you register at our Eventbrite site: http://wellingtonflashplatformgroup.eventbrite.com

Speaking at Flash Platform User Group Wellington (New Zealand) is a post from: Blog in Black

— snip —

Join Adobe in a dynamic live presentation to REFRESH your understanding of the most recent initiatives in the areas of content creation, collaboration and distribution. The Adobe team will showcase the recent announcements including the iPhone developments using the upcoming Flash Professional CS5 as well as showing you how you can build applications faster with Flash Catalyst, LiveCycle Mosaic ES2 and much more. You will also hear Adobe’s most recent announcements from Max 09 and be shown the latest software tools available from Adobe.

— snip —

Dates:

Perth – 11th February (full)
Brisbane – 16th February
Auckland – 18th February
Sydney – 23rd February
Melbourne – 25th February

Registration and agenda:

Auckland: https://events.adobe.co.uk/cgi-bin/event.cgi?eventid=9153&country=pa
Brisbane, Melbourne and Sydney: https://events.adobe.co.uk/cgi-bin/event.cgi?eventid=9155&country=pa

Adobe Refresh in Asia Pacific is a post from: Blog in Black

1. Kai Koenig: Wieviel RIA braucht der Mensch? (@agentk)
2. Thibault Imbert: Ten Innovative Projects for the Flash Platform (@thibault_imbert)
3. Carlo Blatz: Agiles Arbeiten in RIA-Entwicklungsteams (@carloblatz)
4. Justin McLean: Bringing RIAs and hardware together (@justinmclean)
5. Alexander Schulze: RIA-Translations mit lingopool

You might note that some sessions are actually in German – it’s a German conference after all…

Haven’t organised my trip yet and it will most likely be a reasonable short stint in Europe after all. But there’s Scotch on the Rocks in London in the week before Webinale – it woul it be a shame not to put in a stopover on the way over to Germany? Hmm… thinking… thinking…

Webinale 2010 is a post from: Blog in Black

• Launch Group Policy Editor (GPEdit.msc)
• Go to Local Computer Policy/Computer Configuration/Windows Settings/Security Settings/Local Policies/Security Options
• Set “Interactive logon: Do not require CTRL+ALT+DEL” to enabled

All that requires local admin access – if your machine is tied into a network with AD or domain controller settings and group policies all that might be different, but it should do the trick for the typical developer’s “Windows Virtual Machine on a Mac”-scenario

Additional note: you might want to switch off the screen saver or resp. untick the check box forcing a user to re-login after the screen saver was triggered. Again – consider your system, I would for instance not recommend doing that on a full-blow stand-alone Win 2k3 server – but for a dev environment in a VM it’s most likely fine.

Disabling CTRL+ALT+DEL to login in Win 2k3 server is a post from: Blog in Black

It seems that they pretty much just get it. Take their online engagement on Twitter as an example: with accounts such as @flyairnz, our beloved @airpointsfairy or @korulounges they actually communicate with their customers (not to mention @grabaseat and the regional AirNZ offices in the US and the UK). At this stage I can’t think of being in constant chit-chat with another “corporate” account on Twitter besides @flyairnz. Other airlines in the region (and globally, I follow about 50 airlines on Twitter) are either totally ignoring that channel or stupidly push out corporate messages and deal airfares but not much else.

The don’t just get Twitter but also lots of other aspects of “online”. The airpoints fairy has her own little world, there’s grab-a-seat and there’s the Adobe Flex-based Air NZ Frequent Flyer portal (although I’m not totally happy with how that particular app’s being done and delivered – if anyone from Air NZ reads this and is interested, feel free get in touch for some advice)

But seriously – even offline or outside of social media they do a great job. Recently I had an issue that after a flight from Brisbane to Wellington on a Saturday my suitcase was chewed. Chewed as in – destroyed to a level of not being usable anymore. Luckily nothing was missing from the inside. Baggage services “took care” of the issue and told me that I’d have to drop the suitcase at a local baggage repair store where it would be assessed, potentially repaired but they couldn’t really tell me how long it would take due to their workload etc.

Naturally I wasn’t happy with that – the suitcase was an obvious write-off anyway and additionally I had another trip to go on 4 days later where I wanted and needed to use it. Also – why would it be my responsibility to drop off a suitcase somewhere, I haven’t destroyed it after all. So I complained. I tried with baggage services on Monday first but they couldn’t really help me because all claims are being handled by one person in NZWN. I couldn’t reach that person the whole Monday morning and got quite frustrated over that fact (later it turned out that the guy at the baggage desk in the airport gave me the wrong phone number, doh). As I couldn’t get any progress besides “you have to bring in the suitcase” vs. “no, I’m not going to do that” I used Twitter. Luckily I had already vented my frustration about the destroyed suitcase in the first place on Saturday from next to the luggage belt and @flyairnz had reacted to that (on a Saturday, wow). On Monday I used that channel indirectly again, explaining my problem and (actually) made some suggestions for changing the overall broken luggage process after the experience I had and things started to get moving (I’m sure my status with them helped as well).

To cut that story short – by the end of Tuesday I had a new suitcase: same brand, very similar weight (after they firstly delivered me a replacement suitcase that was way too heavy for my purposes) and delivered to my doorstep – that’s exactly how it should be. Very nice turnaround to fix the issue quickly, awesome work Air NZ.

Again – the moral of the story is: they get it. They genuinely want to help if you tell them about the issue and I generally feel treated by them as a valued customer and not just cattle. And that’s even the case when you’re a non-status customer sitting in economy. Everyone makes mistakes, agreed: For instance, I regularly vent about failed “premium luggage delivery” on Twitter (it seriously always seems to hit me ) – but in the overall scheme of things that’s not more than an occasional minor nuisance.

Another example: Last week I was in Auckland (on a very cheap ticket, something like NZ$ 100 for the return trip). Normally those tickets are not refundable and not changeable without a hefty penalty (for a good reason). I was on the 8 pm back home and was in the lounge (after I checked in with my iPhone mPass app) when I suddenly got paged at around 6:20 pm. Having made my way to reception I got offered to be rebooked for free on the 7 pm flight as the 8 pm flight was going to be running 15 mins late and they had a few spare seats on the 7 pm flight. Again, that’s something where I’m sure FF status helps a lot, but it’s still an extremely nice gesture; thanks a lot Air NZ.

Why Air New Zealand is the Airline of the Year! is a post from: Blog in Black

Qlcolorcode already has built-in support for Action Script (although it’s not complete and really 100% correct for AS3 as it appears to me), but it’s supposed to do the trick. I ran into the issue that it unfortunately didn’t work for me. A bit time spent looking around and playing with the default application to open .as files on my Mac brought up the following blog post. Of particular interest are the comments:

http://www.n8gray.org/blog/2008/01/07/qlcolorcode-041/

I can just speak for Snow Leopard and in that case you’d want to look into comments 8, 12 and 18. Basically after this step the relevant section in my Info.plist in the Qlcolourcode plugin package looks as below and syntax highlighting for Action Script works (sort of):

<key>CFBundleDocumentTypes</key>
<array>
	<dict>
		<key>CFBundleTypeRole</key>
		<string>QLGenerator</string>
		<key>LSItemContentTypes</key>
		<array>
			<string>public.source-code</string>
			<string>public.xml</string>
			<string>com.apple.property-list</string>
			<string>org.tug.tex</string>
			<string>public.plain-text</string>
			<string>com.apple.applesingle-archive</string>
		</array>
	</dict>
</array>

The next step was to get MXML working. That’s a bit trickier because it’s not yet built-in into the plugin. Luckily Qlcolorcode supports XML and as MXML is  a proper, fully XML-compliant language it can’t be too hard to enable it for MXML. The good thing is – someone has done it before:

http://playground.deju.nu/2008/10/os-x-quick-look-for-mxml-files/

The bad thing – this is for OS X 10.5 and it didn’t work out of the box for me. In general I’d recommend to follow the descriptions in there. The command to run in step 5 on OS X 10.6 would be different though:

qlmanage -d3 -p yourmxmlfile.mxml 2>&1 | grep 'Generator used'

Also the path used in step 8 had to be different for me. Instead of Resources/highlight/etc/highlight/ the filetypes.conf would have to be looked for in Resources/etc/highlight/. Also in my version of the file the file type definitions for xml and html did look differently:

$ext(html)=htm xhtml
$ext(xml)=sgm sgml nrm ent hdr hub dtd wml vxml wml tld svg xsl ecf jnlp mxml

As you can see, I added the mxml file suffix to where it made much more sense imho. From here on just follow the instructions and you should be good to go.

This should provide a working solution – not necessarily a perfect one as the highlighting for AS 3 is not quite right and it would be nice to tweak the syntax highlighting for MXML and CF; some new CF tags are not properly picked up etc. I might have a look into that – it’s not too hard actually because qlcolorcode uses highlight internally. Will keep you posted

OS X quick look for Flex is a post from: Blog in Black

Accessible PDF documents and forms is a post from: Blog in Black

Recently while migrating a bunch of legacy application code from Application.cfm to Application.cfc, a team member of the team of my client asked me what happened at application start if there was an error (for example a typo in SQL code) in the onApplicationStart method.

The answer is that onApplicationStart will start to execute and (depending on your error handling strategy) just plainly fail with an error message. Your application will not be properly initialised though, i.e. ColdFusion would send the next incoming request to the onApplicationStart method again.

The ColdFusion documentation actually states the following: “If this method throws an uncaught exception or returns False, the application does not start and ColdFusion does not process any pages in the application. In this case, ColdFusion will run the onApplicationStart method the next time a user requests a page in the application.”

That’s actually mostly correct. Basically – if onApplicationStart() does NOT return true (when having specified a returntype) – every follow-up request will be run against onApplicationStart() again. However: from a technical point of view, your application is in some sort of a limbo state because it actually will exist (at least to a fragment) and application-scope variables could be created before the error occurs.

In reality the fact that application-scope variables and an application name will potentially exist even though the application hasn’t been initialized is not of a huge practical concern as the next request will hit onApplicationStart() again anyway, but it’s still an interesting thing to notice.

A look into onApplicationStart (ColdFusion) is a post from: Blog in Black