Yeah I’m watching Ty. Pytype and Pyre are not serious options. Nobody really uses them, and Pytype is discontinued. Facebook have a new project called Pyrefly that’s also worth watching.

But for now, use Pyright. No argument. If you’re really worried about Microsoft (and not Facebook or Google for some reason) then use BasedPyright.

I would say:

1. Just practice, do projects. Also if you can work on projects with other people because you’ll read a lot of bad code and learn how not to do things (hopefully).

2. Learn lots of programming languages. They often have different and interesting ways of doing things that can teach you lessons that you can bring to any language. For example Haskell will teach you the benefit of keeping functions pure (and also the costs!).

If you only know Python I would recommend:

1. Learn Python with type hints. Run Pyright (don’t use mypy; it sucks) on your project and get it to pass.

2. Go is probably a sensible next step. Very quick to learn but you’ll start to learn about proper static typing, multithreading, build tools (Go has the best tooling too so unfortunately it’s all downhill from here…), and you can easily build native executables that aren’t dog slow.

3. C++ or Rust. Big step up but these languages (especially C++) will teach you about how computers actually work. Pointers, memory layouts, segfaults (in C++). They also let you write what we’re now calling “foundational software” (formerly “systems software” but that was too vague a term).

4. Optionally, if you want to go a bit niche, one of the functional programming languages like Haskell or OCaml. I’d probably say OCaml because it’s way easier (it doesn’t force everything to be pure). I don’t really like OCaml so I wouldn’t spend too much time on this but it has lots of interesting ideas.

5. Final boss is probably a dependently typed language like Lean or Idris. Pretty hardcore and not really of much practical use it you aren’t writing software that Must Not Fail Ever. You’ll learn loads about type systems though.

Also read programming articles on Hacker News.

Clean Code was pretty effectively debunked in this widely shared article from 2020. We probably don’t need to talk about it anymore.

Frankly I’m surprised it was ever recommended. Some of the things it says are so obviously insane, why would anyone think it was good?

My only guess is the title? “Your code sucks; maybe read this book that I haven’t vetted about clean code.” sort of thing?

I’d say it would be good to have a modern replacement with good advice to recommend… But in my experience you can’t really learn these things by reading about them. You have to experience it (and have good natural taste).

This list of code smells is pretty decent at least: https://luzkan.github.io/smells/

I use Google Slides - you get better control over the layout.

All three of those languages have library ecosystems at least as good as Python’s. Typescript is just as easy to learn and as fast to write as Python. I don’t see why you’d think Python is faster. If I add up all the time I’ve lost to Python’s terrible tooling it’s quite a lot slower!

Rust is definitely harder to learn - I’ll give you that. But once you have learnt it it’s just as fast as Typescript and Python. Especially if your “fast to write” metric measures to when you program is correct.

I think Python is superficially easier since you don’t have to declare variables, printing is a little easier, etc. And in some ways it is actually easier, e.g. arbitrary precision integers, no undefined, less implicit type coercion.

But I agree JavaScript is generally a better choice. And it is actually more popular than Python so…

I think it’s just because it is always recommended as an “easy” language that’s good for beginners.

The only other thing it has going for it is that it has a REPL (and even that was shit until very recently), which I think is why it became popular for research.

It doesn’t have anything else going for it really.

• It’s extraordinarily slow
• The static type hints are pretty decent if you use Pyright but good luck convincing the average Python dev to do that.
• The tooling is awful. uv is a lifesaver there but even with uv it’s a bit of a mess.
• The package system is a mess. Most people just want to import files using a relative path, but that’s pretty much impossible without horrible hacks.
• The official documentation is surprisingly awful.
• Implicit variable declaration is a stupid footguns.

The actual syntax is not too bad really, but everything around it is.

I mean… C is a low bar. You can write Typescript, Rust and Go code 5x faster than C too.

pip is easily the worst thing about Python. But now that we have uv I would say the worst thing is the package/import system. I’m pretty sure only 1% of developers understand it, and it only really works properly if your Python code is a Python package.

If you treat Python as a scripting language and just scatter loose files around your project and run them directly, it doesn’t work at all. Pain everywhere. Which is dumb as fuck because that’s like 80% of how people use Python.

Very easy to install

This has to be a joke.

Indeed, but there’s no need to shit on people using floats because in almost all cases they are fine too.

That is default IEEE behaviour: https://en.wikipedia.org/wiki/Rounding#Rounding_half_to_even

This is the default rounding mode used in IEEE 754 operations for results in binary floating-point formats.

Though it’s definitely a bad default because it’s so surprising. Javascript and Rust do not do this.

Not really anything to do with determinism though.

That doesn’t make any sense. As you say, in that case you have to “spread leftovers”, but that isn’t really any more difficult with floats than integers.

It’s better to use integers, sure. But you’re waaaay over-blowing the downsides of floats here. For 99% of uses f64 will be perfectly fine. Obviously don’t run a stock exchange with them, but think about something like a shopping cart calculation or a personal finance app. Floats would be perfectly fine there.

Yeah but that’s mostly network effects and free CI, which must cost them a ton of money. I’d be surprised if they’re even profitable just because of that. I mean it’s worth it for Microsoft clearly, but if they ever decide it isn’t and turn the screws, there are at least two good alternatives - Gitlab and Codeberg.

I would also jump ship immediately if there was a platform that properly handled stacked PRs. I literally just want to be able to say “this PR includes this other PR - don’t show that one”. Is that too much to ask?

I support the idea but is it really that important? It’s just a name. Call it ECMAScript if you’re worried. JavaScript if you aren’t.

No. Closest is probably Zed but it’s still way way off from being a serious VSCode competitor. For example it has no settings GUI at all; just a JSON file. It can’t edit large files. Font rendering is still hit and miss.

Ask again in 5 years…

How “production” are we talking? Pretty bad idea if it’s an important work server. “Sorry boss, nobody could connect today because VSCode’s mojam.service hit one of its many many 100% CPU bugs”.

I think in theory there’s no reason it isn’t technically possible, but I doubt it’s set up to allow it because that’s a pretty odd thing to want to do.

Edit: oh you want to access it via Android. That makes vaguely more sense.

Bad code will be unreadable in any language of course.

Yeah I’m talking about good code, or at least not bad code. Let’s not “no true Scotsman” this.

Even for good code you don’t need syntax highlighting to easily see which identifiers are function names and which are their parameters in Rust.

Rust. It has all the good bits of functional programming but basically none of the bad bits.

Good bits:

• Strong type system (though not quite as sophisticated as Haskell or OCaml).
• Map, filter, etc.
• First class functions (though lifetimes can make this a bit awkward)
• Everything is an expression (well most things anyway).

Bad bits:

• “Point free style” and currying. IMO this is really elegant, but also makes code difficult to read very quickly. Not worth the trade-off IMO.
• No brackets/commas on function calls. Again this feels really elegant but in practice it really hurts readability.
• Global type inference. Rust requires explicit types on globals which is much much nicer.
• Custom operators. Again this is clever but unreadable.
• Small communities.
• Poor windows support (not a fundamental thing but it does seem to be an issue in practice for lots of functional languages).

They’re probably pretty good for CRUD apps, which do tend to be like 50% boilerplate, but also I also wouldn’t characterise them as “bullshit”. Boring maybe.