An even DEEPER Dive into LINQ with Stephen Toub
Вставка
- Опубліковано 3 чер 2024
- Scott and Stephen are back to go even deeper on LINQ (Language Integrated Query). LINQ easily enables developers to write query expressions with a declarative query syntax that allow them to perform filtering, ordering, grouping, and so much more with minimal code. Let's go!
Part 1: Deep Dive on LINQ with Stephen Toub - • Deep Dive on LINQ with...
Chapters:
00:00:00 Deep Dive into Implementing Iteration in Programming
00:01:50 Understanding the Implementation and Functionality of Custom Iterators in Link
00:07:45 Discussing Optimization Strategies and Array Specialization in Programming
00:10:43 Understanding the Use of Sharp Lab and Compiler Optimization in C
00:15:20 Discussing Optimizations in Link Methods in Programming
00:16:39 Understanding SIMD and its Application in Computer Processing
00:20:12 Discussion on Code Analysis and Optimization Techniques in Software Development
00:23:46 Discussing and Implementing Iteration-Based and Manual Arrays in Programming
00:30:30 Exploring Compiler Optimizations and State Management in Programming
00:37:04 Exploring Hyper and Micro Optimization in Programming
00:40:11 Exploring Code Optimizations and Trade-offs in Programming
00:45:41 Discussing the Challenges and Implications of Optimizations in Software Performance
00:47:54 Discussing the Implementation and Optimization of Select in Programming
00:51:49 Discussion on Programming Syntax and Benchmarks
00:54:41 Implementing and Discussing Iteration Code in Programming
00:57:12 Understanding the Functionality and Implementation of C# Compiler Keywords
01:02:42 Improving Functionality and Performance of Manual Implementation of Iteration Methods
01:08:39 Exploring the Optimization and Implementation of Select Operators in Programming
01:12:57 Understanding and Optimizing Iteration Operations in Programming
01:18:09 Implementing and Utilizing LINQ Programming: A Two-Parter
Resources:
Documentation: learn.microsoft.com/dotnet/cs...
Connect with .NET:
Blog: aka.ms/dotnet/blog
Twitter: aka.ms/dotnet/twitter
TikTok: aka.ms/dotnet/tiktok
Mastodon: aka.ms/dotnet/mastodon
LinkedIn: aka.ms/dotnet/linkedin
Facebook: aka.ms/dotnet/facebook
Docs: learn.microsoft.com/dotnet
Forums: aka.ms/dotnet/forums
🙋♀️Q&A: aka.ms/dotnet-qa
👨🎓Microsoft Learn: aka.ms/learndotnet
#dotnet - Наука та технологія
I am totally in favor of a deep dive series. This is great
exactly.
Question for Stephen for a future video: I often hear you say "If I could go back and do Tasks/async await differently..." but you never really elaborate. I would love to know what things you would do differently!
^ same
And what are they doing for Green Threads?
Second that
@@alexisfibonacciwasn't that abandoned?
Likely because it’s based on a state machine rather than concurrent patterns . Remember it’s only syntactic sugar but is often implemented in cases where developers intend for true asynchronous cases and it ain’t all that…
These Deep dive series is amazing. For an experienced dev this is gold, because it's actually quite a lot of information that you didn't already know.
The tangent on simd was fascinating. I have pondered on optimizing loops before and now learning that they can be vectorised and have multiple operations happen at a time just expanded my views.
Please keep doing this series. This is the stuff we developers need out on the webs. Top tier computer scientists with decades of experience just talking about concepts at all different levels.
Epsecially for people like myself who work for themselves or maybe don't have colleagues or friends in the developer space, these kinds of coversations are incredibly valuable.
Nick Chapsas has a video on those array parallelisations.
It's great to have the internals explained and demonstrated showing every step in detail. Really liked the "(unit)i < (unit)source.Length". Awesome guys.
DEEP Dive series are amazing!! They are not "bla-bla-super-duper" talks but a diamond gems that reveals hidden aspects of technology!! Keep up such an excellent talks!
I adore these deep dive series. Can't wait for a deep dive into Entity Framework to finally understand how this magic works.
Love this series on several aspects. Both hosts work very well together. It gives great insight into 'magic' we use on a daily basis and now take for granted. We see what thoughts and considerations go into optimization, after a solid basis has been created. Which in the end opens up the mind to see things through a different lense and gives ideas for new concepts and patterns. Great job!
Thank you for this video series on LINQ, very educational!
That tangent about SIMD was awesome. It's not something I've ever dove into. I had to pause and ask CoPilot what you guys were talking about. Really awesome stuff guys! Love this series!
I love this series of deep dives. Even more so, the mentioning and tie ins to lowered and IL. This stuff is gold no matter you level, there is something to take away for everyone.
Even internal to MSFT, ive told coworkers and other devs about this (and the async one especially).
It's amazing where we started from in the previous video and where we got down to what is happening in the lowest levels.
I love this series.
Holy crap, how cool is this. Another one.
Darn tootin’
Loving this content--Deep dives that don't treat the viewer like an idiot. There's not enough software dev content out there that assumes the viewer is already an expert.
This is pure gold. Very educational and doesn't ever get boring. Great job, Scott and Stephen. I hope more of these come out.
I'm amazed by how clear and insightful it is. Stephen's ability to break down complex topics into understandable, low-level explanations is truly commendable.
This video has been incredibly helpful in deepening my understanding. A huge thank you to Stephen Toub and the team behind this invaluable instructional content!
Seeing Stephen Toub, it suddenly occurred to me that we seem to be seeing Performance Improvements in .NET 9 soon? Time flies.
This was amazing. I would also love to see an implementation of Thread Pool and a Task Scheduler.
This is amazing, please make more of these!
These sessions are great. I would love a DEEP dive into the reactive extensions.
Also how IAsyncEnumerable methods are implemented would be cool.
No way, I am just approaching half of the previous one. This is awesome!
I have just one word on my mind - wow! Keep doing such deep videos!
This series is great. Please do continue with it!
This is the awesome, super interesting and ties how of things I thought I knew but didn't quite have right into a super clear narrative.
invaluable content. uncovers much more than just reading documentation and/or books
Deep dotnet! Deep dotnet! Love the idea - please give us more!
This series is absolutely amazing! Thank you so much, great content!
Fantastic content, thanks Scott and Stephen!
Long overdue to bring best of architects and programmers to show us how its done, looking forward to more.
Can't wait for the next episode of Deep dotnet. There is always so much to learn!
Thx guys, please do more of theses!
At 38:38, had the if statement explicitly checked for i>=0 && i
Love the SIMD conversations
I am loving these videos! Keep them coming.
Great videos, thank you!
Awesome deep dive - we want more! ;-)
Thank you so much this kind of very interesting topic are really great ! Please more !!!! 🥰😍🥰
Wish I could explain code as well as you do - loving this Deep dotnet
Just brilliant Scott and Stephen. Keep going these are brilliant
loving this series
excellent optimization hints.
Great. More of that. :) Gooooood informative content.
These are so great!!
Great series
Liked the video already because you know, Stephen Toub.
Thank you, this content is like intellectual honey. Looking forward your next deep C# videos.
Would it be possible to have a Source Generator that recognizes linq call chains and generates dedicated enumerators for those?
Brilliant stuff
Ohh boy!! MOAR! 🙂
Tell us in the comments if this is what you want to see... Yes. Never waste a Toub Tangent. That's where deep learning happens!
We want part three!
Can I suggest Stephen Toub and Joe Albahari together moderated by amazing Scott, from a designer and consumer perspectives and show us great stuff is built
Continue the series!!!! xD i love this DDD(otnet)
did you guys stream or was this pre recorded? ?
pre recorded last week but we do it all in one take
I'd definitely buy a CTRL-Z to Glory t-shirt 😅
awesome!
Thanks, a lot
This is gold
33:00 a very good example of how programmers think
At 1:15:34, what exactly causes the `Where` to be dropped/abandoned?
You do Where, then Select. When calling Select you check if your source happens to be WhereEnumerable and if so then instead of returning SelectEnumerable you combine them into single WhereSelectEnumerable and return it.
@@pagorbunov Oh, right. In my mental model, I was missing that nothing's actually executed until the call chain is "materialized" (ie, .ToList() or whatever is called). I was visualizing it as "Execute Where, pass those results to Select" and confused how we were skipping execution of the Where. What's really going on is at the end, we wind up one "thing" whose execution will "materialize" the results. And the new WhereSelect grabs the Where's arguments (source and predicate) and in effect "jumps the queue". ... I think that makes sense? Words are hard, massive respect to communicators like Scott and Steve who can communicate arcane details understandably but also precisely...
love to see how plinq is implemented .
Great! Take care of your throat, Stephen!
57:23 Why not use var values = from ... Implicitly typed variable. Defined for this kind of scenario. No need to type it again and again.
so cool
Everybody hop on the submersible. It's 100% safe.
Stephen: Sorry, I'm probably getting a bit nerdy.
Scott: Well, tell us in the comments if this is what you want to see?
Comments: THIS IS WHAT WE WANT TO SEE!!!!!!!!!!!!!!!!!!!
It's time.
"Knowledge is power"
Stephen Stephen Shephen
😊😊😊
Hard to read code. Next time may be use Dark theme for better code visibility
I think the LINQ keywords are totally superfluous and unnecessary. They can't and don't cover all use cases, like when I have to create my own extension methods to operate on enumerables. The keywords might make sense if you were loosely copying SQL syntax but instead they exactly (and awkwardly) match the extension method chaining.
Instead of Kill two birds with one stone, we Steven should use: feed two birds with one grain :)
on your risc-V chip what havent being invented yet
This would be superb video if only not presentation -- you found space for padding (top and bottom), for taskbar, for face frames, and well in rest you squeezed the least important content -- the code with 2px font. Awesome logic/thinking.
Given how hard we are personally working on these videos and these series, I would remind you that we are real humans doing their best. I look forward to your well-produced videos on these topics. That said, I agree this one got a little fancier and that we should zoom in on the code more. That message can be delivered without dripping sarcasm. 🥰
@@shanselman "I would remind you that we are real humans doing their best." Of course, but even with stellar content if you don't wrap it appropriately it is not so good after all, and the effort to some degree is wasted. From the other side -- in previous episodes you reminded about font size, during this one you completely skipped this part. And either I am dreaming, or you constantly were squinting your eyes and moving forward. Think about even less fortunate people, with worse eyesight, thank you (checklist would help a lot).