The following code is ripe for some kind of alleviation of excessive typing (it’s a language-mandated violation of the DRY principle).
var newManifestTrackingNumber =
	new ManifestTrackingNumber() {
		Manifest = this,
		TrackingNumber = trackingNumber,
		BoxNumber = (short)boxNumber,
		DateCreated = DateTime.Now

Thankfully, c# already allows the implicit-typing “var” keyword or this would look like Java.  But finally, c# is to a strongly typed language that infers type from variable names, as Java is to c#. I am talking about a language in which the typeof a variable is coded in the name in a patterned way that the compiler can unambiguously parse.  YX where Y in (“new”, “my”, “matching”, user-customizable et-cetera) and X is some type knowable to the compiler based on the loaded modules, included namespaces, parsed files, et cetera.

Lispy macros are like keeping the history of significant IDE-like transformations in your code file within the editor (code snippets, even patterned paste-generic-then-replace-keyword-with-type, et cetera). If you do intelligent transformations upon the text, why not factor those transformations into a code layer more amenable to abstraction and evolution than user interfaces and human input devices (mice, keyboards, touch screens, et cetera).  An intelligent transformation is using a naming convention with variations that indicate code variations.  IOW, more like a natural language, with inflections and declensions.  Intelligent transformations on code involve abstractions that derive input from both the domain model and the design patterns.  Really intelligent coding around macros results in a style of programming that optimally combines the semantics of the domain model with the grammar of the design patterns.

I think we’ve worried far too much about making our programming languages easy to learn at the level they are easy to learn.  So, we can all form a c-syntax function, but few can both imagine and implement simple abstractions.  Our languages, with their 24-hour syntax (perl?), do little to communicate or catalyze higher order structures within our programs.

Part of the problem is verbosity, surely.  A great deal of the problem is the difficulty inherent in simplification.  How much a language can help with this is debatable.  But another part of the problem is how most of the architecture of the algorithm is hidden because it cannot anywhere be represented by the language.  It has to be built in the mind of a programmer by reading the code.  This is what language development needs to target.

In .NET you have the concept of a Solution (which is a set of Projects and settings).  This helps you manage dependencies and ties everything together.  But I would consider a solution to be an html document (Uide) of which a directory structure of projects was not the primary way of exploring the program (I’m talking about the Solution Explorer, which is a tree view of the directories, projects and files of the Solution).  More specifically, I would bake in the idea that programs have a description and that the expansion of that description is the navigation and elaboration of the extant document.

I’ve been enamored of the idea of a hyperdocument for a while now.  Now, I don’t know who all’s reading this, but I can speak for myself and say that while I’m not stupid or blind, I nevertheless never truly reflected on the depth of the idea of a hyperdocument until about 2 years ago.  The idea of a hyperdocument has been around since I was in high school, and I’ve known all the relevant information for a decade, but I hadn’t yet suffered for the problem it solved.  It wasn’t until I’d programmed a lot for many years that I saw.  All program code suffers the same flaw in that none of it can describe nor facilitate it’s own navigation or high level architecture.  Code inevitably becomes a jumble of unnumbered chapters as time removes the details from mind.

And don’t think I except the Integrated Development Environment (IDE) from these reflections.  Or the alphabet.  I’m fully on board with some modern tendencies to meld the programming language into the User Interface (UI) IDE (Uide [like smalltalk, lisp {IMHO}]).  It all comes back to that Paul Graham quote:

If you take the principle of bottom-up programming all the way up to the topmost layer of your program, then that layer becomes a programming language for the user.

– Paul Graham, ANSI Common Lisp, pg. 3

Who better to take it to heart than language designers themselves!  At least that’s my way of seeing things.

I like a language where the code is considered data (homoiconicity).  That’s powerful.  That opens up new doorways of expression.  It’s no wonder that Lisp, the only language with this property (is that correct?), is the language of Artificial Intelligence.  We understand that code embodies behavior.  We understand that we are trying to create life-like intelligence.  We understand that living systems modify their behavior.  Ergo, our AI should be able to modify its codebase.

Of course, it’s all terribly more complicated than that.  The idea that the codebase of a creative AI would be human readable is probably a false one.  But at one time it would have been readable.

I’m interested in exploring the boundaries within the equilibrium between simple syntax and expressive macros, as well as the possible development of a shape-modifying alphabet (in this way, maybe it could be medium-jumping as well [if a geometry is defined using a collection polarities then the shape can be represented in any sensory {or nonsensory} field which can simultaneously differentiate and represent enough distinct axis {or maybe that’s just gibberish}]).

The essential problem is representing connectivity.

One thought on “Uide

  1. […] relates to hints I’ve been dropping here and there and everywhere (here too) about condensing the expression of knowledge.  I like Uncle Bob’s conclusion to the […]

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s