6 ms·
The thing that scares me about jumping into programming today is that you realistically can't know all the layers any more. My programming experience was writin
by mikewarot 5y ago
The thing that scares me about jumping into programming today is that you realistically can't know all the layers any more. My programming experience was writing a program, and a few libraries that went with it, from scratch, in Turbo Pascal.
I knew how my code worked, and the run time libraries were simple enough that they really never caused any issues. I also spoke with most of the users of the program, personally.
Now you're expected to write "apps" that run in some random mobile platform, with almost no feedback when things break. You're depending on layers upon layers of abstraction to make everything work, it's like building on sand.
On the other hand, as pointed out, it's like that in other occupations as well.
We programmers do have a choice, however. It doesn't have to be, though. We could simplify things and remove some of the cruft.
- mips_avatar 5y agoThere was always some layer of abstraction. It’s just the ISA is a more elegant abstraction than a mobile platform is.
- commandlinefan 5y ago> with almost no feedback when things break It was kind of like that back in the days of "shrink-wrapped" (even if it wasn't really shrink wrapped) software, too, though - I remember trying to debug problems that were specific to a particular environment on remote computer users computers before the internet. At least with apps you can build in some sort of telemetry. But yeah, things are way more complicated than they used to be, and it takes a lot longer than most people appreciate to go from zero to productive.
- oconnor663 5y agoI think there's a lot of truth to this, in that it's good to understand all the layers below you. But there's also some truth to the opposite: Did anyone ever really understand all the layers, or even most of them? Even if you knew all the details of how your microchip worked (weren't those details usually proprietary?), you might have wanted your code to work on other chips, or even on future versions of your current chip. At some point, we always have to close our eyes and abstract away parts of the problem behind the contract we believe those parts will follow.
- analognoise 5y agoYou could specifically limit the processing to a microprocessor that doesn't have advanced features, and is implemented on an FPGA. You'd own all the RTL and could make a modern ASIC if you really wanted. You can understand all the layers if the design is meant to be simplified; like project Oberon, but based on a system that runs C code (and the UI would need to be a little more modern). You can understand all the layers, but the system has to be designed to be understood.
- AnimalMuppet 5y agoYou can have a system that is understandable (to someone not at that layer), or you can have a system that is robust (not crash all the time) and functional (more than just a bare-bones feature set). It's the things you have to do to make it robust and functional that make it hard to understand. As time goes by, the understandable version and the useful version diverge further and further.
- analognoise 5y agoI don't think that's necessarily the case, but it's a damn good point; I'd posit that a number of advancements of modern systems could be retroactively applied to a much less sophisticated "base" system and still maintain reliability, because they're born out of increasingly sophisticated programming practices that are widely established at this point (unit testing, fuzzing, even formal methods). I'm no longer sold on "added functionality" though. I want my computers to be dumber, do less, and be fully owned; I want a 32-bit Z80 (or something like it) that runs at 400MHz on an FPGA, and a graphics subsystem that's primitive and easy to understand and work on. It won't play Crysis - fine. But DOOM, sure! (There is a killer project about a multi-Z80-core CPU implemented on an FPGA, I'll find a link to the project later) It seems like we made this deal that we get more and more functionality, and it's set us up so that computing could be taken away from us (walled gardens, the modern internet, telemetry, software that requires subscriptions, updates you don't control, etc etc). But you've brought up an interesting point that I'll need to consider deeply about reliability and its effect on system complexity.
- teddyh 5y ago> you realistically can't know all the layers any more This has always been true. What you percieved to be the case was an illusion. To paraphrase myself¹: Imagine someone who started with soldering, electronics, radio, and circuits, and is just beginning with computers and programming. They would probably feel the exact way you do; that they used to know “all the layers”, but that it’s somehow becoming too large for them. Knowing “all the layers” was an illusion for them, as it was for you. > almost no feedback when things break. This, however, is absolutely crucial. Fast feedback loops, however and at whatever level they are implemented (REPL, fast development iterations, TDD, monitoring) are essential to knowing that what you are doing is actually accomplishing anything and not just doing cargo cult coding. 1. https://news.ycombinator.com/item?id=19113359 https://news.ycombinator.com/item?id=19113359
- blacksmith_tb 5y agoVery true, though unlike a towering software stack, the chances that your hardware was going to suddenly start doing something surprising were lower (not nil, obviously, or we wouldn't have started virtualizing hw, but now any one of several package managers could take your app down).
- teddyh 5y ago> chances that your hardware was going to suddenly start doing something surprising were lower Spoken like someone who has never had to debug (for instance) why a serial port is not connecting properly. All abstractions are leaky¹. 1. https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-abstractions/ https://www.joelonsoftware.com/2002/11/11/the-law-of-leaky-a...
- mikewarot 5y agoActually, I did know all the layers back then I've written compilers, and editors I know several assemblers I've designed and repaired TTL/CMOS based circuits I've done NAND to Tetris I know digital and analog electronics I know how tubes and transistors work I've fixed atomic clocks There wasn't a layer I couldn't troubleshoot or understand. Things were much simpler back then.
- andrew_ 5y agoI'd wager the most common type of developer/programmer/software engineer these days is what they call "T Shaped" [1] whereby you have a breadth of knowledge that you're somewhat familiar with, knowledgable of, or have experience with, along with deep knowledge and skill in one or a few areas. One might even say an expertise in a particular niche. I consider myself in this category where the horizontal part of the T is "fat" with more than a decade of experience in my chosen field, and a long vertical portion with deep expertise in two languages and an ecosystem. This is what the traditional generalist has shifted towards recently. [1] https://en.wikipedia.org/wiki/T-shaped_skills https://en.wikipedia.org/wiki/T-shaped_skills
- LeifCarrotson 5y agoThe technology world is shaped like an inverted pyramid, and I suspect that everyone's T is just a small segment of that pyramid. I was fortunate to study computer engineering at a liberal-arts university that tried to build competent engineers by training them with triangular, rather than T-shaped knowledge. The learning curve went something like this: As the parent pointed out, it's all built on sand - not in the manner they meant, but it's actually built on silicon. At some level, physics and chemistry can teach you about electrons and orbitals and excitation. You can learn about insulators, conductors, and semiconductors. In the lab, you can get some glass plates coated with (clear, conductive) titanium dioxide, an electrolyte, and some Ruthenium or organic dyes, and make a dye-sensitized solar cell, or a tungsten wire and chip of germanium and make a point-contact diode. A little more physics and you can build a bipolar transistor or field-effect transistor. With that physics as the tip of the pyramid, now branching out with the help of commercial discrete components, you can expand into electrical engineering. On a breadboard, you can make a NOT gate, an AND gate, an SR latch, an SRAM cell. Realize that there's a whole breadth of analog electronics, but we're in a computer engineering course, so consign yourself to a cursory introduction and again climb the pyramid to commercial 7400-series logic ICs, and make a binary adder. Realize that there are lots of 7400-series ICs, with various applications, parameters, and specifications, the pyramid is already staggeringly broad. You know how to move sideways here, but don't right now - climb up and expand further to CPLD and FPGA development boards and some VHDL, rebuild your binary adder in silicon, make a seven-segment decoder, add some load/store instructions, conditional logic, and a few more math primitives; you've got a CPU. Now that you know how to build a CPU, go buy an Arduino, it contains a small CPU. But don't download the IDE yet, instead, get avrgcc and become familiar with AVR assembly language. Write a main.s, you can blink some LEDs or drive a hobby servo with a PID loop in response to a sensor. There are lots of microcontrollers like PICs, 8051s, and ARMs, and lots of work done in assembly, but we can't linger here - we have to keep climbing the ladder. Speaking of ARM microcontrollers, grab an ARM dev board. You made a few function calls in your assembly programs, learn about the C ABI. Start learning C on a PC, manipulating text, once you're familiar enough with the syntax to write a "Zork", head back to the dev board and write a Forth, talk to some sensors over SPI, UARTs, and I2C. Write an RTOS, digging through Linux source code to learn about syscalls. OK, your RTOS sucks, and isn't very good at securing real-time constrains when your user code has bugs much less malicious inputs, but it's an OS, here's FreeRTOS. Hook your board to another students' GPIO (optocouplers are handy) and develop a packet network. Install uIP on your boards, and start talking Internet Protocol over sockets. Send an HTML page. Embed some Javascript. Realize that your Cortex-M0 is really resource-constrained, and set up your webpage on a VPS. Install Python on the VPS, and build a web framework. Try to keep track of data in CSV files, redo that as a database, someone already did that and it's called SQLite. And so on up the chain. Down the chain, nothing is a black box, it's all built on sand. Every level of the pyramid is occupied by someone with T-shaped knowledge. Those just below you are writing the frameworks that you have so much experience in, they're using languages and operating systems that someone with experience closer to the hardware than them developed. Those left and right of you are using different frameworks, with a different path to the electron at the bottom of the pyramid, those above you are your clients who use your products. Further up the pyramid are people who don't know exactly how things get done, they have a lot of things to keep track of, fortunately their vendors (your clients) have software to do that. The idea that everyone needs to have the base of their T reach the atomic physics at the tip of the pyramid is a little antiquated, even more so the idea that everyone needs to know everything below their framework. That may have been true in the 6502 era, and for a few exceptional people like Carmack or Knuth or Ritchie for some time beyond that. But few can be expected to maintain encyclopedic knowledge of the esoteric alternatives that don't lead up to their T, and no one can keep track of what every user - who may also be a developer - is developing in real time.