81–90 of 162 posts
Earlier quoted context omitted.
Sounds like enums with extra steps.
it’s Enuma associated with data without having to repeat yourself If you have to define the Enums in one place and then repeat them all in another just to associate data with each one you’ve failed
enum class Color(val rgb: Int) {
RED(0xFF0000),
GREEN(0x00FF00),
BLUE(0x0000FF)
}I don't know that many languages but, having been writing lots of typescript in the last 3 years there are so many things I love about it. It infers types. If I do const data = [ { name: 'bob', age: 35, state: 'CA' }, { name: 'jill', age: 37, state: 'MA' }, { name: 'sam', age: 23, state: 'NY' }, ]; Typescript knows data is an array of { name: string, age: number, state: string }. I don't have to tell it. Further, if…
Java has it through a compiler extension (https://github.com/manifold-systems/manifold/tree/master/man...) but I don't know many other languages that support this feature.
As much as I dislike the entire Javascript runtime environment, I find TypeScript to be the best typing system out there for any imperative language.
We need Anders to make one final language. A MINIMAL memory safe language. The less it has the better. Rust without the crazy town complexity. The distilled wisdom from C# and Delphi and TypeScript. A programming language that has less instead of more.
> Rust without the crazy town complexity. To be clear, the language has a GC then?
Earlier quoted context omitted.
> They did not do a lot of mistakes in the 25+ years If my memory serves, .NET and WinFS were the two major forces that sunk Longhorn, and both have been given their walking papers after the reset [1]. .NET and C# have grown to be mature and well-engineered projects, but the road there was certainly not without bumps. It's just that a lot of the bad parts haven't spilled outside of Microsoft, thankfully. [1] https://…
Are we mixing the language and the runtime here? C# the language seems weirdly free of weirdness and footguns.
Earlier quoted context omitted.
.NET was already a going concern before Longhorn even started. What sank Longhorn was the fact that writing an OS from scratch is hard and maintaining compatibility with existing OSes in the process is even harder, especially when you're adopting a completely new architecture. Longhorn would have been a microkernel running 100% on the .NET runtime, mainline Windows is a monolithic kernel written in C++. I don't know…
See Android, or Meadows for alternative reality.
Longhorn was going to be more than that. Microsoft did have Singularity/Midori projects, started around the middle of Longhorn/Vista, and continued much longer after Vista released to build out the managed microkernel concept. It's been about a decade since they've put any work into it, though.
I don't know that many languages but, having been writing lots of typescript in the last 3 years there are so many things I love about it. It infers types. If I do const data = [ { name: 'bob', age: 35, state: 'CA' }, { name: 'jill', age: 37, state: 'MA' }, { name: 'sam', age: 23, state: 'NY' }, ]; Typescript knows data is an array of { name: string, age: number, state: string }. I don't have to tell it. Further, if…
Type inference is part of every modern language. Structural typing not so much, though. Java has it through a compiler extension ( https://github.com/manifold-systems/manifold/tree/master/man... ) but I don't know many other languages that support this feature. As much as I dislike the entire Javascript runtime environment, I find TypeScript to be the best typing system out there for any imperative language.
The other widely-used one is Go with its structurally-typed interfaces.
Earlier quoted context omitted.
> Rust without the crazy town complexity. To be clear, the language has a GC then?
I suppose it could have some kind of ARC. In theory some future languages could even have some hybrid approach? A high perf default but you can fallback to a GC allocation for hard things?