Bayard Randel's blog

Firebug debugging tip: Strict Warnings

Mon, 26 Apr 2010 13:45:00 +1200

I recently ran into an issue while setting up jqGrid for inline editing that I thought I might share here. For some reason the grid event for editing would fire, however the grid was never put in to an editable state. The Firebug console unfortunately did not return any errors, which made debugging a bit of a challenge.

I then tried enabling Strict Warnings in firebug at which point I found the error:

reference to undefined property g[j].editable ...

It turns out that I was passing a string to the editable property instead of the expected boolean:

This of course should have read:

editable: true,

Had I not enabled strict warnings I suspect I would have been tearing my hair out for somewhat longer. At any rate, if you find you have a js issue of some sort, perhaps try this Firebug feature - you may have a type issue that is silently failing.

"Your death is not the end of your song, because the song you are playing right now is altering the..."

Sun, 21 Feb 2010 22:23:59 +1300

“Your death is not the end of your song, because the song you are playing right now is altering the physical structure of the universe, changing the way in which the universe vibrates. The song you play resonates on long after you’ve played your last note. It plays on in the ideas you’ve created, and in the things you’ve built. It plays on in your family and the people who loved you when you were still playing; we hear the songs we play for each other and inspire each other to create beautiful new melodies. The melodies and phrases that you create are shared and passed on, enriching the song of the universe long after you’ve breathed your last.”

- Mark Neyer

"Unix beard Facial hair that all Unix experts are mysteriously compelled to grow. The length,..."

Fri, 12 Feb 2010 07:22:00 +1300

“

Unix beard

Facial hair that all Unix experts are mysteriously compelled to grow. The length, bushiness, and unkemptness of the Unix beard are all directly proportional to the owner’s expertise. Having a Unix beard is a great way to ensure that you never get laid.

Bob’s a true Unix genius, just look at the size of his Unix beard!

”

- http://www.urbandictionary.com/define.php?term=Unix%20beard

Microsoft is a polycephalic cat, or how I learned to stop worrying and love Rails

Thu, 04 Feb 2010 23:34:00 +1300

Simplicity does not precede complexity, but follows it. -Alan Perlis

I recently sat down to begin a new ASP.Net MVC project and although I am familiar with these tools, a strange sense of unease grew in me as I downloaded the following:

Fluent nHibernate (persistence/orm)
Automapper (model mapping)
Ninject (IOC container)
nUnit (unit testing)
Moq (mocking/isolation)
Spark (view engine)

Six distinct dependencies simply to make a good start on my project! Why does this feel unnecessarily complex? Is there something inherently wrong with our approach? If my goal is to provide a good user experience and solve business problems, why do I feel that I’m spending so much time with plumbing?

Part of this is attributable to the fact that C# is a statically typed language, and lacks the flexibility of dynamic languages like Python and Ruby. In order to write maintainable, testable code in a statically typed language there is some overhead complexity. C#’s syntax, like many statically typed languages, is unavoidably verbose. Consider this comparison of a roughly equivalent MVC.Net and Rails controller from Brian Hogan. You’ll notice that in addition to being terser, the Rails code also makes some sensible assumptions that reduce the weight of the controller.

Interestingly, none of the tools for the MVC project I mentioned above are provided by Microsoft. Although Microsoft provide analogues to some of these such as the Entity Framework, they have been late in coming to the party and the .Net community generally has little interest in their adoption; the open source projects are simply more mature. Many of these projects are artifacts of a community that has grown tired of Microsoft’s ambiguous noncommittal attitude towards best practice, and software design. In fact, an entire community has sprung up over the last several years, self dubbed Alt.Net, in an attempt to address the problem of Microsoft’s vague approach to their platform.

Flirting with Ruby

Over the last year, my time spent in the evenings with Ruby has coloured my perception of .Net development.

It is often better to be in chains than to be free. -Franz Kafka

If I understand Herr K correctly here, I think he was implying that restrictions can be liberating and help to preserve ones sanity, and this has been my somewhat paradoxical experience with Rails.

$rails niftyapp

With that seemingly magical invocation, Rails immediately provides you with:

complete project directory structure
simple, abstracted persistance
foundations for functional, unit, integration and performance tests
an integrated application server
scripts for generation of models, controllers, tests

More importantly however, Rails provides you with direction. There is a clear and defined way of interacting with the framework. There is a Rails Way, and over time one becomes aware that there is also a Ruby Way (both titles of two popular books). Amusingly, a further paradox - while Rails is successful largely because of it’s prescriptive opinionated approach to development, Ruby is anything but restrictive. The creator of Ruby, Yukihiro “Matz” Matsumoto in fact cites Larry Wall as one of his heroes. The flexibility of Perl has transferred to Ruby, albeit in a somewhat more human and digestible form.

ASP.Net in stark contrast provides you with very little in the way of direction. In fact, Microsoft provide two web development frameworks - ASP.Net Webforms and ASP.Net MVC. Although MVC.Net is newer and clearly represents the model adopted by 90% of the world’s web development frameworks, Microsoft still remain noncommittal about which framework you should choose.

Correctly, Microsoft has not positioned ASP.NET MVC as a replacement for ASP.NET Web Forms. Web Forms is definitely a pattern that works for Web applications.

Dino Esposito on Comparing Web Forms with MVC (MSDN)

In terms of persistence, the story is further complicated - Microsoft offer ADO.Net Datasets, Linq2SQL and the Entity Framework.

Out of the box, Rails provides an Active Record implementation that makes concerns of persistence refreshingly easy. Schemas are defined in Ruby migrations instead of SQL. The Rails community is also making swift inroads towards NOSQL implementations. Tools such as MongoMapper allow persistence to become an almost non-existant concern with relatively little setup. After spending any time with a baroque .Net ORM this is astoundingly liberating.

I can only attribute Microsoft’s lack of a unified voice to the fact that their development teams operate in silos. There is certainly progressive work being done at Microsoft; Jimmy Schementi’s DLR team is a testament to this, yet we see another version of Visual Studio ship without IronPython support.

Microsoft need to provide better guidance to a community that is increasingly finding their needs better met by OSS offerings. The Rails philosophy of convention over configuration has obviously resonated with developers, many of them in the Microsoft camp. ASP.Net MVC is an excellent foundation for an opinionated .Net web development framework, but in its current state creates more questions for developers than it answers. Rails 3 with its Merb influenced modularity provides the flexibility that proponents of un-opinionated frameworks desire, while maintaining it’s integrity and structure in a default configuration. MVC.Net however provides a treacherous sea of possibility that only the most experienced developers can navigate successfully.

One can’t help but feel that MS is simply too large or possibly too divided to crystalise and focus their approach to their platform. When some of the most visible proponents of the Alt.Net community express that the only reason they continue developing for the .Net platform is a paycheck, that to my mind is cause for Microsoft to sit up and take notice.

Tab Completion and ANSI colours in IRB

Wed, 30 Dec 2009 15:40:00 +1300

I tend to spend more time using the Rails console than IRB these days, and I’ve grown soft and used to the handy tab completion. Every time I start IRB I wish it behaved similarly. Enter Pablotron’s awesome Wirble!

To get up and running with wirble:

sudo gem install wirble

and then add the following to your ~/.irbrc

begin
  # load wirble
  require 'wirble'

 # start wirble (with color)
  Wirble.init
  Wirble.colorize
    rescue LoadError => err
    warn "Couldn't load Wirble: #{err}"
end

Now typing “foo”.[tab] will give you all the ruby String methods.

Snazzy!

Presenting Agile to my workplace

Thu, 19 Nov 2009 20:32:00 +1300

Today I gave a presentation to the IT managers at my workplace about the benefits of agile software development. We recently completed a large 12 month project, and in retrospect a lot of the things felt unnecessarily difficult.

I figured we needed to look at a way to get the business regularly involved with projects that we work on, and become an active part of the way the software develops. Something like Scrum seems like a good fit.

Anyhow, here’s the presentation. Inspired by this weekend’s Oamaru Victorian Fete I’ve borrowed some of Dan Hillier’s brilliant illustrations. I hope he doesn’t mind.

Agile Software Development, Overview

View more presentations from squidsoup.

Have you tried to move past waterfall at your workplace? Are you already working using an agile methodology? I’d be interested to hear your stories.

"“Computer Science is a terrible name for this business. First of all, it’s not a..."

Wed, 28 Oct 2009 21:11:00 +1300

“

“Computer Science is a terrible name for this business. First of all, it’s not a science. It might be engineering, or it might be art… it’s also not really very much about computers.

It’s not about computers in the same sense that physics is not really about particle accelerators, and biology is not really about microscopes and petri dishes.

It’s very easy to confuse the essence of what you’re doing with the tools that you use, and indeed on some absolute scale of things we probably know less about the essence of Computer Science than the ancient egyptians really knew about geometry.

I think in the future, people will look back and say yes those primitives in the 20th century were fiddling around with these gadgets called computers, but really what they were really doing was starting to learn how to formalise intuitions about process.”

”

- Harold Abelson Assoc. Prof EE & CS, MIT

Delving into Computer Science with SICP

Sun, 25 Oct 2009 01:28:00 +1300

The Structure and Interpretation of Computer Programs by Harold Abelson and Gerald Jay Sussman is often cited by experienced developers as one of the books that fundamentally changed the way they think about computer science and software development.

SICP is also a somewhat intimidating tome that demands a fair bit of perseverance and dedication from its reader. Like most things in life of course, things worth doing typically take time and effort!

Why study sicp?

I suspect many developers today would see learning a language like Scheme as anachronistic, and potentially less than practical. Interestingly, there seems to have been a recent resurgence of interest in functional programming.

Javascript, which in the past has been a somewhat misunderstood language, is beginning to be recognised as capable of some fairly sophisticated constructs and a lot more than just behavioural glue for the DOM. Languages such as F# and Haskell are slowly beginning to work their way into the mainstream software development world. The latest version of Microsoft’s IDE, Visual Studio, is shipping with F# as a first class citizen, supporting .Net F# projects out of the box.

Chris Hanson posted the following on StackOverflow in response to a user enquiring about the value of working through SICP:

Even if you don’t do the exercises, it’s worth reading through Structure and Interpretation of Computer Programs at least once. Unlike The Art of Computer Programming it’s written not to appease some bizarre notion of machine architecture but to demonstrate the fundamentals of computational processes, and it excels at that.

Some of what you’ll learn simply by reading through SICP:

Functional decomposition and modeling problems

Recursion, its uses, pros and cons

Imperative and functional programming

Control structures, and why they have the behavior they do

Language design

Computer architecture

Compiler implementation.

The compiler implementation bits later on in the book will be especially enlightening to many working software developers, who if they haven’t had a class on the topic often think compilers are strange and mysterious beasts and that creating languages is “hard.”

My feeling is that a lot of people suggest reading The Art of Computer Programming because having waded through it makes you feel smart, but that people suggest reading Structure and Interpretation of Computer Programming because it clearly presents knowledge every software developer needs a thorough command of.

Expectations

I’m hoping to document my experience here on my blog to see if understanding the concepts in SICP will have any appreciable effect on the way I approach web development. Given that javascript is essentially a functional language, I suspect a lot of the concepts will be relevant. At the very least I hope to have a better understanding of computer science in general.

I won’t be alone in my journey - a number of others have blogged about their experience as they’ve worked through the book and the course material. Both Bill the Lizard and Eli Bendersky have some excellent posts both on the content of the lectures and working through the exercises.

Course resources

Complete SICP book html pdf

Lecture notes, Exams, Projects

Lecture Videos Also provided from the OCW site, but this page provides links to torrents.

SICP Tutor

Selecting a Scheme interpreter

There are an astounding number of Scheme implementations available today, and to the beginner this can be somewhat overwhelming. The Community Scheme Wiki has the following advice regarding choosing an implementation for learning Scheme:

Beginners should select an implementation that is well-documented, adheres closely to the standard, has good error handling and debugging capabilities, is easy to install, is mature, stable and under active development. Chez Scheme, Gambit, MIT Scheme and PLT Scheme are all used extensively in teaching Computer Science courses and hence meet all the aforementioned requirements. Chicken, Bigloo, EdScheme, OpenScheme, Scheme48, and SCM are quite beginner-friendly too.

I’ve decided to give Chicken a go, primarily because I find the name amusing, but also as it has POSIX support and provides both an interpreter and compiler. A fair bit of real world development appears to be done with Chicken, so there would be no need to switch implementations if I decided to start building apps in Scheme one day.

Setting up a Scheme environment in Mac OS X

Installing Chicken is a snap if you have Mac Ports installed - simply run:

sudo port install chicken

If you don’t have Mac Ports installed, the latest release is available from the Chicken website. You’ll need to have installed XCode to build Chicken from source.

Choosing a text editor

If you use TextMate, you’ll find the Scheme bundle helpful as it provides syntax hi-lighting and bindings for your Scheme interpreter such as ⌘R for Run Script. To install the bundle, run the following commands in Terminal:

mkdir /Library/Application\ Support/TextMate/Bundles/
svn co http://svn.textmate.org/trunk/Bundles/Scheme.tmbundle/
osascript -e 'tell app "TextMate" to reload bundles'

Any text editor that you’re comfortable with will be fine, but you’ll probably find life easier if you select one with some form of syntax hi-lighting and parenthesis matching for LISP/Scheme.

PLT Scheme provides a Scheme IDE called DrScheme, which runs on Windows, Linux and OS X.

Emacs is another popular option in the LISP/Scheme community, and available in many guises. Aquamacs is a good aqua interpretation for Mac OS X.

Managing multiple distinct logins in JMeter

Mon, 12 Oct 2009 16:56:00 +1300

I’ve recently been building a load model of the site I’m currently working on in JMeter, and struggled a bit to find a way to manage distinct user sessions in a thread group.

After some mild expletives, and a bit of digging around in the documentation I found the answer which I’ll clarify here as it’s not entirely obvious.

The best approach appears to be reading username and password pairs from a CSV.

First you will need to create a new csv with username and password pairs delimited by commas.

In Jmeter, add a CSV Data Set Config Element to your thread group, and specify the path to the CSV you just created, as well as setting “USERNAME, PASSWORD” in the Variable Names field.

In your Thread Group configuration, set the number of threads to the number of users you’ve specified in your CSV.

Next you’ll want to create a Once Only Controller, and set your HTTP Request sampler for your login process as a child. The Once Only logic controller will run only once per thread, so based on the configuration above, the HTTP POST to the sign in page will occur 10 times, whereas the HTTP Request sampler below will hit the app 500 times.

Finally, in your Sign In HTTP sampler, find the section labeled Send Parameters With the Request. Find the Name/Value pairs for your username, and password text boxes and set the respective values to ${USERNAME} and ${PASSWORD}.

An even simpler solution

Provided you have a group of test users with the same prefix and an appended incrementing int (testuser1, testuser2 etc.), an even simpler approach is to forgo the CSV node entirely and simply pass something like this to the HTTP sampler:

${username-prefix}$(__threadNum}

Simply define ${username-prefix} in your test plan’s user defined variables, and the $(__threadNum} function’s return value will increment once for every new thread.

Handy!