| > Now "Oh but it's not possible to represent those concepts that we work with visually, only text will do" argument doesn't really hold water since it just demonstrates a lack of imagination to find a way to use other representations for those concepts that are essential to programming I did not say that. I said that we do not have good representations of those concepts. The thing is that programming is rarely the end goal of things. It's merely the help. There's often an actual task or process that existed before we got to the programming itself. The goal is to automate some subset or all of it using computers. And programming is about constructing a model of the task/process, encode the state and the rules that govern the evolution of the state, and then interfacing with the real world to get data (sensors), manipulate them according, and then produce actions (with actuators). Text is universal because it's symbolic (and with it come abstraction which is recursive in that form). And we managed to get a good representation of time (which is also a key part of the task/process) with vertical alignment. And we can implement extra dimensions that matters to comprehension with modularization and whats not. The cons are that symbol manipulation can be abstract and requires a good deal of training to transfer that knowledge. The issue with most 2D representation is that they're not flexible enough. Symbols are recursive. Meaning to encode more things, you just needs to repeat symbols. And then you can use symbols to encode group of symbols. Like we have 1 and 0 as the base of everything, then we encoded the alphabet using ASCII, then we encoded programming concepts using tokens (group of letters and other special symbols) and grammar, then we goes one to define higher other of things like variable definition, functions, types annotation, which just more syntax and grammar rules. > Besides move up in dimensions is a continuation of a natural progression in computing: cogs, switchs, punch cards, keyboards, mouse, touch .... VR, AR That's an evolution in interfacing. And the one thing about interfacing is that it has to adapt to the physical reality of human interactions. Which is often not great for the actual reality of the tasks/process that needs to happen. In the physical world, it's often physical laws and causal order that does all the work, we are only the perturbation force. We move the steering wheel and the car turns, but that's mostly due to mechanical laws than the actual act of turning the wheel. With programming, the task is often to recreate all the laws that govern the evolution of a process and then offers an interface for controlling that evolution. 2D and 3D diagrams are very bad at describing ALL the relations between the different components of a system. Let's take the "F = ma" equation: How would you represent the force, mass, and acceleration concepts in order to create like a very simple physic engine? We can create a special interface for that, but that interface would be likely bad for creating a bookkeeping software or a text editors. Symbolic representation is universal because there's only two things that matters, the symbols and the rules of notation. And the genius of the Turing Machine (and equivalent) is that at the foundation of things, you do not need a lot of symbols and a lot of rules. You can go from one system to the next by creating a translation mechanism. But if you leave the symbolic world, you lose universality for power. That's happen with GUI software and other 2D and 3D representation of things. Which is why you see that professional software have a scripting layer or a plugin mechanism. |
I think at the core of our arguments lies this. Turing representation, i.e., the Turing Machine is the fundamental computing engine that can represent any problem and provide a solution to that problem, in whatever n-space dimension the problem finds itself in. It is the binary representation of any problem space.
Yet no one uses it to do the real world problem solving. Why? Because its symbolism is to verbose for even the simplest solution.
Herein lies what I have come to realise: its verbosity that a 2D representation can reduce at the expensive of flexibility. As the textual representation is a trade-off, so is the visual one.
Text happens to be extremely flexible for problem representation and solution but it is less verbose than a Turing Machine and based on the self principles, so we can be assured of its universality. Yet textual representation can still become very verbose and hard to understand (hence version control and diff'ing tools).
A 2D solution can be even less verbose at the price of flexibility - a 2D representation is more bound to the problem space being addressed.
I think the win comes when a recognition arises that points to a visual representation as being less verbose and therefore more understandable because the problem space is confined and well understood that there is no longer a need for texts flexibility. This being akin to a DSL definition for the problem space.