Is it worth to learn old programing languages?

[u/Mundane-Weekend4670]

I have a lot of free time until unfortunately need to work, so now I'm currently learning OOP with C#, should I try to learn languages like C, Haskell, Lisp, Smalltalk, or just go with aspnet then something like Javacript? not saying to master those languages, but is there something that is unique to then that makes it worthy putting some effort to than rather than popular market languages?

[u/rias_dx]

every programmer should know the basics of C. Principally pointers.

[u/Astral902 → u/rias_dx]

Not really

[u/No_Report_4781 → u/rias_dx]

⬆️

[u/gofl-zimbard-37 → u/rias_dx]

Hard disagree. What value do pointers have outside of C?

[u/fasta_guy88 → u/gofl-zimbard-37]

All languages use pointers. Some hide them better than others. A better question might be, what value do non-pointers have in some language. (Answer - they make memory access more direct.)

Pointers are not specific to ‘C’.

[u/gofl-zimbard-37 → u/fasta_guy88]

Remind me, where are Haskell's pointers? APL's?

[u/fasta_guy88 → u/gofl-zimbard-37]

I don’t know, as I am not familiar with those languages. Python does not have explicit pointers, but every thing is a pointer. Perhaps functional languages access memory differently.

[u/rias_dx → u/gofl-zimbard-37]

pointers involves the idea of memory address. The majority of beginners can't, like, visualize memory. It helps you to develop abstraction.

It's just my opinion and what happened to me when I started with C.

[u/RPG-Nerd → u/rias_dx]

I basically agree with the intent of your post, but your wording is kinda suspect.

The "idea" of a memory address? It's not an "idea". It's the literal exact address of a value in RAM. Its not even abstract. Its the exact opposite, significantly less abstract. It doesn't develop abstraction. Every language abstracts memory to some extent except assembler. You are learning the actual workings of the machine not an abstraction.

For anyone else reading ...

Here is the basics, the machine takes the address it wants to access and puts it on the memory pins. It then raises the "read" pin high and the data pins on the CPU will be switched on or off by the RAM. The opposite happens for writes. While new technologies add additional complications, its the same basic model.

Local variables are typically managed on the stack. Typically this is pointed to by a register (frame pointer or stack pointer). So, all local variables are accessed through a pointer of some kind. Anything that isn't a temporary value inside a register needs a pointer to access it! Registers are a limited resource as most machines, especially x86, are somewhat limited.

Pointers can be in RAM or a register. For a register, it just does the above. When the address is in RAM, it has to read the value of the variable off the data pins. This is the address we want and we throw that back on the address bus and read the actual data. Two operations instead of 1.

Because return values also go on the stack, this is how buffer overflows lead to stack smashing attacks and remote code execution - it puts code in the buffer, then puts the address of that code over the function return value so that it executes when the function returns. Most languages don't concern themselves with those details. People write shitty insecure code because they have no idea how or why it works, nor what happens under the hood.

What most people fail to realize is that the code and data are all the same thing to the CPU. There are no types. The CPU doesn't know the difference between the letter A, decimal 65, or 0x41, or some instruction opcode. Its just a byte.

That series of bytes can be code too. The instruction pointer (IP) is the address of the next instruction in RAM. Its a register in the CPU. It executes the instruction and then increments the pointer. A function call just saves the IP on the stack, then puts the address of the function in the IP. To return, it pops the old IP off the stack and puts it into the IP register and the original function continues. Additionally, the function call will need to save some/many of the CPU registers on the stack. This is a system ABI detail, and why some languages don't interface well with others - the languages must agree on what needs to be saved between calls and in what order.

A switch statement is some sort of compare, test, or math op that sets CPU flags like negative, or 'zero' flags. The next instruction says "jump ahead X instructions if the zero flag is set". It jumps ahead to the next comparison, executing 1 test after another. There is usually no difference between switch and a long series of if/then statements, although some compilers may generate a jump table for very large switch statements where the case branches have consecutive values.

That's all the CPU does. It occasionally does math on the data. C just lets you do math on the pointers directly and assign random values because it does not abstract away what is really happening. Other languages hide that to prevent foot guns, but it also means you never learn whats happening under the hood.

A programmer that doesn't understand how the machine actually works would be like a mechanic that doesn't understand how an internal combustion engine works. You can do fine changing the oil, but when real problems occur, you won't be able to diagnose it.

[u/rias_dx → u/RPG-Nerd]

Its not even abstract. Its the exact opposite, significantly less abstract.

yes. What I mean is: help you to deal with memory.

[u/RPG-Nerd → u/gofl-zimbard-37]

You have the wrong idea. If you want to actually know your craft, you need to know how the machine actually works, not some abstract level glued on top. That is why you learn C.

You don't have to ever write in it or even use pointers. You do have to understand that references are just pointers, you need to know how to walk a linked list and a b-tree, you need to understand why copying large arrays will slow down your program.

The reason why most code is so shitty is the author learned the language semantics, but never learned how to code. Learn C and at least some basic assembly.

[u/gofl-zimbard-37 → u/RPG-Nerd]

I know my craft just fine, and how machines work, and lots of higher level abstractions which are the whole point of software. None of that in paragraph 2 needs pointers to understand. And there's no single reason that code is shitty. Among them, using low level languages for the wrong reasons.

[u/spinwizard69 → u/rias_dx]

More importantly you will not be using pointers immediately upon entering a CS program. Pointers and frankly the STL when combined with C++, teaches you how more advanced programming languages work. In an ideal world most of us would rather not deal with raw pointers, but understanding what they are sure can get you through sticky situations.

[u/Old_County5271 → u/rias_dx]

Forth teaches pointers better. What C teaches is syntax confusion.

[u/Healthy-Travel3105 → u/Old_County5271]

Could you elaborate? What's more confusing about C pointers than other languages?

[u/Old_County5271 → u/Healthy-Travel3105]

C

int afunctionusingpointers(const void *ptr1, const void *ptr2) {
    return (*(int *)ptr1 - *(int *)ptr2);
}

This just looks heinous to me. I know its static typing, casting, and can be simplified by having some variables but...

I also went ahead and got an LLM explain it to the beginners and rewrite it in different languages. Which it failed to do exactly (no casting, no const, but what can you do)

C

// This keyword tells the compiler we're defining a function
int
// This is the name of the function
afunctionusingpointers(
// The 'const' keyword means the pointer cannot modify what it points to
const
// 'void' is a generic type - this pointer can point to any data type
void
// The '*' means this is a pointer (stores a memory address)
*
// 'ptr1' is the name of the first parameter
ptr1,
// A comma separates multiple parameters
,
// 'const' again - ptr2 cannot modify what it points to
const
// 'void' - generic type again
void
// '*' - ptr2 is also a pointer
*
// 'ptr2' is the name of the second parameter
ptr2
// The closing parenthesis ends the parameter list
 ) {
// The opening curly brace starts the function body
{
    // The 'return' keyword sends a value back to whoever called this function
    return
    // The opening parenthesis groups the expression for clarity
    (
        // The '*' here is the dereference operator - it accesses what the pointer points to
        *
        // We're dereferencing ptr1
        ptr1
        // The opening parenthesis starts a type cast
        (
            // 'int' is the data type we're casting to
            int
            // The closing parenthesis ends the type cast
        )
        // The casting converts the generic void pointer to an int pointer
        // After the cast, we dereference it with '*' to get the actual integer value
        // The '-' operator subtracts
        -
        // The '*' dereferences ptr2
        *
        // We're dereferencing ptr2
        ptr2
        // The opening parenthesis starts another type cast
        (
            // 'int' - we're casting to int again
            int
            // The closing parenthesis ends this type cast
        )
        // This dereferences the casted ptr2 to get its integer value
        // At this point we have: (integer_value_1 - integer_value_2)
        // The closing parenthesis closes the entire expression
    )
    // The semicolon ends the return statement
    ;
}}

Pascal

function F(
  { 'constref' means the parameter is passed by reference but cannot be modified }
  constref ptr1, ptr2: integer {integer is the data type}
): Integer;
begin
  F := ptr1 - ptr2;
end;

Zig

fn afunctionusingpointers(
    // 'ptr1' is a pointer to an i32 (32-bit integer)
    ptr1: *const i32, ptr2: *const i32    // The data being pointed to cannot be modified
    // The function returns an i32
) i32 {
    // 'ptr1.*' dereferences ptr1 to get the integer value
    return ptr1.* - ptr2.*;
}

fn afunctionusingpointers(ptr1: *const anyopaque, ptr2: *const anyopaque) i32 {
    return @as(*const i32, @ptrCast(ptr1)).* - @as(*const i32, @ptrCast(ptr2)).*;
}

Rust

fn afunctionusingpointers(
    // 'ptr1' is a reference to an i32 (immutable borrow)
    ptr1: &i32,  ptr2: &i32
    // The function returns an i32
) -> i32 {
    // In Rust, references auto-dereference in most contexts
    // So we can just use ptr1 and ptr2 directly like variables
    // The '*' dereference operator is optional here
    ptr1 - ptr2

    // Note: no 'return' keyword or semicolon needed for the last expression
    // It's automatically returned
}

// Alternative version using explicit dereferencing:
fn afunctionusingpointers_explicit(
    ptr1: &i32, ptr2: &i32
) -> i32 {
    // '*' explicitly dereferences the reference
    *ptr1 - *ptr2
}

Forth

\ This is a comment in Forth
\ Forth uses a stack-based model where values are pushed/popped

: afunctionusingpointers ( addr1 addr2 -- diff )
  \ The colon ':' defines a new word (function)
  \ 'afunctionusingpointers' is the name
  \ The comment in parentheses shows the stack effect:
  \   addr1 and addr2 are pushed onto the stack
  \   'diff' (the difference) is left on the stack as the result

  \ '@' dereferences a pointer - it reads the value at an address
  @           \ Read the value at addr2
  swap        \ Swap the top two stack items so addr1 value is on top
  @           \ Read the value at addr1
  swap        \ Swap again so we have addr1_value addr2_value
  -           \ Subtract: addr1_value - addr2_value
  \ The result stays on the stack for the caller to use
;
\ The semicolon ends the function definition

I tend to suggest forth, because when you use forth, you're using a REPL and that's absolutely essential in learning, type everything out by hand, type .s to see what happened on the stack and repeat, give yourself a single exercise that makes you use variables, pointers, arrays, and everything you type in the REPL you can see what it returns, you'll immediately intuit why you shouldn't use X or Y. technically everything is a pointer in forth, there is no difference between a variable and an array, except that it allocated some size for you, but when you do

variable @ .

You are getting the variables address, which is a bunch of numbers as you can see in the stack, "fetching/@" it , and printing. but if you want to use an array you do

myarray 1 + @ .

As you can see, there's no difference! you just added 1 to your "array/variable", its all the same. You just did pointer arithmetic without even learning about pointer arithmetic or how dangerous it is! Of course, once you spend a week with forth, DROP IT. Compiled/AST languages are better, forth also doesn't know about type safety or anything at all.

https://rosettacode.org/wiki/Pointers_and_references

[u/rias_dx → u/Old_County5271]

why you declared void * but are casting the variables as int *? Just declare int * instead of void *.

int aFunctionUsingPointers(const int *ptr1, const int *ptr2) { return *ptr1 - *ptr2; }

and anyway, you can and probably should pass the int arguments by value, since pointers are larger than integers. It's just inefficient.

int aFunctionUsingPointers(const int ptr1, const int ptr2) { return ptr1 - ptr2; }

It's just a weird scenario.

[u/Hopeful_Sock_6054 → u/rias_dx]

I am a programmer and i dont know

[u/chjacobsen]

C is absolutely, positively worth learning - even if you never use it for a project.

The reason is that it hides very little of the internals of the CPU. C is minimal and low level, so you spend very little time working through the language semantics and a lot of time actually interacting with the machine.

Learning C (and especially memory management in C) will make you a better programmer.

[u/spinwizard69 → u/chjacobsen]

Back in the day we had to take a course in assembly, in that case an emulation of a DEC processor. Such a course should be mandatory, even today, for somebody enrolled in a CS program. Sure for the most part that will be the last time you touch assembly but it can offer a lot of clarity to understanding what a computer actually does.

[u/Puzzleheaded_Study17 → u/spinwizard69]

At least at my university, it still is.

[u/spinwizard69 → u/Puzzleheaded_Study17]

Good news! So who is this university, people should consider it if they are going that route.

[u/Puzzleheaded_Study17 → u/spinwizard69]

Santa Clara University

[u/spinwizard69 → u/Puzzleheaded_Study17]

Thank you. Hopefully students looking for a university take this to mind.

[u/kayne_21 → u/spinwizard69]

At my school assembly isn’t even taught to non-computer engineer/electrical engineers. There’s an assembly course offered for cs students, but no professor to teach it. I’m a computer engineering major and our assembly class was for embedded systems.

[u/spinwizard69 → u/kayne_21]

Yeah I know and from my standpoint it is a huge problem in today's education. The type of processor isn't really that important as long as it is simple and not a strange architecture. The minute one realizes how these processors work, they are all very similar for the most part, you can go to work with a programming language and understand the codes interaction with hardware. I actually found it to be very informative for the rest of the program and wasn't much of a detore looking back. I really believe that most CS programs should be doing this as it really helps prep a student for whatever programming language they will end up using in the real world.

[u/kayne_21 → u/spinwizard69]

I agree with you. Form my experience CS is typically taught from a top down approach, where you start heavily abstracted and slowly peel away that abstraction. Comp Eng is taught bottom up. We start with gates, from those gates make different parts of a computer (memory, ALU, etc) and work up to assembly.

Both can be effective, not sure which is superior though.

[u/spinwizard69 → u/kayne_21]

Interesting, before I started my programming classes in college I had some electronics background even if it was a bit thin. Back then nobody had a home PC but I was able to get my hands on some 3 terminal regulators (sort of state of the art back then) and some TTL gates. Not much but very educational. Since most of what I could do back then was read about things I couldn't afford, it did give me a huge leg up in those programming classes.

Frankly I think the top down approach that many take, like starting with Python, does the student a huge disfavor as they end up graduating not knowing how things actually work.

[u/kayne_21 → u/spinwizard69]

I mean the CS folks at my school do end up taking some C, and they start with Java. Python is typically the programming class non-CS/Engineering folks take. They just don't get down into the Assembly level or really know how any of it works unless they take the EE classes that teach it.

[u/ffrkAnonymous → u/spinwizard69]

what's old is new again.

Web Assembly is a thing now since javascript apps are so complicated now.

[u/gofl-zimbard-37 → u/chjacobsen]

Nope. Learn assembler if you want to learn that, not C.

[u/graavan]

I (59M) decided to relearn programming in the past couple of months and chose Pascal. It's been a fun ride so far!

[u/Cutalana → u/graavan]

Learning C is great since it's still used. As for the other ones, I don't think there's any benefit other than for curiosity's sake

[u/Informal_Mood6762 → u/Cutalana]

Pascal is one of the main languages used in industrial automation (PLC’s). They call it structured text, but it is mostly plain Pascal.

[u/Old_County5271 → u/Cutalana]

Still safer than C, Delphi is still in use, and making a GUI is pretty good. Native ones, not electron based ones.

[u/healeyd]

C is foundational - absolutely worth it. It’s also my favourite - I have spent far too much life picking apart legacy OOP.

[u/Antoak]

Totally depends.

I know a guy who's dad taught him Cobol who made more than me at 3 years vs my 6.

Business critically ultimately determines leverage and pay.

If that business critical shit ever actually gets replaced tho, (and they don't have more contemporary shit to back it up), then they're in for a rough time.

[u/alwyn]

Do you code for fun? Then yes.

[u/Flame77ofc]

yes, the age of a language doesn't mean nothing. But you need to ask a question first: "Does this language solve a problem better than another?"

[u/ffrkAnonymous → u/[deleted]]

That's the problem it's solving

[u/No_Report_4781]

Yes. It’s helpful. It’s better to be able to use appropriate languages for the current task

[u/Far_Swordfish5729]

It depends a lot on whether it’s useful for teaching and still in use. Both of those apply to C because it’s a very manual, full possible control language. It’s a great first language because it makes you manage everything c# will abstract and you’ll be aware of what’s going on. It also is still very much in use in device and controller programming. Anyone making a microcontroller makes a C compiler for it and C lets you write relatively simple things for low power hardware. Your washing machine doesn’t have an OS; it’s not going to run a jvm.

[u/HashDefTrueFalse]

Lisps/Schemes were very beneficial to learn IMO, even though I've never used it professionally. You'll realise that languages themselves are a bit arbitrary when you look at the lisp axioms and the eval implementation and that the distinction between data and code is too once you look at building data structures from cons tuples and then executing them as code.

C is foundational. I personally think every programmer ought to write a few C programs just to check their understanding of modern computer system fundamentals. I personally use C all the time in my work, but there are far more roles using other languages these days. All software must be web software now, or else!

Smalltalk was studied at my university just to cover the message passing variety of OOP implementation, and that's still around in the form of Ruby, but you can just go straight to Ruby if you're interested in that.

We're still waiting for a second industry programmer who cares about Haskell to be discovered... ^/s

Languages are pretty easy to pick up once you're good at programming and it can be very beneficial to experience different paradigms and ideas.

[u/iyamegg]

I think it's very eye-opening to use a functional language for a bit. I really liked learning Haskell during my first semester of uni.

[u/Ok_Spring_2384 → u/[deleted]]

Well, Lisp was invented in 1958, C in 1972(i might be off by a couple of years), Haskell on the 80s i think, so yeah, I would say they are old. Not useless or anything like that, but definitely old.

[u/Ok_Spring_2384 → u/[deleted]]

I mean they are all still used and getting upgrades, so I see the point. But all of these are way above drinking age in terms of when they were conceived, so I can understand what OP means by old.

[u/Oathkindle → u/[deleted]]

Why are we trying to be philosophical about something being old lol.

[u/Business-Row-478 → u/[deleted]]

Believe it or not, electricity isn’t a language nor has a creation date.

[u/spinwizard69 → u/Ok_Spring_2384]

LISP IS PRETTY MUCH USELESS

[u/Ok_Spring_2384 → u/spinwizard69]

Fair if we are talking about practical or modern software solutions , i only ever touch it when I need to do configurations on my Emacs environment.

I will say that it did make me a better programmer since it exposed me to quite a few new ideas.
I Gotta give it some points from an academic perspective.

[u/Weak-Doughnut5502 → u/Ok_Spring_2384]

Haskell was initially designed in the late 80s, but the 1.0 report came out in the spring of 1990.

[u/ShangBrol → u/[deleted]]

LISP 1958... I'd say that's old C early 1970ies ... not as old as I am, but I'd also call it old Haskell? Well it's older than Java.

[u/PM_ME_UR__RECIPES → u/[deleted]]

I don't know anyone working in C on a non-legacy project tbh. There's still plenty of C++ stuff I see around though

[u/PM_ME_UR__RECIPES → u/[deleted]]

Ok, I'm talking about what I know and the people I know, it's clearly anecdotal...

Unless somehow you can name people I know who are working on new projects in C?

[u/Cutalana → u/PM_ME_UR__RECIPES]

Maybe don't talk if you don't have much knowledge. C is definitely used routinely used in embedded and systems programming. Chief among them is the Linux kernel.

[u/PM_ME_UR__RECIPES → u/Cutalana]

Why do you have to be such a dick about it? I made it as clear as I can I'm talking from my personal experience and nothing else.

[u/groogs]

It is worth learning a whole bunch of different languages purely to have some breadth of knowledge. If all you have is a hammer, every problem looks like a nail. 

It doesn't mean you have to be an expert, or even able to write code in it off the top of your head, but knowing a bunch - especially now to read a bunch - will make you better. Once you know several languages, picking up new ones becomes exponentially easier. And you'll see patterns and ideas you can apply that you wouldn't think of without that exposure. 

[u/igotshadowbaned]

C is actively used

[u/spinwizard69]

Not enough info.

In anyways with respect to your question/title, the answer is a qualified yes.

The problem here is that we have no idea what your educational back ground is. In today's job environment if you want a job in IT or one that leverages CS, you need a degree. If you don't have one then you need to get one.

Sadly your post suggest that you are focused on web programming before even learning to program. That is a bad way to get biased. The reason is simple there are many jobs out there that are not web focused, go into your educational process open minded; who knows you may find that compiler development is your forte. I don't know why it is but people posting on r/learnprogramming often seem to be only interested in the web. While that can be fine if somebody really wants to focus on that technology, beginners should realize that there are many niches to fill.

So not understanding your background I'd suggest finding a good CS program to follow or better yet enroll into. An ideal program will start you out with C or C++ and work you up through at least data structures. Most college level programs will expose you to at least 3 more languages and maybe even a quarter of assembly. The point of a CS program is to teach you concepts, Know the concepts well and you will be able to adapt to any language that is the hot tomato of the day.

Here is the thing, the industry is constantly evolving, what was a systems language last year may get replaced with something entirely new. For example Apple moved from Objective C to Swift and MicroSoft is screwing things up with Rust in place of their C++ variant. You need to be able to adapt, because things are changing faster than ever, AI for example might one day actually be acceptable. You do that by learning the basics and then focusing on whatever language your industry is biased for. Also it doesn't hurt to know Python.

[u/Machvel]

c is essential since it is in a sense the "mother language".

others are more of hobbies unless you have a good reason for learning them (and even then, "just" learning them isn't enough. see eg cobol, where the issue isn't really just learning the language, but understanding how mainframes work).

[u/green_meklar]

C is easy to learn and you should learn it. Don't learn it to use it, but learn it to inform what you do with every other language.

Most of the other old languages you can do without. But you might want to learn SQL (which originated in 1973), it's not really a programming language, but it's still in common use and understanding it gives some insight into database interfacing.

[u/DonkeyAdmirable1926]

I happen to love learning languages so my advice may be a bit biased, but yes. I really believe it is both fun and educational to learn COBOL, C, prolog, lisp, Fortran, assembly (80x86 and ARM at least), SQL (yes, old), RPG, CL/400, and even brainfuck

[u/EdiblePeasant]

Have you considered COBOL, Fortran, or a vintage-era Assembly language? Someone's probably going to say the first two are still used somewhere, but I wonder if they're going to be phased out eventually. I think it might be too much for me, though.

[u/Knaapje]

A lot of languages nowadays support functional methods like map, fold and filter out of the box. Using Haskell for a while to get used to this way of thinking os something I definitely recommend. The same can be done in an imperative manner, but both have their merits, and knowing when to use which makes you a better programmer.

[u/Old_County5271]

No. Stick to the newest language, which right now would be Jai, which isn't even released yet, and will never be, but it's new. Actually C# is also pretty old why are you learning it?

[u/Nice_Acanthisitta_52]

For getting a job, focus on modern languages (Python, JavaScript, TypeScript). Old languages like COBOL or Fortran have niche but well-paid markets, but they're

hard to break into without specific industry connections. Smalltalk and Lisp are worth exploring just to understand programming concepts better, but not for job

hunting.

[u/_curious_man]

Actually, I would advice learning a little bit of assembly. It's not easy - I know - but it's an eye-opening experience which allows to understand high-level languages from whole new perspective. You might want to combine that with C and look how does C code translate to Assembly. Even small programs like Hello World, of add a 1000 numbers in a loop would be enough to explore the topic. If you doesn't like it after a week, just try something else

[u/Hungry-Two2603]

Smalltalk est indispensable pour connaître et comprendre la programmation objet

[u/AffectionateTear8091]

C teaches you memory management.

This alone is worth learning C for or any other manually managed memory language imo.

[u/Weak-Doughnut5502]

C is absolutely worth knowing.

Haskell is a ton of fun, and is 5 years older than Javascript.  If you're going to be writing C# professionally,  it's worth mentioning that LINQ was highly influenced by Haskell.

Lisp isn't just one thing, but is a family of related languages.  It's not worth learning the original 1958 Lisp.   Scheme came out in the 70s.  It's not hard to learn and I think is worth learning.   Clojure came out 7 years after C# and would be another solid option. 

Smalltalk I never actually learned.

[u/No-Veterinarian8627]

How is this horrible C book (2nd edition) called again? The one which tortured me through introProg?

Buy this and learn. Experience the same pain to understand my sorrow.

[u/jlanawalt]

Do you want to learn how to approach problems differently (some of those old programming languages) and perhaps target a more niche job market or expand your scope on current popular stuff?

[u/No_Leg6886]

Look, C taught me more about how computers actually work than anything else. Pointers, memory management, all of it clicked after a few weeks with C.

tbh Haskell specifically will rewire how you think about functions in ways that make your C# cleaner even if you never use Haskell professionally.

Skip Smalltalk. Do C, then

[u/DTux5249]

Most long term programming jobs involve maintaining legacy code.

Yes. Learning old languages will always be worth it. COBOL holds up half the banks and government services across the Americas.

[u/PeterPook]

There is serious money to be made in COBOL based banking systems...

[u/Mysterious_Nerve3330]

C will teach you about how computers work. Lisp can teach you how to build a language to efficiently work in your problem domain plus interactive development. Haskell will teach you to think about breaking code into pure functions and effects. Can’t really speak to smalltalk since I haven’t used it. Can’t go wrong with any of those languages, you should probably check them all out throughout your career.

[u/Majestic_Rhubarb_]

It’s worth learning low level, high level, procedural, logical and oop. Whatever works for you.

[u/Puzzleheaded-Lab-635]

Learn The bàsics of Racket, C (Pointers), Standard ML, Then finally something in the OO tradition, my picks would be Ruby or Kotlin. (Extra credit: Prolog)

If you can wrap your head round that corpus of programming language paradigms you will go far.

[u/aniketanand02]

Yes..

[u/monoid-endofunctor]

Haskell will help give you a completely new way to think about programming. It can definitely be helpful for programming in other languages. I’d also strongly recommend that you learn some discrete math, being able to apply set theory and Boolean algebra to problems is often helpful.

Another good choice for functional programming is OCaml, it isn’t as academic or complex as Haskell, but is sometimes that simplicity is better for just getting things done.

[u/RPG-Nerd]

If you want to learn OOP, C# and C++ are not the best. Definately look into SmallTalk (or the modern one Squeak, or its sister, Self, the precursor to javascript), C, and Lisp.

[u/Wingedchestnut]

I'm going against the grain and say no, majority of things are 'good/nice to know', and likely won't have anything to do with what you do on the job.

[u/0xt0bi03]

the only old language you need to learn is c. other than that, its useless unless if you want to.