ryl00

> derefs of complex data structures

Am I the only one who finds perl data structures simple and consistent? Once I understood the difference between () and [] (or {} for hashes), it was easy (too easy, some might say!) to construct complex data structures.

If you're talking about Lehman Brothers, Wikipedia notes that the bankruptcy occurred on September 15, 2008, two months before Obama was elected.

Not much of a PC gamer, are you? :)

It depends on what you're working on. I'm in the simulation area at an engineering company, and we've got plenty of Fortran code that dates back to the '70s that's still just fine. A little maintenance to work on removing deprecated syntax, a little work to replace common blocks with a more decoupled design, and we're probably good for decades more use. And if we can't get to that maintenance work right now, the strong backwards-compatibility of Fortran will have our back until the next opportunity. :)

Steam dropped support for XP and Vista last year

https://support.steampowered.com/kb_article.php?ref=1558-AFC...

> I'm not sure I'm comfortable with python for a typical shell script. But then again, what alternatives exist?

perl still exists, and is a wonderful alternative to python for "shell scripts plus". The syntax should be at least vaguely familiar to anyone who has touched bash, awk, sed, etc.

Non-web developer here... I've personally never seen any Ruby in anything I've ever worked on (only personal, limited anecdote, of course).

Python's nice for gluing more performant native code together (perl XS isn't as straightforward IME). But for text processing I'll take perl every time.

Ever heard of J++?

Nah, plenty of people still care about it (I should know, I'm one of them!). And with regular expressions front-and-center in perl, I still find it wonderful for text munging.

I like the trade-off C/C++ compilers (with a reasonable amount of warnings set) made... warn about constructs like "if (a=b)" unless the user adds an extra pair of parentheses, like "if ((a=b))".

C/C++ compilers (at least, all the ones I know about) squawk about it unless you add an additional set of parentheses around the assignment.

> However they were slower - but not much

I don't think we should underestimate how much performance differences can color opinions here, especially for something like CLI tools that are used all the time. Little cuts add up. At work I use both git and bazaar, and bazaar's sluggishness makes me tend to avoid it when possible. I recall Mercurial recently announced an attempt to rewrite core(?) parts in Rust, because python was just not performant enough.

Fortran and Ada, as well.

What do you consider "real money"? There's a whole bunch of industry-specific software vendors like Autodesk and The Mathworks that have plenty of dependent companies still buying licenses for desktop software.

I think there are plenty of programming languages (maybe even most of them?) which take backward compatibility as a very serious goal. Obviously there's a balance between "don't break user space!" and fixing major problems (e.g., C's gets()), and most of the major ones seem to lean toward the former.

At the company I work at, we've got a large amount of Fortran code from the '70s that works fine with the latest and greatest Fortran compilers (barring deprecation warnings which help guide refactoring efforts). Same with C/C++ from the '80s.

> Now, and going forwards, I think we're in the phase where non flagships are reaching 'good' too

This will obviously vary from person to person, but I felt we already reached this point 4-5 years ago. After getting an unlocked Moto G2 in 2014 for roughly $200 new, I no longer felt like I was sacrificing so terribly much at that price point.

> my skills have not aged well

I don't think that's necessarily the case. C++'s famed backwards compatibility, source of so many issues, is also a fabulous strength. There's nothing stopping one from writing C++03, while gradually adapting C++11 and beyond as time/circumstances permit (which is what I'm doing at my job, maintaining a massive legacy codebase while stymied by slow uptake on newer compilers by my corporate overlords...)

> It's no wonder 'senior' devs prefer to use plain C

Not this senior (in years, at least :)) dev. I've tasted RAII and I can't go back...

> Despite all the love lavished on M.U.L.E. by Ozark Softscape and EA and despite deservedly stellar reviews, it was a commercial disappointment. M.U.L.E. sold only about 30,000 copies over its lifetime

Wow, that's sad to hear. But I still have one of those 30,000 here in my study (if the C64 counts in those numbers!)

Still is, for many of us (I only picked it up in 2000).

From what I understand (which is very, very little!), fundamental NT vs Linux architecture differences wrt their respective file systems prevent much more performance improvement in WSL 1.x.

P+++

I work on a large, multi-platform, legacy codebase of C/C++ and Fortran, and the FFI between the two sides has always been an area where care must be taken to ensure proper interop.

Being multi-platform, multi-compiler through the years has helped us ferret out FFI problems like the one described here, as our Windows Fortran compiler used to be Compaq Visual Fortran, which interleaved character strings with their length argument (as opposed to gfortran, which puts all such string lengths at the very end of the argument list). With Compaq Visual Fortran (and Intel Fortran with the right options set), forgetting to specify a string length argument on the C side would almost invariably lead to immediate crashes (unless, of course, the sole string argument was at the end).

> The ANSI style function declaration was maybe the only innovation that came after that that significantly improved the language.

"const" as well (back ported from C++ ?). And being able to declare variables anywhere (instead of just at the beginning of a block)

I don't think this is correct. If you come from Unix programming, perl should not at all be unfamiliar. It was an intentional amalgamation of shell, sed, awk, etc. And there was a time when that was the "mainstream" programmer community.

To me, reddit is truly Usenet 2.0, and in retrospect it's somewhat amazing Google groups didn't capitalize on the head start they should have had when they "inherited" Usenet and let it stagnate. My Windows phone is still viable primarily because reddit .compact still works in Edge (it'll be a sad day if/when? they remove .compact).

Perhaps I need help? :)

That's weird. Don't we get enough stories about Rust Belt economic hardship and Detroit real estate horror stories to know that property values don't always go up? Have we already forgotten 2008?

Is computer science really that subject to change, though? Especially given what most CS graduates end up doing in industry? The tech stack may change, the syntax of the language may change, but the underlying math/theory mostly doesn't.

> They filled their OS with spyware and adware

But only after Google, et. al. proved how willing we all are to trade our data for free stuff. This is just the new reality of SaaS, at least as targeted to the general public who now expect free updates for life, isn't it?

> Even if you do, it's a better investment to learn a general high level language with strong scripting capabilities, but that is also good at many things else.

And we already have that: it's called perl. :)

Sounds like you are looking for Legal-ese.