The most fun languages to learn that I have learned so far, are Haskell, Factor, Prolog and Agda. Each are quite different from mainstream programming and each other, and it is really satisfying when concepts "click"

I had the most fun learning Haskell. Mostly because it was so different from the languages that I knew. Also, learning Lean was fun. But I guess that's kinda niche since it's not very relevant for anything but pure mathematics.

since you mentioned Rust, it can also be a matter of how you approach learning it – maybe learning a game might be more comfortable – as an example, Reddit’s r/roguelikedev links to multiple tutorials in multiple languages (with at least three Rust based options):

• Roguelike Tutorial - In Rust – also available as a book if you want something more physical
• Roguelike Tutorial in Rust + tcod – uses libtcod from the original Python tutorials they started with
• Roguelike Tutorial 2020

Go is probably the best in terms of time it takes to learn and building something fun. It replaced Python in that regard for me.

See also the closely related concept of code smells. These are things that aren't necessarily wrong like anti-patterns are because in certain niche cases or in limited amounts they're fine, but they're often an indicator that you're doing something wrong in your code. As a quick example I looked up some code smells in JS and a couple of the examples were using == instead of === and having deeply nested/indented code (E.G. have if blocks inside of if blocks inside of if blocks inside of a for loop).

No, for a good modern C alternative I'd look at Zig. The main reason C is used for the Linux kernel is because Linus hates C++ for a variety of reasons. For what it's worth I agree with him. Most other OS kernels are written in C++. Linus allowed Rust in because it demonstrated that it could provide the same power as C++ without all of C++'s problems (mostly that over the years it became a kitchen sink language, anything that anyone ever thought might be a good idea got rolled in even when it was incompatible with some other feature already in the language).

Lol, one of the great philosophers of all time

Lua to me is the language JavaScript wishes it was. It's super minimal and actually designed reasonably well. It knows what it is and isn't trying to be something else. I wouldn't want to try to write an entire app in it, but for a scripting language embedded in something else there's not a lot of languages I'd rate higher.

If you really want to immerse yourself, also use it as the config. language for your Linux distribution.

Write GTK app.s with it.

Stretch your project legs with writing a simple web app. with it.

Explore the sheer joy and consummate beauty of minimal syntax.

Aaaah, yeah. You're struggling with thinking in terms of types and scopes and probably also a tiny bit of stack vs. heap allocation. Javascript side steps most of the concurrency problems by having a single threaded runtime, and of course is a garbage collected language so you never really need to worry about memory management either.

Rust is a much more powerful language, but of course with power comes responsibility. The compiler believe it or not is actually helping you a lot even though it probably doesn't feel like it. In something like C you'd probably be able to successfully compile those programs that Rust refused to build but then you'd get crashes and weird bugs when you ran the program with very few clues on where you made a mistake.

Fundamentally here's the difference. Javascript is making the tradeoff that it will worry about a lot of the details for you, but it will get them wrong a lot and performance will suffer as a result. It also doesn't give you a lot of ability to express your problem well due to its incredibly primitive type system which will lead to a lot of bugs that are very hard to diagnose.

Rust on the other hand says you need to worry about the details but it will give you some tools to make managing them easier to the point where you can ignore them a lot of the time. E.G. most of the time you can just stack allocate your variables and not worry about heap allocation and the headaches that can introduce. But the tradeoff for that is you can get some of the best performance out there and its advanced type system lets you model problems in ways that make bugs far less likely and much easier to diagnose and fix.

Rust doesn't let you write code that works 90% of the time but fails 10% of the time, it forces you to write it in a way that works 100% of the time. This is particularly true for concurrent code where Rust prevents (mostly) race conditions that nearly every other language lets you write. If you're thinking some code that should work isn't compiling it's almost certainly because that code would fail with some kind of race condition under concurrency. The good news is once you start to understand where these problems crop up it's usually easy to resolve them by putting a Arc or RwLock wrapper around something or maybe just a simple .clone() if you don't mind the performance hit.

take a look at one of the “fantasy consoles”, can do quick scripts and see results immediately:

• TIC-80 – primarily uses Lua but they’ve added in support for Ruby, JS, Moon, Fennel, Scheme, Squirrel, Wren, WASM, Janet, and Python as well
• uxn – virtual machine using uxntal, a kind of Forth/assembly hybrid

for an actual language, don’t discount Lua – simple, fast, tiny – “real programmers” like to ridicule it, and yet it keeps turning up everywhere from video game scripting to text editor configuration to databases to web servers

• Learn X in Y Minutes – a good introduction to a lot of languages, gives you a good idea of their look-and-feel
• Rosetta Code – LOTS of languages with LOTS of code examples

My favourite childhood game RCT2 was a masterpiece of assembly: https://youtu.be/ESGHKtrlMzs

Fun? Lua, Odin, nim, zig.

Impractical? Brain fuck.

Rust is close to C++, in that you get a lot of high level constructs to help you. C is very low level, and you can learn the syntax in a weekend, but you'll also have to learn memory management and implement advanced structures (linked lists, etc) yourself.

Memory management isn't too hard, it's mostly remembering who created what, who reads and writes to it, and who is responsible for cleaning up. With some additional comments as you go it's not too hard. Also, depending on what your doing, leaks may be acceptable. A short lived program can leak all it likes, and the OS will clean up for you ibthe end :D

Anti-patterns are essentially what ‘not to do’. Heres a good series of Medium articles on it!

So C is basically assembly with a bunch of syntactic sugar on top. It manages a lot of the book keeping and boilerplate, but at the end of the day there's not a ton of difference between them in terms of the abstractions it provides. If you know assembly learning C is a piece of cake. If you don't you're probably going to take a while to really wrap your head around pointers and the myriad ways C can use them for great and terrible things. Beyond pointers (and race conditions if you're crazy enough to do multithreading in C) the rest of C is super easy because there really isn't much else there.

Rust on the other hand is a much higher level language more comparable to something like Java, C++, or Python. It gives you a lot of tools to solve complicated problems but unlike Java and Python and like C++ it still gives you the option of working at a low level when you need to. The big advantage it has over C++ is that it learned from the many mistakes C++ made over the years, and the borrow checker really is a unique and powerful solution to both memory management but also crucially concurrency problems.

Somewhat. The issue isn't memory leaks themselves so much as learning project architecture, patterns, and generally how to do things without shooting yourself in the foot.

Rust has plenty of gotchas and unintuitive elements, so they're not too different in that sense. Though Rust is more likely to point out when you've done something wrong, where as C will exercise your debugging skills.

Modern C++ is also an option, and surprisingly easy to use. The only catch is that the errors can be very difficult to parse and it's hard to find modern best-practice materials to learn from since most of industry is quite far behind compared to where the language is.

One benefit Rust has is that it's quite new and niche, so the materials tend to be of fresh, without much legacy mindset, and of a relatively high quality. Tbh I'm not sure how Rust is for newbies, but it may be worth a shot. At the very least, the community is passionate and the errors will be readable...

Once it clicks, rust can be type 1, it certainly is for me. But it's definitely a long and hard type 2 to get there.

Python is like your automatic transmission. It handles a lot of work on the backend to make life easier, but the trade off is performance and control.

In C/C++, you’re reaching into the gearbox and moving it by hand. It doesn’t clean up anything for you and doesn’t prevent you from making dumb mistakes. In exchange, it can be wildly faster than Python.

In Assembly/Binary, you’re crafting the gears before you can even start the car.