2008 Mar 25 - Tue

How Not To Form a Standard

Rob Weir has a blog called An Antic Disposition where he discusses
The Disharmony of OOXML.
The eloquent center piece of his article is a table representing how various applications represent a smiple
text string with one word in red, represented here verbatim:

Format

Text Color

Text Alignment

OOXML Text

<w:color
w:val="FF0000"/>

<w:jc w:val="right"/>

OOXML Sheet

<color
rgb="FFFF0000"/>

<alignment horizontal="right"/>

OOXML Presentation

<a:srgbClr
val="FF0000"/>

<a:pPr algn="r"/>

ODF Text

<style:text-properties
fo:color="#FF0000"/>

<style:paragraph-properties fo:text-align="end" />

ODF
Sheet

<style:text-properties fo:color="#FF0000"/>

<style:paragraph-properties
fo:text-align="end"/>

ODF Presentation

<style:text-properties
fo:color="#FF0000"/>

<style:paragraph-properties fo:text-align="end"/>

Some wag once mentioned that a standard is nice, you have so many from which to choose. The standards
writers for OOXML must have had this in mind when they allowed the diversity of Text Coloration and Alignment into
the standard. Oh, wait. The applications were written first, then some general bucket was designed to hold
the output these applications produced.

As the writer says, it would have been nice to create a 'single standard' and then retrofit the application's output
to conform to the file format. If an application needs to store it differently internally, so be it, but conform
to some level of operability in the file format. Hmmm, can each application read each other's handiwork? If not, what
good is a standard?

The article indicates that once ODF was established, Open Office changed to match the standard. And from the table
above, we can see all the tools within Open Office conform, with the result of twin goals of true universality of information interchange
and simplicity of software design have been reached.

Bartosz Milewski, a member of the 'D' design team,
wrote an article
about making the
programming language D even safer than it purportedly already is. He called that subset:
SafeD. In the process of making D and SafeD look good, the failings of C++ were highlighted
in comparison. To his credit, the author was able to list a few good features:
performance, low-level access, and powerful abstractions (the latter being slighted at
the same time for apparently only being useful in operating systems or large systems design).

On the other hand, it is nice to hear that whenever people feel they have to make their
language-of-choice look good, inevitably some subset of C++ comes in as a benchmark. I
include the word 'subset' on purpose. There are specialized, productive, easy to learn
languages out there. I've even used a few of them. Each of them is better than some
specific aspect of C++, but few if any, can beat C++ in many areas. Ok, maybe Lisp does
better.

B Milewski did acknowledge that "There are many other simplifications and safety
improvements over C++. Unfortunately they all come at the expense of expressive power and
performance." well said.

I used C# for a couple of years, buying into the theory that automated memory management
and suborned pointers would be a good thing for me. Ah, no. I like the ability to be able
to 'shoot myself in the foot'. Really good gun-slingers know their guns, know where to
point them, know how to maintain them, know their useful range, and clean often to ensure
good performance. Would a gunslinger hand his gun over to an acolyte for cleaning and
maintenance? The same could be said of a programmer handing over memory management and
object manipulation to some hidden behind-the-scenes mechanism which may not be optimal for
the job.

Perhaps I'm just a control freak, but I had to depart C# and return to the wild west of
C++ programming in order to feed my adrenalin requirement of walking the fine edge of
writing elegant, flexible code.

Isaac Asimov wrote a book called the End of Eternity. The moral of that story was that
if humanity is not allowed to push the boundaries, and get hurt a little in the process,
stagnation sets in. Also, the hero of the story wouldn't have been able to look off
into the sunset with the heroine at his side.

Perhaps C++ is indeed a difficult language to master. It's flexibility may
be its
undoing,
but the for the tenacious learners, it provides a high level of satisfaction for allowing
one
to
come up with good solutions for tough problems, big or small... and for being able to
devise an
appropriate solution from an excellent collection of varied tools.

C++ is
Generic
Programming, template metaprogramming, which is said to rarely interact with mainstream C++
programming.

STL is a sub-language of C++ based upon algorithmic programming, as defined by
Alexander Stepanov.

In the referenced article from the last point above, a few enlightning quotations about
Stepanov's strong views of C++ strengths and weaknesses:
"STL is the result of a bacterial infection", "STL is not object oriented. I think that
object orientedness is almost as much of a hoax as Artificial Intelligence.", "Always start
with algorithms.", "Generic programming is a programming method that is based in
finding the most abstract representations of efficient algorithms", and "So far, C++ is the
best language I've discovered to say what I want to say".

O how they cling and wrangle, some who claim
For preacher and monk the honored name!
For, quarreling, each to his view they cling.
Such folk see only one side of a thing.
Jainism and Buddhism. Udana 68-69:
Parable of the Blind Men and the Elephant

For those hoping to find the perfect language, here is what
The Architect has to
say about that:

"Hope, it is the quintessential human delusion, simultaneously the source of your greatest
strength, and your greatest weakness."

Perhaps C++'s flexibility is both its greatest strength as well as its greatest weakness.

This should actually be filed under a few different headings (which is something I'll do
once I get the new blog software in place). Those headings being programming, software
development, visualization, animation, imaging, interacting, and open source.

It is some software called
Processing of which I speak. It is
hard to put into words what this is. I first took a look at some animation samples that
were produced for a FOX station's movie slot. They need to be seen to be believed. My next
step was to look at programming examples. The programming examples included visualization
of programming techniques...self referential, eh! More advanced examples provided the
ground work for how to do some of the flocking behaviour I viewed in the first animation
samples I viewed.

This site caters to the young and the old, programmers and visualizers. If only for the
eye-candy, it is a site to be viewed.

Disclaimer: This site may include market analysis. All ideas, opinions, and/or
forecasts, expressed or implied herein, are for informational purposes only and should not
be construed as a recommendation to invest, trade, and/or speculate in the markets. Any
investments, trades, and/or speculations made in light of the ideas, opinions, and/or
forecasts, expressed or implied herein, are committed at your own risk, financial or
otherwise.