I feel like swift is really a good view on the future of programming. And it seems that in the future we have really two different kind of software engineers. As we make programming mainstream and easy, we will see some new people able to use langages like swift and dev good apps without having the slightest idea of what is happening underneath. We used to have at least a common background between software engineers but I think it gonna slowly disappear. Is it good or bad? I can't make up my mind yet, but I'm really considering more and more to go back to lower level langages as I feel like the upper levels are going to be crowded by young generations.
"Underneath" just means "the level below where I'm writing". This has pretty much always been true, the way systems are layered. You write install scripts? Apps? Libraries? rendering engines? Drivers? OS? Firmware? Chip layout? You probably don't really know what goes on 'underneath' your layer.
Agreed. I spend half my debugging time with the disassembly turned on - removes ALL the ambiguity. It's like pulling teeth to get other developers to try it. Once you do, you kind of get addicted to it.
I agree but I feel like with swift it's kinda reaching an extent and it really doesn't push you toward learning any other layer. Swift + playground feels like the new dreamweaver to me. Either people are gonna write ugly code that shows them what they want to do or keep building quality apps, I don't know, I guess future will tell us. But I guess my main point was just that where I personally would try to reduce the gap between the different layers so we developers know what happens from A to Z (at least on the software side), the industry is clearly adding layer on layers such a way it's nearly impossible to control and understand the whole thing.
Our entire software industry is built on the power of abstractions. While its always great to know as much as you can about the layers you are building on, solid abstractions that allow you to get away with NOT knowing that unless you want to or need to optimize to extremes are a great thing.
Off the top of my head the only times not knowing what's going on at the layer below has been a problem:
1. The layer below has a bug that manifests at the top layer. You're not sure if your code is broke or if the stuff your code is built on is broke. I see this a lot in the Java world where people use frameworks / libraries they're sometimes not even aware of they're using and it has a bug.
2. You run into performance problems because of the things you're using at the layer below you. C++ STL containers is a good example. It's pretty much black-magic, have you ever looked at the implementation? I also see this a lot in the Java enterprise world. One of the selling points of Java is that it's monkey-coder friendly. Except when it breaks and the monkey doesn't know how things work under the hood.
Other than that, you should be fine not knowing the layer below you.
