zigzag312

I whish that too, but I'm not holding my breath since Google needs Dart-to-JavaScript compiler, which will continue limiting features Dart can implement. The only way this can change is, if they move to WASM and drop JavaScript target.

Aren't there some limits on which legal rights can be signed away through a contract?

I imagine that a contract in which someone agrees to become a slave would be void.

I believe TOS is binding as long as it doesn't conflict with the law. If something is deemed fair use under the law, TOS cannot override those legal rights.

> I always thought the usability/ergonomics of the Flutter framework was slightly poor, but the Dart language itself is pretty darn awesome!

I think a lot of ergonomics issues of the Flutter are because of Dart language lacking in some areas. Flutter team even demonstrated how Flutter is expected to improve when certain features land in Dart. (Not sure if/how cancelation of macros will affects this.)

I'm (im)patiently waiting for augmentations and declaring constructors to be completed. Augmentations alone will help with so many things.

> No one (among non-thinking colleagues) is going to criticize you for using de-facto standard services

Well put!

> A few clicks.

Getting through AWS documentation can be fairly time consuming.

Overture maps docs use it to visualize the coverage of Overture address data.

https://docs.overturemaps.org/guides/addresses/

Picture url: https://docs.overturemaps.org/assets/images/address-coverage...

I was even able to statically link native dependencies during NativeAOT compilation of Avalonia app to produce a single binary. It's not the default mode for AOT compiled Avalonia, but it's possible.

ImGui.Forms is another one that supports NativeAOT.

Fortunately, there have been a lot of improvements to low-level C# since v7 that make unsafe unnecessary in a lot of situations. E.g. ref structs, ref local variables, ref returns, stackalloc improvements etc.

There's an interesting comparison of these C# features with Rust: https://em-tg.github.io/csborrow/

Surprising amount of drivers do transfer between versions of Windows, even if not officially supported. But yes, most break at some point.

I'm able to run binaries compiled over 20 years ago on the latest version of Windows most of the time. They do require enabling compatibility mode and sometimes installing legacy features.

I don't know, if APIs you mentioned are available in compatibility modes, but at least named pipes can still be enabled.

But Windows is going downhill lately, so backwards compatibility isn't what it used to be. Improving backwards compatibility for running old binaries would make Linux adoption easier. I hope that Linux PCs market share keeps improving to cross the threshold where it becomes an economically viable platform for most of commercial software.

What win32 apps were killed by UWP migration? When UWP was added win32 wasn't removed. Win32 applications still work.

> Microsoft sort of only wins in the closed-source, “run this arbitrary binary” race

That is actually a big win as some manufacturers only provide binary blob drivers and a lot of commercial software is distributed as binaries only.

Monopolies being bad for free markets is a simplification. Substantial control over the market would be more accurate description of the issue.

They notice, but do they care? The most popular apps don't mimc the platform's look. Maybe they even like and find different designs more interesting as long as UX is good.

Does this use the new OSM data model?

https://media.jochentopf.com/media/2022-08-15-study-evolutio...

https://github.com/osmlab/osm-data-model

https://blog.openstreetmap.org/2023/01/04/reminder-call-for-...

Resolving the coordinates to node references in current data model is such a nuisance as it's slow and requires lots of RAM.

I would like to see an UX research of what is actually important to match to the platform for the users.

The matching of the look is, from my experience, pretty low on the list. It's usually some interaction that doesn't exist or match that people complain about.

Liquid Glass is meh anyway. Apple's Windows Vista moment.

> Sharing UI in complex apps, in my experience, always ends up being a "write once - debug everywhere" nightmare.

Was that with UI framework that wraps platform's UI framework or with one that draws controls on its own? Shared complex UI is not much of an issue with frameworks that fully implement their own controls. But quality implementation of controls from the ground up is a lot of work so there's not many good UI frameworks that do this.

If you consider Go as a low level language, you might want to try C# which can be as low level as Go while having a lot of high level features. NativeAOT compiler allows you to statically link native libraries or create native shared libraries (.dll/.dylib/.so) that can be consumed from other languages. It's kind of 2-in-1 language, but the ecosystem is primarily focused on the high level part, so you can only depend on small portion of it.

If you are OK with less popular languages you can check any of these: Nim, Hylo (formely Val), Vale, D, or Zig.

I haven't tried any of these yet, but they all have piqued my interest. Nim is probably the easiest one.

> replaced by a rewrite for no obvious reason

Obvious reason is to have less bugs in the long run. Temporary increase during transition is expected and is not ideal, but after that there should be less of them.

It's not like C version didn't have any bugs:

https://bugs.debian.org/cgi-bin/pkgreport.cgi?archive=both;d...

Reddit shows:

"Too many requests. Your request has been rate limited, please take a break for a couple minutes and try again."

Cost matters, but in my experience there's more to this story. It's more like this:

"write 99% correct code in 1 week and then try to fix it as you go, but your fixes often break existing things for which you didn't have proper tests for. It then takes you total of 2 years to finally reach 100% correct code."

Which one do you choose? It's actually not as simple as 1 year vs 2 years. For a lot of stuff 100% correctness is not critical. 99% correct code can still be a useful product to many, and to you it helps you to quickly validate your idea with users.

However, the difference between static and dynamic typing is not that drastic, if you compare dynamic typing to an expressive statically typed language with good type inference. Comparing, for example, Python to C++ is not really fair as there are too many other things that make C++ more verbose and harder to work with. But if we compare Python to for example F# or even modern C#, the difference is not that big. And dynamic typing has a costs too, just different.

1. "Story" can be harder to understand without "metadata" due to ambiguity that missing information often creates. It's a delicate balance between too much "metadata" and too little.

2. Too much composability can lead to bugs where you compose wrong things or in a wrong way. Generic constraints on interfaces and other metaprogramming features allow flexible and safer composability, but require a bit more tought to create them.

3. Reuse is similar. No constraints on reuse, doesn't protect you from reusing something in corner case where it doesn't work.

4. (depends on how you design your types)

5. Dynamic languages require you to write more tests.

6. F# and C# for example both have REPL.

Quality statically typed language is much harder to create and require more features to be expressive, so there are less of them or they have some warts and they are harder to learn.

It's a game of tradeoffs, where a lot of choices depend on a specific use case.

Data sync is one scenario where it can be useful.

Language where most of the libraries are without GC, but has an GC opt in would be interesting. For example only your business logic code would use GC (so you can write it more quickly). And parts where you don't want GC are still written in the same language, avoiding the complexity of FFI.

Add opt-in development compilation JIT for quick iteration and you don't need any other language. (Except for user scripts where needed.)

App that actually does something will probably have even larger startup overhead in Java as there will be more to compile just-in-time.

That's just the best case scenario. Few migrated to it in 2015. Windows 10 was sold for years.

Windows 11 initial release date: October 5, 2021.

That's 4 years of support after successor was released.

What do you mean when you say they were unable to build domes?

https://en.wikipedia.org/wiki/History_of_medieval_Arabic_and...

Sorry, I probably should have quoted to which part I was referring. It's:

> with no technology to speak of for the 1000 years after Roman Empire

While it's true that some technology declined in the West, it wasn't as dramatic as you've suggested. Popular media also often exaggerates it.

https://www.britannica.com/technology/history-of-technology/...

Adding USSR into the discussion greatly increases complexity of the discussion. From analysis I've read, central planning is supposedly fine when country doesn't have much industry, because to start things up, it can provide essential investments and starts organizing production. But when country is somewhat developed, efficiency starts to matter and top-down approach to decision making of central planning vs bottom-up decision making mechanisms of markets produce different results. Politics and other things are important factors too, but I think that would be too much for this discussion.

Aren't you exaggerating it?

I interpreted your argument that suffering that years of burden and stress on loved ones bring is a good reason for an assisted suicide. Or did I misunderstood you?

Regarding your estimates, are you just making up a lot of assumptions or do you have any data backing up your relative numbers? In your other comment you seem to assume that anyone not agreeing with OP's suggestion doesn't have personal experience with close relative having a dementia. I'm very sorry for your loss. At least some others (me included) also have had this unfortunate experience, but don't agree. High bar is actually very hard to quantify. All old people are in gradual decline and are relatively close to their deaths. One alternative to your suggestion would be that a state would provide quality professional care for people with dementia. That way the things OP described wouldn't happen and the family of the patient wouldn't have to bear the financial burden of the disease. We are more advanced and richer that we have ever been in human history, but it seems like we are unable, as a community, to provide very ill people with quality care they need.

That's the issue with assisted suicide. A lot of old people bring burden and stress on loved ones at some point. How many old people will be guilt tripped into an assisted suicide because of this philosophy?