In this world, a few hundred years have gone by since the invention of the first computer and the field of CS has been developed to the point were people are hardly aware hardware exists. Most people are raised in a environment were virtual reality and networks are built upon so many layers of abstraction (hardware -> opcodes -> the os -> applications -> display devices ->interactive realistic 3d worlds etc...) that being aware of things like how the hardware works or how different parts of the os work together has become rare.

My question is: How would developers (specifically "low level" system developers who have to take into account hardware issues as well as application issues) be taught to know and mentally picture how different parts of the software and hardware work together, since they were used to strong sensorial illusions from computers and lots of abstraction layers?


  • the governments in this world are very intent on giving good education to people.

  • People who lived through the years of the first operating systems and programming techniques are (understandably) not alive anymore as well as people who knew the computers from our day (with 2d screens keyboards etc...)

Motivation for this question: It seems to me that it is already difficult for people to understand the "inner workings" of current day software and hardware (what really is an os, what happens when my program runs etc...) and to "go down" the abstraction layers built by previous developers, so I wondered how people in this futuristic world would even manage with no "original developers" left to explain things and so many abstraction layers.

Edit: This question is not about people "knowing everything" it's about them knowing enough about how their programs actually work to do things like debug their programs if the issue is caused by "lower level" components.

  • 1
    $\begingroup$ Comments are not for extended discussion; this conversation has been moved to chat. $\endgroup$
    – James
    Nov 16, 2017 at 18:57
  • $\begingroup$ Not only the knowledge will be compartmentalized, it will need to be centralized to make sure abstractions are working properly and there is a central authority to provide expert advice. I can picture, for example, The Office of System Calls, Virtualization Department, Page Fault Division, Board of Memoization, etc. $\endgroup$ Nov 17, 2017 at 19:37
  • 1
    $\begingroup$ Since CScience is advanced, there must be at least one person who knows the highest level, presumably its creator. Can we get this creator to write a program to make a computer find out the best way to teach humans advanced CScience? $\endgroup$ Nov 18, 2017 at 17:37
  • $\begingroup$ This really depends on how advanced are other aspects of science and engineering. $\endgroup$
    – rus9384
    Nov 19, 2017 at 2:12
  • $\begingroup$ My hope is that as CompSci advances, layers of abstraction will start to be removed, as we come up with simpler ways of dealing with problems. $\endgroup$
    – Nacht
    Nov 20, 2017 at 3:23

24 Answers 24


Complexity is compartmentalized

It used to be that one person could know everything and write a book about it, like Aristotle or St. Isidore. Even after the scientific revolution began, certain polymaths like Newton and Humboldt could make significant advances in multiple fields. As late as the early 20th century, biologists like Fisher and even brewers like Student/William Gosset were making important discoveries in statistics.

That is not the case any more. Lone geniuses (genii?) are no longer making cutting edge discoveries in multiple fields. In fact, the leading edge of modern physics and medicine is more collaborative than ever, with teams of up to hundreds of specialists combining their expertise to unravel particularly complex problems.

So the solution to teaching people really advanced sciences is to teach an ever narrower band of topics. Already, subjects like Chemistry or Statistics are simply too broad for one person to be an 'expert' in everything. Statisticians specialize in machine learning, or neural networks, or bayesian theory or whatever.

So to apply this specifically to your problem, computer knowledge is already compartmentalized. The people who build processors at Intel are not the same people who build operating systems, who are not the same people that develop programming languages, who are not the same people who build webserver software, who are not even the same people who build webpages.

If it becomes increasingly complex in the future, it will just be compartmentalized more.

  • 97
    $\begingroup$ You don't need to create a world for this. As this answer suggests, it's already the case today here on earth. $\endgroup$
    – everyone
    Nov 15, 2017 at 14:19
  • 29
    $\begingroup$ To add to this, consider the distinction between brickmakers and architects. It takes some skills and experience to make good bricks, and an architect doesn't have that experience; but the brickmaker isn't the one who designs the building. Technology isn't just compartmentalised, it is layered. If someone specialises in doing the low-level stuff well, that allows someone else to work at the next layer where they use that low-level stuff. A competent architect still knows that the brickmaker exists though, and bricks do not appear by magic. $\endgroup$
    – Graham
    Nov 15, 2017 at 16:40
  • 10
    $\begingroup$ This answer, and these comments are exactly right. Anecdotal evidence to follow. When I was in university for computer science, I had to take a course on Computer Architecture. Low level stuff, such as how gates on a computer chip work, or how CPU/RAM/HDD all interact. Cool, but useless... until I got my first in field job and started programming ASIC's. In fact, 5k engineers here, and we almost never touch anything as high level as GUI, much less 'application' levels. Specialists will be good in their layer, and may be totally lost above or below it. $\endgroup$
    – Zucce05
    Nov 15, 2017 at 16:47
  • 9
    $\begingroup$ @BgrWorker As a .NET developer myself, I absolutely need to know how the garbage collector, the interpreter and the processor works. I hope that the underlying framework will take care of the stuff for me, but when things go wrong and a memory leak appears I'll have to backtrack my code to know when things got bad. For example, even a simple ShowDialog can leak memory if you don't take proper care. If you ever need to optimize manually your code, you'll find yourself looking at the interpreter. Just because you didn't use it yet doesn't mean a .NET dev doesn't need it. $\endgroup$
    – Mermaker
    Nov 16, 2017 at 12:44
  • 13
    $\begingroup$ @Unlambder This answer nails it but I want to add one detail. The reason you don't need to know everything about the layer below your specialty is because we design "interfaces", which clearly define the inputs and outputs of the layer. You don't need to know how Tylenol works, for example, you just know that if you take a specific amount of it, your pain will go away. Someone else is responsible for making it work that way. That's true for virtually all subjects, not just CS or medicine. $\endgroup$
    – thanby
    Nov 16, 2017 at 20:52

As a programmer maybe I can contribute something here.

How do we do it today? Systems are already incredibly sophisticated and there are so many technologies and programming languages available to choose from. How could anyone who calls themself a programmer could possibly know all these things?

They don't, put simply. There are already abstract layers upon abstract layers that hides a vast majority of the complexity. Most programmers are explained at the basic level how computer hardware works, but it isn't like most programmers could necessarily create you a circuit with a soldering iron and a breadboard. Nor do programmers need to know this because it is all abstracted away. If they did need to know these things, there wouldn't be a programmer in the world who has programmed in a language more complicated than assembly (one step away from machine code).

But wait, somebody has to know how this stuff works, right? Yes, of course. This is precisely my point. The modern model of the computer has been pretty much solidified in the 1960s and 1970s (albeit they've gotten a lot smaller since). So while I won't say most of the original creators of the modern computer have died, if they're not they're most certainly in retirement.

The ones who have inherited this knowledge from their predecessors are working today doing what they do best, most likely trying to figure out ways of creating a computer program that can create a chip layout that is increasingly reduced in size and more powerful than the previous. They don't solder circuits by hand, but they still know intimately this aspect of their job because this knowledge still comes in handy.

Granted, computers do much of this sort of reasoning for them, but lets just say that there are people who know what is needed to be known in order to create the technology we use everyday. If there weren't such people, the technology would not be present. To claim the contrary would be a bit like saying there could be tomatoes in the marketplace and no tomato plants.

Again, this isn't to say that you couldn't walk the streets without bumping into one such person, but they'd exist in small number somewhere in such a world. Most likely, if the world were post-apocalyptic, they'd be looking out for their own best interests as well by doing so.

  • 11
    $\begingroup$ Thanks for this answer. Abstraction is the key. Programmers in the future will just work on higher levels of abstraction. Programming might be something close to: "Computer, correlate this and that, show the results in a double logarithmic plot, apply a suitable trend analysis and throw it all in the garbage, then search for patterns and tell my the three most valid hypotheses". Basically how I wish I could use computers right now. It's probably a skill one can learn. $\endgroup$ Nov 16, 2017 at 11:18
  • 3
    $\begingroup$ Worth noting on this answer. "Somebody knows right?" Not always, actually. We have gotten to the point, specifically with processors, where no human/group of humans can actually conceptualize the board layout anymore, because it is so advanced. Intel, for example, haven't designed chips in years, they wrote a very sophisticated program which designs new iterations of their processors for them. So, it is possible that someday, while we may learn the top mechanics and the basics (booleans etc), we may lose the ability to work with the mid-level altogether because it will be too complex. $\endgroup$ Nov 16, 2017 at 18:34
  • 3
    $\begingroup$ @EvSunWoodard: I think it's more accurate to say that Intel doesn't design whole chips down to the transistor level. There certainly is a lot of human decision-making, but much of it is done at a higher level by using libraries / macros of blocks of gates. I'm sure at least some critical blocks are hand-optimized down to the transistor level, and then that block is used in multiple places (e.g. replicated for each element of a vector multiply/FMA unit). See tweakers.net/reviews/740/…: Intel can patch transistors with lasers while debugging. $\endgroup$ Nov 16, 2017 at 22:42
  • 1
    $\begingroup$ @Neil: Yeah, computer aided design, of course everyone uses that. I imagine many current-day CPU architects could still design a much simpler chip by hand, given enough time and paper. So yeah it's not a lost art, just not useful because it wouldn't be faster or better in any way than what we already have. $\endgroup$ Nov 17, 2017 at 7:41
  • 2
    $\begingroup$ Note that EvSunWoodard claimed that Intel didn't design the chips directly at all, and instead just writes programs that design new chips. This is an AI pipe dream (which could lead to the technological singularity), not reality. This is why I was making the point that people are still involved in the design process. $\endgroup$ Nov 17, 2017 at 7:42

As somebody who studies electrical engineering with a focus on hardware development i can tell you that in this specific field of computer architecture software and hardware development are closely intertwined.

Of course there is the high-end hardware people who do nothing but that and the high-end software people who don't know what their hardware looks like, but there is a whole field of study between them. Computer architecture is a very important field that will not die out just because most people have to do with software. You can simply not have a world that is so incredibly high-tech if there is no one there who can build the technology that world requires.

You don't even need that many people for something like that. If you compare the amount of people who know how to code software with the amount of people who can design hardware there is already a ratio of 100 to 1 if not less.

Computer architecture won't die out in a world like this. Just like physics, chemistry, mechanical engineering and medicine will not die out. It will still be tought the way it is now.

Regarding how it will be taught:

  • The basics of logic and boolean algebra is something software developers learn, too.
  • There are special lectures in universities about all the different aspects of computer architecture
  • Those lectures include basic digital systems and then get more specialised to "simple" processor structures, to elaborate multi-core architectures and then to high-end parallel processors

Unless we have a huge leap in technology and computers work entirely different from current ones (e.g. quantum computers) there won't be anything different about teaching that. But if there is such a change (which is likely, to a degree) we can not predict what will have to be taught then. fact is, the basics of logic and simple processor will most likely still be relevant to the curriculum.

Bonus: Just to compare google search results:

  • "vhdl tutorial": 418,000 (Hardware)
  • "verilog tutorial": 398,000 (Hardware)
  • "c tutorial": 253,000,000
  • "c++ tutorial": 15,400,000
  • "python tutorial": 31,000,000
  • "java tutorial": 58,000,000
  • "javascript tutorial": 64,000,000
  • "c# tutorial": 6,700,000
  • "fortran tutorial": 493,000

note: there are not really other used hardware description languages than verilog and vhdl

  • 1
    $\begingroup$ Interesting anwser although what I was asking was how people learning those jobs would be taught to understand so much complexity, not if those jobs would still exist. $\endgroup$
    – user44285
    Nov 15, 2017 at 13:30
  • 6
    $\begingroup$ why would they be taught any different than any other subject? Or different from now? Learning to design hardware is a mix of physics knowledge and hardware description languages. (the latter is similar to programming languages). $\endgroup$ Nov 15, 2017 at 13:36
  • 3
    $\begingroup$ Not that that it detracts from the core points of this answer but Goggle's search result counts are all smoke and mirrors. I can't get it to return more than 580 hits for javascript tutorial. $\endgroup$ Nov 16, 2017 at 14:40
  • 3
    $\begingroup$ @KellyThomas of course they are not accurate scientific data, but they show that HDLs are a lot rarer than programming languages. Also: that is weird. How can you get 580 hits on javascript? That shit is everywhere. $\endgroup$ Nov 16, 2017 at 14:41

At some point they wouldn't. Making better hardware is essentially an optimization problem, and it turns out computers are getting VERY good at that. Additionally, we are reaching the end of the line when it comes to silicone chips; we can't make transistors much smaller, and that's a physics barrier, not a manufacturing barrier.

Writing code for specific hardware is already abstracted away from programmers with compilers. As soon as computers start engineering the hardware, it's not really all that difficult to have them generate the compiler as well.

This all sounds like serious science fiction, but it's actually closer for real humans than you might think. Many experts say we'll see computers become better than humans at coding within the next 50 years, and as someone who works in machine learning, I honestly think it might be quicker.

The trend for programming languages today is to make them more "readable". That is, you shouldn't have to worry about how you write your code, only what you're trying to accomplish. The computer will take it from there. There are already great strides being made in this area, frameworks like Spark build intricate data structures describing how a program will run and then immediately optimize them so that you're (nearly) guaranteed to have the most efficient program at the end of it.

The logical next step is to remove the programming aspect altogether. In the future we'll likely program the same way people make their own webpages with things like weebly. The important thing will not be how the program is run, but what we want it to do. This change will make the process incredibly simple and within the reach of pretty much everyone. And this is all within the next century.

What the next few centuries will bring, I can hardly guess, but likely computers will take over the entire job end-to-end. People won't need to know how the computers work behind the scenes, and it will likely be too complicated for us to even understand.

  • 3
    $\begingroup$ Programing Step 0 is write what you want to do in english, eventually that will be the last step. And then we won't even have to do that. I like it. $\endgroup$
    – user25818
    Nov 15, 2017 at 14:52

As an IT professional since the 1980s, I can extrapolate on what I've seen.

Their will be levels of difficulty with fewer and fewer at the lower levels.

High-level languages will likely be entirely GUI and menu driven. Imaging working on a tablet, dragging things around, and selecting options, as you set up your calendar. This is how the majority of programming will be done.

mid level languages will likely be variants of what we know as "object oriented" programming today, ranging from the low end, which would have a degree of customization, to the higher end of mid-level having little control, but plenty of pre-made objects and a drag and drop interface. A smaller, but still sizable population will still be taught this.

Lower level languages will be taught to very few people. These will have high complexity and control, but will be needed to help do the "behind the scenes" work of the higher level ones, and to make new advancements in the higher level one.

VERY low level languages and operations will be taught to and known by a select few. There may even be restrictions on who learns these. These will be the operations level, difficult to learn, very powerful base-level programming/networking/database/back-end skills. Highly valued, and highly dangerous to a world where technology runs everything. Most High-level people, if not all of them, will never have any exposure to this level of sophistication at all.

Likely, people will be tracked at an early age to one of these tiers of complexity, based on skill, potential, and psychological stability (you don't want someone crazy to have the power to essentially flip the "off" switch on civilization)

  • 2
    $\begingroup$ "you don't want someone crazy to have the power to essentially flip the "off" switch on civilization" -- Define "crazy"... Or, alternatively, Who isn't crazy? -- Seriously though I think @Thorne pretty much nailed it - AI will pretty much obviate the need for psych tests. $\endgroup$
    – user23715
    Nov 16, 2017 at 21:18
  • 4
    $\begingroup$ @user23715 I'm afraid I can't do that, Dave $\endgroup$
    – user20762
    Nov 16, 2017 at 21:23
  • 5
    $\begingroup$ "languages ... GUI and menu driven" - no way can you call such a thing a programming language. IMHO before this gets really usable, there 'll be speech recognition and AI making them obsolete again. Just say, "add a calendar, just like the last time, but bigger and tune the colors... more... yes, that's fine.... right, show the nearby events, too". $\endgroup$
    – maaartinus
    Nov 17, 2017 at 0:44
  • 1
    $\begingroup$ Yeah, well, if we cannot get our AI to be non-psychotic then there is even less hope of developing undefeatable Psych Evaluations. $\endgroup$
    – user23715
    Nov 17, 2017 at 1:26
  • 2
    $\begingroup$ As something of a parallel from the hardware world... in school you might learn about logic gates, and might 'breadboard' a few projects. Even through Uni, you might end up programming some FPGAs, and if you're really lucky you might get to work on some Gate Array. Making custom silicon for a specific task is something that you'd only learn over years of working on hardware projects. What I'm saying is that no one learns how to make custom silicon in school (nor will they ever), instead you learn some principles and you get to use them as much as you can apply them. $\endgroup$ Nov 17, 2017 at 12:00

In a very advanced world, quite likely people would no longer bother with the nuts and bolts as AI systems would handle it.

As the level of complexity increase, it would become harder and harder to understand it all and as such people would develop systems to help to automate development.

Programming using an AI development tool would be talking to the computer describing what you want to do and guiding the AI's solution. In all likelihood would be done using natural language.

Software programming is already one of the jobs slated to be replaced by AI

Sure people could dig into the nuts and bolts of it all but it will be highly unlikely and more than likely a hobby or personal interest. People will be unlikely to do so professionally because an AI will be able to the job better and faster.

  • 1
    $\begingroup$ I'm imagining rapid iterative prototyping where you specify what you want through conversation and demonstration, the computer generates a mock-up in minutes, then you review it together to request changes. Basically something like the Agile process, but instead of two week sprints, you get iteration almost immediately. The slowest part of the process will be the human users figuring out what they actually want and agreeing on it. Even that will be reduced as AIs get better at manipulating human psychology to encourage acceptance of what's best for the slow-witted meatlings. $\endgroup$
    – Dan Bryant
    Nov 16, 2017 at 16:56

There are already some very good answers here, but there's still one missing: people teach themselves.

As a computer programmer and hardware tech with years of experience in each field and even some college level education, I've taught myself way more than any school did, in respects to computer tech.

From my first programming "class" after school during my 8th grade year, to my first foray into hardware, I used information I learned on my own to get things done. Even as a college student, I taught myself more about my computer classes than the instructor covered. As a professional, I use Google, YouTube, and other places (like SE) to teach myself how things work and how to improve my knowledge of the various topics I'm interested in.

I can imagine people in the future (still) popping off the covers to their VR gear (or whatever tech) and trying to figure out "what makes it tick." They'll do their own research, and even today there's a vast amount of technical knowledge to be easily found online. I know I did that sort of thing as a kid and I still do it as an adult.

There will always be higher learning available to teach these things, and it usually funnels people where they want to go. This kind of training often starts at the easy stuff and works toward harder concepts, so people will stop when they get to their goal. The future may only have small amounts of people wanting to get into the "deep dark recesses" of computer tech, so it may end up being a 1-on-1 teaching/mentoring situation, like blacksmiths. Some of this is currently done, with topics that are so specialized that only a tiny handful of people a year are interested in studying it.

And at this level of teaching, much of it is still done through self teaching. The people at the top of their fields have to teach themselves, since there's so very few people they can draw new information from that they don't already have.

There will also be people who just do things on their own, without worrying about classical schooling. I didn't finish my computer engineering degree, but I've still had +15 years worth of computer tech jobs, +5 years of programming jobs, and I've built many machines that aren't computers, including a 4'x8' capacity CNC machine.

That CNC machine was my first attempt at building a CNC, first use of an Arduino (it currently uses 1 Uno and 1 Mega), and first use of a Raspberry Pi. I did it based on "it can't be that hard" and guidance by the people around me at my local maker space.

Maker spaces can be a springboard to learning topics that become people's careers. Four years ago when I joined the maker space, another member was a young man in high school, and he was designing & building 3D printers plus learning the Occulus Rift (VR googles). He is now a virtual reality programmer with no degree and most likely making way more money than I am. He started college, but was offered the job he's at now before he got very far, so he quit school.

So, to directly answer the question of "how would developers {...} be taught to know and mentally picture...": they teach themselves. They are given the right/all information, the right mentors, the right source material, and the right to forge their own path. They will also need to have the right to make mistakes along the way, since the strong push towards perfection in today's (American/"modern") society is killing people's personal motivation, or driving them insane, but that's a different topic.

And (maybe most importantly) you also need to be able to have not just the access to the "right stuff", but you also need to have the time and energy to do it. Scraping for or scratching out a living doesn't exactly give you the ability to do any learning, regardless of how many informational resources are available. Getting stuck in a job(s) that takes all your energy and doesn't leave you any free time is even worse (IMO) than having to pay out the nose for a degree. Been there, done that, and didn't like it (both getting stuck in survive mode as well as paying a lot of money for a degree).


I'm going to go with a different answer. Beyond a certain point of advancement; we would stop programming computers, and we would start teaching computers.

Computers would have a built-in AI that has a general-purpose 'programming' algorithm, that allows them to create perfectly optimised code to solve any problems; after a while, it would become impossible for humans to understand the low-level programming.

Once this algorithm exists, human programmers as we know them today would become redundant, and be replaced with people who are adept at training.

Look at the language around 'Robotic Process Automation' today. Already we're seeing generic systems that can be 'taught' by a non-programmer to complete simple tasks, without any need to understand the underlying programming languages involved.

  • $\begingroup$ Computers would have a built-in AI that has a general-purpose 'programming' algorithm, that allows them to create perfectly optimised code to solve any problems. Once this algorithm exists, human programmers would become redundant. => I think there is a misunderstand about what programming language means. A programming language is not assembly, which painstakingly stipulate every single instruction the computer should execute; it's a specification language: the compiler transforms the specification into an instruction stream... (tbc) $\endgroup$ Nov 15, 2017 at 16:38
  • 2
    $\begingroup$ ... (continued) I do not see an AI transforming an ambiguous wish into a precise specification anytime soon. I mean, as a programmer I've discussed with people who expressed wishes, and most of the times THEY don't know exactly what they wish for and it has to be worked out! $\endgroup$ Nov 15, 2017 at 16:41
  • $\begingroup$ Yes, someone would still need to teach the computer, but it would be much more like teaching a human to do a task than anything we'd recognise as 'programming' .. $\endgroup$
    – JeffUK
    Nov 15, 2017 at 16:44

But, this is happening today!

You see, a lot of the current software development is in Java. Java code gets compiled to byte code, which runs on a virtual machine. Then, there is some kind of runtime, most likely written in C or C++, that simulates this virtual machine on the fly. This runtime runs as a process within a virtual execution environment (virtual address space, no access to any hardware except the CPU). This virtual execution environment is created by the OS kernel, which thinks it has full control over the hardware. Except that there are parts in the hardware itself (UEFI, System Management Mode, Intels Management Engine, AMDs whatever), that can control the kernel, possibly, the kernel is actually executing inside another virtual machine... (we are running in circles, aren't we?)

You see, layers and layers of abstraction, and where is the actual hardware?

Only preciously few people know. If you just ask the average programmer, they won't even have a clue how their processes manage to write some data to a file. They won't even know, how their request can actually leave the process's virtual execution environment. Even a C programming crack does not necessarily know this, as it's not even a part of the C language! Even people like the kernel hackers do not really see the hardware, they only see the abstractions built by the hardware. It's turtles all the way down...

That said, it is not impossible to teach people the principles that are repeated over and over again to create this monstrous stack of abstractions. You see, there's not so much difference between a process executing a trap to call into the kernel, and the kernel performing a seeming hardware action that traps into its hyper-visor. It's pretty much the same mechanism repeated at different levels. It is also possible to teach students, how you can build a CPU from parts like registers and arithmetic units, and how these are built from individual gates, and how these are built from individual transistors. As such, it is still possible to know all the principles of the full stack.

However, for the vast majority of programmers, knowing the full stack is not their concern. Programmers tend to work at a specific level, deepen their knowledge at that particular level, and thus act their role in the big play that's called the "division of labour"

The same will apply in your setting. Just much more abstraction levels, and much less people caring about hardware. You might still stumble across the odd individual that cares so much about abstractions that they actually know the principles of all the abstraction levels involved. But these individuals will not be of much use to any company, as they won't be able to outperform the various level specific experts.

In any case, the secret services will likely be the ones with the deepest knowledge of the different abstraction levels involved: Each lower level may serve as a back-door into the next higher level. Now, computers are connected at the most basic levels (electro magnetic radiation, or even wires), but the interesting stuff happens at the highest levels (Alice sending Bob some message with interesting stuff in it). So, secret services will want to attack at the lowest levels where their intrusion remains invisible to virtually anybody, but be able to hack their way up through the entire stack to get to the actual contents of the digital communication. Again, this is happening today.

As such, you have to expect the secret services to have their hands/back-doors in every level that IT experts come up with. Right from the definitions of the relevant standards to the actual implementations. They are likely the secret rulers of the world. They are the ones that can find out about anything they happen to care about, and they are the ones that can blackmail anyone (its possible to prove anything about anyone if you have write access to all their devices/accounts). This is especially true, if law enforcement relies on prescribed governmental back-doors. It won't be just the police that has access, and the access by the secret services won't be read-only. No government will be able to control them.


As someone in the IT industry with experience in several stacks (OS support, hardware support, database management, programming, etc.), I can say that it's extremely rare for anyone in my industry to have a full grasp of how things work at various layers.

Instead, you find niches. Someone who is a life-long programmer tends to gravitate towards specific kinds of programming and get really good at that kind of programming. But they usually don't need to do deep dives into how their compiler converts [popular programming language of the year] into machine code or how that machine code connects directly into the CPU to drive events at the hardware layer.

Just like your typical auto mechanic may be an absolute wiz at fixing brakes or changing tires or etc., but probably isn't that well versed on the science going on in your car's internal computer to improve the fuel economy. And that engineer who's tweaking the systems to improve your fuel economy may not have a clue how to know when you need to change the spark plugs in your car...

So in your typical cyberpunk universe, most programmers are working in languages so far removed from the hardware that they don't need to know how the hardware really talks to the language's interpreters. They couldn't care less, because it's not important to their work. They work in the virtual world universe and never need to figure out how the hardware converts that universe back and forth between graphics and binary (or the qubits of quantum computers, if that's what drives your cyberpunk systems...)

If your programmer is professionally / college trained, she probably attended an undergraduate course somewhere that explained the theory behind how their programming languages work at the deeper layers. If she actually learned that material, then she probably knows more about it, but doesn't need that knowledge to actually do the job. Most cyber fiction (RPGs included) don't really assume your characters are formally trained.

But at the companies that make your cyber decks or whatever they're called, there are teams who are experts in those deeper layers. These folks write the translation protocols and APIs that convert between the mainstream VR languages and the hardware-specific stuff their products can understand. They publish the OS for your decks along with whatever tools are required to merge those VR languages with their OS / their decks.

These teams are similar to the folks who still work in Assembly languages today to interface between the hardware and the more popular languages and systems people use. Not many people know these low-level languages, but there's still a demand for that skill set. Maybe they only write enough of those low-level languages to interface between the hardware and higher languages, but that's still a thing.

(See also the engineers who design the CPUs and other complex chips inside computers, and then have to provide sufficient interfaces for programmers to connect to them.)

The other pathway is that, at some point, AIs started taking over the creation and maintenance of those extremely low-level languages. Maybe the AIs develop the newer generations of CPUs, because the logic is now so complex that engineers can't do it. (Or can't do it fast enough to be competitive in the computer marketplace.) Once that happens, maybe the AIs also have to provide the lowest level software as well, since no humans truly understand the hardware in depth anymore.


I agree with what many wrote here on stacks and hierarchies. A small, but hopefully, fruitful addendum:

You are not discouraged to go deeper

Of course, everyone in your world is programming with VR-based "Minority report"-style hoola-hoola. But if someone wants to go down to a graphics API (that is also used and abtracted by VR-hoola-hoola), she is free to do so.

Of course, if their task is common enough, it would have been already implemented and "going deeper" is a waste of time. If they know better, have a new idea, want to implement a novel algorithm or are simply THAT out of the box, that the task is not implemented yet on the high level – in all these (seldom) cases, peeling away a level of abstraction might be beneficial.

I have seen a few times the idea that "old tech" is frowned upon in dystopian sci-fi. The modern reality is that old tech either gets deprecated or still runs somewhere down in the pipeline.

Of course, the deeper you go, the more expertise you need. But you can get it the usual way, by reading smart texts and trial-and-error.

To give a few examples: Markdown (which we use here for typesetting) is cool, but if you want it to make a PDF, it goes via LaTeX, a dinasaur from 80's and 90's. The coolest, best, and fastest Python library for doing proper maths is numpy. It is the way I write some math-related small scripts, and I dare say I know a bit of the trade. numpy relies on some codes that need to be compiled in Fortran. Fortran!


As of now, you have no chance to even understand at a decent level everything going on on your computer.

When I grew up (late 80s/early 90s), it was different. My CP/M microcomputer (8bit) had a grand total of 64kb of RAM. Operating system was probably on the order of 10,000 statements. At 50 lines/page, that's 200 pages. A book you can read over a few months and understand from scratch if you really want to. Everything else (hardware etc) was on the same order of complexity.

Now it's very different. I don't even understand the names of all services running in the background of my computer. If a new name shows up, I have to google it to see if it's a clumsy virus (a good one would not display anything new) or just a new thing added by Microsoft. Forget about understanding how it works inside.

What you do nowadays is working in your "square": You can do worldchanging AI work for Google or Facebook, and still have no understanding how the server it's running on is built. If you have specific needs (a pink-haired server let's call it), you talk to an electronics guy and ask about options for a pink-haired server.

Car analogy: If it were the 1900's a car guy could be a car driver, designer and repairman, all in one. Nowadays, you are an expert in a small subsystem - say, an expert in designing wheels and tires. You have a specification (how the wheel ties in with the rest of the car and how the rubber and the steel you are using behave) but you don't understand either rubber making or "overall car design".


Computer programming will come to an end

Computer programming is the textualized representation of commands that are both readable by humans and machines. I can't stress the importance of understanding this core concept. It's text that a machine can understand. It's why we call it a "language" as we must understand both what it means from a human perspective, but also what it means from the perspective of the machine.

For example;

print "Hello World";

It's a stream of text characters containing special characters, structure, format and literal values. These are then interpreted by the machine to execute a sequence of commands.

Does the above source code really do what I wanted it to?

The question illustrates the limits of programming. The machine has no care at all in it's meaning or purpose.

This is a fundamental limitation on the use of source code to control what computers do. It's all about interpretation of what a human thought he was telling a computer to do, and the actual effect of what the computer did. If the two are not in alignment, then this is called a bug. From the perspective of the computer. It did nothing wrong.

Most people are raised in a environment were virtual reality and networks are built upon so many layers of abstraction that being aware of things like how the hardware works or how different parts of the os work together has become rare.

I foresee that computer programming as we know it today would no longer exist in such an advanced computer culture. The weight of responsibilities for the humans that built the lower-level systems to maintain those systems would yield nothing but failure.

Neural networks as a current day example

We have AI networks now. You can download an AI open source library, design the inputs for a large neural network and teach it new things.

Those neural networks become large complex connections of knowledge that we humans can not understand. There is no text representation of that neural network that we could read and say "oh, so that's what the computer is thinking".

So from that perspective. The art of writing source code and understand the system is one day going to end.

Yes, AI is a tool and there are programmers who wrote it. Over time we will have tools that are so complex and beyond our understanding that we benefit from the use of the tools rather than the understanding of them.

How would developers (specifically "low level" system developers who have to take into account hardware issues as well as application issues) be taught to know and mentally picture how different parts of the software and hardware work together

I would picture such a society to have "low level" systems that are beyond human understanding. These are also systems that are the sum of their data. You could not take new parts and just snap together a new system. The existing system with it's existing data is the only system that could do that job.

It is an interface problem and not a knowledge problem.

These systems would have to have digital ambassadors that represent control over parts of the system. These would be a kind of interface that new people would be taught to interact with. Those people have the authority and power to control what those ambassadors do against the systems. The ambassadors are not people. They are software but complex software. They exist and grow in complexity as the system grows.

Without the digital ambassadors a person would be unable to understand the working internals of the system. It's the ambassadors that can explain how something works from a "human perspective".

It seems to me that it is already difficult for people to understand the "inner workings" of current day software and hardware (what really is an os, what happens when my program runs etc...) and to "go down" the abstraction layers built by previous developers

We today have scientists that study nature. Trying to understand how things work at different levels of scale.

Such a future society would have the same kinds of people. They would perform "research" to figure out what the systems were doing, and why.

I picture a world where scientists make groundbreaking discoveries on how these systems function. This allows society to give those systems more of what it needs to be more efficient. This in turn benefits the society which uses those systems. Each discovery adds to the systems and increases the complexity which yields the need for more research.

People don't learn the "inner workings". They are taught the history of how it came to be this way. From that history is how people gain knowledge. Each step in history solves a problem which leads to the next.

There is a real fear in having such a dependence upon complex technology. If you somehow were to forget the history. You also lose control over the technology. Of, if the technology was to advance faster than you can record the history you also lose control.


If you take the singularity seriously, you are describing what is probably a post-singularity world. In such a world, computers would be all designed by computers which were designed by computers .... (for many generations), all of whose cognitive abilities outstrip any biological character's by many, many orders of magnitude. The computers are beyond the comprehension of any strictly biological being, even those whose ancestors designed the original computers several centuries earlier. Thus it would be impossible to teach such people how these incomprehensible black boxes actually work. Furthermore, people couldn't be taught "sufficient programming skills" because no such skill that a biological entity could possess would be sufficient to program one of these computers (programming being one of those tasks taken over by advanced AI centuries earlier). Thinking that super super computers would need uber uber hackers to program them isn't a plausible way to think of what the situation will be hundreds of years in the future (in much the same way that the terminator isn't a plausible way to picture a conflict between humans and machines)


That depends on whether the society is developing or stagnating. A dynamic society, based on some ability or knowledge, has many people that develop that ability further and further. So, there will be many schools, excellent teachers and so on.

If the society is stagnating, the knowledge will be closed for some IT "priests". There could be many of them, but the principle remains. The number of schools and possibility to code something new depends on the depth of the stagnation. The accepted ways will be called efficient, sufficient and so on. If somebody will try to invent something new and cannot be silented... here it depends. Fired or killed.

If we remain optimistic, there could be even more open solution, that we cannot fully imagine now - computers, becoming individual factories of thoughts and even of the real production, could create a much more free society that what we have today. Of course, it will have problems of its own.

As for programming - don't forget the rule - every task becomes solved and the solvers become to solve metatasks around it. A free IT society will kill finally noneffective languages with large and totally ineffective IT departments. The next move, I think? will be to teach these free coders to organize their way of thinking. It will be a great psychological problem, for they connect any way or organization with these IT monstrums. And they "know" that it is ineffective. I think, they will have to learn how to organize themselves.


There are many ways to go about answering this interesting question.

We can try to extrapolate from what we know, with a focus on recent trends. This line of thinking is probably the most generally acceptable, even though it will certainly result in a wrong prediction of the future.

Alternatively, we can try to imagine a future, based on some assumptions that we know may, or may not be correct. The question defines some of these assumptions, such as people having a need/desire to understand certain things (as opposed to leaving it to AI), that Virtual Reality networks are a thing, etc.

The answer about compartmentalized complexity and an even more specialized workforce uses the first line of thinking. How have we been dealing with increasing complexity recently? We educate people with university degrees that often puts us in our early 30's, before we even begin our first attempts at contributing anything (through this archaic concept known as 'work'). One problem is that this roughly coincides with the age at which we begin becoming slower of thought, and the onset of degrading memory recall. While engineers continue to learn, long after we have finished our education and passed our prime, it is simply not feasible to continue increasing the time spent learning, relatively to the time spent 'doing', even with better health and significantly longer life expectancy. Eventually we will simply spend our entire lives learning about how a specific and narrow area of computer science works, without ever being able to comprehend enough to actually contribute anything new, without introducing an equal amount of problems, as a result of our incomplete knowledge.

About compartmentalization: Similar to the problem of a more specialized workforce, we can do more, but it does not make the increase in complexity go away, and we cannot dial it up to infinity. Think of layered software architechture. We can have a huge number of layers, and while they help a great deal with complexity issues, each layer still adds some complexity. Here it is important to note, that we are talking about systems that go far beyond what we need, and deep into the reaches of what we are potentially capable of, a point that we already passed a long time ago.

The second line of thinking places us inside a Virtual Reality world, where we experience a glitch, and poses the question: How are we going to identify and fix the glitch? Part of the answer is rooted in the fact that the VR world can only exist in the first place, if the needed skills, tools, code libraries and hardware exists. If that is the case, then there must also exist equally powerful debugging tools. Some of the answer seem to be that any modifications on an extremely complex system will be heavily assisted by the tools used to produce the system in the first place, and require highly qualified engineers.

The part of the question that deals with passing on knowledge (after the creators of a system have passed) is mainly a question of being able to sort noise from valuable knowledge, and keeping a huge (and growing) amount of valuable knowledge updated. A detailed answer to this topic alone would be valuable, as it is something all engineering efforts struggle with. Writing things down and making sure there is a backup is trivial, but actually keeping the information relevant and of high quality is a major challenge.

Trying to imagine this future world, knowing what we know today about AI and neural networks, and our inability as a species to stop or slow down our scientific 'progress', it is quite difficult not to think that we will make ourselves obsolete, unable to comprehend the world we live in, even when it comes to just specific systems. Consider global macro-economics as an example of this, or to stay on topic, the recent concerns about why a piece of code made a certain decision (is it a turtle or is it a gun?).


In a sufficiently advanced computer science world, you'd expect there to be uploading of people, and possibly tightly controlled "meat-space".

You wouldn't experience the world unmediated; the unmediated world would be a lot like death valley crossed with a nuclear power station.

The real world is dangerous to people there, uncomfortable while there, dangerous to allow idiots to run around in to everyone else.

Instead, people would be uploaded and simulated. If they must visit the real world, you could download them into a meat-body for the retro-experience, or just access it "remotely" via robitic tools.

In such a world, studying the low level underlying hardware and software would have a few purposes. First, it would be akin to studying fundamental physics; if you are wondering how your (virtual) world works. Second, possibly repairing and upgrading said hardware and software is a good idea.

The field of study might be called "diety science"; studying how to create, maintain, and modify worlds. These people are, in sense, their own gods, making entire universes out of hardware and software.

Now, unlike ourselves, these people have theoretical access to the underlying system, so they can study how the virtual universe works as a white box instead of a black one. But emergent phenomina of the underlying system might be too complex to understand via white box understanding.

At modestly higher levels, computer science becomes akin the the study of physics, chemistry, the study of the world in which you are embedded within. This world would probably be designed to be pleasant, but for the most part you wouldn't want to give every user "god level" access to it for robustness sake. "Consoles" or whatever you imagine to interact with the computer would be similarly silly; if they want entertainment devices, they are just entertainment devices in this virtual world.

This virtual world might allow something akin to scripting. Do X, and get result Y. Maybe said scripts even permit loops and other human-understandable logical constructs. Then computer scientists working on that level would resemble magicians; building spells (scripts) that do things in the virtual world. To keep things stable, the effects of scripts would be bounded based on some resource share, so script-kiddies cannot rewrite reality with ponies.

Sufficiently advanced computer science is indistinguisable from a fantasy novel.

In this realm, knowing how to script would be of value. Lower level theoretical computer science might be useful in finding new ways to write scripts. At some point, people in these worlds wouldn't have permission to interact with the low-level details of their world, but knowledge of them could be passed down, look up, and maybe used to find other interesting ways your user-level scripts can interact with the world.

Forging new worlds might be possible (if expensive), and doing so might require knowledge of relatively low level (but higher level than any CS today) computer science to learn how to arrange rules for a stable universe to be created.

The lowest level of computer science and hardware would be outside the permission scope of any mere mortal, and mainly known as a theoretical discipline. Now, you could imagine that the guardians of reality (meatspace) might die, neglect us, or whatever, and people in the virtual reality might use such low level knowledge to create scripts that violate the "safety" assumptions that where built into higher level ones (find a ring-10e7 exploit, and the effect might be similar to nuclear technology; destructive and powerful).

When the caretakers notice, they can modify the underlying reality to patch the exploit, or do a rollback of universe state prior to it being used. And if you can notice that, you can exploit forcing rollbacks on universe state; make a decision contingent on the universe being rolled back. If it fails, activate a low-level exploit, cause a rollback, and make the other choice.


Abstraction has always been a corner stone of software development. Programmers only care how something works up to the point where they NEED to know how something works. Take this simple Hello World example in C#:

Console.WriteLine("Hello World!");

Most programmer's know this will print "Hello World!" to the console screen. Most programmer's don't care how it does it. All they care about is that, without question, it will print "Hello World!" to the screen.

So how does this work? Well, when you compile this program, it creates an EXE file that contains MSIL code. When you execute the EXE file on a Windows machine, the operating system looks at the header of the EXE file. It determines its a .NET program and it runs a JIT compiler. The JIT compiler takes the MSIL code and converts it into x86 or x64 opcodes. Since the .NET framework is written in C/C++, the JIT compiler produces code similar to this:

    push    message
    call    _printf
    add     esp, 4
    db      'Hello world!',13,10,0

The _printf routine is a routine in the standard C libraries. This routine uses routines found in Kernel32.dll to print a message, by using routines such as Writefile. Eventually, it all comes down to writing bytes into your video card's memory to manipulate what you see on the screen.

There was a time in history when writing a simple program involved worrying about all these little details. Today, however, unless you are writing device drivers or OS Kernel code, these details aren't something the average programmer cares about or needs to worry about.


Likely you would see continuation in the divergence in specialties you are currently seeing today. Data science, Front End, Back End, etc.

The evolution of programming occurs when technology is built on top of existing technology that is efficient and easy to use such that the underlying technology is no longer necessary to know.

For instance: How many programmers code up servers from scratch? (so so few)


Tie it to something they want

If you play World of Warcraft and want to win in PvP, you will learn the macro language (basically LUA).

You want to turn your lights on, every home is a smart home and you better be able to write some Insteon code or you'll be freezing in the dark.

We already have a programming language you need to get by, it's called English (here).


Cybernetic brain implants of language libraries, or voice-recognition software architecture.

The programmer would need to scan a lot of libraries and research efficiently. The libraries would be instantly assessable, so the cause, effect, methods, of all libraries could be efficiently assessed very fast.

All programming languages would have a common interface, and could be nested together effortlessly, and their cause and effect could be conceptually described in human terms and arranged into mechanisms with a human-spoken, computer written, cooperation.


I look at this as an issue with consumers vs the engineers that make it work. Today we have the OSI model, a 7 layer framework that divides computer systems in a logical progression. We already have specialists that work at different layers of the OSI model who may have some experience with other layers but are primarily focused on one or more depending on the work. The model assists in development and troubleshooting. I'm not sure we'll see a lot of changes to this. One trend in the industry is machine learning. This could drive more rapid improvement as these technologies become more mature, but the fundamentals would remain the same as long as people are in charge. If machines become responsible for development of technology and software, and aren't constrained by human oversight they may come up with something radically different, but that sounds like another story.


Compartmentalized AI embedded in Firmware

The answer titled: "Complexity is Compartmentalized" is an excellent one, but for your purposes, I would say the answer from a world-building/sci-fi perspective would be a little more caveated. If I may take the liberty of adding a bit of "history" to your scenario: Long ago, it was determined that creating an all-knowing, "Omni-AI" was a big mistake, and in fact, dangerous.

Therefore, certain AI standards, implemented as hardware modules were established to complete specific tasks. These modules are hardware based so the code cannot be altered - However, they do have an API which allows a person to interact with them. This is where the learning comes in. You can become an expert on using certain modules and becoming certified on them. Let's take "Microsoft Word" as an example. You can probably become certified on it, but you can't really change its source-code. The coding on these modules would be open-source, so as to maintain transparency, however, only a certain governing body would be able to produce authentic modules, which would be trusted in the public sphere.

Therefore, for the aspiring Software Engineer, programming and development would never get any more difficult than it is now. Sure, they would have to master AI concepts, but they would be limited to gaining proficiency on select modules.


I would venture to guess that just like now days the people interested in learning this stuff will actually know about it... And with the less people knowing about this the better paid the jobs will be so the new students will be more interested in studying it.

Or another alternative would be that AI would be advanced enough to design the needed hardware by itself in which case we wouldn't need people in charge of that.


You must log in to answer this question.