old-new-win32api VS winforms

Do you have any recommendations?

I assume this is the one you’re talking about https://devblogs.microsoft.com/oldnewthing/

I was curious, went to the end (page 699!) and it’s pretty interesting. But obviously it’s hard to find the important ones.

Not quite. DOS was just the bootloader for Windows 9x.

While Windows 95's kernel didn't have the full feature set of NT, it still was more sophisticated than DOS.

Source: https://devblogs.microsoft.com/oldnewthing/?p=24063

Some registry keys also have The Old New Thing posts by Raymond Chen [1] /s

[1] https://github.com/mity/old-new-win32api#registry

Lucky you, Raymond Chen did an overview in his blog series "Inside STL". You can view it here: https://devblogs.microsoft.com/oldnewthing/

Yes, Raymond Chen describes such fixes in [several blog posts](https://devblogs.microsoft.com/oldnewthing/) and in his book The Old New Thing. Check the old posts, back at the beginning. There are posts about to which lengths they went to ensure buggy applications still worked after an update or a fix.

https://learn.microsoft.com/en-us/archive/blogs/larryosterman/ https://learn.microsoft.com/en-us/archive/blogs/ https://devblogs.microsoft.com/oldnewthing/

A couple of blogs as an example: - Raymond Chen - https://devblogs.microsoft.com/oldnewthing/ - Pavel Yosifovich - https://scorpiosoftware.net/ - Adam Sawicki - https://asawicki.info/index - Matt Pettineo - https://therealmjp.github.io/ - Scratchapixel - https://www.scratchapixel.com/

https://devblogs.microsoft.com/oldnewthing/

Windows Forms[0] is still alive and will never die, and very low overhead to start with, and works on new and shiny .NET 8.

If Linux or macOS, you can use AvaloniaUI[1] instead which is sufficiently advanced but assumes some prior knowledge.

[0] https://github.com/dotnet/winforms/blob/main/docs/getting-st...

[1] https://docs.avaloniaui.net/docs/get-started/

Winforms: Licencia MIT.

3. Therefore reified generics are not possible to implement in a backwards compatible way.

Ok, sure, but if you instead a new generic collection types and leave the old ones alone, you don’t have to worry about breaking existing compiled code.

This comment about C# suggests a lack of familiarity with the approach C# took:

> C# made the opposite choice — to update their VM, and invalidate their existing libraries and all the user code that dependend on it.

All of the pre-generic C# libraries continue to exist to this day (ArrayList, HashTable, and the non-generic IEnumerable). Applications that used them never stopped working. New code uses the generic collections (List and Dictionary).

Anyways, I think the costs that Java is currently paying for non-reified generics (reflection, performance, and type safety mentioned in the article) is not worth the backwards comparability with the 20 year old J2SE 1.4. The price C# pays for making a backwards incompatible generics (mostly some minor annoyance when designing a collection class implementing IEnumerable) is worth it at this point.

P.S. ok, I do admit that C# forking the collection library is still causing ongoing maintenance work 18 years later: https://github.com/dotnet/winforms/pull/8673

No, it is fully supported and in active development. https://github.com/dotnet/winforms

No, it's still under active development/maintenance. https://github.com/dotnet/winforms/graphs/contributors

The image is kept in-memory— https://github.com/dotnet/winforms/blob/main/src/System.Windows.Forms/src/System/Windows/Forms/PictureBox.cs

Appears that this has been broken for a while. Seems it has something to do with the new designers being run out of process.

Also, the runtime that C# runs on, is also completely open source as well (https://github.com/dotnet/runtime); ASP.NET which is used to create web apps in C# is open as well (https://github.com/dotnet/aspnetcore). WinForms/WPF, used to make desktop apps in C# is also open source (https://github.com/dotnet/wpf, https://github.com/dotnet/winforms). All of the source code for these are on the dotnet Github page: https://github.com/dotnet and most are all MIT-licensed.

You'll likely have to open an issue against https://github.com/dotnet/winforms. If you've already opened an issue here, then feel free to link and I might be able to provide suggestions on how to improve the triage process.