Why Developers Already Hate .NET 9 

I really, really hope that will never happen. It defies the purpose of static typed language, just as keyed services defy the purpose of DI

@@Nworthholf unless if keyed services are based on dynamically loaded modules, where the module may expect specific keys

Java already has it so... maybe they can do it... though not quite in the same fashion i imagine in dotnet

I wish some of the arrays, imaging, and data manipulation from python would be included.

I feel like the people here in the comments missed your pun

Actually, I should say that most of Azure income is by vertically scaled poop code up to Premium levels. I have worked on a solution with less than 20k users overall, and our team solved performance issues just... by switching to premium 3 tier ... No one in the team has heard of async code. No one has heard of caching and data reusability. No one is updating any package unless it shows up in owasp report. And we are a big company with many projects, all in azure. Just imagine how many other companies do the same.

Lol 😂 I still maintain .Net FW 4.5

Even I am with 4.5

God damn man im tired of that shit

hopefully it will bring more attention in the future, it is better than scala in FP terms imo too sad microsoft doesn't give it enough love

Does it really?

gold 😆

Well... we have DUs ;-) Looooooooong ago

I heard a talk recently about F# Myths, and the guy and his team actually adopted F# for production code (for some microservices IIRC), and were happy about it.

and yet your .net framework is supported as long as windows exists and only .net 6+ is supported (for now). :)

Blink? Or a coma?

That doesn't even tell the full story. They went back to v1 w/ Core.

.NET Core was 2016. Sleeping Beauty didn't blink for that long.

Yep, we've still got a lot of FW4 products to upgrade.

3 seconds to google it.

@@swordblaster2596 Shouldn't have to google it!

@@swordblaster2596still not wrong tho

then you wouldn't be forced to watch the video though

And maybe one day discriminated unions 😢

Do you realize that using structs are DTO means that you'll have to copy the struct everytime you pass it? and passing it by ref will not be any different than just using a class. So in terms of performance and memory improvements, you won't really gain anything for using structs over classes. Specially for DTOs which can be really big.

@@JustNrik you’re only copying if you’re mutating. And it works on the stack which is easier to GC and you have not overhead versus the class as the struct is only the sum of the contents. I’ve tested with json doing this by hand with minimal APIs and it’s a 2-3% increase in performance and over time it saves significant GC cycles.

I am always interested how and where people acquire knowledge about the performance of specific data structures, approaches, and related topics. Could you recommend some books that can help me become familiar with such subjects?

@@konstantinkurtev3396 the best way to learn about this topic is to learn that books won't help you, and the only source of knowledge is your own experimentation following guidelines from online resources at Microsoft's doc pages

He's Greek? I always thought he was German. Well, except at first when I thought he was an Arab but somehow also white. I'm not good with accents.

@@EdKolis i thought he was just american lol

Kotlin actually has these! Also extensions that don't need to be defined in a static class. It's awesome, you can just put them in whatever scope you want. Why can't C# do the same? Did Jetbrains patent this stuff? 😂

Maybe time to revisit F#? Ran into bunch of weird things at .Net 6 mostly with EF core that were just killing my spirit :(

I love F# other than lack of "break" and "continue" for loops. You can't test recursive functions very well and sometimes iteration is the best/more practical way to handle algorithms. Please, someone prove me wrong and I will pick up F# again.

No rush, waiting line is long. I am still waiting for a proper hotreload.

IMHO Blazor is a really bad architecture for 90% of the web challenges. Any client side logic with server side rendering is trying to solve the wrong thing in the wrong place. Rendering is easy on the client side and hard on the server side. Logic is hard on the client side and easy on the server side. Blazor makes the worst possible decision, run the logic on the client side with WASM that sends the state to the server to render the html. Sure, you might say you don't have to do this and just render WASM on the client side, but then you need to send your entire DotNet Runtime to the client side, bloating the entire thing. Don't get me wrong, I would love for nothing more than to be able to program web in something different than Javascript and building through Node. WASM has great potential. But as it is, its just another Silverlight waiting to happen.

@@rodrigoserafim8834 why would you send the entire runtime to the client? it just needs to render the UI based on data from the server. in my projects I shared a Dto class library with the clent and the client talks to a web api on the server. It's quite nice to use c# on the client side. works great so far. most of the client logic is based on communicating with the api. Your main logic should always stay on the server for security If you are making a website versus a webapp, then i wouldn't use blazor, because it loads way too slow and you get into more the issues you describe where you might want to render on the server and send that to the client.

@@rodrigoserafim8834 Have you heard of Blazor United in .NET 8? Now you can create an app that starts with server-side, downloads the runtime in the background and then switches to client side when it's downloaded. Or you can configure it however else you want. If none of them work for you, then have fun with JS.

Get the sponsorblock extension for your browser.

@@__Tweek I have no idea how it works, how does it know what content is sponsored? Very cool

@@Efemyay I think people mark sections of the video that are sponsored and that's how it knows

Very underrated language. Even in a non-production sense it’s good for utilities. Two killer features are Type Providers and Units of Measure if you’re doing numerical computing.

IMO, thanks to discriminated unions, units of measure and computation expressions, it's lightyears ahead of C# for decent domain modelling.

I *want* to like F#, but its syntax is so off-putting it's hard. I get that the syntax came from OCaml, but I'm not a fan of it.

@@colejohnson66 Easy enough to get used to and more concise than C-syntax languages.

A lot of the pioneering was done in python because that was what the academics are used to, but the python itself is not the AI. The models are language agnostic. If my entire application is C# then I'm going to need the reliability, type safety and speed of C# for my local AI work loads.

@@johndenver8907But the AI ecosystem is Python, so you have to deal with it. Soon you will get the strongly typed Mojo. But in the meantime if you want to be in the .NET space then go with F# which has a mature data science story with the flexibility of Python.

Current Microsoft is unable to finish any of their projects, as they don't commit to any of their products, Windows itself is half baked nowadays.

I'm am curious why this would be necessary. you can implement static variables in the same class. if your passing a non static variable as a parameter to a static function I understand the frustration, but I think you need to rethink your design. too many static variables == no garbage collection and memory problems/crashes down the road. IMP... but I am junior dev so I may be wrong

That's pretty much what they do, that is why 1 of the releases is long term support, and the other is not. So 6, 8, 10 etc are the major releases (3 years support), and 5, 7 and 9 are the 'minor' releases (18 month support). They don't leave major features till major releases however, so that is why from another point of view there is no real difference between the minor and major releases.

​@@SamJudson In .NET they're usually doing their own thing but in C# what they usually do is release a major feature in (a C# version released along) an STS version and then improve and polish it for the following LTS version.

They think it's another product like Windows

Because every major language has a faster cadence. It makes no sense to wait years for a feature. Java and Go do it every 6 months, Rust every six weeks! Look at where Java and .NET Framework was before a faster release cycle… dying. No one wants another “java 8”

Same question I had in mind. Can someone give us a clue please? I remember Nick making a video talking about them about a year ago, and they looked really cool.

The LDT is struggling to figure out what they want to achieve with DUs. Implementing them in any way is very easy by itself, let alone for the devs behind it. What we really care about is whether they will be blazing fast, or if we will sacrifice too much performance. Adding DUs is a commitment, so it has to be a feature that is prepared to stand for a long time in the language. Meanwhile all these other features and expansions are being given time, in other working groups. So it's primarily a matter of longevity and careful planning.

We can already do DU using StructLayout and LayouKind.Explicit. There's just no language support.

@k72 Only with value types though, you can't have an explicitly layouted struct with an int, float, and a string (or any other reference type) where they overlap for instance.

@@_profan you can, but since strong is a reference type you have to be careful about how you treat the value. Same with arrays... although it's useful if you want to do quick and dirty value type conversion to/from byte arrays. Nasty, but it works.

It's fatigue. It's not a matter of "not using" features. You have to learn and know all of them (and I mean all of them) if you work on a dev team, in case they decide to use them. When you're 20+ years into your career, the breakneck release schedule becomes more of a burden than a bonus. It can almost be seen as technical debt for all .NET developers that keeps getting piled on. You can't just ignore it. In fact, staying up to date almost becomes a full-time job in and of itself.

And then they keep changing how the "startup" works with a million different ways to do application builders, services, etc. I'm still to see how a console app is "supposed" to look these days with DI, etc as the documentation is sketchy.

Don't worry kid, one day you'll be a senior developer and will finally understand why C is still around despite not having an update every few weeks.

@@gbjbaanb I also understand why the industry is desperate to get away from it, and inventing 'C killer' languages roughly every year to do just that.

Hello, "Performance of MAUI has been exactly the same as the java version on android" - meaning it is slow? Please give more details on issues with MAUI. Thanks

Sorry I mean a Java version of the app. The UI looks much different, but then I'm talking about controls and responsiveness of clicks.@@queenstownswords

Not sure I understand what you mean by moving out generic collections? Do you mean to another namespace, or remove them entirely? Generics are essential for collections and I use them all the time, it would be absurd to get rid of them. As for nullability, I am confused about this as well. You can enable nullability since C# 8, and enforce nullable code as a compiler error by modifying your project file (although you can still use the “!” operator to bypass it).

@@11clocky I meant move the classes from the the .Generic namespace to Collections namespace. I know that it was because of compatibility when generics was introduced.

Isn't .NET technically open source now? I wonder why no one has forked it yet.

Plus it will never have the elegance of a DU in F#, no matter how hard they try.

For me it's mostly about far better error handling. C# still has a system of throwing exceptions and try catch, which are very problematic, because they form a way of error handling which is not well encoded in the type system, based on method contract it is totally unclear if a method possibly throws anything. DUs make it possible to handle that issue. But more generally speaking it is about clear ways of being able to know and handle which variants of a type are possible. The current C# pattern matching based on just OOP inheritance allows for infinite possible values, because an interface or class can have unlimited derived types. So pattern matching is very frequently not exhaustive. Unless being done on an enum. But enums cannot contain any other direct values. If they did, then you exactly had what we called a DU. And this is exactly Rust has for example. Enums as DUs.

I guess people wanted DUs to be able to use the same error handling as Rust.. but come on! if your function return error as value and sometime throw some exception, then it will become a mess! consumers have to deal with both errors as values and exception handling..

@@duongphuhiep an easy solution is for all dotnet devs to agree to return exceptions as return values in a tuple. If we all do it at the same time then problem solved. Let’s go. Staring right…..now 😂

They need to buy Avalonia and make it first party.

They are probably already working on its replacement, don'tcha know?

I rather wish they just dropped it instead of pretending it's viable

All time JIT does is what nativeAot does, but worse. The theory is what Jit *could* do is just that, theory. AOT can do a lot more optimisations than you would ever get in a JIT. C# is just realising all the things it should have had from the start, but were ignored because they weren't cool enough, are good. Whats old is new again.

@@gbjbaanb Performance was never the reason ‒ you've had tools like ngen for decades; you can even pick methods for AOT in code by calling PrepareMethod... You don't get anything by removing JIT from a system where both JIT and AOT is already possible. You don't pick NativeAOT for performance; you pick it because you are working in a constrained environment where having the CLR is a burden or outright impossible, such as native plugins/libraries or similar. The "AOT" part in the name is a limitation, not a selling point ‒ by removing the JIT, you lose the possibility to run *any* code that the static analysis skipped in a performant manner, having to interpret at best or breaking it at worst. You don't get anything in terms of power by downgrading C# to C++. You can't accept .NET assemblies, your reflection is limited, you can't interact with dynamic assemblies, and your generics effectively turn into templates since you can only use them statically. That is not something that may improve over time, that is *by design*.

I prefer always Flutter over Avalonia. Avalonia miss a lot of features that is shipped with MAUI, like routing and navigation. At least Flutter and MAUI has a big company behind.

Just to make sure, the discussion is about C# and XAML (as in Avalonia and MAUI) and you are bringing Dart and Flutter? I don't think it is fair pears to pears comparison. As for the big companies, I am not sure what you mean by that. For example, Silverlight and later UWP had a big company behind them.

@@tridy7893 yeah, Microsoft and Google abandon project with lower market, like any intelligent business. I loved NET Maui, but lack of Linux support from Microsoft just make me migrate to another language. We tryed to use Avalonia a lot, but its just familiar for WinUI/WPF developers. Missing routing funcionality, its not easy to just show a dialog from anywhere. Yeah, i mentioned Flutter because its a good alternative to Avalonia.

What about Uno? That is truly cross-platform.

Yes. Again.

What is it?

Yet another attempt at making us forget that we still have no mixins nor multiple inheritance

Rust enums and pattern matching are awesome.

Even if it would require a new keyword to use them, it would always be possible because F# has them and both languages have to be lowered to the same base code of .net.

In IT that's like eternity.

@@krccmsitp2884 yeah, it’s depressing

No, in the contrary. It just wasn't in the scope of the team writing that article.

Means there will be some improvements for Blazor too? ​@@krccmsitp2884

Fine if you do. But please. React, SwiftUI, Jetpack Compose, Flutter, etc. are superior. I don't think it can be disputed at this point, especially since the latter three all copied React. And so did Microsoft with WinUI 3, and they really just need to get on with it. Or get dusted, as per usual, leaving us dry

React? No thanks. htmx all the way for me.

@@71Jay17 If you prefer htmx, I'm guessing XAML is a hard pass

Well, it's not very convenient for advance scenarios, but in general, it's not a big issue. The main issue is that the MAUI is still not usable, the MAUI team lacks hardcore developers, MS lacks large MAUI based projects developed not using students and interns.

@@bondarenkodf Microsoft uses React and React Native internally. It is sad

lol, search for 3. c# floating-point-numeric-types, 2. orleans. why tf would u do GPU acceleration in c#, maybe try Skia

Enums that can have methods like classes would be great. The current workaround of using extension methods is pretty cumbersome.

The Rust DUs and pattern matching are the best examples of these implementations. I'd tried a little bit of F# and missed the "If.. let" and "let .. else" operators. By the other hand C# allows to define guard clauses using type matching. If they combine some features from F# with C# then it will be the best language. Rust is the best example for inspiration. The way they have the Enum is very useful. If the current C# Enum has a way to store generic values it would be very great.

If you want Linux then use Uno instead.

Microsoft likes Linux on the server. On the desktop, not so much (no good RDP client, no Office, etc).

yeah, didn't get that either. I don't see anything fundamentally incompatible in current C# that prevents DUs like in F#.

@@ChyK24 I mean, you can literally implement them by hand in the current C# using explicit struct layouts, so what is the "clashing" (in fact, I have a crate that uses source generation to do exactly this, called 'EasyUnions')? The most problematic stuff I see is with things like interfaces and stuff, but I don't think they are a good thing to use on DU's in C# anyway.

@@diadetediotedio6918 Also check out Dunet

the main issue is the LDT is still figuring out exactly how they want DU to behave and be represented the addition itself isn't complicated

What does .NET have to do with C#'s syntax improvements?

@@AlFasGDyou know what I meant. Usually new .NET and new C# comes hand in hand. It's just an oversimplified comment, not an technical article.

I know what you meant, you don't know what you're talking about. C# has taken the evolutionary direction and it's up to you to take the train or not. If you want a lower language version in a more modern .NET version, you can do that. If you want to stay in .NET Framework 4.8, it's up to you again.

@@AlFasGD You'll get burned out too. You just don't realize it yet.

​@@keyser456 I've already gotten burnt out in the sense of learning all the features. I just make use of whatever comes, as long as it's designed properly and it fits the domain that I use it in. Not to mention that I've argued against the infamous null-arg check shorthand (!!), wanted primary ctors to come with more features baked in, and don't really care about all the moving gears in most new features.