HXA7241 (logo)

abstract tentacly things


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

Basic proglang nomitivities

(permalink: note 2016-07-24T11:27Z)

Tacit languages' internomitivity has a distinct problem, normal languages' ectonomitivity is unorganised and confused, but how to construct endonomitives?

The root of the weakness in tacit languages is that the data-structure of function parameters has a vacuous ordering/arrangement.

Any single data-structure – any single set of parameters – can have multiple forms. But that opens the possibility that two pieces of code using the same data-structure could be expressing it in different forms, and that means that to join them together requires bridging that mismatch. But the ordering/arrangement property is wholly empty, meaningless: the arrangement changes nothing about the meaning of the collection. And so the ‘wiring-together’ work it gives rise to is wholly otiose.

Normal non-tacit languages avoid this problem because they present the data-structure of function parameters as dictionaries, which have no ordering/arrangement. They eradicate the whole difficulty, the whole extra labour, that tacit languages fall into.


Looking closer, you could say that the difference is in the kind of naming. Both languages must address data – that is, select (parts of) it – but they do so differently. Normal non-tacit languages distinguish data adscititiously, or ectonomitively (yes, let us shorten it) – the names come from outside: from humans. Tacit languages distinguish data arrangetively, or internomitively – they select by the arrangement: each relative to the others.

Ectonomitivity is bad because it drags in the great mess of human culture: the logical software structure is polluted and distracted with undisciplined shapeless stuff, and choosing names seems an eternal conundrum. Internomitivity is decidedly preferable in avoiding all that – but it has its own serious shortcoming – the useless extra wiring-together work.

What we want, perhaps, is naming that is intrinsic, or endonomitive – names that are made from the object itself. The only remaining alternative seems to be randomness, like UUIDs (version 4), but they are very unergonomic.

Deriving a name from a thing is about what the thing is. What is a piece of data? Data is really the process that made it: that is what it is. The full name of a data object is the text of the sub-program that produced it – but that would be rather too long. So you need a way of compressing that – which seems like a hash. You could have some coherent structured hash, in a neat encoding, and rendered into pronounceable form (‘structural naming’) ... is that the way? ...



A brief argument against price signals – 2016-07-17T09:15Z
Cooperative systems must be ambivalent, therefore they must be multi-dimensional. Prices are only unidimensional, therefore price-systems alone must be inadequate.
How Objects Naturally Arise – 2016-04-03T12:07Z
Why have objects? They are ‘naturally arising’: components are necessary, callbacks are valuable, and grouping them is good – and there is an object.
Why do tests and types work ? – 2016-01-17T13:06Z
Some epistemology of software correctness – the underlying method seems to be repetition.
OCaml language design articles – 2015-11-08T11:07Z
A list of academic articles on the original development of various OCaml features.
The internet is an engine of centralisation – 2015-09-20T10:02Z
The ‘flatness’ of the internet just makes it even more subject to be shaped by the inevitable non-flatness of our uses of it.
TADIST file naming pattern – 2014-12-31T11:01Z
How should you name user-content files? Here is a possible way: a simple formalised pattern that seems to work for various things.
Software's essential form, and visual programming – 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.
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 2016-07-24