HXA7241 (logo)

abstract tentacly things

NOTES

some short notes on a limited range of subjects

This is a blog-alternative: a series of informal notes of various ideas.

The most common topic is (somewhat speculative) thinking about software engineering. It is not really time-oriented – the latest entry is not especially important, so scroll through the list of summaries and read any one.

Feed icon subscribe

Software's essential form, and visual programming

(permalink: note 2014-03-30T11:14Z)

Text fits software's essential form. And any kind of visual programming will still have a similar kind of structure. We can do better than text, but it seems not a lot better.

Consider (again): http://axisofeval.blogspot.com/search/label/hypercode

That is actually a reasonable pondering and aligns with the conclusion of this note, but let us step back and look a little more generally.

Is this not related to visual programming – based on icons, or diagrams, or other graphical things? What possible visual ways are there? Are there completely new ways to program?

No: any possible ideas of visual programming have certain firm limits. Here is why.

———

Start with this question: how would you input such graphical code? What would be the UI?

For a small language, of 20-ish elements, you can have a menu at the side and pick which to use. But what about including the basic library, of 200 items? Or the main library of 20000 items? A menu to pick visual elements will not work.

The obvious answer is: you type the name of the wanted element – i.e. text! Or a first thought of an alternative: classifying into groups and subgroups, and navigating down the tree. But the path to any such leaf item is just a sequence of ‘keys’ each from a small set: really, just like a name composed of chars, which would be quicker to use – text again.

Maybe the purpose is more about using richer gestures and representations to input and output code. But the problem is still there: how can those be referred to? How could you describe a sequence needed to perform some task? Probably by naming them – which is back to text.

So alternatives to text seem just, well:

“Any sufficiently complicated non-text programming system contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of ordinary text.”

– HXA's 10th law (adapted from Greenspun's).

It is not as bad as that, but the point is there. Purely visual/graphical systems do not seem workable, and there is always something pulling us back to text.

———

But is this merely long conditioned text-culture making everything seem like text? (like money) To avoid that we can ask this question: is it possible to break down and understand the matter in terms that are independent and primitive?

What is the structure, the form, the shape of software? It seems so ethereal and ungraspable, what is there to get hold of?

The form of software is what is done with it. Software has the features it has because of the actions performed on it. And what we do with it is build: assemble smaller pieces into larger ones, and also as part of that process, analyse larger pieces into smaller ones. There are two basic aspects: connecting and nesting – connecting in a kind of adjacency, and nesting as grouping mulitiple into one. Software is constructive. The form of software reflects the engineering design process.

And any sophisticated and powerful way of making things must be like this – built-from-pieces. If every new artifact were made whole and indivisible, there could be no reuse. And we would have no knowledge about what we make – how it would work/behave – because it would contain nothing used, hence known, before.

With material things, their shape and features determines what we can do with them. But with software it is the other way around: we can make any kind of appearance we want, but the activity is pre-set. We have a particular purpose and actions we want do with software, and so we have to make it ‘look’ appropriate for that – or we are best off if we do.

It is this constructive form of software which makes a text-like system always make a lot of sense. Text – ‘built’ of chars, and words, and lines – nicely reflects that form. Text makes for a good expression of the essential structure of software.

So we need some constructive symbol system (of building symbols from smaller ones) to grasp software, and text is probably a well evolved, if not simply a well established standard for that.

———

Also try thinking from the other direction, from picture to software:

You may look at other visual forms – the many varieties of diagrams, illustrations, pictures – and feel they are richer and more communicative than mere text, but this vague feeling is misleading. Stop and ask: what do these pictures mean? what information do they present? what structure do they have?

If you had to draw a picture of software, it cannot be that just anything would do. Just because they might be colourful and detailed does not mean such pictures can express software, that they can fit software. Any kind of picture cannot represent any kind of structure – otherwise ‘representation’ would not mean anything.

Most of the richness you might see is meaningless for software. The main requirement for a picture of software is to express the structure of software. Software has a particular objective form: pieces connecting and nesting. Any picture of it must be centered on expressing that.

Code as text is visual programming: it is just a picture made with a quite simple kind of drawing tool.

———

So visual programming ought not to be an ignis fatuus: it seems not to offer any fundamental breakthroughs. It probably cannot even be about eliminating text, or only in a superficial way. Instead, it must be about expanding text or augmenting it or making new variants of it.

This includes bringing forward various manipulations. Text-editing puts char-shuffling in the foreground, but we ought to emphasise the larger software structure manipulations (starting with the basics of connecting and nesting), that are currently rather in the background.

———

archive

Post-Currencyism 3: Security – 2014-01-19T12:38Z
Does this make a viable cooperative structure? Is it basically self-supporting?
Post-Currencyism 2: Allocation – 2014-01-19T12:14Z
But does this make sense as an economic mechanism? How can it allocate without currency?
Post-Currencyism 1: Outline – 2014-01-19T11:23Z
What is a specific, concrete way to describe the core idea? What software form would it take?
Post-Currencyism 0: Introduction – 2014-01-19T11:09Z
An examination of post-currency economic systems.
‘Boolean-blindness’ is about types – 2013-11-24T09:27Z
‘Boolean-blindness’ is not really about booleans, it is about destructuring data into types, and hence the virtue of a good type system.
Testing vs proof in software development – 2013-08-04T09:39Z
Is proof better than testing? On examination it seems they are not quite comparable, and the key issues are other things: inference and judgement. Development needs both. Perhaps ideally fused into ‘inferential construction’.
Programming language docs structure – 2013-07-07T09:00Z
Some suggestions for documentation from learning several programming languages – along the lines of a quasi-formalised structure.
The morality of persuasion – 2013-06-30T10:38Z
Is persuasion moral? Only, it seems, in a strictly limited sense. And that leads to an informational problem of how to know when it is.
Rule-following and software development – 2013-06-09T09:17Z
“This was our paradox: no course of action could be determined by a rule, because any course of action can be made out to accord with the rule.” – Philosophical Investigations 201a.
How to approach designing an economic system – 2013-02-03T10:36Z
De-focus from currency; orient with independent knowledge; imagine cellular automata; base on supply and demand; think in software; discretise, distribute.
GITI – Electric guitar music text format – 2013-01-27T11:24Z
GITI is a new music text notation for electric guitar: a bit like a specialised kind of abc (another non-traditional notation)
Debt is a bad cooperative structure – 2013-01-20T10:53Z
When you look at debt as an abstract informational/cooperative structure you find it is a dysfunctional one. And a quick check for any rational moral basis turns up nothing either. Debt is unwise and we should stop doing it.
SBNF – BNF in S-Exprs – 2013-01-13T11:07Z
S-Expressions seem particularly well-suited to BNF formulations, giving a simple, regular, and memorable format.
Compensation for work is wrong – 2013-01-06T10:19Z
Compensation is a faulty notion; it does not actually happen, and indeed cannot happen. It is misguided as a basic concept of economic systems.
Money definitions are teleological and tautological – 2012-12-30T11:23Z
The dominant features of thinking about money are teleology and tautology. This is bad both for understanding and coming up with new ideas. We should think of it more computationally.
Credit for info-goods – 2012-09-16T09:56Z
Info-goods should include proper credit/acknowledgement should they not? Maybe that default intention is archaic and narrow, and it is now generally better to decouple description and associate it by hash.
Your next project? Design a new economic system! – 2012-09-09T09:26Z
We are surprisingly close to complete economic revolution. And this is a very interesting thing to ponder and imagine from a software view. Does that seem crazy? The reasoning is, however, straightforward: 1, the economic system works on money; 2, money is really information; 3, information technology is revolutionary.
Evolving global software – 2012-09-01T10:34Z
How should we develop software globally? Is it possible to say what kind of basic process and features, what broad strategies, are preferable? Here are three suggestions.
On Pagel's 'Infinite Stupidity', and what new information is – 2012-08-18T09:24Z
The article ‘Infinite Stupidity’ makes a novel and interesting point. But it does not quite seem to stand up, and examination of why begins to unravel what information is and where it comes from.
Names are wrong, tacit/point-free is right – 2012-07-08T09:07Z
In software, are names not a curiosity? They are like a mini embedded comment – nothing else is like that. But furthermore they seem structurally poor too. ‘Tacit-programming’ is the remedy.
Marxist efficiency – 2012-06-24T11:24Z
Marx's famous slogan of communism, considered purely in itself, seems wholly consistent with the core of (neo-)classical economics, but leads to a much more general perspective.
Artificial intelligence and the future – 2012-06-17T09:42Z
Is strong AI not very far away now? That is not the right question.
The internet, Kickstarter, and the obsolescence of markets – 2012-06-10T09:29Z
How much is the idea of markets obsoleted by digital networks ?
Why is information a string of digits? – 2012-05-13T11:16Z
The fundamental form of information seems to be a string of digits, e.g. DNA, text, bits. Why? This appears to be a peculiarly intriguing question. It is about something apparently very simple, yet it seems somehow profound.
Parsing wrongness and language value – 2012-05-06T09:07Z
Parsing is a poor choice of problem. Programming languages should help us see and help us move.
On VPRI STEPS – 2012-04-29T10:19Z
They seem to be producing a ‘second-draft’ of current practice, and making some good abstractions, not a revolutionary general technique. Perhaps because no general revolutionary technique seems possible for programming as such.
Money as a cooperative mechanism – 2012-05-08T11:21Z
What is money? It is a mechanism that supports/induces a particular framework of cooperation. And it is outdated.
Comparing natural language and software – 2012-01-22T12:07Z
Natural language is very different to software, but what is similar? what makes them seem related? They seem to focus on abstractions of different character.
Living software and dead software – 2012-01-15T11:41Z
What kind of software do you really want to make?
Software as thought – 2012-01-08T12:48Z
Chaitin's little quote about software is interesting but somehow seems not quite on target. So here is a new version, modified and expanded.
A copyright economy is a ‘waterfall’ economy – 2012-01-03T10:08Z
Copyright has deep intrinsic inefficiency and makes the economy like a weak software development process.
Software's economic basics – 2011-12-18T11:51Z
Software is about: designing the right(-est) thing, and letting anyone create benefit from it.
Why an information economy is not an IP economy – 2011-12-04T12:57Z
This is a prompt to think differently about information, IP, and their economic arrangement.
A logical analysis of copyright orthodoxy – 2011-11-27T11:47Z
There is a kind of rhetorical trick in copyright theory. The orthodox model appears to give a rational solidity to copyright, but as an argument for it it is unsound, and proves nothing of what it appears to want to.
Power, predictability, and regularity – 2011-11-13T12:41Z
At the deepest level, software seems to have an essential trade-off of power against predictability. And the problem there is not a matter of conformance but of clarity. That means perhaps the best we can do is design programming languages to have a kind of ‘regularity’.
Enduring software – 2011-09-25T10:06Z
Making ‘enduring software’ looks more like a requirements/product-design problem than an engineering problem.
The insoluble pragmatism of types – 2011-09-18T10:16Z
What one might think of as the problem of type systems looks, in a deep sense, actually insoluble. A useful module cannot be completely specified.
What part of design is possible? – 2011-09-11T09:48Z
Two of the underlying skills possible in engineering design must be part of the grounding of programming languages.
‘Long Now’ of software? – 2011-08-28T10:06Z
Is it possible to have a software equivalent to the ‘Long Now’ project? Can we imagine a software system that would last for 10000 years? (or even just 1000) This means both running and adapting/reusing – both of the two fundamental aspects of software.
The ‘ideology’ of software engineering – 2011-08-21T11:32Z
The theoretical ‘ideology’ of software engineering seems to be logical, mathematical – this is how we implicitly think of software, that is what computer science leads us toward. But is this a little misleading?
Reconsidering a Scheme formatting convention – 2011-08-14T09:44Z
A hugely important matter of getting source-code just right.
The embarrassment of copyright policy – 2011-08-07T11:13Z
Simply acknowledging the facts, or lack of them, leaves copyright in a surprisingly troubling position.
What is metadata? – 2011-08-01T10:44Z
It is usually described as ‘data about data’. But there is a slightly different angle to see it from – not so much ‘above’ but ‘beside’.
Defined rating systems, and Google +i – 2011-07-17T09:08Z
Rating systems – like up-voting buttons for news-blogs – have a problem: what do they really mean? They seem too vague. Rating probably ought to be more clear and articulated.
On Dijkstra on software's radical novelties – 2011-07-10T08:53Z
In ‘On the cruelty of really teaching computing science’ EWD1036, Dijkstra captures some deep truths of software – but seems to give them a somewhat gloomy cast. Software has radical novelties, but we should not see them in a negative way.
Distinguishing abstraction and change – 2011-07-04T11:25Z
Abstraction and change overlap in some way, and maybe it is worth thinking a little about what that means and how they are separate.
The aim of software engineering – 2011-06-27T08:42Z
What, as a discipline, is software engineering trying to do? – One could begin to answer that its purpose is to be an optimal intermediary between requirement and material: a tool that goes where you point it, and shows you where it is pointing.
A fault in blogs – 2011-06-19T09:09Z
We ought not to be using blogs so much.
The second basic question of software engineering – 2011-06-12T08:55Z
Saying we want to improve how software engineering is done seems OK, but can that be clarified? We understand what kinds of computation are efficient by formalising the idea of what computation is. We can perhaps understand what development is efficient by formalising what development is.
The functional/representational division in software – 2011-06-05T07:23Z
The division of software engineering into ‘functional’ and ‘representational’ aspects/structures can be expressed with a simple (if a little archaic) metaphor, and backed with some basic theoretical definition.
A comment on: ‘The Carrying-Cost of Code: Taking Lean Seriously’ – 2011-05-29T07:14Z
The original article seems, on analysis, contradictory to agile. But maybe some resolution is possible, by building more general knowledge from more general investigation.
Software engineering and philosophy – 2011-05-22T09:35Z
Software engineering and philosophy are in a sense (with a little imagination) twin subjects.
In Lisp, should lists be replaced with trees? – 2011-05-15T09:07Z
Conses/pairs/lists are rather low-level when you think about it. Would we not appreciate something just a little more powerful, a little more modern? A tree primitive is here casually and heretically proposed as a better alternative.
Machine philosophy rudiments – 2011-05-08T09:13Z
What is a machine? It is not a sort of complex mechanism. It is not a physical object. Or rather, it is not just those, or essentially those.
IT-farming (or not) – 2011-05-01T09:35Z
Why do IT people like to use the word ‘farm’? – e.g. ‘server-farm’, ‘render-farm’. It does not really make sense. What they really mean is factory.
Considering the limits of DRY(‘dont repeat yourself’) / factoring – 2011-04-24T08:26Z
Factoring is good, but it has to be limited by what you really know. Otherwise adding more abstractions obstructs change more than necessary. But it is not really a trade-off: getting one aspect right makes the other right too.
Surgical registries for software development? – 2011-04-17T09:13Z
Surgical practice has developed an alternative to scientific trials to build knowledge. Perhaps this approach could benefit software development.
Definition of ‘abstract’ – 2011-04-10T09:10Z
Abstraction is definable in a nice discrete way. And abstraction is a fundamental law of reality! maybe.
Licenses are not polite agreements – 2011-04-03T10:29Z
There is a quasi-meme-let around that proposes that software shrink-wrap copy-restriction licenses etc. are just honourable agreements. This is irritatingly spurious, and ought to be exposed. Here is a rebuttal – or inoculation.
Stone cathedrals, structure-preserving-transformations, and software development – 2011-03-27T10:46Z
This note stems from two sources: ‘How To Build A Cathedral’ (BBC; 2008) – a TV documentary; and ‘structure-preserving-transformation’ – a phrase from Christopher Alexander. And it leads to a seeming weakness in sofware development – how we systemetise ‘construction’.
Dependent types are about consistency – 2011-03-20T10:27Z
Dependent types allow constraints to be defined with (almost) full algorithmic richness. Thinking about what this is doing illustrates the distinction between ‘consistency’ and ‘verification’.
Software as web – 2011-03-14T20:11Z
wbcvsn-expansion:http://axisofeval.blogspot.com/2011/02/browsers-will-let-pls-break-free-from.html seems right, and worth considering more, on something of a tangent.
A small trick to Xor – 2011-03-10T21:08Z
An arithmetic way to perform exclusive-or – something that might have a small use somewhere.
Typing and visibility – 2011-02-27T08:33Z
Strong typing is better than visibility, but neither is quite what is wanted.
Wittgenstein for programmers (part 1) – 2011-02-19T11:13Z
What does an early 20th century philosopher have to say about software engineering?
Imagining ‘dynamic macros’ for Scheme – 2011-02-13T09:41Z
It seems possible to merge macros with lambdas, making a smoother single language feature. (At least, as far as a quick casual pondering will take you.)
Reflections on using Scheme – 2011-02-06T22:36Z
The Scheme (R5RS) translation of the MiniLight renderer has just been finished (the latest of 12 translations, 8 by the author). So now is a good time for some reflections on the language.
Testing: thoughts on improving it – 2011-01-30T09:17Z
What does testing really do? And how can it be improved? Thinking beyond the surface seems to lead away from testing and toward automation and ergonomics.
Corporation vs. internet – 2011-01-23T10:31Z
(It is not really just Facebook, it is a general problem.)
OO modelling and the real-world – 2011-01-16T09:49Z
A philosophical answer to a post at Lambda The Ultimate (wbcvsn-answer:http://lambda-the-ultimate.org/node/3265) (pointed out by axisofeval) which asks: “Why are objects that we use in programming so vastly different from real-world objects?”
Programming is probabilistic – 2011-01-09T10:23Z
In common programming, we use abstractions in a particular kind of probabilistic way. It is normally in the background, but is fairly well-defined, and deserves more examination.
Normalised comment rating – 2011-01-02T09:55Z
News-‘forum’ sites, like Hacker News, seem to rate comments just by counting votes: is that sophisticated enough as a measure?
Code style and patterns – 2010-12-27T10:08Z
Code style is open to the same criticism as software patterns – they are indicative of a lack – but they may also be unavoidable
A comment adding to Dijkstra on natural language programming – 2010-12-18T21:58Z
To add to Dijkstra's note ‘On the foolishness of “natural language programming”’: language and program are not even properly comparable
The attribution ingredient in IP justification – 2010-12-11T13:31Z
Mere claim of authorship is insufficient for ownership rights
Implicit code – what makes it good or bad – 2010-12-04T17:16Z
To make a software structure implicit you should adhere to a clear abstraction – then being implicit is good and not bad
Should there be hard limits on program part sizes? – 2010-11-24T19:27Z
There is cause to, based on complexity, but a better solution seems to be to adopt a different structuring – one with different scaling behaviour
‘Incentive’ in intellectual monopoly – 2010-11-16T18:14Z
IP does not give incentive, but a fix for market inadequacy
Designed software will never be substantially higher quality – 2010-11-09T21:02Z
There is a myth in software, that if we could somehow find the magic knowledge, all our software could be built to some future ideal. This cannot be right
What is a 'strong' or 'weak' standard? – 2010-11-01T19:47Z
Here is one possible measure of standards, and abstractions generally, by seeing the gaps in them
The big fault in OO – 2010-10-26T20:52Z
OO's central abstraction – the class – is too weakly, loosely defined.
The software engineering equation – 2010-10-06T20:11Z
If there were a single equation summarising all software development and use – a ‘law of infodynamics’ – what would it be like? – Here is a quick imagination of one.
A conversational convention for the web – 2010-08-11T22:47Z
A simple ad-hoc ‘semanticised web’ idea for making structures of related texts.
Why economists like copyright; but shouldn't so much now – 2010-08-02T22:52Z
A perspective on the basic connections of copyright, industry, and internet.
A Comment On: ‘Why writing software is not like engineering’ – 2010-07-20T18:42Z
Seeing the kernel of engineering in software development.
Alternatives To Design-Construction-Maintenance – 2010-07-13T21:23Z
A possible model of development based on software's own particular ‘material’.
A Core Of Programming – 2010-07-06T22:16Z
A few key structures that most programming languages share.
Copyright ‘Losses’ And Public Gains – 2010-04-25T21:49Z
How a common corporate message of copyright and the internet is the complete upside-down of truth.
The ‘Important First’ naming rule for software things – 2010-04-20T20:46Z
A small but valuable rule for naming things, that seems less considered than perhaps it ought to be.
‘Getting Things Done’ and software architecture – 2010-03-30T19:17Z
There is an interesting characteristic of ‘Getting Things Done’: it seems algorithmic, computational.
Future software engineering's three bases – 2010-03-17T21:04Z
The future of software engineering is in combining less deliberate design with more automated generation and evolution.
Design should be backward-looking – 2010-03-13T17:25
Good engineering design rests essentially on good knowledge – not prediction.
There is only one program – 2010-03-02T21:57
Software tends toward a continual global ecosystem.
The simple rule of why copyright is now broken – 2010-02-21T11:00
Internet benefit is inversely related to copyright strength.
An outline map of software development – 2010-02-15T21:41
A way of dividing up and placing the parts of software development, in terms of other established fields.
Keeping your new ideas secret is probably wrong – 2010-02-09T20:01
A simple rational demonstration.
The illusion in up-front design – 2010-02-01T20:38
There is an illusion in the idea of up-front design in software (that is, code arrangement, not algorithm), that makes it seem more plausible than it really is.
The essential weakness at the core of Google search – 2010-01-22T20:23
. . . and a related problem in user-moderated comment systems.
Paying For Information, Asymmetrically – 2010-01-13T19:17
The most reasonable way to pay for information is right in front of us.
Software Engineering Materialism – 2009-11-16T19:12
It is good to think of software engineering as ‘the design of structures in a special abstract material’.
The morality of copying: a simple Kantian evaluation – 2009-11-10T21:54
A simple, solid argument for the moral goodness of copying.
Vitruvius - 'Firmitas, Utilitas, Venustas' - In Software – 2009-10-25T21:23
Vitruvius' ancient principles of architecture can be used to view software.
Genome Versus Programming Language – 2009-10-19T20:52
Genomes have an extra means of code expression/expansion compared to artificial software.
Genomes As Software – 2009-08-31T20:06
A genome is a digital object, and the way it works as a system may be significantly like software.
A Comment On ‘A Conversation with Alan Kay’ – 2009-08-06T11:42
An observation on an interesting software development analogy.
‘Software Design’ Is Not Design – 2009-05-23T10:24
Software engineering should not be obsessed with representation.
The Missing Principle Of Programming Languages – 2009-05-12T17:48
Languages should support data/computation mechanics (mostly known as performance evaluation/analysis).
The Third Principle Of Programming Languages – 2009-05-05T11:32
A main driver of language design must be the extended design process.
Better HTML fragment referencing, and RDFa – 2009-04-26T21:36
A look at the relation of HTML fragment identifiers and the joining of the GGG with the WWW.
Why Data-‘Piracy’ Is Morally Good – 2009-04-19T10:43
An ethical way to understand and deal with intellectual monopoly and data-'piracy'.
Philosophy Of Software Development – 2009-04-10T16:36
A proposal for a philosophy of software development.
Structured Object-Oriented Programming – 2009-04-07T12:28
Inconclusive consideration of Structured Programming and Object-Orientation.
Determinate Knowledge In Software Engineering – 2009-03-25T17:09
A brief overview of software engineering's principal parts.
The Problem With More Web JavaScript – 2009-03-14T17:38
An extra abstraction might be now needed for web-app engineering.
Logical Structure And Software Architecture – 2009-02-26T11:14
A brief adumbration of software architecture and its underlying realm.
Software ‘Mass-Production’ – 2009-02-19T15:18
A quick formulation of mass-production for software.
Software Development In A Nutshell – 2009-02-18T09:34
An attempt at a minimal 'well-founded' or 'historically-informed' conception of software development.
Feed icon 2014-03-30