ZbigniewLukasiak : What can we do to have both the interactivity of manual manipulation and repeatibility of programming? The answer is SavedMacro. You can grow your program by just saving your interactive sessions with the system/application.


Thoughts / Debate

Zbigniew also says : There is one quite severe disadvantage of ((recording macros)) saving the sequence of operations does not save the whole context of those operations ... So it seems to be suited only for creating relatively small programs.

Interesting point about the insufficient context for larger programs. Why should this be? (And what can be done about it?)

Is it actually a failing with how we currently capture information about wider context. For example, I waste more time with, and give up more projects due to, the problems I have with administrating the system (installing the right libraries, setting pathnames for libraries in environment variables, errors in XML config files) than with actual problems in my program. I always wish this stuff was under the control of my program itself.

So if there was a way to capture / copy / package OS-wide context it would probably boost productivity more than anything else. And would allow macro-recording to scale too.

Also, I suppose the saved macro needs to be edited. So there has to be an EditableRepresentation. I wonder what that's like? Does it revert to being a normal programming language? Or could it look like something else?

I think it looks like a New Market Disruptive Innovation. – ZbigniewLukasiak

The conversation continues on Zbigniew's wiki, but mirrored here ...

The answer to the question about EditableRepresentation is in the first paragraph where I list examples of applications where sequences of user actions can be saved as macros - every is based on some existing programming language. But eventually the 'simplified' facet should lead to something like Templating Languages used currently for generating HTML and other documents, with simplified control structures and with a convenient mechanisms for changing constants into variables. –- ZbigniewLukasiak

Yes, but it might not need to be text. Perhaps it could look like HistoryFlow with the ability to edit it like video.

For a long time, I've dreamed of being able to "drive" through the execution of one of my programs with a game-controller. I'd like to be able to accelerate through familiar working parts, then slow down (adding verbose diagnostics) for parts I'm unsure of, and then go into reverse when I hit a bug, to trace back to how it happened. (OmniscientDebugger)

The same kind of interface might be even more appropriate to sequence of recorded actions made by someone who can't read a language-like script.


This is a very interesting thought, but I think you misunderstood the argument. The problem is that the readers of the saved code don't see the context of it and the context is what really drives the saved commands. That means that readers of the saved code will have much difficulty understanding it.

-– ZbigniewLukasiak

No, I do also see the context question, which I agree is the bigger issue.


more on the PainOfProgramming

Technology which Augments

Over on CostsBenefitsOfMetaProgramming Tayssir John Gabbour is thinking about DavidNoble/ForcesOfProduction which argues that technology that deskills (and hence commoditizes labour) is often prefered by companies than one which empowers and augments labour, even if the overall efficiency is less.

Presumably if this is so it's because a) capital has a long-term interest in commoditizing labour, and maybe b) management has psychological preferences for deskilling rather than empowering it.

Interestingly Tayssir puts saved macros into the second, worker augmenting category, because they capture the skill of the worker, for the worker's own benefit. Does this partly explain why the art of saved macro hasn't been developed more than it has?

Perhaps personal CodeGeneration scripts or PersonalKnowledgeManagement are similar.

Contrast :

See also :

  • JackPot / IntentionalProgramming which have an underlying structured, abstract representation might be loaded through some kind of macro-recording too.
  • The other thing this might be connected to : ContextSensitiveSoftware. If the software is always monitoring and knowing what you're doing, then it has a better chance of capturing that context.