None. C is standardized by ANSI and ISO, and is widely used. Go is controlled by Google, and we all know what eventually happens to every Google project. Google's flagship product, Google Search, probably isn't going to be shut down any time soon, but it's constantly getting worse and they're doing nothing to fix it, so even it clearly has one foot in the grave.
It is under a BSD licence. It is used extensively by many people, and development would be moved elsewhere if Google were to ever drop it, which they won't be as they use it internally.
Grim. It doesn't even have sum types.
All projects should have script for autoformat. If there is none, it's a sign it is lead by retards.
It make sense for some languages and not others.
At this point, I consider sum types to be mandatory for any language for me to enjoy. Along with first class functions.
Historically, that's been one of the great crimes of OOP: you can't define a sum type but instead define a base class and a number of subclasses with the ability for the user to define additional subclasses. The OOP cult thinks this is great because it's open-ended and extensible, but it denies that there are situations where the number of cases are logically restricted to a fixed set (e.g., Haskell's
Ordering type has constructors LT, EQ, and GT, which exhaust all possible cases) and is inconsistent with mathematics, where definitions include one or more basis clauses (e.g., "Zero is a natural number."), zero or more inductive clauses ("The successor of a natural number is a natural number."), and some sort of closure clause ("Nothing else is a natural number.").
imo generics can be really handy for cutting down on expensive type assertions. And effective use of type constraints (and the idea of type sets in general) can be way more concise than having to implement methods of a certain interface for every relevant type.
constraints.Ordered, you can do stuff like implement a BST for any ordered/comparable type:type BST[T constraints.Ordered] struct {
left, right *BST[T]
value T
}
func (t *BST[T]) Lookup(x T) *BST[T] {
switch {
case t.value == x:
return t
case t.right != nil && t.value < x:
return t.right.Lookup(x)
case t.left != nil && t.value > x:
return t.left.Lookup(x)
}
return nil
}constraints.Ordered is (or was) simply defined astype Ordered interface {
Integer|Float|~string
}Extensibility also heavily breaks exhaustiveness. So when you add another subtype, the compiler can't help you properly deal with it. (for example, having to run some piece on code whenever an element gets added to a collection, that has to decide based on the type, without it being a method on the object itself, as that piece of code would be a violation of that objects responsibility, like calculating some measurement total over the collection)
That's kind of orthogonal to the other stuff. Data oriented grouping like data together, rather than grouping logical units (for example, group all movement data into one collection to handle movement, rather than having each enemy store that position in itself, so with an enemy that can't move, like a wall, you'd just not have the movement data for that enemy)
I consider OOP to be one of the biggest poisons to software devs these days, because it seems to work great until it doesn't. And by then, you already got poisoned into thinking the OOP way about everything.
Deepseek-v4-flash is still pretty cheap during US business hours and you can juice it with paypal, so there's no ongoing subscription. $10 is more than enough to try it out and do some experimenting.
What are you actually asking us to give you? Am I just drunk or did no actually-answerable question get articulated here?
You should be shot. You'd better not be wearing pink/white/blue striped programming socks.
No, I'm asking specifically about the large, frontier models. I'm looking to pay money for one of the large ones. I've done all the free/local shit. I'm finishing up a free week of GLM-5.3 which is a different beast entirely. Free/small models require a lot more tending, and I'm very busy with my day job right now. The "provide some guidance at breaktime" model of LLM collaboration is working for me.
I was getting kicked off Reddit for arguing that transgenderism was bogus before the phrase "cancel culture" had been invented, not long after Obama was first elected. Scary close to 20 years ago now. I guess I was in a bit of a mood when I wrote my last post. Don't worry about it. I try to avoid taking myself too seriously, that's all.
I'm a big fan of goroutines and concurrent processing in Go. It took a little bit of time to wrap my head around it, but once I got the hang of it I found that I could do a lot of really useful things with goroutines and channels.
I didn't know we worked in the same office.
