I'm "only" 39, but it's been 30 years since I've written my first line of code. And I have to say that while things have changed a lot, the basics of how it is to program and how you write code, are still the same. I find myself applying techniques I've learned back then, and even though I haven't written assembly since the 80s, the basic low-level understanding of how it all works still serves me to this day. The main difference is maybe how accessible good info is now. Back then each programming book was a treasure that was passed around.

I often wonder how much of that will stay the same 30 years from now, and I hope I'll still be hacking then. My bet is that we'll still have some versions of programming languages we know today, maybe even Linux running it. But it will be much more exciting if that won't be true :)

I've been through 50 years of "programming" with a major change each decade. The key thing is to be in the company of young people.

It's harder to learn new things because you have to unlearn earlier ones. My Java started by looking like FORTRAN, my Python now looks like Java.

It's critically important to use good Open tools. Eclipse is wonderful. I could not work without JUnit and whenever I run into problems I use the discipline of using tests to define the problem. I have learnt to "love" Maven as I can't do without it. I could not live without Jenkins/Continuous Integration.

The main problem is that all these add up, both in learning, installation and support. When I "retired" my website in cambridge gradually decayed and an upgrade to the OS meant Jenkins no longer worked. It's now back (thanks, Mark Williamson) and has restored impetus in the chemistry coding.

You have to include time for exploration ("dead ends"). I jumped into javascript when it first appeared - it wasted huge amounts of time as every browsers "upgrade" was a disaster. I started Python and that was nearly as bad. Now , 10+ years on, they're robust and I shall relearn them. Probably be working alongside experts in a hackathon.

I believe in code review and am happy for others to review mine!

I find it that HackerNews itself, while it does waste a lot of my time reading and toying with such "dead ends", keeps me on the edge of things. I've started using Go because of posts and discussions here, and it's changed the way I do my work in the past year.

>My bet is that we'll still have some versions of programming languages we know today, maybe even Linux running it.

Unix is going strong for 41 years, says Wikipedia:

http://en.wikipedia.org/wiki/Unix

Other than some IBM mainframe operating systems, this is probably one of the longest-lived ones still going.

70 years of Unix, that would be something

33 years since I started, and virtually nothing has changed in programming. In the graphics arts, yes. In the UIs, yes. I've seen a lot of fads loudly explode onto the scene and quietly blow away. But recursion is still recursion, picket fence bugs are still picket fence bugs. There are some new algorithms, most of which I never use of course. Fundamentally 30 years ago I spent most of my time designing, defining, and screwing around with the contents of data structures, and nothing has changed since then other than the technologies, all of which are pretty simple and easier to pick up, each time I pick them up.

I'm not yet 60 but WRT "Do you find it more difficult to grasp with age or does it get easier?" OMG you have no idea how much it gets easier. Unbelievably so. Think about it for a second, nothing's ever really inherently new on the biz side, its all a remake of something else, and most of the tech side is the same other than adding more zeros to various specs. And I figured out how it works and how to debug it and when it breaks, last time around, and nothing has really fundamentally changed this time around other than some specs that are irrelevant or simple to work with. All I need to do is pattern match it now and I'll have the answer instantly compared to people who never experienced the same thing last time around. Also its much like learning foreign languages or math, in that the more you learn, the more you learn how YOU best learn, so the easier it is to learn. Trust me, kids, learning your 6th language is unimaginably easier than learning your 3rd.

There is a lot of self selection bias. If the lifespan of a poor programmer is 3 years, not even long enough to graduate, and a tolerable programmer is 10 years, well, if you're doing this as an old guy, you might actually know one or two things about programming.

I'm not a very good carpenter, but I can wield a saw on occasion, and things have changed in carpentry, but not much. Another interesting example is cars, both driving and repair, where the frosting has changed but the cake is pretty much the same. Another similarity in both fields is there are loud subcultures taking great joy in reminiscing and refusal to learn about the new frosting and complaining about today's cake flavor, blah blah blah.

One very curious aspect of computing is I can do everything at home, very slowly, compared to what I can do at work. I don't need to wait for the boss to give me permission to play with Scala at home. Or Clojure. And I started using Scala at work because I had fun at home (other than the compile times, and getting pissed off about arbitrary size limits of case classes, and ... oh wait I keep telling myself I like Scala, every rose has its thorns I guess) Anyway my first major a long time ago was ChemEng and its hard/impossible to fool around at home with the same stuff as the lab at work, so its actually kind of unusual to be so "free" in computing, compared to other vocations. I could see life being pretty rough as a 60 year old chemist, but not so bad as a programmer.

Very much concur on things getting easier, at least up until now (I'm 48). Compared to when I was in school, I'm able grasp concepts so much more easily, probably as a benefit of 30 years of programming experience. I'm able to to relate new ideas to similar or related concepts I already know. I also am able to see how many times each generation solves the same problems over again, which is a little discouraging at times.

Some syntactic sugar is sweet; others, just another bitter aftertaste of saccharine.

Enabling interrupts before initializing the stack pointer does just about the same thing on a 2014 processor as on a late 70s processor, just maybe a little bit quicker. And a bazillion other bugs I've seen before.

There's a negative sense of programming as an activity, programming is the art of not creating bugs, and that certainly gets a lot easier with age. Or rephrased is the young guy hasn't made and learned from his stupid mistakes yet. I still have dumb mistakes left to make, just a lot fewer of them.

You probably already know this but in Scala with SBT sub projects and incremental compilation you get a very snappy dev cycle (clean builds will always be much slower than Java). I believe the 22 tuple limit is gone in the 2.11 release (in next week or so); if not there's Miles Sabin's Shapeless library (https://github.com/milessabin/shapeless).

Glad to hear you're still going strong, 42 here and can't imagine stopping anytime soon ;-)