You seem to have the idea that there are "people who want RT" and they'll overcome any inconvenience to get it, therefore making RT more convenient to use won't increase use of it.

Clearly nonsense, and I think the GPS analogy is a good one. My mum isn't "a person who wants GPS" and she would never have bought a GPS device in the 00s, but she uses one now because it's conveniently already available in her phone.

you can write perfectly safe software in it.

In the same way that you can safely walk through a minefield.

I dunno what you mean about it being an expressive language either. I would say it is relatively low on the expressiveness scale compared to something like Python or OCaml. It's basically as expensive as Go which is renowned for being unexpressive. Maybe you didn't mean "expressive".

The biggest problems with gRPC are:

1. Very complicated. Way more complexity than you want in most cases.
2. Depends on HTTP 2. I've seen people who weren't even doing web stuff reach for gRPC, and now boom you have a web server in your stack for now reason. Compare to Thrift which properly separates out encodings, transports, etc.
3. Doesn't work from the web. There are actually two modifications to gRPC to make it work on the web which means you have three different incompatible versions of gRPC with different feature sets. IIRC some of them require setting up complex proxies, some don't support streaming calls, ugh. Total mess.

Plain HTTP can be type safe. Just publish JSON schema or Typespec files or even use Protobuf.

Yeah depends on what you're using it for. CSV is terrible in many many ways but it is widely supported and much less complex.

I would guess if you're considering Parquet then your use case is probably one where you should use it.

JSON is another option, but I would only use it if you can guarantee that you'll never have more than like 100MB of data. Large JSON files are extremely painful.

Make a post on StackOverflow claiming that no such project exists.

Haha, seriously though, ChatGPT is a solid bet. Lots of Googling. Maybe try https://grep.app/ if you have some very domain specific words to try.

Ha I once googled some question, found a great answer in some random forum and was like about to write a reply saying what a great answer it was when I realised it was me, like 10 years ago.

Nice! Though a lot of the pages don't show any charts at all on mobile. E.g. the Pie Charts page doesn't seem to contain any pie charts? And the line charts page only shows a line chart in landscape which is weird.

It doesn't sound like it's difficult, just extra work that they don't want to do.

For example they might want to use native USB instead of libusb which is LGPL. I've done that in the past because libusb was lacking some features. It means you have to implement your USB code for each platform and doing that work for Linux probably isn't worth it, even if it isn't difficult.

FOSS is the only answer. Fuck capitalism. Fuck paid software.

Grow up. FOSS is great but it obviously isn't the only answer.

If everyone had a magic lamp that told them whether performance was going to be an issue when they started a project then maybe it wouldn't matter. But in my experience people start Python projects with "performance doesn't matter", write 100k lines of code and then ask "ok it's too slow now, what do we do". To which the answer is "you fucked up, you shouldn't have used Python".

I don't think I would call this functional. Python is decidedly not at all functional - there's no way to declare arbitrary functions inline, no chaining of map/filter etc.

But the static types are definitely welcome. I didn't know about the type keyword. Apparently it makes it support forward references.

I've been working on some OCaml code recently. It's a quite elegant language but it has two or three big flaws that really make me not want to write it.

1. OPAM is buggy as hell. There's one piece of OCaml software that we use at work and literally everyone that tried to build it had problems due to OPAM. One was that it couldn't find zip if you are in more than 32 groups!? I don't even want to think about the kind of code that could lead to that bug. And this is on Linux! Have you tried installing OCaml on Windows? Yeesh.

2. Global type inference means loads of types are inferred as generics, which means you give up a lot of the utility of static typing. Yes you can add explicit types, but the code I'm working on doesn't have them. Rust was 100% right to require explicit types on functions.

3. The syntax is pretty awful in my opinion. Yeah I guess it looks elegant and I'm sure whoever came up with it was very proud, but honestly maybe 40% of my time fighting OCaml has been spent figuring out where to place the damn brackets and semicolons. It's extremely unforgiving too. E.g. if you put an extra semicolon on a top level let where you weren't meant to it can sometimes be "valid" but it pulls the rest of the file into an inner scope, which means the compiler gives you a valid but wrong fix suggestion. Languages using curly brackets don't have this issue at all.

The lack of brackets for function calls can also make it difficult to work out what's going on because you have another operator precedence to remember. Have trouble remembering which is higher precedence out of & and ==? Well now we've thrown calling functions into the mix for you to forget too!

Finally the functional focus can lead to mega-expressions that are very hard to follow, especially when combined with the lack of brackets it can end up looking like word soup.

OCaml has a ton of really nice ideas but I'm glad it's just inspiration for better languages (e.g. Rust) rather than actually popular. I mean... it's still a million miles better than Python... But that's a low bar.

It does. x-x == 0 is true unless x is NaN or infinity.