It is entirely possible to move higher up to very HLL's and still have a very deep understanding of how things work.
I have been using Haskell, a very high-level language for about 4 years now, and there is so much deep stuff to learn. Not superficial "playground is changing" stuff, but deep, nature of computing and logic stuff.
The Haskell eco-system is very open, and the optimizers and compilers have excellent utilities to look under the hood. This all makes it very possible to actually understand what's going on.
It is definitely harder than it used to be, because we're using more sophisticated tools to solve larger problems.
I started learning Haskell for the same reason that Peaker described.
From what I understand so far, Haskell is a very high level language which lets you do more with less.
One of the examples that come often is quicksort which you can write in like 3 lines:
But the thing is you still have to understand a lot of stuff before being able to use it correctly.
I think one of the most difficult (and interesting) topic would be monads, there are tons of tutorials online if you're interested on reading on it.
It's not a quicksort. It's a quasi-quicksort, which is actually not quick due to memory allocations.
Here's how quicksort looks like in haskell:
import Data.Vector.Generic
import qualified Data.Vector.Generic.Mutable as M
iqsort :: (Vector v a, Ord a) => v a -> v a
iqsort = modify go where
go xs | len < 2 = return ()
| otherwise = do
p <- xs `M.read` (len `div` 2)
m <- M.unstablePartition (< p) xs
go $ M.slice 0 m xs
go $ M.slice (m+1) (len-m-1) xs
where len = M.length xs
> I am programmer because I am naturally curious and because I love creative problem solving.
Which is still an excellent reason to be a programmer.
> What honestly pisses me off, is that these days programming is way more boring than what it used to be.
Completely disagreed! He's just focusing on the wrong things.
> The paradigm has shifted from low-level to high-level and as such we've lost steady, stable interfaces and systems and moved to very rapidly changing playground
I was trying to say that moving from low to high level does not mean losing stable interfaces, and it doesn't mean we need to have a "rapidly changing playground".
I have been using Haskell, a very high-level language for about 4 years now, and there is so much deep stuff to learn. Not superficial "playground is changing" stuff, but deep, nature of computing and logic stuff.
The Haskell eco-system is very open, and the optimizers and compilers have excellent utilities to look under the hood. This all makes it very possible to actually understand what's going on.
It is definitely harder than it used to be, because we're using more sophisticated tools to solve larger problems.