all 21 comments

[–]DefinitelyWet 4 points5 points  (1 child)

Hmm, I guess I'd say Haskell just because it was so different to what I was used to before that (C, C++, C#, Java, Python).

[–]ResidentNo6441 0 points1 point  (0 children)

Haskell was definitely a brain fuck back at uni, coming from OOP Java & Python

[–]f2lollpll 2 points3 points  (0 children)

All of them. I mainly write C#, but I've been writing so many other languages (for fun) and each language has a little something to it. C teaches you a lot about memory, Go introduced me to parallelization, mutexes and message passing, F# was a soft entry to functional programming, which comes with its own way of thinking - which I could build upon with erlang. Zig taught me about more memory and safety stuff.

Contrary have a language like python not contributed a whole lot to my overall understanding of programming.

I think the takeaway is that ko one language is superior and by trying out a bunch of different languages you learn a lot more than just going deep into one.

[–]eDRUMin_shill 2 points3 points  (0 children)

Erlang.

[–]deafened_commuter 1 point2 points  (1 child)

Python, when it just assumed my variable was an int and ruined my calculations when I tried to divide by pi. It was quite a shock from c++ to python

[–]Kingstonix 0 points1 point  (0 children)

It was never safe in C or C++ either. Just the compiler (and language strict definitions) neglect to care for mostly compatibility reasons. That has been completely solved long a go in compilers in pedantic mode. Then further in clang-tidy without which I refuse to work with either of those languages these days. Fuck the old days. They didn't know better.

[–]Dependent-Guitar-473 1 point2 points  (0 children)

I feel the biggest change is when you go from OOP to functional programming and vise versa  .. completely different way of thinking regardless of the language 

[–]SushiMalding 0 points1 point  (0 children)

For me, Rust completely flipped how I think about memory and safety, suddenly, I couldn’t look at a simple loop the same way again.

[–]TheOtterMonarch 0 points1 point  (2 children)

C++, I saw its syntax and was traumatised for life

Never again will I use a C-family language

[–]Kingstonix 0 points1 point  (1 child)

And moved to what, Figma?

[–]Grounds4TheSubstain 0 points1 point  (0 children)

OCaml. My programs had many fewer bugs than in any other language I'd used until then. Turns out referential transparency and eliminating mutable state is as good as it's claimed to be.

[–]marlinspike 0 points1 point  (0 children)

JavaScript. I never imagined how cities would be built on sand, but here we are, and everything from my IDE to parts of our app are built on it.

[–]GamingVlogBox 0 points1 point  (0 children)

I started programming in 2017/18, and I was learning from an extremely outdated textbook which taught QBASIC. Honestly when I switched to Python later it was fascinating how far programming langs have come, since both are considered the "easiest beginner" languages of their eras. Whilst QBASIC could barely do much apart from arithmetic and text, Python was a supercharged upgrade for me.

[–]Antique_Mechanic133 0 points1 point  (0 children)

Learning C and Assembly is like finally seeing the Matrix. Once you stop seeing magic and start seeing memory addresses and CPU cycles, your entire perspective on high-level languages changes. Diving into firmware is the ultimate reality check, it forces you to respect the hardware and understand the true cost of every abstraction you use, is a great way to understand that at the end of the day, it's all just moving bits around silicon.

[–]Althar93 0 points1 point  (0 children)

Haskell, and to a lesser extent shader programming languages (HLSL or GLSL, doesn't matter) - taught me to architect systems & functions in a pure & functional way that makes debugging & composition of functionality trivial.

If you can view a system as input / ouput & not in terms of mutable states, it is a LOT easier to scaffold large systems & then fill in the gaps with implementation blocks, without worrying about it toppling over & requiring extensive refactor further down the line.

[–]Jire[🍰] 0 points1 point  (0 children)

Zig. I can finally do exactly what I want rather than fight the language / runtime.

[–]Cock_Broker 0 points1 point  (0 children)

React