157 karma · joined April 20, 2015
Sure, the complexity difference in operating a cart vs a car is not that big. But if someone has never seen a car or familiarized themselves with how to operate one then the perceived complexity is going to be enormous.
The one who observes the thinking arises in relation to what is thought ("the one who is thinking"--in your words).
This means that as the thought changes from one to the next, the one who observes the thinking also changes.
The thought and it's observation arise together, and pass away together. This is followed by the arising of another (different) thought and corresponding observation of that thought.
Prior to perceiving this inconstancy of observation/consciousness whatever consciousness that arises is identified as I, mine, that I'm within it, or that it's within me.
When perceiving inconstancy of consciousness, whatever change of consciousness that arises is understood as just another change and is not identified with as me/mine/etc.
Right now we have far superior tools available to us than the ones used by the average programmer, but due to a combination of historical reasons, poor education, and sheer inertia of past commitment to inferior tools, we don't yet see widespread adoption of the superior tools that are already available.
The visual languages that I've seen so far are a kind of adaptation of existing languages to make them simpler and more accessible to beginners. What I'm talking about is not merely simplification of existing languages, but more a shift to an entirely different kind of paradigm. A shift that would require the development of new abstractions that are uniquely suited for visual programming that are not just adaptations of existing abstractions.
But as with all tools there are limitations. Certainly visual languages will not be best tool for all jobs, but there are certain classes of problems that are going to be easier to tackle with a visual language. There is also the possibility of solving a particular problem (or different parts of the problem) with both visual and text-based programming concurrently. First class support for data structures like graphs are easier to do with a visual language. I use Neo4j for graphs and the cypher query language is quite good, but it's effectiveness comes from the fact that it incorporates visual elements within the text. Something like MATCH (n)-[:REL]->(y) is a query for matching a part of the graph but you're still limited by the one dimensional structure of the language. You could imagine a visual query language for graphs being vastly more powerful in ways that a text based language couldn't possibly be.
This ability is largely influenced by having been exposed to similar problems in the past and having applied various strategies to solve those problems. One reason why a lot of programmers struggle is because our current educational systems do not expose students to computational thinking at an early age. They've simply not have had enough exposure to that kind of thinking.
Even though computational thinking draws on computer science as a formal discipline the insights are applicable to various other domains and virtually everyone will benefit if they're able to apply the same kind of thinking to other problems in their personal and professional lives. Without having to solve any problems specific to computer science people can still acquire the ability to effectively apply computational thinking by solving other problems in their lives because the inherent complexities of those other problems are going to have some similarities to the inherent complexities in designing software systems.
Now some people may already have highly developed computational thinking abilities without ever having touched a computer because intuitively they've understood how to solve analogous problems in a different domain. Such people may be far better at dealing with inherent complexity than some or most professional programmers but they could never apply those abilities in this domain due to the barrier to entry posed by the incidental complexity associated with the tools and languages.
A friend of mine, a physicist, is an example of the above. Her approach to dealing with complex problems is already far better than many developers I know, but she wouldn't be a good programmer simply because she doesn't understand the tools. However, if she were to invest significant time to understand the tools then she'd be a better developer than most. Not only that, if she had familiarity with the tools then her already developed computational thinking skills would mature much further. If she were to have access to tools that allowed her to apply her ability to deal with complexity without getting in her way then that would be the ideal outcome. What I'm trying to say is that we are a very long way away from minimizing the incidental complexities introduced by our tools and languages.
EDIT: Sal Khan gave a relevant Ted talk on the limitations of our educational systems: https://www.youtube.com/watch?v=-MTRxRO5SRA
He mentions that if you were to ask a literate individual in a past society with a 10 percent literacy rate what would be the maximum possible literacy rate they would've said something like 20 percent (80 percent of the population is incapable of overcoming the inherent complexity associated with gaining literacy). But our educational systems have progressed far enough to achieve a 99 percent literacy rate, which would've been impossible for someone in a society with 10 percent literacy to even consider as a possibility. Our estimates of where the boundary between incidental and inherent complexity lies is generally going to be strongly biased.
This need not be limited to network-connected devices either. You can define interfaces for any object even if they aren't electronic.
For example you can define the interface for a bottle as something that can be opened. You can define processes based on the interfaces of multiple objects. These process definitions can then be transferred to a robot that will then be able to interact with the real world based on those definitions.
This goes from traditional 1-dimensional text-based programming to 2-dimensional visual programming.
What I envision is a 3-dimensional augmented-reality programming language where program elements will be floating around in 3d space around us and we use an augmented-reality interface to interact with them.
It’ll also enable us to do IoT programming in a very literal sense.
For example if you look at an air conditioner, light switch, or some other network-connected appliance that’s in front of you in the real world then the augmented-reality display will overlay the interface exposed by that device.
Let’s say that you’re looking at your phone (not the screen but the actual object). Since this is a device with a GPS chip your AR interface will indicate that you can do location-based programming with it.
Then you create the equivalent of an if-condition specifying a 10m radius around your current location.
if (phone is within 10m of current location) {
}
Now you look at a lightbulb in the room and your interface shows you that the lightbulb has a method for turning on.
You draw a line from the then-branch of the if condition to the light bulb.
You’ve created a program that turns on the light bulb in your room whenever you’re within 10m of this room.