Blunder Dome Sighting  
privacy 
 
 
 

Hangout for experimental confirmation and demonstration of software, computing, and networking. The exercises don't always work out. The professor is a bumbler and the laboratory assistant is a skanky dufus.



Click for Blog Feed
Blog Feed

Recent Items
 
Republishing before Silence
 
Command Line Utilities: What Would Purr Do?
 
Retiring InfoNuovo.com
 
Confirmable Experience: What a Wideness Gains
 
Confirmable Experience: Consider the Real World
 
Cybersmith: IE 8.0 Mitigation #1: Site-wide Compat...
 
DMware: OK, What's CMIS Exactly?
 
Document Interoperability: The Web Lesson
 
Cybersmith: The IE 8.0 Disruption
 
Cybersmith: The Confirmability of Confirmable Expe...

This page is powered by Blogger. Isn't yours?
  

Locations of visitors to this site
visits to Orcmid's Lair pages

The nfoCentrale Blog Conclave
 
Millennia Antica: The Kiln Sitter's Diary
 
nfoWorks: Pursuing Harmony
 
Numbering Peano
 
Orcmid's Lair
 
Orcmid's Live Hideout
 
Prof. von Clueless in the Blunder Dome
 
Spanner Wingnut's Muddleware Lab (experimental)

nfoCentrale Associated Sites
 
DMA: The Document Management Alliance
 
DMware: Document Management Interoperability Exchange
 
Millennia Antica Pottery
 
The Miser Project
 
nfoCentrale: the Anchor Site
 
nfoWare: Information Processing Technology
 
nfoWorks: Tools for Document Interoperability
 
NuovoDoc: Design for Document System Interoperability
 
ODMA Interoperability Exchange
 
Orcmid's Lair
 
TROST: Open-System Trustworthiness

2006-04-01

 

Does Visual Studio Rot the Mind?

Does Visual Studio Rot the Mind?  Thanks to Doug Mahugh having a dreary day indoors, I’ve found this October 2005 gem from Charles Petzold.  Petzold gives voice to a number of problems that have been nagging at me and for which I haven’t found a clear view.  Petzold (who’s April 1st 2006 parody on XAML is also brilliant) sharpens the difference between programming fast, programming well, and programming clearly.  Doug’s grey-day post and Petzold’s appraisal are instant candidates for Best Software Writing II when Joel Spolsky gets around to it.

{tags: conceptual integrity
  }

[update: There were some nasty typos and mangled wordings.  “Does Visual Studio Rot the Mind?” is already on Joel Spolsky’s list, but I was happy to add my vote.]

I only recently learned that Petzold has a blog.  The RSS feed quickly went into my WinDev category among others including Larry Osterman, Michael Kaplan, Raymond Chen and, of particular relevance here, the MSDN Forum for the Visual C++ 2005 Express Edition.  I learned of Doug’s blog through his involvement on the new site on Office Open XML formats and their use in document interchange.  I notice that seeing each new offering from him has me smile.

First, I think that Doug’s use of a kind of Structured English (what is also known as pseudo-code) for high-level characterization of a programming approach is classic.  It’s a recognized software-engineering methodology and is a recognized way to work on the conceptual organization and essentials of a procedure before dealing with the syntax and low-level details that can easily obscure the important overall organization.  It’s literally classic: it goes back to the very early days and Grace Hopper’s efforts to make programming languages match that level of expression more closely.  (I watched a dismal failure on that, ambitiously and prematurely advertised as “English Spoken Here,” but Cobol has to be counted as the eventual success.)

I can even recognize how that approach, which I have used and which I preserve in comments that introduce the detailed sections of code, fits into my breaking down of mainline procedures into use of components.  There, I find that I am designing header files with descriptions of interface principles and stub procedures with pseudocode, all to be filled in progressively and confirmed with successive layers of tests as more function is available to exercise.

This works great for procedural logic and decomposition of the approach, something that remains a valuable practice.  It also ties into how we can tell we’re done and that we have produced what it is we started out to provide. It should also let someone else confirm that what the program's for, not just what it is doing with the bits. That way, others can perform maintenance and continuation work with easy recognition of the invariants that preserve the program’s architecture and functionality.  (Yes, it helps to code like a girl, or anyone else who cares about who will need to read and understand their programs.  I code that way as a gift to my future forgetful self so I can recreate what exactly I was doing and why.  I’d like to think others may find interest in it.  It’s important to me for my own sense of competence and completed work.)

Where structured-anything doesn’t work very well without a lot of careful preparation and practice is when our code consists of fragments/components of something not in view (and that we may not understand how to debug).  For example, our bits might form a cohesive interactive performance only when integrated with a not-so-well understood User Interface threaded-messaging process.  We should be concerned about Petzold’s observation that we are losing something with tools that hide this mystery and leave developers with an uneasy sense of incompetence.  Old hands can adjust to it by bringing solid experience along with a willing beginner’s mind.  That’s advantageous to finding out what is going on and how to establish establishing that our creations are reliable and, with luck, maintainable too.  My concern is that beginners will not have that perspective and will suffer its absence down the road.

One of the great qualities I find in Petzold’s work is his appreciation for the beginner.  I value his care in making sure that his readers are advised about what they need to already know, while letting them operate with as little tool support and startup-cost as possible.  You don’t need Visual Studio for his classic Programming Windows (ending with the 1999 5th edition for Win32) and its sequel, Programming Microsoft Windows with C# (2002).  You just need the compiler, understanding of command-line operation, and some standard developer utilities plus the appropriate and freely-available SDK.  Another common feature of Petzold's work is progressive learning by doing and then doing more, backed up by worked examples that actually do something it is valuable to know about.

My interest in the Visual Studio Express Editions is not just that they are currently available for free so far (and there are books now available that include copies of them on CD-ROM).  It is that it the Integrated Development Environment is limited but sufficient, and the packages are intended for beginners, students, and hobbyists.  I also get to see where some people are stumbling and reporting it on the forums.  I don’t know how representative that is, but it gives me a sense of where there are serious blanks to fill in.  I notice this most with Visual C++ 2005 Express Edition, where there are the fewest beginner books and the power of the system is strewn with landmines for the unwary beginner.  Now let’s see if I can tap my beginner’s mind well enough to fill in the blanks and ease the entry for others who want to program for Windows.  Something that lets newbies come play with the likes of Doug and Charlie and see how satisfying that can be.

2006-03-29

 

Grady Booch on the Limits of Software

Blog (Handbook of Software Architecture). Grady Booch makes a gracious observation about the furor concerning the announced delay for Windows Vista on his blog (no permalink: current article will scroll off).  He looks at the angst posted by Microsoft developers and observes 

comments suggest that the root problems are not technical, but rather orbit the region of design and organization in my characterization of the limits of software [registration required — dh:].

{tags: }

Booch’s depiction of the limits of software and the situational factors that originate many of those limits is a must-read.  The registration process is painless.  I heartily recommend the draft materials in the on-line Handbook of Software Architecture to anyone interested in architectural considerations that apply to software systems design and development. 

One tangential value for me, on my third or fourth scan of the limits page, is that I finally have come to understand where “Forces” come from in templates for pattern languages.  I’m still uncomfortable with that metaphor for patterns of non-physical systems, and will stick to concerns.  I also notice that it is important to identify important constraints as well as requirements, especially non-functional ones and I haven’t looked at that in the context of patterns for computer-based applications.  (I also see that I have one more David Harel book to track down.)

 

Modeling the Office Open XML Packaging Conventions

OpenXML Developer - Modeling OOX Packages. I've been waiting for an open forum for discussion of the ECMA TC45 Office Open XML Document Interchange Specification (now at draft 1) and especially the OOX package conventions, apparently a subset of the Microsoft Open Packaging Conventions.  Now there’s openXMLdeveloper.org (I hate the name — XML is already open — but love the place).  I just posted about my interest in the packaging model and though it would be useful to share that more widely.

{tags:   }

I'm a protocols and formats standards junky and I started to look at how to describe a conceptual model for the Office Open XML packages. I notice that there seem to be at least three levels of abstractions involved, and while I mull on that some more I was wondering if anyone with a similar interest had any observations to share.

Here are the at-least three:

  1. Package Conceptual Model - this is the highest level of what a generic OOX package is, what its essentials are and what it carries. This does not deal with the specific OOX content, just the package itself. Getting to the carrying of office documents is a much bigger deal, with more levels of abstraction. The relationship and content-type items might not exist independently of parts at this level.
        
  2. Package Logical Model - this is in terms of the abstracted items. I'm waffling, here, on whether the [Content_Types].xml part is reflected or whether every component simply has a content-type attribute. I'm pretty certain that parts and relationships are reflected here, as is the hierarchic structure. This provides a logical, navigational representation for the conceptual OOX packages. It is independent of particular method of storage and technology for access and manipulation.
        
  3. Persisted/Serialized Storage Model(s) - this is in terms of storage-system and data stream formats. Carrying a package in a hierarchical file system (e.g., before-after Zip-extraction) applies as do other possible storage abstractions. The Zip format as a serialized storage structure or data stream is another case. This level makes use of the Zip model (itself an abstraction) as a carrier. Taking it all the way to the bits can be handled below that. An important characteristics at this level is that the models all have a way to be transformed into and out of the Zip serialization. I find the use of a constrained hierarchical-storage model easier to visualize and explain, even though the Zip serialization is the key to interchange.

So that's what I've been thinking about as I tinker with diagrammatic ways of coming to grips with the OOX Package conventions. The reason I'm doing this is that document-processing is a pet interest of mine. I'm interested in explaining and demonstrating how we use abstract levels like this to ultimately accomplish useful processing of digital documents. I think OOX Packages (and OPC even more-so in some respects) are ideal choices because these open formats are going to be of great practical value as well as useful objects of study.

Dennis E. Hamilton
AIIM DMware Technical Coordinator
http://odma.info http://DMware.info

The package model is a very interesting application of Zip files as containers for more-complex related components that may carry references to each other and to material that is elsewhere.  The package allows the essential relationships (and the nature of the package components) to be determined without having to know how to process the individual parts themselves.  That makes for some interesting opportunities in document processing and in the interchange and preservation of digital assets.

 
Construction Structure (Hard Hat Area) You are navigating Orcmid's Lair.

template created 2004-06-17-20:01 -0700 (pdt) by orcmid
$$Author: Orcmid $
$$Date: 10-04-30 22:33 $
$$Revision: 21 $