Unity is Plural

Install Git under Windows

2012-02-08T16:05:00.000-08:00

Install Git

Windows installer here.

Under Windows, use the Bash Shell or GUI app.
You can also fetch TortoiseGIT to work with the Windows gui environment.

Menu -> Git -> Git Bash

You will see:
Welcome to Git (version 1.7.8-preview20111206)

Run 'git help git' to display the help index.
Run 'git help <command>' to display help for specific commands.
$

Set up a proper workspace

Please translate the username (whome) and pathnames as appropriate.

$ pwd
/c/Documents and Settings/whome

$ mkdir workspace
$ cd workspace

$ git config --global user.name "Who Me"
$ git config --global user.email "whome@some.domain.com"

$ git clone some.repo.url/reponame.git

Cloning into 'reponame'...
done.

At this point, you'll have a working local git repo that can be pulled from the remote repo, and pushed (assuming the repo url allows write access).

More cheat sheets for git can be found here:
http://help.github.com/git-cheat-sheets/

Why we should care about server side JavaScript

2012-01-27T21:08:00.000-08:00

A software practitioner recently asked me what are the benefits of a functional language, and why would one want to use, say, JavaScript for an MVC Web application stack. A stack to consider would be Ruby on Rails for instance. Clearly, developers in the Node.js community have their eyes set on that problem space.

I wasn't prepared answer his question, at least not adequately.

JavaScript certainly offers interesting things like closures and anonymous functions, which make event-driven programming interesting. Closures, my friend pointed out, are like deep class hierarchies in an OO system, and can obscure the flow of control. It is true that closures come at a cost, but there are benefits as well in the reduction of code and less time spent in allocating temporary variables and in avoidance of copying. But closures are just one construct among several primitives in functional programming that work together to form an extensible system of logic. A grammar, if you will.

Why should we care?

Improved engines, especially Google's V8, have brought speed characteristics to rival that of C++. If JavaScript were still as slow and memory intensive as, say, Java, it might have survived in the browser space. Yet V8 brings JavaScript benchmarks into the same order of magnitude as statically compiled languages. It still isn't as fast as C or Perl5, but it is on-par with PHP and C++ and edges out Ruby (sorry Ruby, I do love you, but you're not quite as fast as V8). That is one characteristic that has some Web app developers all hot and bothered about Node.js.

And for whatever faults it has, JavaScript has less cruft than PHP, C++, or Java. Functional primitives combined with a kind of Lamarkian inheritance and minimal data types make it a very cohesive language despite its half-baked flaws. It doesn't have classes, but then again, it doesn't have classes. JavaScript does have prototypal inheritance. Modules and packages have much more practical benefit, and you can make those in JavaScript. With cleaned up syntaxes such as that offered by CoffeeScript, some of the worst flaws can be entirely elided from the coding experience while making programs even shorter.

As a language, JavaScript leaves some things to be desired. The lack of tail-call optimization, while generally treated as YAGNI, prohibits some interesting implementation techniques. The widely used long-running script detection makes sense for browsers and servers, but for background processing tasks and monitoring not so much. There are some interesting ways of managing blocks of code, formulating methods, and handling control flow in Ruby and Python that I sometimes wish were in JavaScript. The weirdness of falsiness and truthiness and == is eye-rollingly campy.

But in spite of its flaws, JavaScript is still a much saner language than Java and unlike Java/Ruby/Python/C++/Perl/PHP/whatever, it is part of almost every Web browser. Node opened up the path to a coding experience in which the seams between deployment environments are much cleaner and tighter, allowing them to be increasingly well-defined, well-factored, well-integrated, and well-tested with less code.

As a spiritual descendant of Scheme it is difficult to stay mad at JavaScript for very long even when the browser environment makes simple tasks grueling; eventually the elegance and simplicity of the language still draws you in.

Approachable beauty intrinsically engenders creativity and productivity. That in a nutshell, in my very humble and only poorly-informed opinion, is why programmers are noticing JavaScript.

Class Variables versus Class Instance Variables in Ruby

2012-01-26T21:19:00.000-08:00

I'm going to do a code dump and annotate.

#!/usr/bin/env ruby

class Something
  @@class_variable = 0

  def initialize( name )
    @@class_variable += 1
    @name = name
  end
  def value
    "#{@name},#{@@class_variable}"
  end
end

class SomethingElse < Something
  def initialize( name )
    super(name)
  end
end

joe = Something.new("Joe")
puts "Joe = #{joe.value}"
mary = Something.new("Mary")
puts "Mary = #{mary.value}"
sam = SomethingElse.new("Sam")
puts "Sam = #{sam.value}"
puts "Finished creating. Now Joe = #{joe.value}, Mary = #{mary.value}, and Sam = #{sam.value}"

Class variables are shared among all subclasses.


class SomethingEntirelyDifferent < SomethingElse
  @@class_variable = 0
  def initialize( name )
    super(name)
  end
end

puts
ferdinand = SomethingEntirelyDifferent.new("Ferdinand")
puts "Ferdinand = #{ferdinand.value}"
puts "Created subclass with same classvariable. Now Joe = #{joe.value}, Mary = #{mary.value}, and Sam = #{sam.value}"

Class variables are not shadowed. They are scoped wrt the inheritance chain.
Class variables are candidates for unintentional side-effects.

class SomethingAgain < SomethingElse
  @class_instance_variable = 0

  class << self; attr_accessor :class_instance_variable end

  attr_accessor :instance_variable

  def initialize( name )
    self.class.class_instance_variable += 1
    super(name)
  end
end

albert = SomethingAgain.new("Albert")
puts "Albert = #{albert.value}"
puts "Albert's class = #{albert.class.name} && class instance = #{albert.class.class_instance_variable}"
jane = SomethingAgain.new("Jane")
puts "Created subclass with class instance variable, and two instances."
puts "Jane's class = #{jane.class.name} && class instance = #{jane.class.class_instance_variable}"
puts "Albert's class = #{albert.class.name} && class instance = #{albert.class.class_instance_variable}"

Class instance variables are attached to an object's class object.

class SomethingMore < SomethingAgain
  @class_instance_variable = 1138
  def initialize( name)
    super(name)
  end
end

mike = SomethingMore.new("Mike")
puts "Mike = #{mike.value}"
puts "Mike's class = #{mike.class.name} && class instance = #{mike.class.class_instance_variable}"
puts "Created subclass of class with class instance variable, with its own class instance variable"

Class instance variables aren't visible to subclasses.
Class instance variables are required on subclasses when base-class methods that read or write them.

puts "Albert's class = #{albert.class.name} && class instance = #{albert.class.class_instance_variable}"

Class instance variables are not visible to other subclasses in the inheritance chain.

All in all, the @@class variables encourage collusive coding and appear to carry a high risk of causing race conditions and other unintentional side-effects. The @class instance variables carry a somewhat lesser risk. Barring some obscure trick, a class instance variable is always associated with precisely one class. But even with class instance variables, multiple object instances can gain access to the variable through their own "class" property, with the potential for unintended side-effects.

Simpler than possible

2012-01-25T19:54:00.000-08:00

A scientific theory should be as simple as possible, but no simpler

- A. Einstein

I'm not sure of the precise context of Einstein's words, but it seemed to do with deflection of criticisms toward one of the relativity theories.

A kid with a magnifying glass intuitively understands the meaning: the focal length of the lens being a theory, too close in or too far away both give rise to fuzzy representations that aren't too bright.

By DrBob via Wikimedia Commons

The question is one of focus. Literally, not figuratively.

Considering that vision originates in the brain and its purpose is to create a predictive theory of the world around us, it is unremarkable that lenses are incorporated into our biology. The lens reduces the scale of the external ~~problem~~ visual field while concentrating signals in the process, and makes a projection onto a concavely curved surface covered with photoreceptors. The lens is an image transfer device.

The brain then, is a device onto which images are transferred. Into, onto, it is hard to express: the memories modify the fine grained structure of neural dendrites, which incorporate the sensory inputs in analog gradients, and do so more or less as a whole.

So I propose an idea of Focal Distance and the degree of Focal Alignment when considering how fit a software language, idiom, framework, system, or platform is to a particular ~~purpose~~ set of stakeholder needs.

This assumes that the needs are in some manner, self-consistent -- they lie along a parallel trajectory. It may be that due to conflicting interests between stakeholders, the solutions deemed acceptable will never, ever, approach Focal Alignment. There could be orthogonal components to the needs, causing the lens -- and by extension the solution-image -- to skew. There could be absolute differences in stakeholder positions along the same trajectory or orientation in opposite directions along the same trajectory, giving a compromised Focal Distance and solutions that are blurry.

What Windows POSIX Compliance Teaches Us: a Wink and a Nod

2012-01-19T07:57:00.000-08:00

Many years ago, the Federal government put out a series of requirements, the FIPS standards. IIRC, the POSIX specs are part of FIPS. To generalize, Linux is an implementation of POSIX.

POSIX was pushed because of a few factors:

vendors' operating systems are divergent, making it harder to migrate programs between systems
vendors go out of business, shut down product lines, and make radical changes to them, so development using their APIs are an unsound investment over time
government institutions have to carry the burden of systems they buy into for decades

FIPS are procurement standards. This means that in order to sell a computer solution to the Federal government, a vendor must satisfy the POSIX requirements. The intent is clear: to safeguard public investments. An improper balance of power in the hands of a supplier inevitably leads to deleterious actions against consumers. POSIX has the effect of making investors out of consumers.

What happened afterward is a travesty: Microsoft Windows/DOS based PC clones had picked up steam in the consumer market, and NT was being aimed at enterprises including government. Microsoft gave NT a partial POSIX subsystem, which just about nobody used, to get a rubber-stamp for sale into government accounts. A panel of judges gave the nod, and forced the Coast Guard to accept Windows based proposals in a 1995 case.

Apparently, the NT POSIX subsystem has been replaced a few times, and was crippled from the start. That's why everyone and their brother uses Cygwin, UnixUtils, or MinGW for porting Unix apps to Windows. But due to Windows' non-compliance, it doesn't run Unix style applications all that well.

credit: Zombie classified by bloodredrapture on Flickr

Microsoft only added the DOA POSIX subsystem so they could claim compliance, when their compliance was a sham on its face. The subsystem was virtually a zombie interface.

The Coast Guard lawyers in the 1995 case would have done well to ask a multilingual colleague to assist, using a deliberately broken grammar in a non-English language to present some portion of their argument. Prior to being cited for contempt, they could then argue that their compliance with requirements for language interfaces in court was similar in kind to NT's conformance to POSIX interface requirements, and with identical outcomes.

Government purchases of closed systems like Microsoft Windows amount to a collusion with vendors in constructive non-compliance: apparently in conformance but with precisely the opposite effects as those intended by the standards authors. Such is the power of the judiciary to rewrite law.

One way to re-approach the original intent of FIPS is to reformulate compliance in terms of public trusts, or something akin to a credit union in which software is the primary asset. We have very good institutional precedents in the form of non-profit organizations, like the Apache Software Foundation and the Mozilla Foundation. (Indeed, these two alone account for a huge amount of the Web infrastructure that drives our economy.)

For software to be purchased by a government entity its assets and its dependencies should be escrowed in the public trust, largely if not completely. In the case of open source software using distributed version control services, this could be accomplished easily: just identify yourself and the repositories. Private concerns would have to accept that the public's interest in not losing access to the intellectual property outweighs their interest in keeping it private, and trust the escrow service to not leak their IP prematurely; or chose to not play in the public space.

Those institutions that adopt closed systems learly get immediate and substantive benefits, particularly in the predictability of the user interface, and plug-and-play commodity peripherals. Those same institutions are also now bumping up against the long-term consequences of adopting a strategy of developing for privately held operating systems. A nod is as good as a wink to a blind horse.

Compass imports

2012-01-16T15:08:00.000-08:00

Yeah, some articles on this blog are a dumping ground for when a crib is needed.
The Compass docs are not particularly easy to scan through quickly.

Compass imports
ex: @import "compass/layout"

compass/

grid-background
sticky-footer
stretching

css3
appearance – Specify the CSS3 appearance property.
background clip – Specify the background clip for all browsers.
background origin – Specify the background origin for all browsers.
background size – Specify the background size for all browsers.
border radius – Specify the border radius for all browsers.
box – This module provides mixins that pertain to the CSS3 Flexible Box.
box shadow – Specify the box shadow for all browsers.
box sizing – Specify the box sizing for all browsers.
columns – Specify a columnar layout for all browsers.
font face – Specify a downloadable font face for all browsers.
gradient – Specify linear gradients and radial gradients for all browsers.
images – Specify linear gradients and radial gradients for many browsers.
inline block – Declare an element inline block for all browsers.
opacity – Specify the opacity for all browsers.
text shadow – Specify the text shadow for all browsers.
transform – Specify transformations for many browsers.
transition – Specify a style transition for all browsers.

typography
links

hover-link
link-colors
unstyled-link

lists

bullets

horizontal-list

bullets
clearfix
float

inline-block-list

bullets
inline-block
float
horizontal-list

inline-list

text

ellipsis
force-wrap
no-wrap
text-replacement

vertical-rhythm

utilities

links – Tools for styling anchor links. (from typography)
lists – Tools for styling lists. (from typography)
text – Style helpers for your text. (from typography)

color – Utilities for working with colors.

color-contrast

general – Generally useful utilities that don't fit elsewhere.

Clearfix – Mixins for clearfixing.
Float – Mixins for cross-browser floats.
Hacks – Mixins for hacking specific browsers.
Minimums – Mixins for cross-browser min-height and min-width.
Reset – Mixins for resetting elements (old import).
Tag Cloud – Mixin for styling tag clouds.

sprites – Sprite mixins.

sprite-image

tables – Style helpers for your tables.

table-striping
table-borders
table-scaffolding

Closure as a property of a package management system

2012-01-16T09:26:00.000-08:00

I filed a bug today for a simple OSX Homebrew recipe for git-hg. Basically, git-hg allows you to clone and work with mercurial repositories using a git repo. Upon installing the recipe though, cloning resulted in an empty directory, and a fetch (performed out of curiosity) got:

Traceback (most recent call last):
File "/usr/local/Cellar/git-hg/HEAD/bin/../fast-export/hg-fast-export.py", line 6, in <module>
from mercurial import repo,hg,cmdutil,util,ui,revlog,node
ImportError: No module named mercurial

Aha, so the immediate problem is that the Python mercurial module is missing.

The actual problem is a little more pervasive: the git-hg recipe didn't close over all of its environmental settings and software dependencies.

A further example of faulty closures was seen in the associated Python install. Why was the module missing? The first place to look is the Python distribution's site-packages folder ( /usr/local/lib/python2.7/site-packages for the Homebrew example).

This turned out to be a puzzler because OSX also comes with an older version of Python installed. Thus, as the Homebrew and Python page explains, you have some fiddling to do with your PATH and PYTHONPATH environmental settings. While one cannot predict or completely automate environmental dependencies, it would have been very nice to be reminded of the potential conflict by the Python recipe.

The omission constitutes a lack of closure of the recipe over its dependencies.

JavaScript is Dead. Long Live JavaScript

2012-01-15T21:19:00.000-08:00

OK, this is going to be light on fact and heavy on impressions. I admit to not having much to go on, other than my own memory of history. I'm simply spewing intuition here.

I just took a whiff of a new programming language. Something smelled wrong. It reminded me of

Fully blown Corba enterprise standards
C++ for business applications
Java for the Web
W3C XML Schema Language
Web Services Standards (pick just about any)

It is not that there isn't some merit to each of these, but each egregiously forces a practice of making many decisions early in the design process; they do so in the name of performance; and they all suck because they embed too much cruft in the deployed systems.

The language I smelled was Google's Dart. It smells an awful lot like Java, from the tooling (Eclipse) to the static typing (uh, "optional" static typing). Then there's the 17 thousand + line of code "Hello World" example. But OK, even gcc compiles Hello World to around 8k on an OSX machine. (Then again, that's machine code gcc is compiling into on a desktop, not scripted source in a Web browser.)

If Google wants to push an alternative to Java, more power to them. But they should not have done it under the pretense of killing JavaScript, or of making open Web scripting easier with enterprise tooling. That's just a little bit "evil".

SVN Cribs

2012-01-12T10:25:00.000-08:00

(Cheetah credit: Wikipedia Commons)

svn co https://some.where.no/path/trunk main --username username # "username" is from the server

svnadmin create reponame # a local repo (the repo itself, do not modify!)

mkdir protouch proj/somefile.txt

svn import proj file:///Users/yourname/reponame/proj -m "Initial import"

svn checkout file:///Users/yourname/reponame/proj proj-copy
svn export file:///Users/yourname/reponame/proj proj-copy # export instead of checkout

cd proj-copy

svn status

svn update # Pull changes from server to local; update working copy
svn resolve --accept working # claim that conflicts were resolved

# change, create files
svn add changedfile.txt
svn move oldfilename new filename
svn copy oldfilename new filename
svn delete filename

svn commit -m "made this change" # commit and push changes to server
svn ci -m "changes comment" filename # commit for one file

svn log
svn log filename # look at log for file

svn diff -r priorversionnumber
svn diff -r ver filename # diff only for this file

svn update -r priorversionnumber # roll back to a prior repo state
svn revert FILE

Global options:
  --username ARG           : specify a username ARG
  --password ARG           : specify a password ARG

more at http://svnbook.red-bean.com/

SVN is dead. Long Live SVN

2012-01-12T08:35:00.000-08:00

I prefer GIT, but SVN is widespread too. Even though SVN is not very old (it is only 12 years old) but it represents a clone of, rather than a re-imagining of, the antiquated CVS tool (released around 1989). CVS was itself a reworking of the (at the time) popular RCS tool first seen around 1982. RCS inherited its good looks from SCCS, created in 1972 for an IBM System/370.

(Dodo credit Wikimedia Commons)

So the core concepts that frame up SVN are over forty years old. The workflows have changed with each re-implementation, but the basic approach to version control is pretty similar. Vaguely, the way these tools work can be characterized by a few features:

there is a single central point of update
changes are tracked one file at a time

it is left to the user to use labeling and other tool features to ensure that sets and subsets of files corresponding to systems and modules are self-consistent and sane configurations
histories must be computed in a more or less unbroken chain

filesystem level changes, and special file types, are not tracked well, or not at all

renames are not well tracked
file history can easily be lost

higher level constructs for configuration versioning are missing

no symbolic tagging

branching is clumsy, heavyweight, long-lived, and error-prone
data and metadata access is rigid and fragile, but fast

repositories are exposed to corruption from trivial user level actions
SVN is both faster and more robust, but still trivially easy to corrupt by network errors and faulty clients

OK, maybe this is being a bit unfair, incomplete, abstract, and irrelevant as judged by an SVN expert. I admit to having completely lost interest in the SCCS evolutionary branch of VCS's when Tom Lord's Arch (tla) arrived on the scene in 2001.

(Original finch image credit Wikipedia Commons)

The vine that was TLA died but not before sparking a vibrant ecosystem of competing Distributed Revision Control systems. My recollection could have gaps, but to my mind Tom Lord never really got the credit he deserved for this innovation. Mercurial and GIT are two modern representatives of this evolutionary genus.

(Cheetah credit Wikimedia Commons)

While the SCCS->RCS->CVS->SVN branch has thrived in the open source community, it remains a rather stilted lineage. This isn't because SVN is a mature tool now (although it is). Rather, it is because SCCS had fixed in place a large number of decision points that were not (or could not be) revisited even when its descendants broadened and matured the design. Up to a gross approximation of workflow, SCCS == RCS == CVS == SVN. Further diversification has a very high cost and low payback, and so no richness of form will arise from that fount.

For a more positive spin, read about the advantages of a distributed VCS on ThinkVitamin.

Check out the Node Beginner Book

2012-01-06T12:39:00.000-08:00

Check out http://nodebeginner.org/ , the Node Beginner Book.

This is an unprovoked, unpaid, unrequited plug, just because I enjoyed looking through the site and working out the example. There is ample room to tweak the idiomatic style and play with the example, which is completely straightforward. The writing is a tiny amount sugary, but it presents a very good narrative. This guy needs to write more user guides.

Reading Blocks in POW and Node.js

2012-01-01T08:35:00.001-08:00

A writer's block is when you've got some serious motivation to write, but can't seem to find the inspiration to get started or the cleverness to get past a simple difficulty. Readers can face blocks too, especially when the writer has done a poor job of weaving the threads of the story and bringing them together.

The same problems exist for programmers when writing and reading code, except much more so. As programmers, we often need to tease out the answers to questions about where some control path came from, and were it is going.

I'm thinking now of a snag hit while trying to convert my personal site to use HTML5's caching manifests:

Application Cache Error event: Invalid manifest mime type (application/octet-stream) http://mitch.amiano.agilemarkup.com.dev/manifest.cache

I was using the 37Signals' POW server to do my local testing. It looks like POW serves up the manifest file as an octet stream, instead of the recommended type (text/cache-manifest). I searched for the mime type handling in POW. It is not there. As a reader, I face a small block.

POW is reusing modules defined in Node.js, the V8 evented I/O library. So naturally, there is nothing present in the POW source code base that will clarify how it resolves missing mime types.

More precisely, POW is calling a connect.static method. There is no "connect" module in POW or Node.js, and nothing in the source code base that would suggest what "connect" is, other than an anonymous Node.js module. So we have to search elsewhere, elusively.

Implicit in using Node.js is use of a flat global namespace for modules, implemented by npm, the Node Package Manager. It isn't clear to me how (or whether) npm manages versions, or what people will do if and when a competing package manager is released, or when packages adopt similar or identical names. It seems as if git repo urls are implicit in the packaging, but not in any way that is definitive in the client source code.

Now, a programmer who is experienced in a given library will become a priest, familiar with all the dangling threads of the righteous library. But that's no excuse for leaving threads dangling. This is the stuff of a cult-like priesthood, not of a profession. all a bit of a guessing game.

[edit: turns out that Node uses package.json for version/dependency management; however, unless you've downloaded all the sources, UNIX tools like "find" or "grep" will obviously not find anything.]

Connect is ~~(very probably)~~ ~~some~~ a version ~~(which one???)~~ of a Node.js based middleware framework. specified by package.json in the root of the source tree. The git repo says that static is a middleware module packaged with connect. The static middleware calls mime.lookup(path). The mime package and version are not anywhere to be seen in the Connect source code. I'm seeing a pattern here, or rather an anti-pattern.

References should not be more exact than necessary, but nor should they be so ambiguous that they contain insufficient information to find the referenced entity.

So I locally clone Connect, and Node.js, and POW, and use OSX' find command to sniff out the possible locations of the mime type handling, to see if there is an idiomatic way of adding a new type. The mime module is a package included with Node.js, down in deps/npm/node_modules/request/mimetypes.js.

I'm repeating myself, but the mime module is not part of the Connect source code base, and I have to assume that it isn't referring to some other module also called "connect". This case is simple enough - mimetypes.js is just an associative array with a lookup function - but in the general case, which version might we be linking to, and who is the owner?

Writing like this isn't just an interruption to the reader, it is a failure of the writer to pull together the threads of the story. That makes the story more difficult to follow than necessary, and it isn't sufficient to deliver a reliable piece of software except by fortunate accident.

Avoiding searches for ambiguous references is what Integrated Development Environments were designed for. But using an IDE is missing the point: it shouldn't be necessary when reading sources to go through an unreliable search for every dependency.

I'll chalk this up to my own inexperience with Node.js.

~~Maybe~~ I ~~don't~~ didn't grok Node.js and npm well enough ~~yet~~. ~~Maybe there are some conventions that make the resolution more definitive and repeatable.~~ The convention requires that you use npm like one would use bundler and gems in Ruby.

~~But writing code that requires mental long-jumps to anonymously named, un-versioned modules seems like a very stupid way to program. Perhaps Node.js needs its own version of bundler.~~

[edit: Yeah, node.js has its own means of packaging components -- I had missed that in my haste. I still think there is a disconnect between where entities are defined and where they are used by clients... the dependencies wind a path through multiple packages, give opportunity for mysteriously similar names amongst package methods and variables, and generally make piecing together the story more difficult than it needs to be.]

Selling Yourself Out of Projects

2011-12-29T16:00:00.000-08:00

So, a friend tells me about a buddy who "has a software project you can help him with."

Prospects are very subjective creatures. I tend to think that a professional, whether a software craftsperson or an engineer, or something else, has a kind of fiduciary ethic even toward prospects. If a prospect asks about developing a software project, my immediate concerns are

Does the client really need custom development?
Is there an existing service that already meets their needs?
Will the recurrent tangible and intangible costs (of any desired path) present an impractical future burden ?

Unqualified prospects would result in No to the first question and/or Yes to the second question. The third question is one that no salesperson in their right mind would venture to probe, but it represents a core value of the engineering ethos. Is the prospect willing and able to accept the costs?

I'm in my right mind, but I'm not as much a salesperson as my friend. So I informed the prospect of his options and alternatives early, and gave him some context of the cost. That approach pre-qualifies many prospects out of project, or at least, sends them looking for someone else who is more willing to lead clients down a primrose path.

The thing is, my friend would have just jumped into the job, sweeping questions about the likely costs under the rug, playing dumb about the prospect's needs and getting them to pay for scraps of functionality as soon as possible. This sort of drive-by software development is all too common.

I'd rather sell myself out of a project than put blinders on and lead prospects down a rabbit hole. That may not be the magical thinking that fuels so many Law of Attraction acolytes, but it is the path an ethical person will tend to follow.

Unconscientious Prospects

2011-12-22T13:13:00.000-08:00

I was contacted recently via email, by a prospect seeking assistance with a small PHP/MySQL project. Now, disregarding my personal distaste for Rube Goldberg skunkworks cobbled together in PHP, I offered to help anyway. Paraphrasing the conversation it went something like this:

Prospect:

Hi, I was given your name by *********. I have a web based tool and would like to make minor modifications to it. I want to remove some functions for a one-time use. It should not be very involved or big task but I need to have it up and running in three weeks. If you think you might be interested please let me know.

Me: (replying a few hours later)

I'd be happy to discuss your needs for the Web tool. If you would like to talk, I have some time this week. Let me know.

Prospect: (no reply for two days)

Me: (two days later, this time with a return receipt attached)

Hi, I just wanted to follow up to make sure you received my reply. Are you still looking for assistance?

Prospect:

Hi, got follow up from someone else before your reply. Will need to do some other work and will get in touch with you when I am ready.

Me:

My immediate knee-jerk reaction to this was, "hey, someone beat me to it, good for them!" but then a couple of thoughts occurred:

It is unprofessional to ask someone for help, then ignore their attempts to communicate.

Everyone gets distracted once in a while, but even if you aren't immediately going to do business with someone, if they extended the courtesy of a reply you owe them the same courtesy in return.

The oblivious lack of courtesy of dropping an email exchange is like walking through a door and letting it slam shut in the face of the person behind you. It isn't very pleasant to the slam-e, and it reflects poorly upon you.
Conversely, if you judge suitability based upon the how quickly one responds, you aren't looking for a relationship but a one-night stand.

Look, as a freelance programmer I'm not seeking to date you or marry you. But I do have an expectation of a certain amount of reciprocal attentiveness and return on my investment of time. Treating your search for help as if you are casting chum and netting the first fish that bites, shows that you are not very conscientious. Or at least, when push comes to shove you become neglectful.

I'm less and less interested in giving people second chances, perhaps because I've often been so long-suffering on the first go-round. What is really beginning to annoy me though is the attitude that we're just "resources" or "commodities". Damn it, Jim, I'm a person, not a commodity. If you care so little about who you employ and you can't communicate and you consider the effort to be so small, why would I want to bother doing business with you?

CSS Grammar Considered Wrong

2011-12-16T11:52:00.000-08:00

I get a little nit-picky every time I look at CSS.
Take the way that the media queries spec handles dimensions like width and height. They couldn't just say "width", no, no, that would be just too easy. Instead they say min-width, width, and max-width.

CSS grammar is meant to be declarative, but that's not the reason for using prefixes. The CSS media queries section on media features tries to explain the rationale:

Most media features accept optional ‘min-’ or ‘max-’ prefixes to express "greater or equal to" and "smaller or equal to" constraints. This syntax is used to avoid "<" and ">" characters which may conflict with HTML and XML. Those media features that accept prefixes will most often be used with prefixes, but can also be used alone.

Never mind that CSS selectors already use the greater-than symbol. The grammar has gotten land-locked, but it has never used commonly accepted notation for mathematical expressions. You know, expressions such as:

width: (160,320)   (interval notation)


160 < width < 320   (set builder notation)


(160..320,true).include? width   (Ruby, using a range)


width BETWEEN 160 AND 320   (SQL)

Whatever. The nit I'm picking is not that the CSS editors have had to work with what they've inherited.

Whether an historical accident or pragmatic contingency, using prefixes (min-, max-) on property names as grammatical substitutes for logic expressions (>=, <= respectively) constitutes a multiplication of entities way beyond necessity. Instead of one property (width) within two scopes (logical and device), CSS presents us with:

width


device-width


min-width


min-device-width


max-width


max-device-width


aspect-ratio   (CSS pixel width/height)


device-aspect-ratio


min-aspect-ratio


max-aspect-ratio


min-device-aspect-ratio


max-device-aspect-ratio


orientation  (width > height ? landscape : portrait )

Them's A DOZEN MORE properties, baby.
That's just for one stinkin' property, so don't be callin' me all pedantic on this. If y'all leave nits alone they grow and soon enough you find yourself infested with lice. (Not that I have any experience with lice.)

The gratuitous prefixes don't make the resulting media queries any more elegant to express:

@media screen and (min-width: 160) and (max-width: 320) { 
  stuff {  goes: here;  }
}

The problem is that CSS uses a fixed set of discretely expressed predicates for continuous and dynamically varying values. What I want it to say instead is something more along the lines of:

@media screen and (160 < width < 320) )  {
  stuff {  goes: here;  }
}

@media screen and (width: range(160..320) ) )  {
  stuff {  goes: here;  }
}

CSS is what it is and for better or worse this design choice passed through the editing and public commentary process intact. Other efforts can still learn from its missteps as much as its successes. Injecting special-case grammatical devices is an easy way to make a language available early but injecting them often will turn even a greenfield language into yet another Rube Goldberg device. As a device, CSS has more than a little Rube Goldberg in it.

Dropped Google Ads

2011-12-13T20:02:00.001-08:00

For a long time, I had a little sidebar of Google ads displayed on my blog. No more.

At the time it seemed like the thing to do. Syndicated advertising was all the rage, everyone was supposed to find ways to monetize their sites, blah blah blah...

I just threw up the sidebar to go through the steps needed, in case I needed to do it for someone else and just out of curiosity to see what it would generate.Well, this blog is, should we say, along the road less travelled, so the ads never amounted to anything monetarily.

It turns out that Google ads looked really sucky when the mobile template was active. Actually, they look sucky any time, but their relative sucky-ness increases as the display window decreases. I don't know why, they were just ugly.

There was another downside too: besides detracting from the visuals, syndicated advertisements contradict one of the messages of the blog: our society has put so much of its human capital into manipulating perceptions that it has eaten away at workplace ethics and cannibalized its equity in the process.

Bye bye, Google ads, I'm not really going to miss you.

Musings on consciousness

2011-12-12T05:07:00.001-08:00

Janice Janes had a very informal, very anecdotal hypothesis: before the human condition first acquired consciousnes, our existence was dictated by a non self-aware construct he termed the bicameral mind. Janes argues that the development of consciousness is in part language based, and in part wired into our brains, based upon the authority structures of the culture. Consciousness thus developed over time as the challenges of dealing with multiple interacting cultures forced the simple structures to break down and be reconstituted, generation after generation.

I don't know whether Janes' ideas were away in left field or in any way mainstream, but they were intriguing. Through his lens it was easy to interpret xenophobia, black and white doctrines, separatism, etc. as attempts by a subculture to regain some measure of the simplicity of the less self-reflective mind.

Janes' assumptions that consciousness was/is an ever progressing evolutionary eventuality are wrong. Cultures can and do move backwards towards a less than fully conscious hive mind mentality. If anything, consciousness is Lamarkian, not Darwinian. Consider the culture of Afghanistan, or, closer to home, religious cults. Fanatical followers of media personalities such as Oprah or Jim Bakker (not to say they are equivalent however) oven have great difficulty separating their own opinons from those espoused by their glorified leaders. Prejudice is the antithesis of consciousness.

And it isn't just about collectivist authority structures, but personal identity. Experience of the world drives consciousness about that world. Less experience implies a narrow, specialized focus but also a limit to consciousness. Ignorance is bliss. Experiences by proxy, as through the Web and TV, create a consciousness that does not accurately image or respond to the physical and social world. In this case, ignorance is not bliss as the conflicting and falsified viewpoints creates unnecessary and unhelpful reflection.

Autocorrective Crowd Sourcing and Autocatalytic Systems Programming

2011-12-08T20:16:00.001-08:00

So, a friend sends me this link about how Recapcha is being used to pawn off digitizing work to unsuspecting users, in an ingenious manner:

Setting aside for the moment any ethical considerations of virtual slavery and digitally indentured servitude, it really is a masterful plan.

The crowd sourcing model can even be used to clean up application data, even when the crowd is relatively small.

Another friend related the case where a US federal government department contacted him, to consult on scrubbing business names from a terabyte scale database. The chief difficulty is that much of the data originated by people typing in whatever they wanted. My friend rightly points out that it is always cleaner to select a coded value from a list, rather than allow free form typing. That is not possible when the values vary, as human contrivances (company names) frequently do.

Systems may be designed to allow people to type in new names in a free form manner. Free form data input means Garbage in, Garbage out: there is no way to identify the unbounded variation of lexical strings by which a company name is known. Consider the morphisms of the Johnson & Johnson corporate apellation:

Johnson and Johnson
Johnson & Johnson
Johnson & Johnson, Inc.
Johnson and Johnson, Incorporated
J&J,
J & J,
J& J,
J. & J. ,
J and J
jnj.com

The letter case is not such a big deal. Neither is the variation of whitespace, or even the substitution of the ampersand for the word "and". The problem is that the set of these names is finite but unbounded and the set changes over time. There is no easy way of identifying entries that go with the canonical name for a given organization.

Or isn't there? Applications capture this data in daily interactions with users. Combo boxes can list previous entries and make coded selections, while allowing novel inputs. So use string pattern matching to do a lookup of the possibilities based upon the first few characters typed. But don't look into the old records, look into a map of generated and collected synonyms instead.

Allow the user to start entering the name of the company. If after the first few letters, you find an exact match on a canonical name and the user accepts it, you're done: just take the code for the canonical name. If there are no perfect matches, generate a set of weighted regexp patterns based upon the user input; any original names that match and are accepted by the user are recorded as a probable match for future lookups.

That is admittedly rather sketchy, but I'm sure someone has implemented a few schemes along these lines to clean up old data. What would some of the advantages be?

Cost is not incurred when the effort has no value.

Data for companies that are no longer participating is not touched.

Effort is expended whenever it is needed.

Data for companies that are participating often are improved more rapidly.

Refinement of the data set is embedded as a design feature of the system.

Not one-shot: Cleaning of the data continues over the lifespan of the system.

Tracks the moving target: Data set targets are ambiguous symbols representing shifting human contrivances (businesses).

Can the strategy work? Biological systems do something analogous in the form of DNA error detection and repair. They are far from perfect, but organisms maintain their integrity for decades, up to hundreds of years... thousands if you consider some of the oldest organisms like trees and fungi.

The key idea here is accepting that determinism in complex systems is a convenient myth that is sometimes more trouble than it is worth. That realization opens the way for explicitly probabilistic feedback loops -- just one more way for complex computer systems to fulfill their original design intent to illuminate the processes of life.

Attending Triangle JS Meetup

2011-12-06T16:13:00.001-08:00

I'm attending the Triangle JavaScript Meetup tonight. They're discussing Toura Mulberry.

the original photo is by mauroguanandi on Flickr

The open source mobile development and deployment tool, not the fruit. @rmurphey from Toura is presenting.

Mulberry is a toolchain and deployment strategy wrapped around PhoneGap. The unofficial description is that it follows a Rails-like approach to the toolchain. As far as deployment is concerned, Mulberry acts as an HTML browser in a private application.

Mulberry attempts to be a full-cycle development stack for applications deployed as embedded Web-browser (using Sinatra?), displaying content from JSON. Most of the responsibility for presentation sits on the mobile device, implemented in JavaScript. In fact, most of the HMTML and markdown gets converted into JSON content data, which is then composed into DOM by JavaScript on the client.

Like Rails, Mulberry is opinionated, and provides generators for scaffolding. It relies upon the exposure of content through a "node" interface to publish data. Several of the artifacts created with the generator are configuration files for things like the media form factors, devices, site map, default content (in markdown), routes, etc. The system is then immediately available to test using "mulberry serve", the built-in server, without a build process. Also like Rails, the system uses special URL formats to convey configuration settings in the running app.

Basically, Mulberry is a single page, off-line application meant for quick deployment.

Mulberry sends most of the content down as a static set of nodes, but the deployment wrapper supports polling for content refreshes. Currently that functionality is limited to content, not including templates or behavior, due to Apple Store guidelines.

Also mentioned
Ripple
Weinre
iWebInspector

Thinking matters, even in Condé Nast magazines

2011-12-03T06:36:00.001-08:00

I'm on a quest to get healthier despite my programmer ways, and I do a fair bit of researching. To that end, I review medical literature from databases like PubMed/Medline, and look for the reasons supporting or conflicting with pop-culture (including government) recommendations.

In my perusing, I came across a nutritional site about the Fructose content of various foods, operated by SELF Magazine. That's good, because fructose acts like alcohol to the liver, leading to cirrosis, insulin resistance and diabetes, which is bad.

SELF is one of those Condé Nast periodicals aimed squarely at the well-off-but-otherwise-insecure-young-female crowd. I'm trying to limit the intake of high fructose foods in my lifestyle, and if is informative to hot, wealthy, young women surely I can use it too.

Except it doesn't matter if we guys have almost all the same genes as gals and fructose doesn't seem to respect any of the differences...

...because as presented the site offers utterly bogus information. In fact, the data is often upside-down.

Let's take a look and make some conclusions based on the site's rankings:

Molasses has half the fructose content of iceberg lettuce
Applesauce is ranked higher (worse) than honey
Plums and onions are almost the same
Celery is at #179, within the top 200, having 6.4 grams of Fructose
Cabbage is ranked higher than Raisin Bran cereal

By ranking the foods based on a fixed calorie count, rather than on a realistic volume or weight basis, the Condé Nast list implies utterly terrible lifestyle advice. It can't be that hard to figure out that foods like cabbage contribute a tiny amount of fructose to the diet. People who rely upon SELF for nutritional information are not at all well-served by such a poorly designed guideline. Clearly, the folks over at Condé Nast aren't very serious about presenting good nutritional information to women.

If I were Sarah Chubb (president of Condé Nast Digital) I'd order the nutrition site taken down immediately and replace the person who had editorial responsibility for it. Chubb should find people who can reason quantitatively, and think about the content, not just about how it is presented.

Forgetful Filesystems

2011-11-28T11:41:00.001-08:00

There is a slather of news and criticisms aimed at IBM for its recently awarded patent application for a document aging file system.

I'm going to come to Big Blue's defense here, and say that it makes some sense in certain contexts.

There is no such thing as a non-degrading media; digital storage simply reduces the error injection rate infinitesimal proportions and increases the rate at which refreshes occur by orders of magnitude. Purposefully degrading the fidelity of the data stored on a system is a way to put the lifespan of the storage on par with the lifespan of pre-digital technologies, and thus be enabled to offer a similar value proposal.

Individuals, businesses, and governments generate a lot of junk data. Should this junk data be treated with such high fidelity value as the stuff we really care about? As long as we get to chose between what constitutes the good stuff and the junk, I'm all for having forgetful filesystems. They are inevitable.

There are a LOT of business and government records in particular that would be well placed into a round file. I'm told that some of my tax records, for instance, should be kept around seven years. Here is a way I can put such records, that to me are truly garbage, in a round file and know that eventually they'll be discarded just like paper copies, and the storage space can be reclaimed and sold to someone else.

We couldn't save such junk data when the medium was paper, but why maintain it just because it went digital?

OSX Wireless Printing with Leftover PC printers

2011-11-27T17:56:00.001-08:00

Apple's AirPrint has very little in the way of direct vendor support. HP seemed to be the only printer maker that supports the protocol. Now Epson and Cannon have joined in.

Epson printers suit me just fine. With an external inkwell, the cost of operation is a tiny fraction of the HP ink suckers. I have an older Epson though. What to do?

I dug up an old TrendNet TE100-P1U wireless print server. The install manual claims that only PostScript printers are supported under OSX. Not so!

Just install the Gimp Print CUPS drivers. You then add the print server as a printer under System Preferences, Scan and Print settings. Set the printer type to your printer's model (mine is an Epson 9400Fax). Print a test page and... it worked! So now I can print from OSX wirelessly to my old PC printer, without the old PC.

No, as to AirPrint... OSX Lion can act as a host to your IOS devices via Activator 2. It works fine sharing the print server printer, using the cups driver.

Textured Typeography with CSS3

2011-11-21T06:39:00.001-08:00

Let's suppose I have a textual element that serves as a title and I don't want it to be a plain boring flat color. CSS3 has a nifty way of letting an image serve as a mask for an element.

Let's take an image with some texture to it, say, the Lava effect from Gimp:

We can apply this to an element using the mask-image property:

.title {
   -webkit-mask-image:  url(http://mitch.amiano.agilemarkup.com/images/titlemask2.png); 
  -o-mask-image: url(http://mitch.amiano.agilemarkup.com/images/titlemask2.png); 
 -moz-mask-image: url(http://mitch.amiano.agilemarkup.com/images/titlemask2.png); 
 mask-image: url(http://mitch.amiano.agilemarkup.com/images/titlemask2.png); 
}

This gives us:

Textured Text

Wherever the image mask is fully opaque, the original element content shows, and wherever it is fully transparent, the original element content is occluded. Between opaque and transparent, bits in the mask will show(or hide) content to the degree that they are partially opaque(or transparent).

College Computer Science: We don't speak with LISP here.

2011-11-19T20:34:00.001-08:00

A presenter at a conference was dismayed at how poorly the computers languages he was taught at NYU translated into practical application on the Web. I asked if LISP was among the languages. It wasn't.

The look on some of the attendees' faces seemed to suggest I was being a wise-guy. I wasn't trying to be snarky; I expected his response because I'd heard it repeatedly and found through personal investigation of engineering curricula that it is not in the mainstream.

λx.x

Substitution of terms in expressions is a fundamental concept. It is so fundamental that kids who are allowed to handle money will do it intuitively when making change. It is bizarre that such a fundamental hypothesis of calculation in computer science and mathematical logic is elided in modern computer science degree programs.

(The same kids will run into difficulty reframing their experience, when given non-monetary challenges in math classes. They get counting and computing when it is informed by their use of language; they lose the cognition when the language is removed. So add the vocabulary and operators of substitution to their repertoire , early, often, and concretely, and perhaps they will actually start intuiting what computation is all about.)

To the best of my recollection the first standardized transformation language for markup content was ISO/IEC 10179:1996 (DSSSL). It used a subset of Scheme (a LISP dialect) and in turn informed the development of XSL(T). Functional languages (Javascript is another example) are excellent tools for processing markup. University educators need to get beyond their own reframing difficulty to recognize the obvious substitution of "markup" for "Web," and Scheme to re-introduce a little more of a LISP in their discourse.

Emotional Maturity and Divorce

2011-11-17T07:04:00.001-08:00

My spouse has been married to me for over 25 years. The relationship is symmetric: I've been married to her for precisely the same amount of time. It certainly isn't reflexive: we're may be married to each other but I'm not married to myself. And it isn't transitive either; if I was married to someone else, that wouldn't mean that my two wives would be married (and anyway that would be bigamy). Therefore:

Marriage is Not An Equivalence Relation

Look, I'm not bragging about it. I'm no more worthy of accolades on this matter than any one of my divorced friends and relatives. Life has not always a bed of roses either; just as in the economy, externalities shift and expectations change, excitement can give way to disappointment, disappointment to grief, and new realities set in. But in our 25 years of marriage, we've been witness to a great deal of divorce, which substantively impacted our family and relationships.

No matter how close you imagine yourself to be to someone, you're not that person and they are not you. The unity is plural. Perceptions matter a little, to be sure, but having a good grasp of reality and an emotional balance between empathy and self-interest matters much more. That means taking time to be reflective together, actively exercising empathy and not just entertaining yourselves on a date night and slugging through chores the rest of your time. Or in the case of those struggling with a loss or divorce, taking a year off to normalize your emotional response to relationships.

The Pakled Philosophy of Development

2011-11-16T11:20:00.001-08:00

A rambling, opinionated, and very poorly justified rant. Please don't shoot me, I'm just venting.

A few months ago I blogged on my disenchantment with PHP. It isn't just PHP, but Java, Perl, and ASP/.NET that make me feel similarly estranged. The thing is, I want to work with languages, platforms, and systems that don't really, truly, deeply suck, on projects that are worth doing. Sadly, that's a rare combination.

I'm not sure exactly what it is about server-pages platforms that gives rise to such feelings of discomfort. I've worked with Joomla and Drupal and ASP sites, so perhaps it is in part the layering of immature cultural cruft inherent in their codebases that gives me the stray thoughts of "what a freakin' mess," and "are you kidding me?"

But as convoluted as some poorly written components can be, it isn't the primary reason these platforms suck. They suck because, for a dollar you put in today, you have to put a dollar plus change more in tomorrow just to keep the stack from completely collapsing in on itself. In effect, these platforms encourage a kind of codebase Ponzi scheme or a development Hell.

"We look for things."

All development builds upon previously constructed artifacts. Those artifacts must be available, demonstrably functional, and comprehendible to contribute to the next generation. Our objectives should not be merely to "make things go", but should include incorporating our knowledge into our archetypal forms, a process of language refinement. With PHP, Java, and so many other languages, we focus our efforts on entraining more and more information into the platforms, like some sort of junk DNA as it were; the languages and libraries grow in complexity much faster than they grow in value. Similarly, artifacts in these languages seem to have a very limited impact in advancing the system to higher levels of functionality.

Web Developers using server-page approaches produce piecemeal patchworks of solutions that last for a few months to a few years. Do such systems get increasingly easier to understand and maintain, or do they get increasingly cluttered and ever more risk laden? Is there repeatability, refinement, increasing transparency, and data unencumbered by private licensing, or a daily slog of Development Hell?

PHP systems rarely gain the level of maturity needed to be approach either self-consistency or completeness and closure over a domain. The intelligent fall-back position when you're ignorant is Lean -- sacrifice completeness and reduce the feature set to that which is minimally viable. Focus on what provides value. But if you just want to make it go, Pakled style, even when provided sufficient resources it won't contribute to the process of exposing and refining the domain language. Developing a domain language to incorporate new knowledge simply isn't a value proposition that is often pursued in that development culture, and it isn't well supported by the language.

In mathematics, there is the concept of the derivative. In the context of a function that plots a curve, the derivative tells you the rate at which the function output values are changing at a given point on the curve: it tells you the slope, as it were. In order for solutions to remain viable over time, the slope of the curve of revenue generating features must be greater than the slope of the curve of hidden costs and intangible liabilities. Otherwise, you're creating a shell hollowed out of real value. My sense on server page technologies is that feature incorporation has a relatively flat slope, the cost curve increases more rapidly, and hidden liabilities arise very abruptly and without warning.

For most clients of technology, it is a lose-lose proposition: they know they need to spend the money to stay in the game, but the game is rigged with goods frequently subject to erratic and unplanned obsolescence.

But that begs two questions. Are there any more sustainable alternatives? Would a more sustainable alternative slow down the pace of innovation? I don't pretend to know the answers but after blathering on in this article, I at least understand some of the reasons why languages like PHP rub me the wrong way.

Groan! Sass is great, but incomplete

2011-11-14T06:49:00.001-08:00

Seduced by the lure of smaller, cleaner, neater, and more responsive stylesheets, I began moving my home page to Compass and SASS. I installed compass, and got the basic framework in place quickly.

Then I went away for a while.

When I came back, it was because I had the brilliant idea to clean up the media selectors I had made a mess of. "Variables," I thought, "Why, SASS' variable interpolation would make that much easier!"

Sadly, this is not yet the case as of version 3.1.10 :

Syntax error: Invalid CSS after "(max-width: ": expected expression (e.g. 1px, bold), was "$phone-height) {"
on line 33 of /Users/mamiano/workspace/mitch.amiano.agilemarkup.com/sass/screen.scss
from line 1 of /Users/mamiano/workspace/mitch.amiano.agilemarkup.com/sass/index.scss

Backtrace:

Well, they are pushing to fix it in version 3.2. The thought occurs to me that for simple cases, a regexp replacement could do the trick if it could be inserted before Compass processed the file through SASS.

Getting fuse4x installed on OSX Lion

2011-11-13T07:22:00.001-08:00

I tried out Fuse4x and sshfs for OSX, through Hombrew, this week-end. It should have been a piece of cake, but apparently the recipes aren't very good about telling when another fuse package is installed.

As recommended, I did the install:

$ brew install fuse4x sshfs

Homebrew cheerfully informs me that sshfs won't work unless I sudo copy a file, so I follow its instructions. Seems a bit strange to have to do this manually:

$ sudo cp -rfX /usr/local/Cellar/fuse4x-kext/0.8.13/Library/Extensions/fuse4x.kext /System/Library/Extensions


$ sudo chmod +s /System/Library/Extensions/fuse4x.kext/Support/load_fuse4x

Alas, things just didn't work:

$ sshfs myname@mysite.me:  ~/mnt/mysite.me
/Library/Filesystems/fusefs.fs/Support/fusefs.kext failed to load - (libkern/kext) link error; check the system/kernel logs for errors or try kextutil(8).
the MacFUSE file system is not available (71)

Well, actually, it looks like the kernel extension never even loaded. OSX is supposed to attempt to auto-load them when a fuse filesystem is mounted, but it doesn't look like it succeeded. I use kextunload and kextload to get it to load the extensions:

$ kextunload /System/Library/Extensions/fuse4x.kext/

(kernel) Kext org.fuse4x.kext.fuse4x not found for unload request.
Failed to unload org.fuse4x.kext.fuse4x - (libkern/kext) not found.

$ kextload /System/Library/Extensions/fuse4x.kext/
Yet trying sshfs again gives the same error. What gives?

I look for more info on homebrew and fuse4x forums and bug lists. Wading through Web pages -- they all describing the solution to the link error as (to sum up) "use fuse4x". I *am* using fuse4x. One bug report on homebrew hinted at a possible cause to the problem.

It looks like at some point, I had a MacFuse installed, and it left an orphaned copy of /usr/local/lib/pkgconfig/fuse.pc:

$ cat /usr/local/lib/pkgconfig/fuse.pc
prefix=/usr/local
exec_prefix=${prefix}
libdir=${exec_prefix}/lib
includedir=${prefix}/include

Name: fuse
Description: File System in User Space (MacFUSE)
Version: 2.7.3
Libs: -L${libdir} -lfuse -pthread  -liconv
Cflags: -I${includedir}/fuse -D__FreeBSD__=10 -D_FILE_OFFSET_BITS=64

So I brew uninstall fuse4x, remove the fuse.pc file, and brew install fuse4x.
The homebrew recipe symlinked to the correct fuse.pc file, and I hoped all was good.

It was not good. Same error. I check the system kernel error logs:

 kernel[0]: fuse4x: starting (version 0.8.13, Nov 11 2011, 17:54:24)
 kernel[0]: kxld[com.google.filesystems.fusefs]: The following symbols are unresolved for this kext:
 kernel[0]: kxld[com.google.filesystems.fusefs]:  _OSRuntimeFinalizeCPP
 kernel[0]: kxld[com.google.filesystems.fusefs]:  _OSRuntimeInitializeCPP
 kernel[0]: Can't load kext com.google.filesystems.fusefs - link failed.
 kernel[0]: Failed to load executable for kext com.google.filesystems.fusefs.
 kernel[0]: Kext com.google.filesystems.fusefs failed to load (0xdc008016).
 kernel[0]: Failed to load kext com.google.filesystems.fusefs (error 0xdc008016).

Egads! Unresolved symbols? Something just isn't right. Looks like the same 32 bit MacFuse garbage.

At this point, I'm seriously doubting the sanity of the the homebrew fuse4x/sshfs recipes. Maybe someone thought they were working, as a coincidence of them already having a working fuse4x kernel extension installed.

Well, it turns out that the MacFuse code was not fully uninstalled, and the brew recipe simply accepts the existing files without complaint or comment:

$ ls -ld /Library/Filesystems/fusefs.fs
drwxr-xr-x  4 root  wheel  136 Dec 19  2008 /Library/Filesystems/fusefs.fs

December of 2008 ???! That's a little dated for a filesystem I installed today (Nov 2011). Even if it were unzipped from a file (which it wasn't), the datestamps of an active project should be more recent than 2008.

My experience with the fuse4x recipe is that it doesn't do squat for detecting previously installed files.... it just accepts them without complaint.

If you've got a previous install of anything remotely resembling MacFuse, clear it out, clean it out, and purge every remnant from your system before monkeying around with fuse4x.

$ /Library/Filesystems/fusefs.fs/Support/uninstall-macfuse-core.sh

MacFUSE Uninstaller: Sudoing...
Password:
MacFUSE Uninstaller: Can not find the Archive.bom for MacFUSE Core package.

Alas, if you upgraded to OSX Lion and MacFuse was previously installed, a LOT of garbage was left around. Kind of makes you wonder, why Apple still has no package management system, but I digress...

$ brew uninstall fuse4x
$ brew uninstall sshfs
$ rm -rf  /usr/local/include/fuse
$ rm /usr/local/lib/libfuse_*
$ sudo rm -rf /Library/Filesystems/fusefs.fs
$ sudo rm -rf /System/Library/Extensions/fuse4x.kext/

Hopefully, I'm not clobbering anything too important that actually worked before now. I check for anything else fuse related:

$ find / -name "*fuse*" -print
/Applications/Custom/expandrivencsu/ExpanDrive.app/Contents/ExpanDrive/fs/fstools/fuse.pyo
/Applications/Custom/expandrivencsu/ExpanDrive.app/Contents/Resources/com.expandrive.ExpanDrive.exfs.components/libfuse.dylib
/private/var/db/receipts/com.google.macfuse.bom
/private/var/db/receipts/com.google.macfuse.core.bom
/private/var/db/receipts/com.google.macfuse.core.plist
/private/var/db/receipts/com.google.macfuse.plist

AHA! That explains where my MacFuse install came from! It was a stowaway on a tool I had used to support a client project! Well, expandrive can be trashed with CleanApp. I plug the com.google.macfuse receipts as well:

$ sudo rm /private/var/db/receipts/com.google.macfuse.bom
$ sudo rm /private/var/db/receipts/com.google.macfuse.core.bom
$ sudo rm /private/var/db/receipts/com.google.macfuse.core.plist
$ sudo rm /private/var/db/receipts/com.google.macfuse.plist

OK. Time to start over.

$ brew install fuse4x
==> Cloning https://github.com/fuse4x/fuse.git
Updating /Users/myname/Library/Caches/Homebrew/fuse4x--git
==> Checking out tag fuse4x_0_8_13
==> autoreconf --force --install
==> ./configure --disable-debug --disable-static --prefix=/usr/local/Cellar/fuse4x/0.8.13
==> make install
/usr/local/Cellar/fuse4x/0.8.13: 16 files, 728K, built in 35 seconds

$ brew install sshfs
==> Cloning https://github.com/fuse4x/sshfs.git
Updating /Users/myname/Library/Caches/Homebrew/sshfs--git
==> Checking out tag sshfs_2_3_0
==> autoreconf --force --install
==> ./configure --disable-debug --prefix=/usr/local/Cellar/sshfs/2.3.0
==> make install
==> Caveats
Make sure to follow the directions given by `brew info fuse4x-kext`before trying to use a FUSE-based filesystem.
==> Summary
/usr/local/Cellar/sshfs/2.3.0: 6 files, 116K, built in 10 seconds

$ brew info fuse4x-kext

fuse4x-kext 0.8.13
http://fuse4x.org/
/usr/local/Cellar/fuse4x-kext/0.8.13 (5 files, 304K)

In order for FUSE-based filesystems to work, the fuse4x kernel extension
must be installed by the root user:
  sudo cp -rfX /usr/local/Cellar/fuse4x-kext/0.8.13/Library/Extensions/fuse4x.kext /System/Library/Extensions
  sudo chmod +s /System/Library/Extensions/fuse4x.kext/Support/load_fuse4x

http://github.com/mxcl/homebrew/commits/master/Library/Formula/fuse4x-kext.rb

$ sudo cp -rfX /usr/local/Cellar/fuse4x-kext/0.8.13/Library/Extensions/fuse4x.kext /System/Library/Extensions

$ sudo chmod +s /System/Library/Extensions/fuse4x.kext/Support/load_fuse4x


$ sshfs myname@mysite.me:  ~/mnt/mysite.me

Finally! Everything just worked! Satisfaction!

Going to Compass

2011-11-09T09:39:00.000-08:00

A new home page for me, myself, and I, is posted at http://mitch.amiano.agilemarkup.com .

After playing with some ideas about a canvas toy and Javascript managed page, I decided to stop screwing around with it. There is still a "play" page, for silly toys, but the rest of the site uses good-old, straightforward HTML5 content and CSS3.

The intent wasn't to do anything too flashy (as if I'm capable of being that flashy), but to at least show off some of the technologies I use or have used, and to put out a general call to action (hire me!)

After putting up a few more pages I realized I'd be wasting a lot of time futzing around with the CSS rules. The problem isn't one of mere file organization, but of the brutally redundant information spread among the style rules themselves, and the interdependencies among the rules.

A common software technique for managing increasing complexity is to modularize. Yet CSS provides no meaningful modularization mechanisms. Splitting style rules into separate .css files is a trivial, almost valueless, proposition, because the cost of keeping up with which rule is (or is not, or should be, or should not be) in which file overwhelms any benefit from separating the rules appropriate to each page. The problem of repetition of semantic-less constants and interaction among rules also still remains.

Managing style rules as CSS syntax in files, even with an IDE, is a waste of time. Yes, people pay for it, but it is still time wasted. We can be cleverer than that.

Compass, or more precisely, SASS, provides a meaningful modularization and refactoring syntax layer. SASS is a kind of algebra for CSS, allowing you to identify patterns and factor out common variables. Compass is the tool that makes it feasible to use.

First step: get Ruby. Since OSX runs my development machine, and I use RVM to manage the scripting engines and gem components for development, I've already got Ruby. But I do need to chose which Ruby and gemset I'll use:

cd ~/workspace/mitch.amiano.agilemarkup.com

rvm gemset create agilemarkup
echo "rvm use ruby-1.9.2@agilemarkup" >.rvmrc

Next step: get Compass. I tend not to like it when components for one project pollutes another project, and hate the hassle of manually figuring out component dependencies, so I'm going to use Bundler to make the gem dependency explicit:

cat < Gemfile
source 'http://rubygems.org' 
gem 'compass' 
EOT
bundle

Running bundle will fetch the Compass gem and any other gem component dependencies needed to use Compas' features.

Now, Gemfile and .rvmrc are specifications of the toolchain that supports the publishing process. Those are pretty high value bits, so they should be version controlled. I use GIT, so yeah, that's easy:

echo "Gemfile.lock" >> .gitignore
git add Gemfile .rvmrc .gitignore
git commit -m "add Compass to manage stylesheets"

The Compass gem installed, it is time to set up the basic framework of files in the working tree:

cd ..
compass create mitch.amiano.agilemarkup.com

cd mitch.amiano.agilemarkup.com

There is a load of stuff created:

directory mitch.amiano.agilemarkup.com/sass/
directory mitch.amiano.agilemarkup.com/stylesheets/
   create mitch.amiano.agilemarkup.com/config.rb 
   create mitch.amiano.agilemarkup.com/sass/screen.scss 
   create mitch.amiano.agilemarkup.com/sass/print.scss 
   create mitch.amiano.agilemarkup.com/sass/ie.scss 
   create mitch.amiano.agilemarkup.com/stylesheets/ie.css 
   create mitch.amiano.agilemarkup.com/stylesheets/print.css 
   create mitch.amiano.agilemarkup.com/stylesheets/screen.css

Finally, get Compass to watch the directories and process any SASS files that change:

compass watch &

That's it! I'm all set for refactoring my stylesheets.

When a UI is too smart for our own good

2011-10-24T08:47:00.000-07:00

I'm tearing my hair out at Apple's latest user experience faux pas: gestures on the desktop.

Now, they seem really cool at first. But a few of the gestures really interfere with my experience in incredibly painful ways.

The most painful so far, is the idiotic choice to make a rightward swipe equivalent to the Back button on the browser. This is such a completely brain dead idea that it actually makes me question the competence of Apple's UI team.

Years ago, some other patronizing UI designer decided to make the Backspace key an alternative trigger for the Back button action. The overloaded behavior meant that countless almost-completed forms were at risk of being wiped away by an obvious response to a typo.

Yes, there are programmatic workarounds, but they shouldn't be needed. Backspace-As-Navigation-Button is a potentially destructive action tied to a control that has a completely different function, and that is

JUST PLAIN WRONG

Apple not only did not learn the lesson that overloading controls is a really bad thing to do, it copied this egregious example of pathological UI design and made it worse by tying it to leftward scrolling.

Fortunately, Apple does give the ability to turn off the gestures. Just go into System Preferences, into the Trackpad settings, and choose More Gestures. Uncheck the Swipe between pages checkbox, and your experience in browser forms will be much less problematic.

Mac Marginalia

2011-10-05T09:43:00.000-07:00

I'm fiddling with getting my resume up on my Web site, and getting diverted by sundry tweaks.

Might as well note the tweaks here, as they seem to be handy.

This Picture Has Nothing to do with the post.

The resume is kept in a git repository. The repos are all kept under ~/workspace (and sometimes mirrored to GitHub, Dropbox and/or pushed to the Web.)

Problem:

Dropbox appears in the Finder "Favorites" sidebar, but ~/workspace does not.
So I go looking for it repeatedly.
That's annoying. What to do?

Solution:

Open a Finder window.
Navigate to ~/workspace.
Press Command-T to add ~/workspace to the Favorites list.

Problem:

git status in a terminal shell window at ~/workspace/resume reveals a .DS_Store file.
Mac OSX pollutes folders with .DS_Store files to hold Finder information. Call 'em lazy.
That file doesn't belong in the repo. That's annoying. What to do?
If you remove the file, it will just come back. That's annoying. What to do?

Solution:

Go to the terminal shell at ~/workspace/resume
echo '*.DS_Store' >> ~/.gitignore_global
git config --global core.excludesfile ~/.gitignore_global

Problem:

"Opinionated" as a Professional Practice

2011-09-27T16:18:00.000-07:00

I hear programmers tossing the word "opinionated" around a lot these days.

Usually, it is used to characterize a development library or framework, as in,

Rails is an Opinionated Framework

So why is it that "opinionated" also seems to be used as a euphemism for hard-coding, discrete variables and subroutines, avoidance of data-driven process, or otherwise representing decisions as fixed structures in the code?

An old rule of thumb in engineering is, that the earlier in the fabrication that decisions are fixed, the deeper and more wide-spread is the impact. Regardless of the decision's impact as a cost saving or increase, making a decision early causes a cascade of ripples throughout the system. That's the trouble with being too opinionated: you have already made decisions prejudicially.

Researchers of old used to say that you should build one (or two) to throw away. Perhaps the tendency of programmers to be too opinionated is why. Perhaps it is also why so much of today's hot newest Web coding technologies appear to be legacy code before they even get released.

MacOS X Lion XCode 4 madness

2011-09-27T09:23:00.000-07:00

Ah, I'm going utterly insane with frustration. After sitting down two hours ago to start doing some coding, I found that my upgraded Lion system with Xcode 4 has a mysteriously broken command terminal:

MacBook-Pro:~ user$ clear                                                             
terminals database is inaccessible

Wha ???

Now, if you go looking at forums, a lot of them are going to say something like "check your TERM" or "try removing your dot files temporarily", or some such. That's misdirection, based on someone hacking together a Linux environment. This is OSX, and I haven't been hacking my environment recently.

Seems that either the Lion upgrade or Xcode 4 screwed something up. An Ubuntu posting on Stack Overflow discusses the cause of the problem, a missing terminfo file (/usr/share/terminfo/78/xterm-256color). I go into Time Machine to investigate, and lo and behold, there is no /usr.

#$@@$%@$!!!

Mac OSX apparently hides UNIX files. Where's the UI setting for that? Um, well, the folks at Apple decided that magically hiding files should be managed by a magical switch:


MacBook-Pro:~ user$  defaults write com.apple.finder AppleShowAllFiles True
MacBook-Pro:~ user$ killall Finder

(Really, Apple? Why is there no UI? The man page detritus has no indication of what the actual settings are. So much for UI discoverability, but at least some of the info is documented, and thanks to Google and places like Stack Overflow it can be found.)

I go to restore the file, finding it a couple of weeks back. Unfortunately, Time Machine still won't show UNIX directories in its file browser. The original location (/usr/share/terminfo/78) isn't visible as an option. I copy it manually. Stupid.Magical.Finder.

Note to the person on the Xcode 4 team that decided to do the cleaning up: multiply the time wasted that by all the developers you tripped up, and your one mistake probably comes out to hundreds of hours, not to mention the systems that now have crippled terminfo files.

Nokahuna and That Other task manager

2011-09-22T08:08:00.001-07:00

The name of that other task manager is Trello. Even though the name is forgettable, it offers some interesting features. Things like auto-updating, and a very strong visual metaphor.

In contrast, Nokahuna has a kind of 1950s style - the pastel lime green made me think of the worn out Formica of some old diner out in the middle of some old, mostly abandoned downtown.

To be fair, Trello isn't visually stunning itself. But it does offer a more chunky version of the todo list. The metaphor is one of pinup boards with cards stuck to them, and highlighter colors used for labeling. It is not an unpleasant departure from the creamy, everything-runs-together-until-your-eyes-bleed shtick that dominates almost every project management system and todo list manager under the sun.

Unfortunately, in it's current incarnation Trello doesn't work well on my iPad2. There was a "transport unavailable" error on every page... I doubt that the auto-updating feature works as expected... And whatever they did to code up the browser UI, it has jerked up the touch events to the point that every action requires at least two touchdowns to register one.Some things that were pointed out in the welcome board simply did not work, like Drag and drop, or the elusive user manual (um, where is it exactly?)

That brings me to the last feature that seems to be missing: the ability to delete your account. Trello doesn't give you that option. It seems that some users adopted the practice of appending "delete" to their screen names. Maybe that is in the missing manual.

So I turn my attention to Nokahuna. First issue up: the welcome screen offers me (an iPad2 user) to view a Flash based screen cast. Not exactly the best first impression.

The rest of Nokahuna reaffirms my initial style impressions.... This _is_ an old dive. There are no frills in Nokahuna, and for the most art that is a good thing. It is a task list manager, and that is it. Teams with fixed functional roles for people may find the minimalism a little too simple, but I can see the appeal to Agile folks who collaborate as independents or in a tiny cross-functional team.

For visual metaphors, Nokahuna is much weaker than Trello. It is unremarkable and like a dozen other tiny todo list tools I've seen, hacked, or used in the past 20 years. This isn't a remark about the minimalism, but about the absence of pleasant variations and of the tired look to the thing. For all the weird stuff that cropped up on my iPad2, Trello is still more attractive. A name like Nokahuna raises expectations a little higher, and the visual appeal of a list just doesn't meet that expectation.

Summary: I'm sure both work well enough on a desktop browser. Trello aims at being multi-platform, but doesn't seem to have reached that goal in practical terms. Nokahuna is the more minimal of the two, perhaps too much so; Trello is more feature filled, almost trendy. Minimalism aside, Nokahuna still needs a facelift.

Conundrum, a sample of UTF-8 in Ruby 1.9.2

2011-09-21T18:51:00.000-07:00

Posted to Github as this gist.

# encoding: utf-8

# conundrum.rb

alias :λ :lambda

alias :Ω :abort

module Enumerable

alias :⇔ :collect

alias :∉ :reject

alias :∈ :select

alias :∫ :inject

alias :∀ :all?

alias :∃ :any?

end

class Array

alias :× :each

alias :⊠ :each_index

alias :≡ :eql?

alias :∋ :include?

alias :∪ :|

alias :∩ :&

end

%w(a b c).× do |letter| puts letter; end

%w(a b c).∪ %w(x y z) do |letter| puts letter; end

%w(a b c).∩ %w(c y z) do |letter| puts letter; end

a = λ {|s| puts s}

a.call('test')

Ω "It is the end"

I miss my Spaces

2011-09-21T11:00:00.001-07:00

I'm sure the NC DOT has its reasons for designing roads that induce drivers to switch lanes constantly or be forced into turn-only lanes. But having a reason is not the same thing as making a good choice or making acceptable trade-offs.

I'm sure Apple has its reasons for removing Spaces from OSX Lion and replacing it with Mission Control. But they went all NC DOT in the process, forcing desktops into a single lane. The result is a system which is more difficult to navigate and less functional than its predecessor.

How can the seemingly simpler Mission Control be harder than the two-dimensional Spaces? Well, Mission Control isn't actually simpler. Like an NC DOT onion-skinned road design, the user is forced to shift their attention from getting to an objective destination, to a forced choice problem of avoiding undesired exits.

Forcing choices on people in an interface is good when the options are potentially equally valued, and you need to determine a preference. Forced choice is a terrible thing when there is no need to determine the preference, or when there is no preference.

Spaces could be used to eliminate the need to search, by using the brain's natural inclination to remember details based on physical location. Mission Control turns the direct access ability of Spaces into a linear scanning process.

I'm sorry, Apple, but Mission Control is a big time FAIL.

Interesting Ruby Tidbits

2011-09-20T21:14:00.000-07:00

In Ruby,

@@var class variables are shared between the class, its instances, and any extended classes; thus they act like globals within a superclass' hierarchy.

do...end blocks bind at a lower precedence than { .. } blocks; thus,
p a.map {|s| s*2 }
p a.map do |s| s*2 end

"string" is equivalent to %(string) and %Q(string), but the latter two allow nesting of quote characters without special escaping

To get a list of user methods from a subclass, use the cls.methods method and subtract the base class method list from the class method list.

If you use the default argument to Hash.new("default"), the value gets shared among all defaulted hash entries, so assignment to any of them will change all of them. Use the block form of default initialization instead: { |h,k| h[k] = "default" }

To Quote or Not Two Quotes, Taht Iz Dah Qvestion

2011-09-16T10:49:00.000-07:00

In C, when one needed to insert a special character or ensure a regular character was interpreted as-is, one would use the backslash character (for those of you in Rio Linda, that's the '\', not the forward slash '/'), like so:

\n
\"
\\

In Ruby, supposedly you can do the same thing. The exception is that in Ruby, the action of the backslash is restricted within single-quoted strings. That is,

" this is a quote: \"" (length 18)
' this is a quote: \'" (length 19)

Be mindful of your escaping, you could be escaping too much, depending on the type of quotes you chose. This often caused trouble in our RSpec tests, particularly when Capybara "have_content" matchers were involved.

Once Bitten, Twice Shy

2011-09-14T08:39:00.000-07:00

Got bitten but the Ruby Constants Are Not Constant bug again. Actually, it was in the same part of code that I'd found it before, only dealing with a portion of a hash a bit more deeply nested.

SOMEHASH = {
:elem1 => {
:props => [ :a, :b, :c ]
},
:elem2 => { }
}

hash = SOMEHASH.clone
# replaces SOMEHASH[:elem1][:props]

hash[:elem1][:props] = hash[:elem1][:props].shuffle

I know, you Rubistas are going to say it isn't a bug; that it is just my naivete; that in Ruby, deep structures like nested arrays and hashes contain references to objects that do not change but the objects that are referenced can mutate.

What is happening here is that the anonymous hash (the object pointed to by the key :elem1) is not being copied. Its reference is what is copied. So shuffling and replacing one of its members (:prop1) necessarily changes SOMEHASH[:elem1].

One approach is to freeze the hash, but you'll end up forcing your app to abort when it tries to manipulate values. In our app, we were creating copies of elements and shuffling them. The problem being that our copies weren't really full copies: they contained references to the objects still in our original "Constant" hash.

And Matz might argue that it is not surprising, once you understand the details well enough. But it is still undesirable. I find many aspects of Ruby to be elegant, but not this one.

A more gruesome, brute-force approach is to deep copy the hash by serializing the data to a stream, and marshaling it back into a new hash object. It is a one-liner, but that one line is doing a lot of work in order to copy an hash.

def deep_copy(hash)
  Marshal::load(Marshal::dump(hash))
end

PHP Considered Inelegant

2011-09-11T13:01:00.000-07:00

I'm looking at this year's SparkCon (2011) and noticed that the server had vomited on the sidebar. SparkCon's site apparently uses PHP to parse XML, and the parser threw an uncaught exception:


Warning: SimpleXMLElement::__construct() [simplexmlelement.--construct]: 
Entity: line 1: parser error : 
Start tag expected, '<' not found in /home/sparkcon/www/www/wp-content/plugins/gcal-sidebar/gcal-sidebar.php on line 369

Well, I'm not picking on SparkCon - it looks like a fantastic set of events - but increasingly I'm feeling less and less tolerant of those kinds of fit-and-finish flaws showing up when I'm interacting with a Web site.

Imagine what you would feel like if you were meeting a new business associate to chat at a cafe, and while you were talking they said "hold on...", unzipped, reached inside their undergarments to adjust themselves, scratched around for a while, and then tried to resume with "ok, go ahead".

We are all human, but some people are just more circumspect than others. That's why, intuitively, PHP rubs me the wrong way: inelegance.

Update: I'll give two examples. First, PHP's over-reliance on special characters and strings of special characters as operators in the syntax (from its Bourne shell -> ED/AWK/SED -> Perl heritage); and second, its concomitant reliance on gruesomely ugly idiomatic expressions for expressing trivial relations and operations. Neither of these PHP characteristics adds value to the solutions; both detract considerably from the readability of the code and add excessively to its code length. Since code-length is a correlate of error injection rate, PHP is objectively a worse basis for making an investment in code.

I'm not sure if PHPs inelegance is entirely justified as a conclusion, but PHP isn't alone. PHP lacks the charming Rube Goldberg contraptions of Ruby metaprogramming, elegant to some but a sham to others. Perl is its ugly older brother, so ugly that it almost goes all the way around the ugly clock with one liners that appear elegant for how tightly they can compress their ugliness. And as bloated as the JVM platform has become, Java was not a particularly elegant language even when it started. JavaScript is like a fractured gem: turn it one way, and it looks elegant, turn it another and the flaws ruin the illusion. And then again, the apparent elegance of a language is not always sufficient to offset poor run-time performance. PHP is just the scab I'm picking at today.

See also this tongue-in-cheek comparison.

Passion Considered Harmful

2011-09-09T15:05:00.000-07:00

I had a discussion with a colleague recently, and she was telling me about work in the university. As we parted ways, she quipped that for those university jobs, one really "needed to be passionate about education."

I'm sure that she was serious, and in some ways it is true. I'm also sure that there over 50% of the people working in those jobs who could be said to be less than passionate. Middle-manager dreary even. I've seen those people at work, and the utter banality of their expressions is sometimes just torturous to watch. So naturally I'm a little confused by the apparent contradictions.

My question is, why?

It is important to be committed to what you are doing. My question is why is it necessary to be so passionate that you never stop to think about whether it is important or good. We could save a lot of really worthless economic activity, not to mention heartache and grief, with a little dispassionate introspection.

Should we encourage teens to join the sex industry, since many teens are passionate about sexual activity? Passion is not the source of commitment.

Nor is passion a necessary outcome. I want my doctor to be keenly interested in his profession, to be dedicated and deeply involved in whatever it is that he specializes in. But I don't want him to have an unusual excitement, enthusiasm, or compelling affinity for his mode of treatments above alternative protocols that are equally valuable.

A doctor's attachment to his specialty should not cloud his judgement about your specific situation. Passion is a fog to judgement, a useful motivator but deadly without restraint.

Besides which, people lie about being passionate. They especially exaggerate their passions when it is perceived to affect their job prospects. Sometimes, a pretense of passion can indeed turn into the real thing. Yet the incessant drumbeat for passion has become such a common refrain that it has corrupted and colored the very message it was meant to filter.

Professional actors are paid to present a pretense of passion. Such passion is hollow at best - a clever deception for our own amusement - but it is all too common to find people who can act a passionate role with excellence but have little value for honesty and integrity.

In marriage, passion without honesty, integrity, and commitment is just a precursor to divorce, or worse. Passionate actors poison their relationships.

Passion shouldn't be an acid test. It shouldn't even be the first thing you look for. Look for healthy relationships instead. When you find them, the passion will grow out naturally.

Marginalizing Your Peers

2011-09-08T14:11:00.000-07:00

I'm reading a blog by S. Iannarino, in an entry titled "No Garbage In, No Garbage Out." Now, Iannarino's material is a little above the fold compared to some sales and marketing pieces, but it is still more pop psychology than rocket science. Among the pithy aphorisms and exhortations, Iannarino repeats a few recommendations I've heard often. Just as often, they give me pause.

One of his exhortations is "avoid negative people." Now, on the surface, it seems quite reasonable, even almost natural. An uplifting environment and the comfort of intelligent, positive peers is definitely better. But it has always bothered me a little bit that what the pop-positive-psych-preachers propose to get there, is essentially that we abandon those most in need just so we can protect a personal pie-in-the-sky mental state.

Think that's too extreme? Am I being too negative?

What does this recommendation say about how you should widows, orphans, poor, under/unemployed, sick, those coworkers nobody really knows well, or some minority class of the disenfranchised? No, I'm not writing here of abstract groups who see themselves as victims, but those real people that you contact that actually have stresses and struggles. Their coping mechanisms don't always compensate.

What this advice says, essentially, is "Let them go to Hell, so I can pretend I'm in Heaven."

Selfish rule making like this is one of the reasons why a Sales and Marketing mentality is so bereft of ethical standards, and why honesty, transparency, and trust are so much harder to come by in the business world. By narrowing their own focus based upon their own personal dogma, they marginalize their neighbors.

They are also probably discard the wisdom of more realistic minds. A study I read suggested that depressive tendencies in kids is usually associated with a more accurate self-assessment, than of more up-beat peers.

Put another way, knowledge isn't always as uplifting as it is made out to be. The fruit of the tree of knowledge may have been a way of opening the eyes to good and evil, but it also had the effect of excluding its consumers from a garden of ignorant bliss. Ignoring people who complain may be wise; but conversely you may also be ignoring their wisdom.

There is a place for assertiveness when dealing with people who have trouble coping. But it is not assertive to avoid people just because they challenge your world view, force you to consider risks, account for costs, or consider consequences. No, that is far closer to passive-aggressive cowardice.

There is no particular place in Hell reserved for those who choose to close their own ears to other's sorrows. As Jesus said in the Book of Luke (10:25-29), empathy is required for salvation. So if you're a believer who follows this sort of guidance and marginalizes people out of a sense of protecting your personal belief system, your belief isn't a free get-out-of-hell pass. Even if you're not a believer, there's no magikal taboo protection to be had in that sort of positive psychology.

Don't Abandon. Learn to cope with the negativity. Help others to see past their own limitations, and mentoring those who can accept it by teaching them better coping mechanisms.

Running cars on zinc

2011-09-06T09:30:00.000-07:00

The federal government has been pushing hydrogen research, and after looking over several research papers I'm astounded at how complicated approaches seem to take all the attention. It is as if people are more interested in playing with science than with solving practical problems.

One concept that caught my eye was an Israeli solar project, which proposed a zinc/zinc oxide/water/hydrogen cycle. Even there, extreme heat is used in the process of reducing water to hydrogen. Six hundred degrees may me manageable, but it isn't really necessary.

But is the zinc process practical? Well, a gallon of gas is equivalent to about 1kg of hydrogen. Hydrogen weighs about 1.01g per mole, so it would take about 990 moles of H to get the power of a gallon of gas. You need one mole of zinc to release two moles of hydrogen from a mole of water, or 495 moles.

Since zinc weighs in at 65g per mole, you'd need 32178g of zinc to liberate enough hydrogen to equal a gallon of gasoline. So now we are talking about 70 lb of zinc in a powdered or slurry form. That's not counting the weight of the water you'd have to consume. The weight of 495 moles of water is about 8910g or 20 lb.

It would take 10 gallons to provide for a typical commuter vehicle. Carrying around a 900 lb tank of zinc and water doesn't seem at all a good trade off to a 10 gallon gas tank. Gasoline itself weighs in at about 90 pounds.

We could do the same sorts of computations to find that aluminum or magnesium would cut the weight by somewhere around 2/3rds, or around 300 pounds, which is certainly more competitive, although either metal would require more energy to reclaim.

Git's Poor Command Line Habits

2011-09-02T14:59:00.000-07:00

Tom Lord's Arch, or 'tla', was one of the first open source distributed version control systems. It was widely criticized as having overly long names and convoluted command line interface. Linus's Git has shorter names, but the command lines can be just as perverse.

Take, for instance, the command to set the repository back in time by one commit:


git reset --hard HEAD^

OK, what's up with that? It was not necessary at all to introduce a idiosyncratic tree walking syntax just for Git ?
Seriously??

[edit: not to mention, git reset is as dangerous a command as rm * for pretty much the same reason.]

In Git, the HEAD^ shows the parent of the HEAD commit. But wait, there's more!
Use HEAD^^ to see the parent of the parent of the HEAD commit, if it exists, or HEAD~3 (that's a tilde, '~', not a hyphen) to show the great-grandparent.

There's not a lot of consistency to the various command line interfaces in Git; most of the commands make use of a mix of positional arguments and labelled parameters and options, which can make the commands rather arbitrary and thus needlessly more difficult to remember. The choice of command names is also rather spurious.

Git has some good qualities, and lots of documentation. But lots of programmers keep complaining that they can't remember what that particular command was they were looking for, and it is evident that with Git it is difficult to infer for many of us to infer the proper semantics based on the syntax of the options. It's not us, its you, Git! You're hard to remember!

Configuring a GIT controlled Web site

2011-08-31T19:18:00.000-07:00

This is assuming you're using a *nix setup for the server, and Mac OSX for the workstation.

First, register your public key with the server's SSH. On a shared host, this would typically be under a control panel icon for Shell Access or SFTP/SSH . Consult your hosting service for details.

Suppose your site is "loli.pops.com" and your user name is "jonathan".

You should be able to log in to your site. Open a command terminal window, and:


ssh jonathan@loli.pops.com

If you can't do that and get a shell prompt, you're hosed. There are ways around it, but that's another post. Knowing how to navigate this level of complexity is a sort of prerequisite... you don't need to know, just know how to find out how to do this kind of stuff.

So, you are logged in to your server, and you create a subdirectory for your repositories, and a directory for your web site or app:


mkdir -p ~/repositories/loli.pops.com.git

You initialize that directory as a "bare" git repo. (A bare git repo has no modifiable source files present, just the repository metadata and data files). This will be the repo you will stage changes to immediately prior to deploying:


cd ~/repositories/loli.pops.com.git
git init --bare

Now, you switch to another terminal, either another window or a tab. Create and/or change your to the working directory for your lili.pops site:


mkdir -p ~/workspace/loli.pops.com
cd ~/workspace/loli.pops.com

Now, at this point, we're assuming that there are oodles and oodles of cool source files with names like "index.html" and "flavor_picker.js" just sitting around in ~/workspace/loli.pops.com.

We can (we should, nay, we must!) turn the directory into a git repo (a non-bare repo with source files, that is):


git init
git add .
git commit -m "initial commit of loli.pops.com content"

This is the really weird part:Git links up repositories very loosely. Git keeps data about the sets of files that are changed, which it calls a "commit". These commits can be pushed by you to bare repositories, or pulled by people working with you into their own repositories.

So people contribute independently. Note also, that it isn't necessary for everyone to have complete and utter exposure to all of your files.

Let's link our repository to the bare repository on the server:


git remote add staging ssh://jonathan@loli.pop.com/homes/jonathan/repositories/loli.pop.com.git

# (Uhhhh.... long line folding is making this look wrong. It should all be one line.)

What we are doing here is simply making an association between a local label "staging", and a url that points to the server's repository. In this case, we're using the SSH protocol to make the link. Since we provided a public key, we aren't going to be asked for a password in the next step.

The next step is to set up a branch on the remote that will track our local main line branch, and copy our changes to it:


git push staging +master:refs/heads/master

The "+master:" part means "create a master branch on the remote repository".
The "refs/heads/master" part means "compare the remote branch's references to references from the local head master branch".

Once that association has been made between the local and remote repositories, the command to push our changes is much simpler: we just refer to the label we used ("staging"):


git push staging

Go ahead, repeat that command. You should see:


Everything up-to-date

At this point, all we've done is pushed changes to a remote repository. No one can see our files because that remote is "bare" -- there is no working source tree. The most obvious way to deal with this is to go to the server and ask git to pull out a copy of the working files into some web root location.

Switch back to your SSH command window, and checkout the changes on the server:


GIT_DIR=~/repositories/loli.pop.com.git GIT_WORK_TREE=~/public_html/staging/latest git checkout -f

Here, I'm assuming that you use public_html/staging/latest as a location to push your changes to before they've been finally released.

Now, that's all that is necessary, but we can streamline the process by automating that last step. There are two ways to do this. One is by way of a shell script, which I'll call "deploy":

deploy.sh:
user = ${1%%@*}
server = ${1##*@}
branch = $2
git push $server $branch
ssh ${user}@$server "GIT_DIR=~/repositories/loli.pop.com.git GIT_WORK_TREE=~/public_html/staging/latest git checkout -f"

Well, that's a rough guesscript. It looks like it would work, but I haven't tested it.

Another way is by a Git "hook". Go to the SSH window, and run the following:


cd ~/repositories/loli.pop.com.git
cat > "hooks/post-update" <<EOT
GIT_DIR=~/repositories/loli.pop.com.git GIT_WORK_TREE=~/public_html/staging/latest git checkout -f
EOT
chmod u+x "hooks/post-update"

Now, whenever you do a git push staging, the post-update hook on the server will do the checkout for you.

Note: if you are deploying applications, you probably already use a .htaccess file or alternatives to hide or block access to resources that aught not to be exposed on your site.

A case for web site Minimalism

2011-08-21T19:53:00.000-07:00

It has been several months since my old Joomla based site was hacked. At the time the workaround was to put up a static placeholder page, with minimal contact information on it. It seems as if the time has come to revisit the site, now that I'm again on the prowl for more work.

While I endeavor not to lose focus, too many questions arise. "Why?" for instance. My Web site has never been a source of clients. For technical communication purposes I blog here, and for project work I use external services like github. There is just a little bit of lie to the oft told tale that a business "needs a Website".

What a business needs is a reputation. A Website is just one location people expect to help them inform their own opinions. Most people don't bother to read, let alone dig around for information, so unless a bit provides some meaningful novelty that contributes to your reputation that bit should be discarded.

And that's just information on a static site. Bits in database driven CMS sites come with much higher initial costs, a greater ongoing maintenance burden, and unmeasured risk exposures. Is a PHP content management system a worthwhile expense? Maybe. Is it an investment in an asset? It could be, if your brand is worth something. But from a technology perspective most CMS systems present more of a liability than asset.

Debugging Consoles with Ruby

2011-08-18T19:10:00.000-07:00

In ruby the debugger is not nearly as nifty as the console. Fortunately, there is https://github.com/pry/pry, a gem that provides an embeddable console. In the simplest terms, Pry provides real-time access to your program's state through a Read-Eval-Print-Loop, much like Rails' console.

I've been a shell programmer for most of my working life, but I've never, ever, ever, been a fan of REPL user interfaces. They suck. Readline interfaces are fine for shell tools, but there's no particular reason the user interface has to be line-oriented.

One of my first computers, an Atari 130XE, had an interesting editing interface for prototyping code. It kept lines in a buffer, and supported both immediate execution (of un-numberd lines) and editing (of numbered lines). Buffering, baby, buffering! That's the difference between a 30 year old 8k BASIC console and a modern Ruby console: in-place editing.

But wait -- we can get a first approximation of in-place editing by cleverly hooking in an editor component. A quick search turned up two possibilities: http://sketches.rubyforge.org/ and https://github.com/jberkel/interactive_editor . I gave the interactive_editor gem a try.

To summarize, in a Rails 3.x app, you would just add the two gems to your Gemfile, run bundle, and then embed the expression

binding.pry

in your code where you want the console to open.

There are a few other details. The vimcast has some useful tips on setting up the interactive_editor, for instance, to make sure you get nice colorization turned on. But after that, using it is a breeze. Just use

vi

to open a vim editor into a temporary buffer. When you save and close, the console will run your code. Running vi again will reopen the last temporary file. It's a VEPL, a Vim-Eval-Print-Loop.

But even more interesting for debugging, you can use the editor to work with objects through YAML representations. Just add ".vi" to the end of an object, and your vim editor will open with the YAML. For instance, in UserController#update, I might do:

@user.vi

You get something like this:

  1 --- !ruby/object:User                                                                                                                                                             

  2 attributes:

  3   id: 2

  4   email: mitch.amiano@agilemarkup.com

  5   encrypted_password: $2a$10$s/NKiMEC1UfHzgG5JlCCJuHpZbAZ77dz623rq6gt12YUqW7RpvoWW

  6   reset_password_token:

  7   remember_token:

and so on (except, nicely colorized if you followed the vimcast).

Not only is it much easier to look at and inspect than a puts or the debugger's "p" output, but the YAML is a mutable representation. Editing it, saving and closing will modify the in-memory object. You could do this sort of hot debugging already, but the editor makes it a lot easier to visualize, and lets you tweak multiple properties in one step without having to type any code.

Is DRY a little wet? Part 2

2011-08-16T21:51:00.000-07:00

A more fundamental fallacy behind DRY is the illusion of orthogonality. That is, hierarchical categorization is by and large achieved through a self-imposed discipline. Even where structural relationships are apparently observable in physical, neither the naming or the affiliations of parts are essential, intrinsic properties of the system.

Like Feynman's birds, one can know all the names for a creature in every human language, and yet know nothing at all about the animal itself.

I know, I know, it is a fine distinction, possible to the point of splitting hairs. Software systems are systems of logic, and as such they are synthetic human contrivances, are they not? So why can't we just assert that one perspective take precedence, and rationalize that the collection of all properties forms a space with an orthogonal basis?

Well, we can deliberately live in such denial. That's just the kind of linear thinking that has served the scientific and engineering communities well over the past few centuries. It is quite pragmatic in fact.

Yet it is also self-limiting. Eventually, the addition of features causes the system to undergo a phase change, as thresholds are reached in the expressiveness of the supposed authoritative source, and the constructions of the relations from the source to the dependent sinks.

More pragmatically, the fallacy can take root in the form of overt and aggressive over-simplification, in which the developer mistakes a source for a sink, and summarily discards it.

Algebra is the branch of mathematics that speaks to orthogonality, giving us the axioms and theorems by which to formally comprehend how such systems are structured. If we look at a software system as if it were some abstract vector space, this would tell us that there must exist some set of primitive vectors that form a basis for the space. Such a basis need not be finite, but ideally it is free of interdependencies... any one given basis vector cannot be generated by any combination of the remaining basis vectors. Approaching that kind of behavior is an objective of DRY. Improperly identifying the supposed basis, the "single source of information," is the underlying cause of the fallacy described here.

What Algebra cannot tell us, is how will one representation of information varies with respect to another, between stakeholders or over time. It is dead on exact regarding the dependent representations, but an Algebraic system cannot determine its own axioms. The real world is the primary source. In practical terms, this is why normalization, founded though it is on mathematical theory, is yet still a very subjective practice.

DRY must be just as subjective, if not more so, for it is a(n informal) form of normalization. Coincidence in space does not imply connection, and precedence in time does not imply causality, yet it seems to be common practice for some programmers to rely heavily upon such contingent phenomena to "DRY up" their code.

Programmers may even assert that as professionals, they know better than the customer, swapping out explicit distinctive representations in exchange for implicit dependencies upon co-incident data. Doing so may be a useful contingency while prototyping, but it is still a rationalization based upon assumptions. Not acknowledging that it compromises the model, if just a little bit at a time, is personal myopia but more critically this mode of thinking encourages retroactive imbedding of structural flaws.

Dealing with customers over how software should behave is a very probabilistic endeavor, and a world governed by rapidly changing probabilistic entities will only exhibit linear structure as an average over all the events and elements in its history. This indicates that doing "just enough" with respect to comprehending the source representation's dimensions will be a persistent cause of of rework, and a major injector of latent flaws. Yet we don't want Big Design Up Front- the shifting of the problem space makes that an even bigger risk factor. What to do?

I would suggest adopting confrontational forced choice testing whenever a supposed functional dependency is about to be removed and a source eliminated, and it seems the least bit questionable. In an optical exam, a confrontation test forces each eye to inspect a target independently, and a forced choice test is given when corrective lenses are progressively passed through, and beyond, optimal ranges. The idea is to force the subject just a little beyond their capabilities, to better assess the best overall focal corrections to make along multiple dimensions. The candidate bit - the "information source" for removal - is potentially a critical dimension of the problem; what is the strength of the concept in the customer's language? Even if it doesn't have a name, how established is it in the domain? Things the programmer thinks he sees may be his own figments and should be subjected to increased scrutiny as information sources. Ask what would happen if some other information sources were not present or altered after factoring out the candidate bit - if the other source has any impact at all on any one of the dependencies of the candidate it should determine them all, and only together. Functional dependencies cannot be partial. Ask yourself, after removing a candidate bit, have you introduced multiple conditionals where previously there was one or none? The more conditionals introduced, the further the system has become from being based on well-factored information sources.

In general, I lean toward explicit representations of feature information. Code should say what it means, and mean what it says, within the constraints of the expressiveness of the technology. DRY is not a reasonable justification for relying upon coincidence in your code, it is telling us not to multiply factual data or relations unnecessarily in our constructions. We used to call that Occam's Razor.

Is DRY a little wet? Part 1

2011-08-16T20:52:00.000-07:00

DRY is a principle articulated by Agile practitioners (IIRC pragmatic programmers Dave Thomas and Andy Hunt are credited with coining and popularizing the term), which is supposedly often misapplied. Don't Repeat Yourself is the acronym, and the principle is stated as:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

The supposed fallacy that gives rise to the misapplication of DRY is being too narrowly focused upon one particular aspect of the system, commonly a project's source code base. Single-sourcing is the objective, not code reduction.

Now, kudos to the pragmatic programmers, but even more to all those technical writers who worked on single sourcing production processes, and the set-theoreticians who gave us relational normal form practices. If these other practitioners explored single sourcing and orthogonality for decades prior, the development community should be wary about just why it is they themselves as a profession are so late to the game, and what plays they might have missed along the way.

When acting "Professional" is anything but

2011-08-12T16:54:00.000-07:00

There is an interesting antipattern of communication exhibited by many diverse professionals, when dealing with clients, namely, of asserting a direction that one should take even when it works across the purposes or completely against the client's apparent interests.

Two cases come to mind. There is the consulting software developer who does just enough to get by while carefully eliding any discussion of alternatives, consequences, or expectations of future outlays. The programmer exercises creative license when he chooses to build out crude approximations rather than represent the most likely costs and risks of minimally viable features; he walks the line when he continues to avoid generalizing solutions no matter what life cycle stage the system is at; but he crosses over when the customer asks for and expects a certain level of architectural repeatability and well-factored, reusable patterns, but gets point-to-point wired-up, one-off code instead.

There is also the all-knowing expert doctor. Recently, an eye doctor gave a prescription for glasses. I explained to him my difficulties in dealing with a previous doctor -- of being given false diagnoses, and the doctor's refusal to discuss options. Naturally, as an expert, the doctor nodded his head and did an exam, explaining to me the condition of my eyes and recommending progressive lenses. Well, the progressives were weird and unfortunately the optical shop could not get the prescription right. Everything looked trapezoidal with them, and half my peripheral world was always fuzzy. I never purchased the glasses. "That's stupid," I thought, "why would anyone want to live life with such an irritating gimmick making their eyes go buggy?" Explaining this to the doctor, I asked for contact lenses. By now he has put me in a pigeon hole, and instead of giving me a prescription that works, he gives me one fuzzy left contact and one overcorrected right contact. And I can't see anything as clearly as with my old glasses. "Give it two weeks," he says, "I've been doing this for 25 years". Well, I've had my eyes for over 47 years, and I know what I wanted, and it wasn't monocular vision with my eyes going all googley and being out of focus for two weeks. The contacts lasted for two hours before they got shelved.

In general, consultants are trained to think assertively, and the more successful consultants learn to steer clients in directions favorable to their pocketbook. Yet it is easy for that assertiveness and persuasiveness to push one down a slope of ethical blindness. The practice speaks to a lack of trust in the client's ability to look after their own interest, a parasitic paternalism emerging spontaneously from the professional relationship. At best, it leads to willful ignorance of the client's intentions. At worst, the process can bilk the client out of countless hours and lead down a path too costly to maintain.

Apple HFS as a provencial technology

2011-07-23T17:16:00.000-07:00

Mac's HFS+ filesystem is case insensitive. I'm a little disappointed that Apple is so provincial and short-sighted.

$ touch "Amy"
$ touch "aMy"
$ touch "amY"
$ ls
Amy
^ only one file got created
but
$ touch eñya
$ touch enya
$ ls
eñya
enya

So it is OK for some characters to automagically translate but it is not OK for others.

Be very careful when copying files from the Web to a Mac. One supports international alphabets in file names, the other apparently does not.

Pairing for the Imperfect

2011-07-23T17:13:00.000-07:00

Consider System. Faults. Expected Behavior.
Reconsider. How to go from Here to There?
How to make it work.
Maximize coherence, minimize arbitrary decision points.
Now, go.

Have "pair" step in after work is halfway there.
Explain. Rationale rebuffed.
"Need to make it go," is the reason, "need to rethink" is the justification.
Toss out the changes. Then watch as he goes about.

Considering System. Ignore faults as unimportant. Dismiss Expected Behavior.
Substitute bald assertion for consideration. Just enough to get by for now.
Ignore coherence, let number of arbitrary decision points float freely.
Spend more time fixing faults instead of providing functionality.
Repeat.

I've seen that process play out over and over now. Enough to realize that it is a well-defined strategy for playing out a work slowdown while simultaneously playing up to the customer's desire for immediate satisfaction.

Often, after repeating the latter loop two or three times, it dawns that the first path was the right way to go. Except that in a dishonest environment the original authorship will be discarded, the ideas having been surreptitiously adopted by those who were initially dismissive. This is an antipattern that pervades the tech industry.

Spurious environments give spurious results

2011-07-04T21:25:00.000-07:00

I've said before, and will say it again: the suitability of a programming environment (or platform, or language, or technology stack) to a task is inversely proportional to the number of coercive statements you have to use it to get it to behave the way that is intended.

Put another way, if you find yourself trying to trick your computer to get it to do what you want it to do, you probably aren't working with the right mix of technologies.

That said, most programmers must give in to that dark impulse on a daily basis, creating elaborate fictions as it were, because the mix of technologies they must tolerate is often very unsuitable. Sometimes it seems as if the entire profession is working at the level of medieval barbers, just hacking at bits and hoping their patients don't die before paying the bills.

A similar heuristic is that an operating environment will be as predictable (unpredictable) as it is closed (open). Or, stable environments give stable results, and spurious environments give spurious results. You're likely to see this in Web programming when developers fail to grasp the idea of closure, and do not ensure that deployments are provisioned in precisely the same way as development and test environments.

For instance, the difference in a database from version 5.93 to 5.94 is not likely to be very great, but most of the likelyhood of failure arises from the fact that there is a difference, not the particular version numbers used.

I keep running into this issue with a Rails project, because "rake," one of the most central tools in the tool chain, is being treated as a shared component. Rake gets updated from 0.8.7 to version 0.9.2 by the bundler at some point, and things start to break. Fortunately, bundler complains:

You have already activated rake 0.9.2, but your Gemfile requires rake 0.8.7. Consider using bundle exec.

The "bundle exec" thing is a little misleading perhaps, but at least it is actually telling the truth. The punt for now is to gem uninstall rake and remove the 0.9.2 version. The honest solution is to make sure each project gets to see only its own version of rake.

The road less travelled

2011-06-14T04:47:00.000-07:00

I've noticed a pattern. Whether in my coding or homework when I was in school, it felt as if life was playing tricks on me.

Life is full of ambiguities. People use language in ways that leave open all kinds of possibilities, and yet they consider themselves to be honest and forthright. More subtly, they assume that others have perfect knowledge, or unwaivering attention.

And I find that I notice things that others do not. Unfortunately the things I notice are often not central to reaching my goals and objectives. Hyperawareness goes hand in hand with attention deficits. I've been called perceptive, but what it comes down to is that noisy environments are very disruptive to my thinking. Then again, silent and still environments are very sterile and quickly lead to feelings of isolation.

While my attention holds together, I do not seem to decode messages in the same way others do. I have been acused of deliberately misconstruing others' views; one English teacher thought my opinions in a book report was a willful misreading of the text, going so far as to insult me in his feedback comments. It seems as if, when there are multiple possible interpretations (and even when there are not), my brain chooses the one which is least obvious.

Expressing opinion becomes an impractical proposition when your thinking is always orthogonal to that of the people around you. It can seem as if your thinking is always cutting against the grain. It means that the group dynamic works against you, countering your every thought, leaving you feeling drained instead of enlightened.

Seeking out the less traveled road wouldn't be so bad if it were a practical problem solving strategy at an individual level. Mostly, it is not.

Another fine mess

2011-06-13T18:55:00.000-07:00

One of the hardest things about programming is when your eyes betray you. A simple twiddled character becomes an extended debugging session, or hours of meaningless research.

That happened today. I was installing Postgres with Homebrew on my Mac OSX, for a Rails application originally on MySQL. Well, I was getting this:

rake db:migrate
rake aborted!
Please install the postrgesql adapter: `gem install activerecord-postrgesql-adapter` (no such file to load -- active_record/connection_adapters/postrgesql_adapter)

Tasks: TOP => db:migrate => environment
(See full trace by running task with --trace)

If you check Google you see scores of helpful suggestions like these , suggesting that it is a mismatch between the memory model used to build the pg gem, and that used to build the Postgres library.

What can also happen is that you write something like this in your database.yml:

development:

adapter: postrgesql

Egads! Look at the latest changed code first. Then have someone else look at your code. If you don't have a co-operative coworker to lend you a spare set of eyeballs, do a diff on another working file (that's how I ended up finding it). Otherwise all that internet advice is just so much more misdirection.

There was also some other spurious warnings about Rakefile and DSL. It turned out to be a feignt, a minor diversion, quickly cleared up by Stack Overflow. So, yep, maybe Googling is a useful technique, but don't rely on it too much. It cannot make up for a lack of eye-worthiness.

Problems with Pictures

2011-05-18T07:05:00.000-07:00

A client recently sent a use-case document as a requirements specification, and after quite a bit of discussion the team decided that, while it might have been good as an exercise for the client, the result was still a bit far off -- and missed the point that what the project needs is more dialog.

Well, there are lots of other issues there, but I went looking for use-case examples. Alistair Cockburn is a prolific writer on the subject, and his stuff makes sense in so far as one is following a use-case driven approach.

I was struck by the disconnect between the pictographic use-case techniques and the use-case narrative templates. Pictures can say a thousand words, it is true, but strangely enough it can actually be very difficult to vocalize what is presented in use-case pictograms. It not only requires translation, but you have to be a bit of an archeologist and forensic linguist as well, to come up with wording that accurately maps what is in the pictogram. And even then, you probably missed some obscure but important details.

Pictures are great for conveying emotion, giving a fuzzy sense of the breadth and connectedness of parts of the problem, and the intended strategies of a solution. But if they make the reader do extra work or suggest detail that isn't there, that is a bad thing.

Par Fried Programming

2011-05-17T07:12:00.000-07:00

This is a kind of code smell, or more precisely a coding smell.

Par frying is a technique used in cooking french fried potatoes, the goals being to increase the fat content and crispyness of the product. In the context of the fast food industry partial cooking is useful because it reduces the time needed to prepare the product for sale at the retail end-point.

In the context of programming, a par frying is what happens when the coding for a given feature is left with small parts worked on but in an inconsistent and incomplete state, during a given coding session. I find that some technology stacks tend to encourage parcoding more than others.

I would guess that parcoding increases jointly proportional to the dispersion of responsibilities around the stack and the time spent performing tasks not directly implementing the application feature (such as debugging interfaces; working around flaws in the technology stack; testing routine features of the stack; and writing internal documentation).

Parcoding can also increase when you are tired, sick, or otherwise stressed.

Some degree of parcoding is normal... it is the vision we keep in our working memory that allows us to bridge the gap and finish with something that is more than half-baked. But technology stacks and applications are so poorly organized that they tend to overextend the working memory, giving rise to parcoding behavior patterns that will feed back on themselves.

There are greater factors responsible for turning your projects into Yourdon's Death Marches, but leaving things incomplete should only be done if you intend to abandon the code. When you par code, that's basically what you're doing: abandoning a half-baked train of thought.

2011-05-16T08:05:00.000-07:00

Ahhhhhhhhhhh! I just tried to use the VoiceOver accessibility feature of the iPad 2 on an ms word attachment.

Painful at best.

The top and bottom of pages are unreachable.

The Voice is horrid.

And you have to see the words and touch them to get anything read???

A screen reader would be simpler.

Content Libertarianism

2011-05-05T09:42:00.000-07:00

Several months ago, one of my Web sites using Joomla got hacked. It wasn't a particularly important site, and wasn't bringing me in any money or giving me any useful exposure, so the best option was to simply drop the Joomla system and put up a holding page.

Well, the holding page has been up long enough, and I'm thinking through how to do the next site. The problem with Joomla, like Wordpress, Drupal, or any other software-intensive approach to deploying information, is that they degrade at a far too rapid pace to pay back the initial investment, let alone the hidden on-going maintenance costs.

There are many reasons for the degradation. All software contains bugs and security holes, some of which are known by original core developers at the time you, the software user, deploy your site, but many of which are not. Every security flaw discovered in the core software, exposes your deployed site to increased risk of hacking. That discovery process, which happens over time, immediately reduces the value of your site. You have to incur the cost of responding by updating your deployed site with newer software, which contains a whole new set of bugs and security flaws.

In turn, you potentially incur costs to deal with new bugs. If you had made fixes to bugs in the older software version, you will also incur costs to determine whether those fixes to the old bugs are still applicable... such forks to the core software must be backed out if they are incompatible.

The situation is considerably muddied by a general lack of comprehensive revision control in databases and file-system based media (giving non-repeatable and non-reversible operations), and complete absence of testing discipline in many (most?) Web software deployment strategies. The state of the machine at a given point in time is simply not knowable, so we cannot properly evaluate the impact or mitigate the consequences of changes without completely revoking them.

Instead, the profession has attempted to deploy even more software, layering one piece of software over another in order to monitor and control one or another aspect of the deployment. The reality is that it usually falls to individuals to act heroically, if they can, or to pay others to act heroically, which can get exorbitantly expensive.

When your business is on the line, people will pay such costs, but that doesn't change the fact that basically this cost of owning software is a usury fee... a kind of professional protection money to keep the consequences of software bugs off your business' back. The realization that something isn't intrinsically providing positive value, is what gives rise to many clients of a feeling of being extorted. It is as if you went to a doctor to set a broken bone, only to be told that due to the way the doctor chose to set it, you'd have to return to have it reset -- every month for the next 5 years.

Other reasons for the degrading include the relative unavailability of developers skilled in an idiomatic technology; the waxing and waning popularity of the supporting technologies in the "stack"; changes to public services that your system is interfaced to; the fading of the memories of the developers and stakeholders involved in making decisions that determine how the system operates and how it is structured. Most of all, the goals of the organization operating the site usually necessitate changes simply for the sake of enacting a process -- a communication cycle, performance monitoring, marketing program staging and execution -- and these all have the requirement that stuff on the site change.

We call that rather euphemistically "content management", but collectively it is really about changing stuff to do stuff that will accomplish goals. The more stuff we can remove from that universe of discourse, the better off we'll be.

Content Management (sic)

2011-05-04T18:02:00.000-07:00

"Beware," my System's Analysis instructor warned, "of labeling anything with the word management." The rationale behind the warning is that management is a euphemism for "I don't really understand this." Like uttering profanity when you're frustrated. Or a euphemism for profanity (but you still know what you meant). Or not, but still wanting to.

Content Management is one of those substitution profanities. Consultants like to throw this term around a lot, especially those whose job is to glue together processes and procedures to perform management of content. Because if you don't manage content, it will keep taking those long smoking breaks and won't be focused enough to be productive.

Lazy freakin' content. But I digress, and now I'm stooping to using lame profanity substitutions myself. The problem isn't that content lacks self-motivation, nor that it needs to be told what tasks it needs to accomplish for today. We don't even really know what content is, at least, not in any way that distinguishes it from information or data. Or stuff.

Stuff Management is a more honest appellation. Since Management when applied to IT problems is most often a euphemism meaning "stuff," Content Management amounts to Stuff Stuff.

I'm all for creating good abstractions, but Stuff Stuff strikes me as a little bit too abstract for practical purposes, and just a little redundant. Content Management should be jettisoned.

When is Lambda not a Lambda, Part 2: Replacing the Stubs

2011-02-11T04:44:00.000-08:00

In the Ruby programming language, there is a construct called "lambda". In answer to the second part of the apprentice's question, it is called lambda because the developers wanted to give it an air of authenticity, by identifying the construct with the computational theory of lambda calculus. The Ruby developers weren't the first to do this, and won't be the last, and are following in a tradition among computer scientists of borrowing popular labels from one another.

Not that I know enough about the internals to tell whether or not they are justified in their use of the term lambda. What I do know is this: that anonymity has nothing meaningful to do with the computational theory, nor anything really meaningful to add in practice.

What makes lambda special, at least in Ruby, is not that it doesn't have a name. In fact, it does have an identity, otherwise Ruby couldn't pass references to a lambda around as function arguments. Ruby just hides whatever internal identity it maintains for a lambda from the user. Nor does it stop the user from assigning a lambda to a name. Anonymity is completely and utterly irrelevant to the purpose and utility of a lamba.

Where anonymity really comes into play is in the concept of a block, which in Ruby is a syntactic sugar for what other languages might call an inline function.

What makes lambda special is that the enclosing scope is bound to the lexical environment in which it is defined, and that it maintains a calling structure from which the "return" keyword will properly exit. This differentiates lambda from a method which has a scope defined by the object to which it is bound; and from a Proc, which doesn't impose a deeper return nesting... acting as it does as a reference to the otherwise anonymous { block } syntax. Oh, and lambda has the argument signature more strictly checked.

Apparently the implementation is all based off of the kernel Proc class. So Ruby's lambda isn't really much like its functional counterparts; like the "java" in "javascript", the name "lambda" is used more for affect than effect. This is further highlighted by the name pollution, Y combinator gymnastics, and stack overflow surprises one gets into when attempting to use it recursively...

On a side note, one has to give credit for the Ruby community for adding more functional language constructs. The reference implementation of Ruby 1.9 supports tail call optimization as an option.

When is Lambda not a Lambda, Part 1: Conversational Mocks

2011-02-11T04:13:00.000-08:00

One of the apprentices at the office asks

What is this thing called Lambda, and why is it called Lambda?

I'm trying to formulate a concise answer, when one of the more brilliant young developers in the office blurts out

Lambda is just a way to make an anonymous function.

My explanation thus cut short, sticks in my throat. His quip is pleasantly succinct and sufficient to move a pre-teen on to more productive work. I'm sure I came off as ignorant and overly complicated by comparison.

Except that his explanation, succinct though it was, is entirely and utterly

W R O N G

not to mention misleading. Now, the kids didn't really need an explanation, and they got the sort of glossed-over, abstract re-labelling that passes for an explanation without actually being one. Like saying that what makes something a circle is that it is round. It was a mock and a stub, a convenient pretense of understanding that allowed them to conversationally move on without getting bogged down by reality.

Not that he isn't capable of insightful explanations. We're working in Ruby here. He knows better.

Curious Misunderstandings and Other Faux Pas

2011-02-10T19:52:00.000-08:00

Among this week's curiosities there stand out a few weirdnesses. Like the slamming of doors by a 46 year old woman and being left to chill with my own thoughts for the rest of the night. Or to have a seemingly professional prospect throw a hissy fit at not being rung up in a couple of weeks, saying he doesn't want to work with me after all.

Sigh.

The prospect-turned-insulted-date was weird enough. It was more disquieting to have someone close throw a tantrum for having to take her own dog to a potty break for the first time in days. That'll teach me for letting them take me for granted, all right!

Some people will get the wrong impression about you simply because they lack the empathy themselves to see things from your point of view. But it helps no one to be too agreeable too often.

Why, Again

2011-02-10T03:20:00.000-08:00

I've felt recently that I'm picking up new skills; still questioning the pace at which I pick them up, and why it seems frustratingly slower than those around me. I'm a loner, to be sure, not by conscious choice but apparently by the side-effects of internal preferences and tendencies as yet beyond my ken. Not that I feel alone in this... there are many who appear to be alone and just don't see it.

I have trouble following in conversation, in being where everyone else is being, doing what everyone else is doing. It is as if, if someone else is already there, squatting and tearing up the soil, I need to be elsewhere. Not sure why that is, or from whence it stems, but yeah, it has been with me since I was a little kid.

One aspect of this tendency to take a side-long view of social interaction, is that I'm constantly asking "Why"? And the more focused I get on a single skill area, the more strongly that question pervades my thinking -- why is this a worthwhile technology, why will it be useful to struggle with what seems to be the gratuitous constraints it imposes, why am I focused again on technology when it is the social interaction that is most obviously my own stumbling block, and why is it that I am not profiting sufficiently personally or professionally from either my skills or relationships ?

But the most important question "why" seems to be pointed at everyone else... my peers... why are you doing what you are doing? Sean Hannity reminded me of this on his radio show. As I flipped on the drive home, I caught the tail end of a conversation about him confronting a businessman over taking stimulus money. He remarked that as a former construction worker, it would have violated his sense of ethics to build an abortion clinic building even if it was well funded. To me, it isn't whether or not a customer is "being made happy," it is whether what we are pursuing should be done at all.

Iron Filings

2011-02-05T04:48:00.000-08:00

Iron by iron is sharpened, And a man sharpens the face of his friend.

A minor incident this week reminded me of this proverb. Actually, a lot of incidents do. As a metal blank is turned into a usable tool, it must first be shaped, then smoothed, and finally polished. Likewise, older tools can be refurbished by first welding, then re-grinding and polishing. In the process a lot of little bits of metal castings are generated, the stuff that was useful at some moment in time but now goes completely against the grain of the refurbishment.

My hope is to be able to find a path that makes me feel that I'm not constantly leaving great big piles of "me castings" around on the floor.

The other day, I cut some code for a Rails report. Relatively simple stuff. But there were a few problems. First, I was fatigued. Second, I was programming alone. These contributed to the actual root causes, the "me castings" for this week:

Short-cutting tests is just a way to lull yourself into a false sense of security. Run them the way they are supposed to be run, completely, from top to bottom, and pay attention to the details of what the results are saying. Make sure you run tests fully before attempting to commit changes.
When you have a failing test, don't commit. Or if you do commit, make it clear to everyone involved that you have failing tests, and ask for help; or offer to commit to a branch; or stash the changes and move on momentarily until you can get help.
Line-wise and paragraph-wise Cut and Paste is a recipe for error injection. It is just dangerous, period. I used to code by cut-and-paste often in 4GL languages due to the repetitiveness of the apps' boilerplate approach to development. I foolishly thought I could use it and find a way to not inject errors. The lesson, in retrospect, is that there is no way to separate cut-and-paste errors from cut-and-paste. Copying lines and paragraphs is especially evil because my brain tends to be looking for and see the similarity, and auto-correct for the differences, but those corrections may never make it to my fingers. Besides, the approach to Rails used here is most definitely not a boilerplate approach: the app may be copied to start, but everything after that is treated as one-of crafting. This was the most grievous "me casting" of the week.
Cutting into other's code requires special mindfulness. Doing it with cutting-and-pasting is completely wrong. Doing cutting-and-pasting while tired is a crime. At one point, I saw what looked exactly like a three-line function I just wrote, so I cut. It wasn't my function, and had I run Rake properly I would have seen that it was not. Fortunately, we had git. Make sure you communicate if you have an elusive sense of uncertainty, but especially if you feel completely confident.

I'm tempted to force git to warn me had I not run Rake before committing, or obfuscate the line-oriented cutting commands in Vim, but these are mere technical crutches. The reality of the examples of practice that I'm seeing, is that it forces you to be mindful of your surroundings, of your code, of your peers.

Being mindful enough of the affect of your actions, and communicating often and early with those in your circle, is critically important. At least, if you want to stay in the circle. It has been many years since I've been in a group of developers that really functioned as a team. It is profoundly disturbing to see how much less proficient I can be compared to some of the younger developers, and as difficult to consciously spot and let go of poor habits. But I am trying.

Is Consulting Like Dating?

2011-01-25T21:26:00.000-08:00

If so, it really explains a lot. The tech republic has a blog entry that goes all pedantic about the simile, but there is at least the illusory feeling of truthiness to it.

I never dated as a kid. As a teen I think I had one date, and it went nowhere. Truth is, I didn't know what was expected of me in social situations then, and more or less still don't now.

The article starts off with, "keeping clients happy may be similar to keeping your significant other interested," which strikes me as ironic and a little funny given that most married folks in the US end up divorced.

Well, I tried to bend over backwards to keep people happy. It doesn't work, for them or for me. So when a recent prospect complained to a mutual friend that I was a "dead end," because I hadn't been in contact for three weeks, at first I was a little bit taken aback and afraid that something I had not done was unprofessional and had spoiled the relationship.

Then I realized, we don't have a relationship, that prospect and I. We never did. She said she'd be in touch, but expected me to be banging down her door. She wanted me to tell her I had free hours I did not have. She complained to her friend instead of probing me back. She wanted me to dance, and I'm not a dancer.

I understand. I know there are many people far more successful than myself because they do the dance, they have a knack of schmoozing and persuasion. Those were skills that at first I merely lacked, but then consciously eschewed. It was not just a recognition of how much effort was wasted, or that the cost to me personally of trying to do that dance was too exhausting.

It was the false premise of it, the inert fakery sitting behind the outward countenances, and the desire of seemingly nice people to take advantage of your openness. It does not excite me to be constantly mindful to probe and prod clients constantly when I'm solving technical problems.

And when my own family members aren't interested in talking to me, worrying about whether I'm stroking a client's ego frequently enough just isn't on my list of priorities. Frankly, the prospect complaining to her girlfriend told me a lot about her style of communication and her own ability to think straight, and it isn't good.

Acting like a consultant

2011-01-25T04:41:00.000-08:00

This week-end I had a small verbal slap on the knuckles reminder that acting like a programmer is not sufficient to be a good consultant. It is difficult for some of us to come up from the sea of hardware and software and breath, and in the meantime people can feel abandoned or ignored.

Truth is, my boldness comes in fits and starts, and it is difficult for me to maintain constant communication with my network. It is complicated by my personality, but it isn't

who I am

, it is rather a skill that, in practice, I haven't mastered.

On the other hand, I find that it terribly distracting to be thinking about who I need to contact, keep their particulars in my head, and think proactively about their situations. I have to block the social aspects out of my mind while I'm programming, otherwise everything blurs.

Thinking like a consultant has other differences from programming in the raw:

Strategic thinking versus an "order taking" mentality
Dialog versus top-down communications
Probing for needs versus accepting plans as communicated
Asking questions to build a strategic understanding instead of focusing on tactical steps
Build a working context of the client's business: how they generate income; how they differentiate themselves from competition; industry shifts; customer and employee issues; the problems at hand and the client's objectives
Leading the discussion and influencing it to set expectations
Keeping the dialog going (this is a pain point for us programming types!)

Hobos hacking on Rails

2011-01-22T03:13:00.000-08:00

Testing my newly found programming confidence, I started hacking up an example survey form for a client. I tried Hobo, which led to some interesting observations about what Agile really means.

One moment my sample app was working, the next it was not. The problem was that I had generated a resources controller and model combination with a name that Rails did not like.

I checked over the model names and use ack to search for deviances. Convention over configuration, they say, except that nothing appears to be deviating. Somewhere along the line something got mixed up, and now it doesn't just work. Instead it broke the whole application.

Well, that points up a couple of ugly properties of Rails apps.

Small changes have an application-spanning impact

Pre-Web languages, such as C and Perl, have their issues with program structure and encapsulation, but Ruby on Rails (and other Web frameworks) have nothing to write home about in this respect: it is trivially easy to expose your system to breakage.

The thing Rails does right is to help ensure that such changes don't get pushed out to production. That's the test-first methodology. The thing it does wrong is a feature: the use of English language part-of-speech heuristics to create mappings amongst the MVC components. It gets it wrong about 10% of the time, that is to say, I get it wrong but the framework makes it easy to do so and hard to spot the location of the incorrect guesswork.

I'd rather not have to keep fixing the 10% or so times when the heuristics don't match the way I want to phrase the solution. But heuristic gaps are correctable; the persistent itch is that the framework wants to tell me to stick to a formula but hides all the wiring that would tell me where and how I'm crossing the lines, and translates tiny errors into epic fails.

A System That Uses HTML Is Not A Hypertext System

MVC frameworks are not really Web application frameworks but application frameworks that utilize the syntax of Web technologies to communicate. That is not easily correctable by slight alterations in practice.

State representations and transitions in a Rails app are all wired up through explicit code. Each entity is identified by a row number and associated by integer relations (this management strategy is reminiscent of DBase, but what "relational database" means and how Rails isolates the database layer is another discussion altogether). MVC uses views that spit out markup, but in themselves, views do not comprise state representations.

The RESTful Web uses links to stepping through the state space, and delivers markup documents that embody the current state representation along with the transition paths. That takes a kind of markup calculus to implement. Although Rails attempts to derive MVC patterns and hides a lot of its complexity in convention and meta-programming, there is an essential difference in the level of logic at play in the reduction of a solution.

A url format does not makes a system RESTful. A framework that stores almost all but not quite everything in sessions, and wires up features in point-to-point coding is doing what amounts to a Web algebra. That is very un-RESTful. Rails is on the top of the MVC heap, but what MVC platforms do is a little of the wrong sort of bespoke calculus mixed with a lot of idiomatic algebraic logic.

Bottom Line

MVC platforms are more than a slight inductive mismatch to the RESTful archetype. In my humbler opinion, REST requires a comprehensive markup calculus to accomplish. An effective REST platform should provide comprehensible algebraic representations and coherent integration and derivation techniques that do not require nail-up code to implement, conventions not withstanding.

Recent proverbs, aphorisms, and admonishments

2011-01-18T17:17:00.000-08:00

Never interrupt an interrupt.

If you don't understand this, you may be functionally ADD.

Me: "Do you know what that means?"
She: "No."
Me: "_That_, is why you fail."
She, laughing: "No, sir, that is why I succeed."

From experience, I can tell you she lets her interruptions get interrupted all the time. One might also suppose that it is bad to stack interruptions, or shuffle them around, but let's not bend the metaphor too much lest it break and we expend too much time picking up little pieces of interruptions all about us.

Organized like scrambled eggs

My son suggested this simile after attempting to design landscapes with a group on an online game called Minecraft. It applies well to the domain of programming. Ad-hoc development, whether coding, Minecraft landscape layout, or any other design regime and medium, all share common characteristics... what seems organic and natural at first may quickly decompose into an amorphous slurry of mush.

Code Grieving

Another anti-social pattern observed in Minecraft, and doubtless other online simulacra. A "griever" is a game player who rather purposefully destroys other peoples' creative efforts. By analogy, a code griever is a peer who, without acting collaboratively, breaks down working code that is already there. (Pair programming can sometimes feel as if you are being grieved, but it isn't the same phenomena.)

Vanity of vanities. All is vanity.

Explaining that wouldn't be worth the effort.

Minimal Viable Specification

2011-01-17T22:05:00.000-08:00

Every now and again you get to see glimpses of how people think in the way they formulate and frame up a discussion, that tells you they obviously adopted language from someone who did not think as they did. Such is the case with the term "Minimal Viable Product".

The term is remarkably similar to euphemisms for unborn babies [er, "fetuses"]. It invokes a metaphor of a gestating product, which might be aborted should it fail to exhibit a minimal feature set. I personally find the term to be in poor taste, and more than slightly stupid in assuming requirements form a static set over which you can assess a minimum.

Nevertheless, it is commonly used in Agile/Lean circles. Transitively and reflexively, one might ask the question of why there is then no "Minimal Viable Specification". It is not a foregone conclusion that a system must be over-specified before building can proceed, but neither is it an obvious truism that a stream-of-consciousness approach to coding gives the best value proposition to the client.

A minimum viable product implies that a set of coherent requirements could have been envisioned at some scale, while some who use the term often advocate explicitly against just such specifications. I understand why: as programmers, we get paid to code, not to specify. Well, sort of. Maybe, maybe not.

I've also heard it said that the code _is_ the specification. Or that the tests in TDD/BDD are the specifications. While these arguments have merit from the programmer's perspective, they are arcane and continue to sound weak from a customer's viewpoint -- at least as far as the tests or code don't rise to the level of abstraction that the customer's brain is at.

Einstein is widely credited with saying that things should be as simple as possible but no simpler; yet it was Newton hundreds of years before who was able to practically refract white light and recompose them again... thereby demonstrating that the most apparently simple of colors is also a composite and the most complex colors of all. The trouble with scientists is that sooner or later a few of them will make inconvenient things like facts get in the way of conveniently wrong abstractions. The trouble with reality is that it doesn't respect Agile ad-hoc abstractions and just keeps on behaving the same whether you believe in it or not.

So I posit that there is some minimal specification that really does need, in effect, to be professionally drafted and validated, else someone is taking too much risk, paying too much money, and/or just getting suckered into a co-dependent relationship with coders. Not that I pretend to know what that minimum is, I am just suggesting that it must exist, and the tangible artifacts representing it should consist of more than just a few notes taken while schmoozing with a client.

Different Shades of Grey

2011-01-17T21:23:00.000-08:00

I just spent some time finishing cleaning up my gemsets, and re-installing Bundler, per my earlier posting about using RVM. In all, I have three distinct Rails applications set up in my workspace right now, each with a slight variation on the technology stack:

Rails 3 and Ruby 1.9.2
Rails 3.x and Ruby 1.8.7 and Hobo 1.0.3
Rails 2.3.5 and Ruby 1.8.7 and Hobo 1.0.2

Using the "put everything in @global" approach worked OK for (1) alone, but when (2) and especially (3) came along, Bundler got downright confused about which Rails to run even though it knew which one was supposed to have been installed and which version was called out in the Gemfile.

Two failure modalities were found. First, even though the Ruby version-specific global gemsets had been emptied, the 1.8.7 global gemset had inadvertently been repopulated by an errant bundle install. Second, neither that gemset nor the app-specific gemset contained the Bundler gem itself, which had been silently "adopted" from the enclosing (system wide) environment.

The solution was to reset... go back and clear out the gemsets like I had before, and this time make sure the app-specific gemset had been properly selected before running gem install bundler and then bundle install.

Incidentally, how you start the server depends, but it seems that there are at least two ways :

script/server
rails server

I guess I don't know enough about the blessed way of Ruby server zen, but it certainly wasn't obvious by looking at the files sitting in the local directory.

Pretending Javascript has Object Orientation

2011-01-10T15:17:00.000-08:00

Suppose I have a Prototype.js class:


var Parent = Class.create({ 
initialize: function() {... }
invariantProcess: function() { 
this.part1();
this.part2();
},
part1: Prototype.emptyFunction,
part2: Prototype.emptyFunction,
});

and a subclass


var Child = Class.create(Parent,{ 
initialize: function($super) { $super... }
part1: function() { ... draw part 1 ... },
part2: function() { ... draw part 2 ... },
});

Ordinarily, inheritance and virtual dispatching allows us to override part1 and part2 without touching the invariantProcess in the base class. This often fails in Javascript as an indirect side-effect of the fact that classes are library constructs, not first-class objects.

In Javascript, what is commonly called "inheritance" is actually just copying properties around instances and instance prototypes, and names in method bodies are lexically bound to the scope in which the method is defined.

None of that is a bad thing. The bad thing is when you take a second-class method and treat it as if it were an independent function. This can happen, for instance, when you pass the method as a callback function. The bindings can get botched, with names either undefined or bound to the wrong object. In the example above, "this" might not be the "this" that we want it to be.

I ran across this recently while creating Prototype.js class wrappers for a Processing.js example. Processing expects a callback that will bind a drawing function to the library, but when a method is used as the callback it can horribly ugly to get the bindings correct.

The solution generally amounts to using a Factory pattern, returning a new function with the critical variables defined in the enclosing scope. This all but rules out using methods directly, which then take the role as supporting functions instead.

More hoboization

2011-01-08T07:58:00.000-08:00

I was playing with Processing.js and decided that it would be easier to use a Rails server to fiddle with the prototypes than installing an apache server or ftping to a host. So I returned to one of my trial apps, leapercan, and tried to run the server. It bombed out.

Yet I hadn't touched that code tree! When side-effects happen just because, is an obvious sign that you have violated (or never adopted) the axiom of closure. I happen to think closure is a good thing in general, when you can get it. I'd much rather trade extra disk space to get it than my time in debugging strange errors.

It happens that we use RVM, the Ruby Version Manager. We also use Bundler. What we haven't been using is RVM's Gemsets. Other developers with whom I've been pairing with over the past few months maintain a practice of always using the @global gemset, and use Bundler to maintain the gems. In this practice, RVM is relegated to maintaining only distinctive Ruby versions. This is supposed to work in theory because Bundler version control for the gems used by an application.

The root cause for the failure? My Leapercan application was based on Hobo 1.0.x, using Rails 2.x and Ruby 1.8.7. With a Splotchup application I tried out Hobo 1.3.x, using Rails 3.x and Ruby 1.8.7. Starting to see the trouble yet?

Bundler is fine for fetching and installing specified versions of gems. But in practice I have found that it did not maintain two different versions of the same gem, each for a different application. I'm told that it should, and that the ".lock" file should fixate the versions of the gems in use. But when I switched my working context, things just broke. My working hypothesis is that my Gemfile did not specify a version for some gems, and the use of a single gemset allowed bundling from one app to affect the gems v another app.

Using @global gemset is a good idea when you run a single Ruby version for a single application, and want to save space. It is a bad idea otherwise.

My solution? Impose closure. I don't care if I lose a little, or a lot, of disk space with separate gem copies. I want my application development and source tree completely and utterly self-contained and self-consistent. The way to accomplish closure is to get rid of global defaults and spurious sharing.

Don't rely on the System ruby. Unfortunately, if you've done anything interesting already you'll have to hack some directories to get rid of the system gems. Ironically enough Mac OSX lacks even a half-baked GUI for managing system add-on components. It would be better to fix RVM to avoid the real problem, which is that it does not sandbox out the system gems, but I had already done the removal before thinking of that approach.

sudo mv /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8 \/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8.default
sudo mkdir /System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/lib/ruby/gems/1.8
Use RVM to install each Ruby version you will use
rvm install 1.8.7 rvm install 1.9.2
For each application, create a gemset; empty the global gemset for the ruby it will use.
rvm use 1.8.7 rvm gemset empty global rvm gemset create splotchup rvm gemset create leapercan
When you start developing, switch to the gemset automatically
cd ~/workspace/splotchup echo "rvm use ruby-1.8.7@splotchup" > .rvmrc cd ~/workspace/leapercan echo "rvm use ruby-1.8.7@leapercan" > .rvmrc
Install Bundler, then let Bundler take care of the rest; avoid using gem to install gems other than initially installing bundler.
cd ~/workspace/splotchup gem install bundler # if you haven't already bundle install
cd ~/workspace/leapercan
gem install bundler
bundle install
If you maintain different mainline branches of development (an unnecessary complication in my book), create and use a corresponding empty gemset.

There now. My apps are completely isolated from one another. A purist might object that I'm duplicating a lot of code here, but there are two answers to this:

So What? Most ruby gems are small. The supposed space saving is a false economy, since the bugs introduced by violating closure cost much more.
There is no duplication and this is not a violation of DRY. Application-specific gemsets are necessary and sufficient because the gems are a factorable part of the application source, not universal attributes of the environment.

Knowledge is not infinite; neither is ignorance

2011-01-01T11:16:00.000-08:00

A FB friend posted a quote by Zhuang Zi,

Life Is Finite, While Knowledge Is Infinite.

Thing is, words have meaning, and those many meanings that words can have may be unbounded. Yet while unbounded implies pluralities it certainly doesn't necessitate infinities. The real difficulty here is that we neglect an operational definition for knowledge, one that allows us to allocate our ignorances wisely.

Knowledge poses an interesting term in this respect, because we so often conflate the many meanings to the point that the word itself barely means anything distinguishable. To Zhuang Zi, knowledge is certainly not a trait wholly attributable to humans, else his quote would be silly on its face. Zhuang's knowledge exists outside of Life, something to be pursued yet which is unfathomable.

On the other hand, what is knowledge if it is not known by a knower? The true knowledge of every man perishes with him, whether he be an author or a ditch digger, rich or poor, wise or foolish. Without a knower, our thoughts may be meta references to that we don't yet know; they may be delusions, or dreamlike feelings reverberating in our skulls affirming that we know when really, we don't.

It is the arrangement of neural inter-patternings enabling imagining of our universe including concepts such as "other" and "self" that we call knowledge. Those patterns are complicated. Numerous. Interdependent. But not infinite. It is that finitude that allows us to learn, make practical generalizations, and to reframe and parameterize our understanding.

While the experiences that are thrown at society in general and us in particular are unbounded, they induce knowledge if and only if they alter someone's brain chemistry; and that knowledge only remains around as long as those brains retain their altered states. In effect, our brains are big self-mutating hash functions, funneling those experiences from an infinity of infinities down to a countable set of neural patterns. And like any hash function, the pigeonhole principle rules.

Using Hamachi for Remote Desktop Sharing

2010-12-31T15:38:00.000-08:00

I, or more correctly one of my clients has used GoToMyPC before to share their PCs for support purposes. I am not in the PC support business so it isn't something I care too much about, but sometimes I do get curious about alternatives.

One alternative is LogMeIn. Definitely lower cost. If you are a gamer or non-profit, some of their products and services are provided without fees. That's actually something a few people and organizations I know of would benefit from.

The first free thing is the LogMeIn Free service. Even the Pro version is not at all pricey. LogMeIn Free gives you most of the interesting things of GoToMyPC, without the cost. If you still need to share files, you can always use DropBox or one of the other fine sharing services.

The second free thing is what would appeal to hobbyists, gamers, and some non-profit IT types: the Hamachi Virtual Private Network. You download a little pop-up utility that lets you connect to another computer also running Hamachi, or host a connection. They call it "mesh" network, but it is basically peer-to-peer networking.

One neat thing about Hamachi is that you can also use it to tunnel Windows Remote Desktop Connections or VNC connections. Create a network on one of the Hamachi clients and connect to it on the other client. After that you can use any RDC client to connect to a Microsoft Windows PC or VNC to connect to a Linux, Mac, or PC client, using the IP address that Hamachi shows in its pop-up.

Don't forget to grant access to Hamachi in your software firewall and through your router's firewall. Also, Windows users will have to enable RDC sharing and set a password for it in their control panel.

As I write this, I'm connected through Hamachi to my Lenovo T61, and running RDC to access the Windows desktop. It is on my local LAN, so performance is not representative, but it is neat that it can be done, effectively making it unnecessary to use LogMeIn or GoToMyPC at all for non-commercial purposes.

Classes and Inheritance in Javascript

2010-12-29T22:12:00.000-08:00

Here is some news for Javascript monkeys: Javascript does not have classes. None. Nada. When people speak of OOP classes and Javascript, they are making it up, literally.

Any talk of OOP classes in Javascript code is a pretense. Now, some of that code is really ingenious, really nifty stuff. But there are no first-class classes in Javascript.

There are two consequence of these non-first-class constructions:

Core language primitives were designed before the faked constructs existed and although the core language retains its closure (as much as before the extensions), the faked constructs introduce new elements and relationships that are not necessarily conserved through the primitive operations.
The extended constructs do not necessarily meet the same algebraic axioms; the library may not entirely consistent within itself.

A typical case is the use of JSON to send around objects which use library-based inheritance frameworks. It is easy to reconstruct the property sets, but difficult to ensure that the invariants assumed by your class framework remain invariant after a round trip.

Another birthday past

2010-12-27T19:19:00.000-08:00

I turned 47 today. It wasn't the birthday I might have hoped for, but it doesn't seem like I could have expected much more.

The weather was rough this week-end, but the roads were mostly clear and I planned on going in for a half day at least. My son wanted me to drop him off at a buddy's house, which meant he wouldn't be home. His mom asked me, obliquely, if I had wanted to drive her to work, to which I replied not really and made an unwise remark about what a wise aleck she was being. She called me a jerk, and left a bit later. On my drive out my son wished me a happy birthday, which was poignant. So that was how my day started.

I went in to work for the morning. Nothing special, just some debugging to figure out why someone else's home-brewed JSON parser wasn't actually doing the right thing by failing to properly initialize Prototype.js object's base classes. I figured it out but it didn't get fixed. It is not my place to set that priority as yet, but still -- it is the difference between doing the right thing and making things work for right now, that can bite you later when you are no longer looking. Deserialized objects should always be constructed the same way any other instances of classes are; anything else is a proximity fuse code mine. So that was the second part of the day.

Plans to have lunch with a friend were interrupted at the last minute due to fear of the previous weekend's weather. I don't blame my friend, but it was unexpected and I was looking forward to having a good conversation. Instead, I spent much of the rest of the day alone. I took a late lunch out and chatted with the restaurant owner, but it wasn't the same. I read up on Hobo and got a Jasmine gem to install properly, and looked over how JSON should (really) deserialize... finding that people don't seem to do it right at all in most cases, at least not with respect to higher-order class/inheritance constructions implemented at the Javascript library level. It continues to amaze me that people do mud-pie programming in Javascript and pretend that there is rigor and soundness to what they are doing. So that was the third part.

Checking messages, a few people wished me a happy birthday. My mom, her sister, and my sister called to say the same. That's nice. Not unimportant, but they all seem so... distant. Well, they are distant, but we don't really have much in the way of enriching conversation going on either.

Later, my wife got home early, and needed to vent about the goings on at her place of employment. Lots of dishonest communication in the workplace, compounded by a general lack of integrity, unrealistic goals, and hidden agendas, make it pretty rough for people to have a satisfying workplace life. When management and practitioners accept false premises for arguments, the fallacies inevitably compound and accumulate like waves cresting and crashing back upon a beach. It wears you down personally, and slowly undermines whatever solid thing you do manage to build. I got to hear about it, and offer consolation and comfort.

She got me a present too, a ceramic grinder because I grind nut mixes. Nice thought, but it was from the local mall and, as it happened, gummed up within about a minute. OK for fat-free things maybe, but not nuts and cocoa beans. I spent the next hour cleaning it out carefully before re-wrapping it for a return. I thanked her for it, but given the price (over $60) it did not seem like a keeper.

She put the TV on. I've come to hate TV. It isn't my choice of spending any evening, let alone my own birthday. It is icy out now, the roads are dangerous, so there is no going out. I lay down on a love seat in the other room to reflect on the day.

She puts the dog out and goes to bed early, not saying much otherwise. She doesn't seem to be angry or bothered in any way, just indifferent. Sigh.

I wonder how to improve upon what seems like a completely hideously unsatisfying social life. I mean, seriously - being alone all day??? It isn't reasonable. It isn't healthy. It just isn't right.

Blogging about it seems like a good enough idea, at least to help me reflect. I wrote once before about analogies in fiction, how there are often disturbingly concrete mappings to reality. Today was a day in the life of Robinson Crusoe. I tilled the soil, planted corn, minded my traps, said my prayers, and spent the balance of my time thinking about what else I could do to improve my situation and do more than merely survive in isolation.

Normally that would be enough, but today was sad and lonely, and here at the end of the day I'm just glad to say it is over.

And I have seen that there is nothing better than that man rejoice in his works, for it is his portion; for who doth bring him in to look on that which is after him?

- Ecc. 3:22

Christmas Spirit

2010-12-25T20:34:00.000-08:00

Standing in the doorway, early snowflakes

falling gently down. A quiet violence lights

the nighttime sky. Our darkness was long ago

stolen by the kings of business and commerce.

Their light could not illuminate, only confuse and irritate.

Meltwaters dripping slowly from the eaves.

The TV fades into the distance, no video

succubus to steal the soul of our conversation.

No conversation left to be had. Just drips

of ice water punctuating the silence.

Storage without the GitHub price

2010-12-24T07:56:00.000-08:00

So, I'm looking at GitHub and thinking, "It's a great service, but what are the other options?" Their micro plans are a very good value at $84 (USD) to $264 per year, but I just purchased a 1 terabyte LaCie NAS for about $150, and I'm already paying about $60 per month for broadband access to my (home) office. Would self-hosting my own space make sense?

The main disadvantage of using an office-based solution, in two words, is "lightning strikes". Most office equipment is exposed to higher risks of electrical surges or direct strikes, especially when it is located in a residential building. Forget about what uninterruptible power supply companies and line filter vendors will tell you -- if lightning strikes any utility connected to your home, chances are good that their equipment will be the first, but not the last, to be taken out. Lightning can travel miles through air, so a 1/4 inch spark gap isn't going to be much protection.

And computer years are logarithmic, especially the consumer-grade stuff most of us use at home offices. A lot of equipment is just going to fail after a couple of years. At three years, odds are much better for failure. At five years, even if it is still running your equipment will appear to have been purchased eons ago and you'll wish it would fail. I don't look at my LaCie NAS so much as an investment, as a necessary expense for the sake of quickly restoring my MacBook Pro. It just does not pay back to deploy mission critical services on an ad-hoc platform.

Especially if it is your mission, you'll put in way too much time to fix and maintain the platform. It is certainly fun to hack devices to get, eg, git running on a NAS device, but unless you are using that knowledge to build a salable infrastructure as a paid service, it makes no sense at all to pursue. It isn't your core competency and you don't gain competitive advantage by doing things in a technically curious but otherwise inferior way.

Finally, vendors make it hard all the way around to deploy your own micro services. Broadband providers are well known for limiting what you can do with their bandwidth. LaCie blocked a Webdav based hack to enable ssh access (and hence a GIT install), because it was also an obvious back-door security hole.

So a home-brew solution is really kind of stupid on its face. The one valid reason for doing it at all, is if your technical curiosity leads to a genuinely better way of managing your data. I can see a massively distributed peer-to-peer rsync like service being a way for micro businesses to avoid dependence on large data centers. Again, as a curiosity, perhaps, but that is a far cry from a sensible operational strategy.

Interestingly, though, LaCie offers an alternative in the form of Wuala (pronounced like the French word "viola"), a service offering encrypted file storage space. Wuala is very much like DropBox, and reportedly has faster throughput. One other attractive feature is that you can trade excess storage capacity on your LaCie NAS for space for cloud space... in effect by allowing a section of your NAS to be part of the cloud itself. Not sure I want to trade my bandwidth as well, nor risk getting on the radar of the broadband provider.

URI Knot Theory

2010-12-21T04:21:00.000-08:00

It is proposed to use language developed in the theory and practice of knots, as a primary metaphor for the architecture of the Universal Resource Identifier.

Introduction
As remote as mathematicians and topologists can bring Knot theory, the practical application is immensely approachable to most people. At the very least, they understand implicitly how useful and at the same time challengingly complex it can be to arrange loops in strings of tensile material. URIs are strings, and tie together the World Wide Web through a process which involves pulling &emdash; which is to say tension &emdash; as the primary means of establishing connectedness. That is to say, URIs are knots.

The study of knots is at once both a highly developed intellectual pursuit and a supremely pragmatic, almost purely mechanical skill. The architecture of a knot determines its strength, aesthetic beauty, elegance and approachability, and ultimately whether it has any utility in practice. The art and science of knots goes back into prehistory, and thus it evolved a language and sets of patterns that well-describe thousands of years of problem solving, where the problems involve tying things together. Thus, the language of knots should be a rich source of language well-adapted to the problems of designing URI architectures.

Background and Overview of The Language of Knots

From the perspective of analyzing the mechanics of a knot, it is conventionally decomposed into the following parts:

Bight
Bitter end
Loop
Elbow
Standing end
Standing part
Turn
Working end
Working part

As a hint of the fecundity of this language, consider briefly the idea of the "Working End" of a line: it is the leading portion which allows further extension of, and adaptations to, the knot. Just as some knots can be constructed in the middle of the line, it is predicted based on the metaphor that some URIs can be constructed as fragment taken out of a continuous string, without access to the working end.

At the time of the first draft of this post, August 3rd 2010, a Google search indicated no results on the query ' knots "uri architecture" ', and similar searches failed to produce any results. I have yet to do a formal literature search, but the Google results suggest that it is an idea which is not thoroughly discussed, and is perhaps a novel contribution.

Types of Knots

The common practical (or alternatively, the mathematical) classification of knots can also provide a meaningful working language for URI architectures. The list is from the Wikipedia entry on knots. Considering what each might mean in a Knot Theory of URI architectures leads to interesting possibilities for enriching the language of addressing on the Web.

Bend: A knot uniting two lines (for knots joining two ends of the same line, see binding knots or loops).
Binding: A knot that restricts object(s) by making multiple winds.
Coil: Knots used to tie up lines for storage.
Decorative knot: A complex knot exhibiting repeating patterns often constructed around and enhancing an object.
Hitch: A knot tied to a post, cable, ring, or spar.
Lashing: A knot used to hold (usually) poles together.
Loop: A knot used to create a closed circle in a line.
Plait (or Braid): A number of lines interwoven in a simple regular pattern.
Slip (or Running): A knot tied with a hitch around one of its parts. In contrast, a loop is closed with a bend. While a slip knot can be closed, a loop remains the same size.
Seizing: A knot used to hold two lines or two parts of the same line together.
Sennit: A number of lines interwoven in a complex pattern.
Splice: A knot formed by interweaving strands of rope rather than whole lines. More time-consuming but usually stronger than simple knots.
Stopper: A knot tied to hold a line through a hole.
Trick: A knot that is used as part of a magic trick, a joke, or a puzzle.
Whipping: A binding knot used to prevent another line from fraying.

I will discuss more on the applications of this language to problems of URI architectures in follow up.

On-line Meeting Options

2010-12-12T09:19:00.000-08:00

Recently, a member of the Raleigh-Durham Web Design Group challenged me to hold on-line meetings for the group. I'm really interested in the the physical meetings, and remain a bit skeptical that on-line anything is a substitute for face-to-face interaction. Yet there are some interesting possibilities.

It makes me curious: what does "on-line" really offer us? The mundane features seem to be

screen sharing (with or without keyboard and mouse pointer sharing)
instant messaging
conference calling
videoconferencing
presentation or application sharing
session recording
whiteboarding

Personally, I've never seen a high-tech conferencing option that doesn't suck compared to the elegant simplicity of a low-tech in-person meeting. But that's beside the point: on-line services are not a substitute for human communication. The members who are asking seem to be saying that the costs of attending in-person meetings outweighs the reward... but some of them may be willing to put out some effort to meet on-line instead.

We are a volunteer group, so free or low-cost alternatives are attractive. Members use PCs, Mac, and even Linux systems, so single-platform clients are ugly.

Some of the more obvious options:

GoToMeeting
Join.Me
DimDim
Yugma
Mikogo

Of these, Yugma's free offering stands out. It integrates with Skype, and allows up to 20 participants on-line.

We are looking for options. What are they? Is there anything better for remote members than screen sharing? What's the latest and greatest in telepresence? What features are bloat and what do people actually use in practice?

Social Networking and Propagation of Ignorance

2010-12-10T06:06:00.000-08:00

People tend to think of ignorance in terms of something absent, as a gap or a hole in conceptual space. That's a pretty ignorant view of ignorance.

Ignorance, by its nature, is represented in peoples brains by neural patterns, is exchanged in communication, and is clearly evident when mob-think pervades Facebook discussions. Urban myths are ignorance encapsulated as the stories of our modern apocrypha.

Ignorance, when realized consciously, can be variably hope, fear, or some other longing, but never faith, confidence, or trust. Without knowing what others don't know, ignorance is not just bliss: it pervades everything you say and do rather deeply and very materially.

Fighting ignorance with ignorance is not like fighting fire with fire. It is more like burning your neighbor's house down because you see fire on the horizon. That strategy is not very likely to be successful, even if it you are taking action.

This is the truest danger of social networking: ignorance is a learned meme.

Unnatural Bifurcation of Progressive Enhancement vs Graceful Degradation

2010-12-08T04:25:00.000-08:00

I'm working a couple of projects out of NC State University, where Universal Design is not just a buzzword, it is a whole design center. We recently discussed priorities for an HTML5/RoR Web application (in a nutshell it is to be a social delivery vehicle for giving diagnostic assessment to kids), and the subject was raised.

We are dealing with many different mobile devices, and the problems we are face are an extension of those seen by designers working toward different desktop platforms and browser combinations. That brings to mind several other philosophical approaches as well, among them Transcendent CSS and Yahoo's Graded Browser Support.

NCSU incorporates its own design philosophies into Universal Design, so I don't want to mislead the reader, but my comments are not about any one philosophy but about a tendency among all of them to take the problem as a single dimension and premise the solution as a two-partition.

More specifically, quoting the YUI Graded Browser Support article:

Graceful degradation prioritizes presentation, and permits less widely-used browsers to receive less (and give less to the user). Progressive enhancement puts content at the center, and allows most browsers to receive more (and show more to the user).

In our case, the application is perceived, navigated, and reasoned about as an application with a set of behaviors and data to be stored and retrieved. Both "presentation" and "content" are second-class citizens; the behavior of the tooling takes precedence by an order of magnitude, overshadowing all else. Whether that is right or wrong, that is the way it is on many if not most Web application projects.

My point is certainly not to argue for or against a focus on tooling; rather, that in any dynamical system it is the trajectory that is being followed that is of interest, not any one static coordinate. Content and presentation are coordinates in the space, and don't really give us the conceptual tools necessary to analyze the trajectories of moving objects.

The bifurcation is unnatural, and one might suspect it is because it is being applied to applications whose meta-model doesn't really track that of the Web. They work, not because they treat their information as content or cleanly delineate content and presentation layers, but because they use model-view-controller architecture.

Hence, there is a tension between understanding these applications in terms of content (and the two philosophical approaches to making designs adaptive), and understanding these applications in terms of behavior. For the most part, the applications, by design, ignore content as means of integrating behavior and strongly favor an explicit, imperative approach to sculpting a system.

There is really nothing progressive about imperative coding; really it is rather old-school.

Hobo: Play play play, edit edit edit, do stuff...

2010-12-06T23:00:00.000-08:00

So, I'm about ready to do something grounded with the Hobo/Heroku/Git/RubyOnRails/Rails technology stack.

One of the really sad things about the present state of Web technology, is the amount of preliminary technology stack setup that has to go on just in order to get to the starting position. That's another series of posts right there, but I digress.

A cool thing about OSX is that it allows terminal sessions to be pre-configured to launch commands, then bundled into groups, so I can launch (a) a regular command window in which to run shell commands or rails consoles (b) a terminal in which to run the development server (c) a terminal in which to run Jasmine (d) a terminal in which to run rake, rspec, steak, cucumber, etcetera and (e) a MacVim with NerdTree; and have them all pre-configured with the right shell, Ruby, and Gems. A featherweight setup for development of a specific application can be configured within a few minutes and launched with one click. But again, I digress.

Start up the server for Leapercan; oops -- my other logged in user has a Rails 3 app running on port 3000 -- need to use -p option to make this one run on, Idunno, port 3030.

/script/server -p 3030

Huh. MySQL gives an error:

Can't connect to local MySQL server through socket '/tmp/mysql.sock' (2)

OK, this isn't the first time MySQL has gone AWOL under OSX. I'm still wondering why this is happening. Workaround seems to be: ps -ef|grep mysql to get the PID of the MySQL server, then kill $PID or kill -9 $PID to force the service to start a new process. Of course, MySQL has been installed to load automatically as a process upon boot, and to restart if it is ever killed. Killing the MySQL process works.

Ah, but alas, now it is really late, and I've got to pause again. Perhaps the next thing I'll do is create a questionnaire application -- something to play out 25 questions or so in order, and capture the results in a simple table. I'll use a one-time-pad to provide some measure of scope of access, to limit the visibility of the questionnaires to just those who should be authorized to fill one out.

I'll also need a time-limited list of authorizations -- basically just a mapping of user identities to scope identifiers. Both elements of the mapping could be opaque, but the user identities should be supplied externally. The idea here is that an institutional user should be able to load up a list of authorizations for a one-time use.

Another aspect of the system: the user interface should be Web based and targeted toward mobile platforms, particularly the iPhone/iPad/iPod Touch or similar Android devices. It should not give any special consideration toward working on an IE browser or any other insecure platforms.

Things I Don't Miss About Windows

2010-11-28T12:37:00.000-08:00

After working on a MacBook Pro with OSX Snow Leopard for a few months, I almost go into convulsions when I am forced to tolerate the utter inferiority of Microsoft Windows. Don't ask me which version: XP, Vista, or 7 are all just different colors of terrible.

Why?

While UNIX was a proven and well-understood operating system (OS) for mini computers, the original PCs were underpowered and had to settle for much less than a real OS. Yet UNIX had captured much critical knowledge about how to succeed at providing access to computer resources. Support for multiple users, connectivity, and the security it would require were accommodated by fundamental design decisions built into its core.

Over years the feature set of Microsoft's OSs have expanded to cover many of the same requirements as UNIX, yet without the same level of consistency and performance as the latter. The Windows OS line is itself probably responsible for more security breaches and real dollar losses expended in dealing with its security issues, than any other OS on the face of the planet.

Steve Jobs made a brilliant move in adopting a UNIX style core for OSX. Are there still flaws? Sure. But you just don't see the time robbing, attention wasting, excessive security risks that you are guaranteed to see under a Windows regime.

They say, "Time is Money,", but really it is worse than that. You will never get back the time you lose dealing with the short comings of the Microsoft platform. Best never to go that way, for down that path lies madness.

Industrial Strength Testing for Joomla Part 3

2010-11-26T05:00:00.000-08:00

Under a test-first development practice when you're rolling out an add-on, you should also be rolling out a rigorous suite of tests to demonstrate that the add-on really works and satisfies some fundamental security and accessibility criteria.

Lacking such an automated test suite, it is not rational to expect an add-on to perform correctly. It is certainly not reasonable to purchase an add-on without the assurance that a test suite passes and can be repeated under your host environment.

The truth is, most software is crappy. Let's posit a valuation function Crppnss(t) to determine how crappy a piece of software is, and suppose it is inversely proportional to the number of automated tests V(t): Crppnss(t)=1/V(t). That's a reasonable assumption. Although there are studies that suggest the relationship between latent bugs and number of tests is linear, even a small number of tests can have an impact much greater than a linear correspondence.

Since most Joomla components show little or no evidence of automated testing, it follows that most Joomla components should have high Crppnss. That is to say, the theory would predict that they should be quite crappy, and that is just what we see in practice.

Am I missing something here? No doubt. Yet I suspect that the Joomla/PHP testing cup will still be less than half full when I'm filled in on what I'm missing.

After my initial draft of this post, I did more research. Apparently PHPUnit and Selenium, with a Joomla specific runner, is the soup du jour for Joomla 1.6 testing. It is evident that the team has put in a good amount of effort to put together a rational tool chain and process. So the Crppnss for Joomla has officially gone from infinite in version 1.5 to less than one in version 1.6.

Industrial Strength Testing for Joomla Part 2

2010-11-25T11:24:00.000-08:00

Following up to my previous post, I'm really regretting the lack of general testing facilities in Joomla.

Curiously, the Joomla MVC framework doesn't seem to help as much as hurt. Unlike Rails/Grails/Cake etc the framework doesn't do code generation and doesn't speak to clean coding idioms. So you end up with the worst of both worlds: the constraints of a framework with the productivity of from-the-ground-up work.

It isn't that testing in the framework is poorly framed -- it is simply absent from the picture. The developer shouldn't really be "rolling his own" when it comes to extending and integrating with a content management system. An active Joomla contributor could speak better to the test coverage and soundness of their PHP tool chain and technology stack, but I've seen little evidence that testing is handled with any rigor in the Joomla community at large.

Why do I bring it up? It costs a lot of time to fix stuff that other people broke, and I cannot afford to do that. I don't like doing it either. Foundations should be demonstrably sound and stable. If you cannot demonstrate soundness and stability with rigorous tests, your are living in a magical pixie dust land where everything flies because you wave your hands and say it is so.

Let The Right One In

2010-11-24T11:36:00.000-08:00

As I sit here in my favorite pizzeria, Anzio's, having downed one too many of the tasty circular sectors, I notice someone walk in the door that I recognize. It is the owner of a local auto repair chain, and a prominent member of the local chamber.

We've met a handful of times; his blank expression says that he either doesn't recognize me or doesn't want to acknowledge my presence through eye contact. Either way it is fairly strange behavior from someone in sales.

Now, ordinarily I might re-re-re-introduce myself, but I've gotten some very peculiar vibes from chamber people. Like they don't know me, and don't want to. There's something very icy about meetings that they and other organizations do as networking-for-networkings-sake events.

When someone doesn't want to acknowledge you it probably isn't worth a second thought. Like this blog entry. Ah well. No harm, no foul.

The second thought is this. I contrast his behavior to that of a sales clerk. During a visit to the local Tiger Direct, uh, sorry, "CompUSA", turning to speak to my son I heard someone say, "hey, I know you". Looking back, I immediately recognized a guy who had visited the Raleigh-Durham Web Design Meetup several months back.

The guy had taken a sales clerk position after a business venture failed to come together. We chatted briefly about a common problem of finding resources to pursue projects, about networking, and his new job, then he showed my son where some cables were.

What's the difference between these two people's perception of me? One was approachable and open, and treated me as a peer; the other was absent and closed, and treated me as a total stranger. One was searching for business, the other had inherited his business from his family. One seems to have more money than the other, but I'm more likely to get leads and business from people who are open like the sales clerk than people who are closed like the auto guy.

We can and do affect how people perceive us through our initial contacts with them. On the other hand, no amount of contact will alter a person's integrity. Some people are just going to play you. Others will maintain an adversarial position and keep a poker face on, no matter what your intentions, altruism, or openness. It is best not to let those ones in.

Industrial Strength Testing for Joomla Part 1

2010-11-24T10:30:00.000-08:00

Ugh. Developing with PHP seems like such a crap shoot, and the picture gets even more muddled if you try to work with a rats nest of third-party components. In general, the quality just isn't there.

My development environment for PHP bears some of the blame. I'm not a Zend user yet, though I probably should be. Still, like C and Perl, PHP seems to encourage inelegant coding.

One tool that I have used is VirtualBox. "What," say you, "does VirtualBox have to do with testing?" Well, for one thing, VirtualBox allows me to virtually reconstruct almost any hosting environment on my Lenovo T61 or MacBook Pro. The result replicates the hosting environment much better than a "WAMP" style native installer, compartmentalizes the services in a sandbox that can be put to sleep, and avoids application upgrade hell. It can even replicate the horrors of "open_basedir=." in its PHP configuration (that breaks a LOT of packages).

I've used the Joomla JumpBox appliance for a test deployment server, but recently switched to using the TurnKey Joomla appliance. Could I use shared or cloud hosting for test deployment? Yes, but the local virtual machine is private, fast, and can be junked much more quickly.

When used in the development cycle, a virtual appliance is, in effect, an industrial strength test fixture. But test fixtures are only a part of the solution to testing. A general purpose test framework is needed.

Hobo, Finally

2010-11-22T16:41:00.000-08:00

During the previous setting up of the Heroku staging, I found out the name Heroku gave to my new application:

Creating afternoon-water-18...... done
Created http://afternoon-water-18.heroku.com/ | git@heroku.com:afternoon-water-18.git
Git remote leapercan added

OK, that's a bit strange, but I can deal with it. The name of my app as known by Heroku is "afternoon-water-18".

I need a database for my Hobo. I choose MySQL, just because it makes me do something to set up. Plus, I've already got it installed.

I update my Gemfile to include the mysql gem:

mvim Gemfile

gem 'mysql'

:wq

then invoke bundler again

bundle install

Now to create the database:

mysql -h localhost -u root

mysql> create database leapercan;

Query OK, 1 row affected (0.12 sec)

mysql> quit

Bye

I don't have a password set up for my database. I should. There's no excuse for laziness, except procrastination. I'll do that later. The changes will go into database.yml . Since I don't have a password set up it should just work.

Now I call Hobo to generate the application:

hobo -d mysql leapercan

Lots of output. Well, everything is great, except that the app now lives under a subdirectory. I use mv to put the files up one directory.

mv leapercan/* .

rmdir leapercan

There, that's better. Next time I'll do that a bit differently.

I follow the tutorial from here, and create a hobo migration:
ruby script/generate hobo_migration
Unknown database 'leapercan_development'

Uh-oh... did I miss something obvious? Yup -- I omitted the _development from the intended database name... go back into mysql... drop database leapercan; create database leapercan_development;

Try again... looks good this time. It asks me if I want to generate or migrate now, or cancel? I migrate now and accept the default migration name. Hobo takes care of running the migration for me, so I don't have to rake db:migrate at this point.

OK, so time to try it out a little:

ruby script/server

A mongrel server is started, which we can visit at localhost:3000. Very niftily (I know that's not a word): hobo has created a closed shell of an application with user accounts, and is ready to set up an administrative user. Hobo feels more like a 4GL rapid application builder than Rails alone.

I'm adding a model now. The tutorial is talking about Contacts, but I want to think about the warranty information I had to track down this morning. I carry around keys and coins and never really have trouble finding them because they are either in my pocket or dropped into a bowl on the nightstand. I admit, sometimes I leave them in my pocket and dig them out before throwing the clothes into the laundry.

ruby script/generate hobo_model_resource pocket name:string content:text

Wow, it really generates a lot of stuff. A RoR purist might say it is a bit much, but I don't know enough to be that picky. I migrate again, same method as before:

ruby script/generate hobo_migration

Cool. Now there's a new tab for Pockets, apparently with the CRUD interfaces bootstrapped for me. I create a new Pocket, call it Leapercan, and put some application maintenance details in it. Stuff someone would eventually ask about, if they were asked to support the application.

It just works. That's a very, very nice quality.

Did I mention how little I value debugging? Debugging other peoples' code is like trying to understand and have a discussion with another developer by relaying the messages through a stupid, more or less insane, and completely soulless being. I'm in awe of people who can do it, but I'm finding I have less and less tolerance for stuff that doesn't work as expected.

The tutorial mentions how Hobo works at this point, automagically adding or removing fields and tables, based directly upon what it finds or doesn't in the models. To delete a table, just delete its model and generate another migration. You'll be doing the hobo_migration dance a lot during early development.

On the other hand, rolling back to a previous version apparently involves editing of the migration files directly and a rake db:migrate VERSION = version_no

It isn't much, but I'll push it anyway. Nope... Heroku says I need to run bundler. Bundler says I don't. What gives? It tells me to look at http://docs.heroku.com/bundler... completely unhelpful advice... GoogleTime... looks like a common problem, but the advice offered doesn't work. Like, AT ALL.

git add Gemfile.lock
git commit -m "Added Gemfile.lock"

After several attempts at modifying the Gemfile, running bundler, and adding both the Gemfile and Gemfile.lock, git push leapercan master still craps out with that same error. Every Time. Even when I destroy and reinit the git repository.

Looks like Heroku is in the crapper at this point in time. It took me from a nearly seamless experience to an brick wall. Epic fail. Waiting, wondering, and - the thing I hate most of all - debugging someone else's code.

I'm starting to hate you, Heroku, and I hardly even know you.

So I start hacking, wildly guessing. I figure, something is lying to me, so I decide to do exactly the opposite of what it seems to be telling me. It says

   You have modified your Gemfile in development but did not check the resulting snapshot (Gemfile.lock) into version control

   You have deleted from the Gemfile:
   * version: 1.0.6

MISDIRECTION! I really wish that some programmers would learn to communicate better than brain damaged slugs.

Google had a lot of bad advice, utter nonsense, akin to cutting off a chicken's head and sprinkling its blood on the ground. The true reason for the problem is that Bundler records its version number in the METADATA section (which happens to be at version 1.0.6), and the bundler up on Heroku (version 1.0.3) apparently cannot deal with the fact that it has a slightly different revision level. So I deleted the version number line from Gemfile.lock, and BAM, it just works.

WOOHOO!

Except... it didn't work. The command line says "yes" but the Web interface says something went drastically wrong. Wait. I forgot one more step: the Heroku database migration.

heroku rake db:migrate

Ah, such sweet release. All done.

The bundler version discrepancy reminds me of US EPA emissions requirements for commuter vehicles: not only do the requirements add to the cost and complexity of the auto, the emissions parts are directly the cause of most of the failures. How much difference is there between 1.0.3 and 1.0.6? Probably very little. Yet the version labels themselves completely HOSED the system. There's a lesson in there somewhere, about not enforcing something that doesn't really matter.

References

Rapid Rails with Hobo (Free from the Hobo site)

Hobo on Heroku

2010-11-21T15:10:00.000-08:00

Ok, so I'm toying with a Web application, code named "leapercan" because Leprechaun is not only unavailable as a domain name it is also difficult to spell.

Not that I claim to be especially proficient in Ruby or Rails, but I've been fortunate to help a really crack team of Ruby on Rails programmers for the past couple of months. I'm a dinosaur by comparison, but I'm picking up something along the way.

So I want to try something new, but RubyOnRails based. We've been using Rails 3 with all sorts of gems including RSpec, Steak, and Jasmine, and deploying with Capistrano. I'm looking for a solo app -- Hobo sounds interesting, and a free account on Heroku is an easy way to get started.

Here's what I've done and found so far.

Before anything else, note that I'm hanging back on versions so as to avoid having to deal with bugs at the bleeding-edge. My goal is to explore Hobo and Rails capabilities, not to debug them.

Debugging time is time mostly wasted. Like an argument with your spouse once you've worked around the disagreement you generally forget why it was a problem in the first place.

First, I use RVM to manage my Ruby versions, but not the gemsets feature. So I install version 1.8.7 and set a .rvmrc up so that my work environment will default to rvm's global gemset for 1.8.7.

cd ~/workspace
mkdir leapercan
echo "rvm use 1.8.7@global" > leapercan/.rvmrc
cd leapercan

RVM now tells me that 1.8.7 is selected. Now, if I had other 1.8.7 apps on this machine, I might use a named gemset instead, to avoid polluting the global space; in that case, I would have used the gemset name instead of "global". Now that I think of it, that probably would have been a better idea...

I confirm it is using the right Ruby. As it happens, my system ruby is also 1.8.7, so I could have avoided the download. I check the version

which ruby

/Users/mamiano/.rvm/rubies/ruby-1.8.7-p302/bin/ruby

Next, I install the bundler, because it is just easier to list the right gems in a file than to 'member the nitty-gritty details in stream-of-consciousness mode.

gem install bundler

After that, I use my trusty MVIM to edit the Gemfile, and put in the gems we're expecting to use:

source 'http://rubygems.org'

gem 'rails', '2.3.10'
gem 'hobo', '1.0.2'
gem 'heroku', '1.13.7'

I'm a freakin' idiot savant, to have come up with the version numbers, right? Wrong. I used the fact that rubygems.org provides a RESTful interface to look at the all kinds of information about a given gem, and just plugged and chugged until I figured out which versions I could probably use without too much more trouble. The format I used was http://rubygems.org/gems/GEMNAME , where GEMNAME was one of rails, hobo, and heroku.

Write and quit the Gemfile, and run bundler:

bundle install

Gahk! It complains about

Could not find gem 'rails2.3.10 (>= 0, runtime)' in any of the gem sources listed in your Gemfile.

Well, that's not right. I had omitted a comma after the gem name and version number, and bundler just concatenated the two into one string. I correct the mistake and continue.

After a while of downloading and installing, you'll end up with a bunch of new gems in your rvm maintained gemset. You can list these with gem:

gem list

*** LOCAL GEMS ***

actionmailer (2.3.10)
actionpack (2.3.10)
activerecord (2.3.10)
activeresource (2.3.10)
activesupport (2.3.10)
bundler (1.0.6)
configuration (1.1.0)
heroku (1.13.7)
hobo (1.0.2)
hobofields (1.0.2)
hobosupport (1.0.2)
json_pure (1.4.6)
launchy (0.3.7)
mime-types (1.16)
rack (1.1.0)
rails (2.3.10)
rake (0.8.7)
rest-client (1.6.1)
will_paginate (2.3.15)

OK. So, by now I've also set up a free account on Heroku, gotten a link to activate the account, and logged in. Heroku says I need to add my public SSH key, so I do:

heroku keys:add

Enter your Heroku credentials.
Email: mamiano@nc.rr.com
Password: ********
Uploading ssh public key /Users/mamiano/.ssh/id_rsa.pub

(Note that I had used earlier used ssh-keygen to create my public and private keys as part of a GitHub account setup. You don't need a GitHub account to use Heroku, just git. Google it if you don't know how.)

You can use "heroku help" to list a quick reference to the commands. I won't repeat them here.

Heroku says I need to set up my working directory as a GIT repository, so I do:

git init
git add .

git commit -m "LeaperCan: gold at the end of the rainbow"

4 files changed, 63 insertions(+), 0 deletions(-)

create mode 100644 .bundle/config

create mode 100644 .rvmrc

create mode 100644 Gemfile

create mode 100644 Gemfile.lock

Now we need to tell Heroku about the new application. A helpful blogger has already run into the problem of using a slightly newer version of Rails than is standard on Heroku, and pointed out the command line to use the "bamboo" stack instead, which has my version of Rails on it:

heroku create --stack bamboo-ree-1.8.7 --remote leapercan

Git remote leapercan added

So, at this point, I've gotten myself a live sandbox to play in... I'm ready to actually play with a Hobo application.

To Do: Play play play, edit edit edit, do stuff...

Now suppose we have played enough that we have something to deploy. According to Kiwiluv, it is as simple as doing two steps:

git push leapercan master

And

heroku rake db:migrate --app heroku-app-name

Unfortunately at the moment my family wants attention and I'm just about out of play time.
Sigh. Rather than forget what I've just done, I take what time I have left and dump it into my blog, along with the references.

References
http://rubygems.org/gems/heroku/versions/

http://rubygems.org/gems/hobo/versions/

http://rubygems.org/gems/rails/versions/

http://docs.heroku.com/rails
http://www.kiwiluv.com/techblog/?p=560
http://cookbook.hobocentral.net/manual/download

A Smattering of Design Guidelines

2010-11-20T16:58:00.000-08:00

Use the metaphor of resources to determine consistent, implementable URL and URI patterns for your pages. Sketch your site's map. But only just sketch. If you don't understand how this relates to your design, consider that "pages" is just a metaphor itself and the branches of site map don't necessarily mean "page".

Lay out for substantive content first.

Get specifications for the devices you expect to support for access to your information. Generalize the specifications into a set of parameters characterizing a category of media, rather than device. Create a style profile for each generalized category of media space. You might have a Desktop space, a high-definition smartphone space, a low-definition mobile space, a tablet space, etc. Consider each profile a proxy for one of your audiences.

Define your profiles incrementally. Choose a grid or columnar layout, and flow content into place.

Apply a strategy using Occam's Razor to your code:

pluralitas non est ponenda sine necessitate

Joomla means carnage

2010-11-19T15:44:00.000-08:00

Man oh man. I just got done futzing around with an XML RPC service plugin for Joomla. What a nightmare, like slogging up to your neck in feces for four hours.

Thing is, it isn't that complicated a problem, but trying to do things the "right" way is what makes it virtually impossible to accomplish.

First, there is little published information that is in any way self-consistent. Please don't tell me about the so-called "Master ..." book for Joomla. It is spotty at best. The information might be there, but it is so poorly organized that you have to jump around in the book to patch it together, making it that much more difficult to judge if you've gotten the pieces right. Still, one can muddle through part of the way on that.

Second, how do you test it? There is no admin side functionality for testing the RPC interfaces you enable. Isn't it a little bit mission critical to know if they work?

Third, none of the Joomla APIs appear to be very stable. Write something custom for it, and you're most certainly guaranteed that custom code will break when you update. At least, you'll have to test it thoroughly before updating any production system that uses your code.

Fourth, debugging this stuff is one epic hack after another, just for the debug environment. I tried the PHP XMLRPC debugger and finally had to give up after being roadblocked in three completely different ways.

First, the xmlrpc feature had been left out of the "hardened" php test server.

Then the Javascript based debugger started firing off "OPTION" requests because the test server was running on the local network (The standards working group that came up with the rule of sending an OPTIONS header aught to be taken out back and stoned for that particular hack. At least, the browser should warn you it is deliberately ignoring the method of your request and pretending to be brain-dead.)

Then, when things didn't work, the debugger doesn't give you details, it just says "Didn't receive 200 OK from remote server. (send failed)". OK, um, DUH. What failed?

Well, best not to continue. Down that path lies madness.

Request for Proposal, or, Trying to Bypass Design

2010-11-19T13:26:00.000-08:00

Consider what an RFP for a house might look like, were it to be written in the manner of an RFP for a Web site or software project:


Request For Proposal

Requirements
1) Contractor shall construct one building shelter, to accommodate one (1) family including all bedrooms, a kitchen, dining room, and toilet(s). 

2) All work performed must comply with industry standards.

3) Wood studs and gypsum drywall are acceptable materials for construction. 

Proposals without detailed plans and estimates will not be accepted.

Do you think developers give you wildly varying proposals? Is your RFP process designed to get others to do design work for you for free? Then it masks your own lack of due diligence, and you will get every bit of design that you pay for.

Big Design Up Front is not necessary nor is it sufficient for a project's success. But you still need to take the process seriously. Such requests are a clear indication that the RFP writer is not at all serious about project success.

Personally, I think RFPs used to elicit design input without payment are unethical. The behavior is no better than asking one dentist to lay out a strategy for fixing your teeth, then paying another to follow the program without remuneration to the first.

A Design Guideline

2010-11-18T17:45:00.000-08:00

Lay out for substantive content first.

Define your profiles incrementally. Choose a grid or columnar layout, and flow content into place.

Follow Occam's Razor:

pluralitas non est ponenda sine necessitate

Which is to say, don't use more markup than absolutely necessary to convey the meaning of the message. Use CSS for style. Don't use DIVs for positioning or include other gratuitous markup for layout tricks. Don't rely upon the relative positions and parent/child relationships in the markup for style or layout effects beyond in-line layout.

Include a browser reset. That will eliminate browser-introduced pluralities. The Yahoo! UI library has one. Eric Meyer has another. There are plenty of examples.

Choose a dominant typeface family and style to fit the message, audience, medium, and purpose. Use a san-serif font for body text, a serif font for headings. Align the sizing of both, since characters in two fonts will often differ in size. Use a font stack to specify the desired font, one or more fallback fonts, and a generic family as a stand-in. Carefully consider use of an OT/TTF or SVG Webfont with or without a foundry service like Typekit or Typotheque, or WOFF.

Choose a subordinate typeface for UI controls. Distinguish them with different colors or a different font family.

Determine word spacing, letter spacing, line spacing,

Use Em for relative sizes, but understand that one Em is equal to 100% of the font size property in effect within the context of the markup. So there is a cumulative effect of the settings.

Use proper glyphs for hyphen, en-dash, em-dash, and minus signs (I don't on my blog). Use the HTML entities for these and other special characters. (See smartypants or typogrify.)

For text blocks and columns, use multiples of ems to set line width relative to multiples of characters. Aim for 10-15 words or 75-100 characters per line. Set line height with a unitless number so that it is based on the font size.

CSS3 may support hanging punctuation (quotes and parenthesis are hung in the margins.)

Check out webtypography.net, usabletype.org, alistapart.com/topics/design/typeography

Points vs Pixels vs Percents vs Ems

2010-11-17T08:00:00.000-08:00

There's a saying attributed to Mark Twain that one should never argue with a fool because onlookers may not be able to tell the difference. I've seen a lot of Web people arguing about accessibility, design, and typographic units, and I am forced to agree with Clemens.

I'd like to see some compelling arguments. There are none. Units are units, and whether the browsers actually do the right thing or not is quite irrelevant to the question of accessibility. A site cannot be made accessible by hacking it to coincidentally work around defects in specific browsers.

Accessibility to a building is not a property of the bricks and mortar that make it up, but an emergent condition stemming from the challenges a person faces when navigating the patterns present in the structure. We cannot design buildings to address every challenge, so instead we create building standards to guide the minimum architectural feature set.

Similarly, accessibility of a Web site is not a property of the bits, nor is it feasible to design them to address every challenge faced by users - instead we have nascent standards for building-in accessibility by proxy, as a set of architectural features.

When we build our town halls and commercial buildings to ADA standards, what we are saying is that we expect certain patterns and relationships to be exhibited in the resulting structure. What we are not saying is that the door frames were field modified to accommodate an Acme brand Model 68020 wheelchair. Nor are we saying that the door frames were field modified because the doors were found to be constructed of defective alloys. The first case is too specific to one assistive device, and second case is clearly cause to demand a completely new set of standards-compliant doors.

Changing style sheets and muddling with markup in order to make something "accessible" for a specific set of browsers is ludicrous. It also smacks of being way too touchy-feely, relying upon subjective qualitative ideation rather than quantitative assessment.

Either we develop to standards, or we don't. Hand waving about pixels being inaccessible, points being "just for print," or percentages and ems being superior, is missing that argument entirely. If some feature of the site doesn't work for you, to the extend it is specific to a given browser it is not an issue of accessibility but a defect in the product... and we will all be better served if we stop making accommodations to defective products.

I'm Enjoying Ruby on Rails and BDD

2010-11-16T16:56:00.000-08:00

Nothing beats writing tests first with a truly integrated framework like Rails. Steak and Jasmine make it practical, even if they have their oddities. FactoryGirl, I'm not so sure about, but once it is set up it seems to be pretty reliable.

Done correctly, things just work. Done incorrectly, especially with FactoryGirl, side-effects can really clobber you and steal precious development hours away.

The case for concrete sizing

2010-11-16T08:00:00.000-08:00

What people have to say about "points" in Web typography. Points...

are a "standard method" for print typography
may be more legible in print, less legible on screen
and page resizing may not work consistently in certain browsers
are not relative to changes in base font-size (smallest, smaller, ... larger, largest)

OK, so I'm seeing the real problem here: lots and lots of Web designers are mixing the metaphors of Web layout as a formatting process and Web layout as an interface specification.

Don't do that.

If you are going to design liquid layouts with relative sizes, by all means, go ahead and play. Your designs are going to be beautiful, but then again no design on the Web belongs to the author. A design is always the merging of the intentions of the author with the choices of the user, within the limitations of a browser. So all that pains-taking is going to look great, but we know that by design it is guaranteed to break.

The thing is, points mean something objectively. In modern typography they have been defined to mean 1/72 of an inch. Yes, that's an English measure, the only widely used measurement system based upon human factors. Like our calendar it is entirely based upon the pragmatic considerations western civilization determined centuries ago. It is flawed and odd, but it is objective and well grounded in our experience.

So, tell me again, why do we want to measure fonts in pixels or percents, when we want our designs to be accessible to humans?

Incidentally, the argument against points on the basis that Web typography must deal with multiple device formats and layouts, is fundamentally flawed. The world of print typography has far more media formats than Web browsing devices can shake a stick at, ranging from huge to tiny, and on many different types of substrates. Points work precisely because they are an objective measure that can be directly multiplied by a unitless ratio for scaling, and thus do not need to be re-interpreted for each formatting context.

On the ideal of networking

2010-11-14T04:26:00.000-08:00

Thinking about some of the finer points of the IndieConf, on the ideal strategy of choosing several people and being helpful over time with the goal of establishing numerous positive interactions, thus building trust and establishing relationships.

Don't assume that payback from that strategy is uniformly distributed. It is most definitely not.

It isn't random either.

Nor is the payback going to be from the people that seem to be the most friendly, or those for whom you've put yourself out for the most. At least, not at the start.

What you'll find is that most people are leeches, willing to get but not to give back. Many more will undervalue anything offer that doesn't have a price attached to it. And a great number will just simply be prejudiced against something about you that has nothing to do with anything, but will prevent them from ever doing business with you.

There were some key things in this respect from the IndieConf speakers on the subject:

Intentional Pursuit. They chose who to pursue, and those they chose to pursue are people around the industry in which they wish to work.
Quick Selectivity. They made snap judgments to quickly eliminate disfavored prospects from their list.
Overt Spying. They made lists, and profiled the people they were pursuing.
Low Commitment. They did not over-invest their time, their reputations, or their other resources.

An example of #4 is that most of them mentioned, as the "positive interaction", sending an email note with an article of potential interest to their target, once every 45 days or so. They would review a list of their prospects once or twice a week, and with them in mind glean articles from RSS feeds and the "help a reporter" site. If they found something they'd push out a note. Very cheap, low outlay of time and no commitment, but it reminds the prospect that you are there.

Yet, people will still forget you, ignore you, or even get annoyed at you. If someone doesn't respond positively, don't obsess or fret... just move on. When you find someone who welcomes advice but never reciprocates or who actively works against you, strike them from the list and pick someone new to network with.

I've spent a lot of time pursuing connections at our local chamber, and in town, with the hope of getting business. Now I see that I've done several things wrong.

none of the chamber or town hall people are in fields in which I'd like to work, or express similar interests
my openness, tolerance, and patience have been extreme; in particular I was too slow to weed out poor connections
no tabs were kept on people, or other personal profiles, though I did stay in touch, and
the commitment of my time and emotional energy in volunteering, offering advice, and making other resources available, was substantial and interfered with me earning my keep elsewhere

There were people I admire, people I connect with, but I've been passed over twice for major business that I asked for, and on the whole it has become an un-enjoyable experience. Time to move on.

Stupid Blogger!!!!

2010-11-14T04:12:00.000-08:00

I hate Web based applications. Always, I get fooled into spending time writing something, only to have some random keystroke navigate away from the page and into oblivion.

AAAAAAAAAAAAAAAAHHHHHHHHHHHHHHHHHH!!!!!!!!!!!!!!!!!

We need to put a stop to this crap. We use these freaking interfaces

ALL

DAY

LONG

Why should they continue to be riddled with sucky design features. BACKSPACE causes you to lose all your writing? REALLY??????

OK, so, score one for Blogger. It saved the edit as a draft. (Insert begrudging Calvin-and-Hobbes grimace here.) It is still stupid to have backspace change the page.