Perl was fun to write. Not so fun to read and maintain!
OK, it's actually good for a lot of things. But I used it during the old CGI scripting days when it spawned horror shows of flaky spaghetti piles duct-taped into monolithic applications. And that's how PHP happened.
I find TCL/tk is a great language for quickly prototyping a user interface to demo to a customer. It is easy to modify, sometimes right in front of the customer. When the UI is approved, then code it using real Windows controls.
Of them all, I miss Pascal the most, specifically Turbo Pascal 5.5, which introduced objects and OOP to the platform. At the time, functionality balanced by maintainability was the current hot topic, and this product was the epitome of that concept. Everything since has lowered the bar of maintainability by obfuscating what used to be almost self-documenting code. Pascal was as clearly understandable as plain English, even to non-programmers.
My first programming education at university level was in Pascal. The professor required us to model all data as RECORD types ('struct' in c lore), and define all operations on these records as a coherent set of fuctions / subroutines, all taking the record instance as the first parameter. (He also required input parameters to precede the output/var parameters in the parameter list, but that's a different matter.) We structured subtypes as multiple level RECORD types, or as variant records ('union' in c lore).
This was in 1977, eight years before C++. Simula68 was nine years old, but the professor never referred to that, or for that sake to OOP at all. He just did OO programming, without labeling as such.
Having that background when OO appeared, the change was limited to a few syntactic details. We had to move the first parameter ahead of the function name and add a full stop. We had to add braces around the RECORD type and its associated functions (and start calling it 'methods' rather than 'functions' ), but those are details. The code needed no fundamental restructuring. The way we thought about the problem solution didn't really change much. The addition of objects/OOP to TP 5.5 was undramatic. If your previous experience was with Fortran or Cobol, I guess it would be different.
Very cool experience! I started in 1975 with FORTRAN II on punched cards; back then Engineering was very into FORTRAN. I tried COBOL once, but that was a clear dead end. When Turbo Pascal came out, it was the only compiler I could afford (MS products were so obscenely expensive it wasn't even a consideration) and having been programming in Paradox it was a breath of fresh air! The 5.5 version introduced OOP, and that was so well documented in what we used to call, "User Manuals," the learning curve was trivial. The only stumbling block for me was the concept of serializing data to disk. I was used to random access approaches common at the time. Still, it worked out great. Then it was over... the Dark Age of cryptic languages and made up terminology began.
I never got to pick, so why fight it? Make the most of what you've got to work with.
Each language has its strengths and weaknesses. I have loved writing code in every language I have tried. If the language didn't support something in the best way, it was a chance to create libraries of helpers. That's fun, too! And makes you appreciate the language that does that thing well.
My only regret is that I rarely got to work in Assembly. What a blast that was. Like having legos at the molecular level. You could make anything you could think of.
An honest answer would be to select only from the languages you know. For me that list would include C, C++, assembly, and scripting languages (Windows "batch").
I can't say any of them are my least favorite. For a given problem one of them will be the proper choice and the others will not. That doesn't mean I dislike the other languages or would refuse to use them if they were available.
I think the point of the question was.
Given access to all of these. If starting a new project, which would be LAST on your list of choices.
I struggled in that direction. Assembly, for example, is fine on Motorola Chips, and the Old DEC/VAX systems with MACRO-11 Assembler. But Z80 instructions... Shoot me now! LOL. I wish Apple would have chosen Intel, and IBM chose Motorola! It would be a different world. I think they would still be working on the original Mac OS!
Oh yeah DEC Assembler is nice! Though it is ancient it was chosen for us to learn in university because of its rich addressing system and overall good structure. I liked it.
Texas Instruments DSP assembler is also a masterpiece, I should say.
I worked with an assembler where a register load was written as 'W3 := <loc>', store as 'W3 =: <loc>'. Basic math was like 'F2 + <loc>', 'F4 * <const>' and so on. Turn off (most) interrupts (unprivileged, for at most 256 clock cycles): 'SOLO', back on: 'TUTTI'. Memory swap, halfword: 'H SWAP <loc1>, <loc2>'. Conditional jump: 'IF <cond> GO <dest>'. malloc/free: 'W1 GETB <size>' / 'FREEB <size>, '.
You could read the assembly code without learning a gazillion acronyms!
Going from this assembler to C was a small step for a man ... and, I'd say, no large leap for mankind, either.
It's painful to write in any assembly language but everyone who did it know the sensation afterwards. I loved it, especially when I had to delve deep into all the SSE instruction set - I had to optimize some functions for different generations of processor, from SSE2 to SSE4.2 passing through the infamouse SSSE3 (yes, triple S).
GCS/GE d--(d) s-/+ a C+++ U+++ P-- L+@ E-- W+++ N+ o+ K- w+++ O? M-- V? PS+ PE Y+ PGP t+ 5? X R+++ tv-- b+(+++) DI+++ D++ G e++ h--- r+++ y+++* Weapons extension: ma- k++ F+2 X
Assembly language programming is fun, I enjoyed it for many decades.
It takes a specific mindset though: if you don't "get it" than you'll struggle and hate it. I think it's a load easier to go from "good assembler developer" to "good high level developer" than it is to go the other way - which may be why so many people hate it.
I started with COBOL at Uni (which is "English with a small vocabulary") and FORTRAN (which was "Assembler with less lines to type") to Assembler, then then up the Algol / Pascal / C / C++ / C# ladder, often in parallel.
"I have no idea what I did, but I'm taking full credit for it." - ThisOldTony
"Common sense is so rare these days, it should be classified as a super power" - Random T-shirt
AntiTwitter: @DalekDave is now a follower!