It seems cute and commemorative to preserve the test results from many of the whack-ass mechanized tests developers are sometimes required to take in order to engage with cattle-call-oriented recruiting companies.

There are people, friends/ex-coworkers/family (mostly connected to me on Facebook), who still are likely to assume that I’m unemployed—and this Blog skimmed over is not going to help that misconception. What is very comedic/tragic is to have a friend finally realize that I’ve been working for about six months only to become unemployed upon their realization.

Here’s my CSS test:

Bryan Wilhite, CSS Test Results

Here’s my HTML test:

Bryan Wilhite,

And, finally, my JavaScript test:

Bryan Wilhite,

Now the organization(s) that “asked” me to waste hours of my time taking these tests have a great idea of who they are representing. It turns out that my current employment has nothing to do with taking these tests. Yeah, right. So it might be possible to say that this was a complete waste of my time. However:

  • I did not think it was possible to write a serious CSS test until I found myself taken by surprise completing one.
  • I have learned about the quality, patterns and practices of selected recruiting agencies in the Southern California area.
  • In “defense” of the organizations that had me taking these tests, I am almost certain that at least one them was not a “real” IT recruiting outfit—one was more of general office staffing shop—that’s just how tough the job market has been and is like to continue to be.

Related Links

I am not a military scientist but I seem to insist that this concept I call ‘ready state’ comes from the military. ‘Ready state’ means that you have worked with your organization and have achieved a certain level of preparation. This level of preparation is ready to handle a certain set of known scenarios. For me this implies that there are (at least) two kinds of work: you work to obtain a certain level of preparation and you work to maintain a certain level of preparation.

I am not a Tibetan monk but I seem to know about this way of suffering called “the suffering of change.” This implies that whenever I use words of permanence like “maintain” I am making myself vulnerable to the suffering of change. Life is about constant change—and any “intelligent grasping” for the illusion of permanence is a recipe for the Blues, baby.

My clever grasping would suggest to any willing to listen that my two kinds of work are worth it. And, in fact, obtaining a realistic ‘ready state’ is a defense against the suffering of change. The delicate, professional, career-orienting move here is to prepare for these ‘known scenarios’ but also be ready to abandon them completely. So, with my Songhay System organization, I have been ‘suffering’ for years working toward reaching a level of preparation in these areas:

  • Building a generic solution (now called ‘GenericWeb’) that generalizes the document-centric Web application. This is largely server-side work in ASP.NET, XSLT and Microsoft SQL Server with a little bit of client-side AJAX/CSS under YUI.
  • Building a generic solution (with no fancy name—so let’s call it ‘Next-Generation Songhay UI’) for displaying content on the Web. This is largely a client-side effort, using AJAX/CSS under YUI, with a little bit of server-side Zend Framework/PHP/XSLT.

These two work areas described with the buzzwords above suggest the following:

  • The Songhay System is using XSLT to render user interfaces (with AJAX). This implies that XML must be used to represent data that “bound” to these interfaces. This further implies that an XSLT/XML “pipeline” had to be built in PHP and .NET.
  • The PHP-based solution described above mentions no database systems. This does not mean that databases (like SQLite) are not being used. What this means to imply is that something other than direct contact with a DBMS is the future here. Yes, we can speak of “cloud computing” but for the humble scale of the Songhay System we can look at a sample of how this ‘next-generation’ UI can connect to a WordPress Blog and pull data from an RSS feed.

Why prepare so much for some theoretical scenarios when you may have to abandon them completely? Well… why be born when you know you are going to die? The essentials of what I am grasping for here in this IT context are these:

  • XML is the preferred way of transporting data across tiers. This preference for XML influences the desire for user interface technologies that support XML-based, declarative, techniques (e.g. XAML, E4X in Flex, XHTML and HTML 5).
  • XML is the preferred way of transporting data across tiers. This preference for XML influences the desire for data management technologies that support XML-based, techniques (e.g. SQL Server 2005 and above).
  • The use of XSLT and certain “good parts” of JavaScript directs my work toward functional programming for purely pragmatic reasons.

So what’s ‘ready’? I think I am ‘close’ to ready-state nirvana. More journal entries to come… Here are some proposed milestones for this journey toward ‘ready state’:

  • An upgrade to my web site will use this ‘next-generation’ UI. This release would be a strong indicator of readiness.
  • New .NET projects from me appearing in or in the “MSDN Code Gallery” would be a strong indicator of readiness.
  • New, formal documentation for all the mess I’m talking here showing up at is definite readiness.

These would-be achievements do not represent something I would impose upon you in order to justify its existence. These achievements represent my personal technology strategy—my proposed expression of sanity amidst crazy worlds of proprietary technologies. It is one thing to whine and complain about another strategy (supposedly outside of one’s “self”)—it is another matter (according to my illusions) to “possess” what represents a technology strategy that can be considered ‘ready.’ I even I am not concerned about you using “my” solution. My concern is that a solution—that is actually regarded by me as a solution—exists.

What I find, after almost twenty years in IT, is that I have solutions to problems that many don’t even regard as real. This is one of two reasons why my score is so low!

Buy this book at! I have not updated my résumé in years. I have been doing time in the same W2 labor camp for almost ten years. Since I’ve known me for quite some time, I can tell that I am interested in summarizing my skills because my damn-near ten years of ‘exile’ has produced a revised and improved view of my personal technology plan. This writing here is like a little fire drill to exercise my ability to succinctly communicate the scope of my information technology concerns.

My IT Concerns by Operating System

There are two operating systems that are used for my development work: Microsoft Windows and Ubuntu Linux. Microsoft Windows is required because of its native support for the .NET Framework and Microsoft Office file formats. Ubuntu Linux is required because of its friendly relationships with the Java Runtime and the Apache HTTP Server. It is extremely important to emphasize that these operating systems are maintained by organizations that encourage and discourage technologies. In the “real world” of the IT business we must pick our “battles” wisely and not recklessly “fight” such organizations by using technologies that are not “approved.”

Buy this book at!My IT Concerns by Software Environment

There are three major ‘software environments’ that are of my concern: the .NET Framework, the “Standard Edition” of Java with its associated runtime and the XAMPP ‘stack’—a grab bag of traditional Linux technologies featuring Apache, MySQL and PHP (supplemented by my use of the Zend Framework and YUI).

My IT Concerns by Shell Language

There are two ‘shell’ languages that are of my concern: bash scripting and PowerShell. My bash efforts drive directly into PHP-related file management (featuring rsync) and the Java runtime for console applications (featuring JAXP solutions). My PowerShell efforts are currently very minimal with a few XCopy deployments for Visual Studio.

My IT Concerns by General-Purpose Software Language

These are the general-purpose software languages that are of my concern: C# and Java. These two languages are the preferred choice after working through BASIC, FORTRAN and Visual Basic (which implies I am familiar with Visual Basic .NET—and very familiar with VBA). A future language to explore might be F#.

Buy this book at!My IT Concerns by Domain Specific Software Language

These are the domain-specific languages of my concern: t-SQL, JavaScript (under AJAX), PHP, XSLT and XAML. These result from working through MS-SQL (for Microsoft Access) and ASP (for Microsoft Internet Information Server). Currently, there are no plans to explore new domain-specific languages outside of ones based on XML.

My IT Concerns by HTTP Server

There are two HTTP Servers of my concern: Apache HTTP Server and Microsoft Internet Information Server (IIS). Do note the glaring omission of any Java-based server technologies. Also the presence of IIS here—coupled with my concern for .NET—implies that I am actively using ASP.NET.

My IT Concerns by Database Management System (DBMS)

There are two DBMS products of my concern: Microsoft SQL Server and MySQL. It is not technically accurate to include SQLite in this list but it is definitely worth mentioning because I also use this database frequently!

Buy this book at!My IT Concerns by Client-Interface Technology

There are three client-interface technologies of my active concern: AJAX-based HTTP clients, XAML-based HTTP clients and Adobe-Flex-based HTTP clients. All of these concerns share HTTP as the means of transporting data for human-readable viewing.

It important to emphasize that I also divide these concerns into two use categories: clients for intense data editing and clients for mostly-read-only scenarios. The mostly-read-only clients needs to be available to a wide audience—this implies that AJAX and Flex work well here. In my considered opinion, the intense-data-editing client is suited for XAML technologies like Windows Presentation Foundation (WPF) and Silverlight 2. This means that I intend to produce data-editing tools for a small, specialized set of users (supporting a mostly-read-only audience through a decoupled publishing system). This position is not in agreement with the current trend of social, “Web 2.0” applications where “everyone” can be reader and writer.

It is also important to mention that since my commitment to building clients exists, this means that I have working knowledge of traditional design software products like Adobe Photoshop and Adobe Illustrator. I am also quite skillful in the field of sound design but this area leaves the scope of this writ.

My IT Concerns by Integrated Development Environment (IDE)

There are three IDE products that are of my concern: Microsoft Visual Studio, Eclipse Foundation Eclipse and Sun Microsystems NetBeans. I prefer to work with Eclipse and NetBeans in a Linux-based graphical user interface like Gnome or KDE.

Did I miss anything?

What would be really strange (for me) is to take the time here to set healthy boundaries only to find out that there is this whole other world of crap that I do in IT that I am unaware of… that would be literally unprofessional. My intent here is to capture and control my behavior and find out exactly what I am doing so that actually can profess and produce with potency.

My YUI-based Ajax is biased toward XML over HTTP. So, of course, I needed my ‘ingenious invention’ for simple string posts—the old fashioned application/x-www-form-urlencoded stuff. Ideally my solution should be able to handle both formats. Yesterday it was not:

  • So, first, Ajax.js was modified to see a stringGetter function (as well as an xmlGetter).
  • The Zend framework had to be checked to verify that the PHP $_POST array was being filled (hey, you never know). And then the contents of $this->getRequest()->getParams() was checked for $_POST data. After a slip up that mistook the role id attributes play in form elements (these are not like name attributes), it all worked. (This is a common mistake that I make since I use my AJAX stack to submit form data—I forgot how to do send data the old-fashioned way).
  • Then YUI without my code on top of it had to be checked to verify that a raw application/x-www-form-urlencoded string can actually be read by PHP/Zend Framework. This worked.
  • Then my core helper function that calls YUI.util.Connect.asyncRequest() was checked to verify that it was calling YUI properly. This worked.
  • Finally, my convenience function at the top of this entire stack was called. Assembling all of the data to pass into this function was a chore. I blame myself for designing it this way… not very test friendly… In any case, this worked. But! But when I changed the explicit setting of application/x-www-form-urlencoded to application/xml, PHP $_POST came up empty again.

Buy this Book at! The lessons learned here are old ones and new ones. The elder lesson is that trying new code in the political IT workplace is very risky. In a “perfect world,” I would rather test new code on “my own time”—literally leave the labor camp for about three months to work on my new shit and then come back when I think I am done.

The newer lesson for me is to consider using the ‘named parameters’ pattern in JavaScript: passing an object, using its properties as parameters instead of passing in a bunch of arguments that are time-consuming to track.

One consideration (not really a lesson) is to learn how to use YUI debugging/testing methodologies. A new consideration as well is recognizing the YAHOO.util.Connect.setForm() method: “This method assembles the form label and value pairs and constructs an encoded string. asyncRequest() will automatically initialize the transaction with a HTTP header Content-Type of application/x-www-form-urlencoded.” This member has been around for at least a year.

There are two (known today) very subtle bugs coming from my latest bright ideas about professional JavaScript. Actually there’s one bug today the other is a design ‘issue.’ The bug is characterized by a click event that fires and fires—like it’s in a loop. I wasted many hours (at ‘home’ and in the W2 labor camp) trying to look for loops. No dice.

It turns out (J’ah provides) that my Display Builder pattern did not account for running display builder procedures once at load time instead of again and again. I’m not going to take the time (this month) to find the exact proof of this but it appears that ‘wiring up’ events repeatedly with YUI can cause them to fire repeatedly.

The second issue (bug?) has to do with Firebug. You see, my interpretation of Douglas Crockford’s module pattern (published in JavaScript: The Good Parts which slightly different from the YUI pattern) means my code is full of this stuff:


    SONGHAY.ui.Client =
        //use ‘self’ instead of ‘this’ in here…

    var self = SONGHAY.ui.Client;


Buy this Book at! According to Doug’s, the variable self is not of a closure. This is because it appears after the object literal, SONGHAY.ui.Client. In fact, the variable self is marked “unused” by (but, when the variable self appears inside of SONGHAY.ui.Client, it is not marked as an implied global—until further notice, this little detail is very important to me).

When debugging this stuff in Firebug, the variable self is assigned to “Window”—which I assume is a bug or me writing crappy JavaScript. I am not afraid to be told that I am writing crappy code—so any person reading this (with some documentation to back them up) please do take the time to inform me instead of snickering to yourself like a punk-ass Church mouse and moving on… I assure you: you will not be wasting your time… You see how deprecating I am when asking for help?

The question “we” might ask here is, “Why are you trying to avoid using the keyword this?” Here are a few links that cover the this issue: