.NET Configuration with CoreStack Academy

𝐒𝐨𝐥𝐯𝐞𝐝 𝐚 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 𝐭𝐰𝐢𝐜𝐞 𝐭𝐨𝐝𝐚𝐲. 𝐅𝐢𝐫𝐬𝐭 𝐰𝐚𝐲 𝐰𝐚𝐬 𝐠𝐨𝐨𝐝. 𝐒𝐞𝐜𝐨𝐧𝐝 𝐰𝐚𝐲 𝐦𝐚𝐝𝐞 𝐦𝐞 𝐫𝐞𝐚𝐥𝐢𝐬𝐞 𝐰𝐡𝐲 𝐭𝐡𝐞 𝐟𝐢𝐫𝐬𝐭 𝐰𝐚𝐬 𝐬𝐥𝐨𝐰. 𝗟𝗖 𝟭𝟮𝟲𝟴 — 𝗦𝗲𝗮𝗿𝗰𝗵 𝗦𝘂𝗴𝗴𝗲𝘀𝘁𝗶𝗼𝗻𝘀 𝗦𝘆𝘀𝘁𝗲𝗺. 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝟭 — Built a Trie, stored words at terminal nodes. For each character typed, walk to the prefix node → collect all words below it → sort → take top 3. Honestly loved this one. Clean separation. searchCharByChar just finds the node. collectAllWords just gathers words. Each function doing exactly one thing. Felt elegant. Then I counted what was actually happening. Typing a 10 character word = 10 traversals + 10 sorts. Same work, repeated every single keypress. 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝟮 — 𝗣𝗿𝗼𝗱𝘂𝗰𝘁𝘀 𝗮𝗿𝗲𝗻'𝘁 𝗰𝗵𝗮𝗻𝗴𝗶𝗻𝗴. 𝗦𝗼 𝘄𝗵𝘆 𝘀𝗼𝗿𝘁 𝟭𝟬 𝘁𝗶𝗺𝗲𝘀? Sort once upfront. During insert, at every node on the path just store up to 3 words as they arrive. Since the array is already sorted — the first 3 that land at any node are automatically the smallest. Search becomes just walking one character and reading what's already there. Nothing else. I don't think I get to approach 2 without writing approach 1 first. Sometimes you need to see the slow version clearly before the fast one becomes obvious. Which one would you have jumped to first? 👇 #DSA #CPlusPlus #LeetCode #Trie #DataStructures #Programming #100DaysOfCode

Day 6 of 30 — One keyword that saves you 30 lines of boilerplate 🧹 C# Records changed how I model data in .NET. No more manual Equals(), GetHashCode(), or ToString() overrides. When to use Records vs Classes — full breakdown in the image 👇 Are you using Records in your projects yet? Drop your use case below 👇 #CSharp #DotNet #CleanCode #SoftwareEngineering #Programming

Why does it matter? .Count() — as an extension method on IEnumerable<T> — must walk the entire sequence to return a number. Even if the list has 10,000 elements, it checks all of them just to tell you "yes, there's at least one." .Any() short-circuits. It returns true the moment it finds the first element. On large collections or deferred LINQ queries, this is a meaningful performance gain. The nuance worth knowing: → If you're working with a concrete List<T> or array, .Count (the property, not the method) is O(1) — that's perfectly fine. → The trap is calling .Count() (the method) on an IEnumerable, which triggers full enumeration. → .Any(predicate) is also cleaner than .Where(...).Any() — same result, one less pass. #dotnet #csharp #linq #dotnetdeveloper #programming #cleancode #performancetips

🚀 Day 6/100 – .NET Configuration | CoreStack Academy Continuing my #100DaysOfCode journey, today I’m moving from theory to hands-on in .NET configuration. ⏰ Study Time: 8:00 AM – 11:00 AM 📚 What I worked on today: Custom Configuration Providers (Hands-on) Options Pattern Options Validation Yesterday, I focused on understanding the theory behind Custom Configuration Providers — how .NET allows plugging in custom logic to load configuration from different sources. 💡 Today’s goal is to implement that understanding: 👉 Building a custom configuration provider 👉 Exploring how it integrates into the configuration pipeline 👉 Applying Options Pattern with validation in a practical way This shift from theory → implementation is where real learning happens. Step by step, building deeper clarity on how .NET works internally 🔥 Live Stream : https://lnkd.in/gQ8fX9Kt #CoreStackAcademy #100DaysOfCode #DotNet #BackendDevelopment #SoftwareEngineering #Developers #Programming

Reflection in .NET carries a performance stigma, but newer versions may change that perception. Caching and precomputation can significantly reduce the performance gap in sensitive contexts. The results suggest reflection can be a reasonable choice when clarity and maintainability outweigh minor speed losses. This isn’t a green light for overuse, but a reminder that assumptions about performance often don’t hold when newer runtime optimizations are in play. Code clarity and long-term maintenance can benefit when patterns are chosen with actual data, not folklore. Choosing the right tool means balancing measurable facts with team understanding — not just code efficiency. #CSharp #DotNet #Programming #SoftwareDevelopment

Started learning .NET today. At first, it felt confusing. Platform? Framework? C#? But once I broke it down… it actually started making sense. .NET is just the engine. C# is what you use to drive it. Built a small flow today: input → logic → output Nothing crazy. But it felt real. If you’re starting out, don’t try to learn everything. Just understand one concept at a time. That’s what I’m doing. #dotnet #csharp #programming #coding #developers #softwaredevelopment #webdevelopment #backend #learncoding #beginners #tech #codingjourney #computerScience #100DaysOfCode #buildinpublic #studentdeveloper

🚀 C# 1.0 – The Foundation of Modern .NET Development Back in 2002, C# 1.0 marked the beginning of a powerful, type-safe, and object-oriented programming language that continues to evolve today. Understanding its fundamentals gives strong clarity on how modern C# features are built. 🔹 Key Features of C# 1.0: 👉 Object-Oriented Programming (OOP) Introduced core OOP principles like classes, inheritance, encapsulation, and polymorphism — forming the backbone of scalable applications. 👉 Delegates Type-safe function pointers that enabled callback mechanisms and laid the groundwork for events and asynchronous programming. 👉 Access Modifiers Control visibility and encapsulation using public, private, and protected — essential for secure and maintainable code. 👉 Arrays Strongly-typed, fixed-size collections to manage data efficiently. 👉 Events Built on delegates, enabling event-driven programming — a key concept in UI and reactive systems. 👉 Exception Handling Robust error management using try-catch-finally, improving application stability. 💡 Why it matters? C# 1.0 wasn’t just a starting point — it defined the design philosophy of simplicity, safety, and scalability that still drives .NET today. 📌 Master the basics. Everything advanced builds on this. #CSharp #DotNet #Programming #SoftwareDevelopment #Coding #TechLearning #Developers #OOP #BackendDevelopment #CareerGrowth

🛑 𝐘𝐨𝐮𝐫 𝐎𝐧𝐌𝐨𝐝𝐞𝐥𝐂𝐫𝐞𝐚𝐭𝐢𝐧𝐠 𝐢𝐬 𝐚 𝐦𝐞𝐬𝐬 - 𝐡𝐞𝐫𝐞'𝐬 𝐡𝐨𝐰 𝐭𝐨 𝐟𝐢𝐱 𝐢𝐭 You add one entity. Then ten. Then indexes, owned types, value converters. Suddenly nobody wants to touch that method anymore. EF Core has a built-in pattern that solves this - and many developers never use it. Full 8-minute walkthrough in my latest video: https://lnkd.in/dceDNrjF ♻️ Repost to help your team write cleaner EF Core code! 📌 Save this for when your DbContext becomes a mess Follow Remigiusz Zalewski for more daily .NET tips 👇 #csharp #dotnet #aspnetcore #efcore #database #softwaredeveloper #programming #webdevelopment #careergrowth #developer #coding #aspnet

C++Online Workshop Spotlight 🧠 How C++ Actually Works — Hands-On With Compilation, Memory, and Runtime with Assaf Tzur-El View Full Details: https://lnkd.in/eiPNCgcR Watch Workshop Preview Video: https://lnkd.in/eKeAg3Ze 🗓 May 18–19 — 16:00–20:00 UTC (2 × half-day sessions) 🎯 Suitable for: Advanced Ever seen a bug that: - Disappears in debug mode? - Only appears with optimizations enabled? - Behaves differently across compilers? You’ve encountered the limits of the C++ abstract machine. This advanced workshop dives into the gap between what the C++ standard guarantees and how real implementations behave in practice. Through live demos and hands-on exercises, you’ll build a practical mental model of: • How C++ code is compiled and translated • How memory is laid out and accessed • How language constructs map to runtime behavior • Where implementation details affect correctness, portability, and performance • How to detect fragile assumptions in production code The goal isn’t memorizing rules — it’s developing transferable reasoning skills for debugging, optimizing, and reviewing complex systems with confidence. 👨🏫 Instructor: Assaf Tzur-El Veteran software development consultant with 30 years of experience, specializing in developer excellence, engineering culture, and high-performance teams. Book today! https://lnkd.in/eiPNCgcR #cpp #cplusplus #programming #coding

🚀 Clean Code is More Important Than Clever Code Writing complex code that only you understand isn’t impressive. Writing clean code that your entire team can maintain? That’s real engineering. ❌ Clever code: 🔵 Short but confusing 🔵Too much abstraction 🔵Hard to debug 🔵Difficult for teams to maintain ✅ Clean code: ✔ Readable ✔ Predictable ✔ Simple to modify ✔ Easy to test 💡 In ASP.NET Core projects, this means: 🔵Thin controllers 🔵Proper service separation 🔵Meaningful method names 🔵Consistent API responses 🔵Clear project structure ⚡ Reality: Code is written once… but read hundreds of times. Optimize for readability, not ego. 💬 What matters more to you — clever code or maintainable code? #ASPNETCore #CleanCode #SoftwareEngineering #DotNet #BackendDevelopment #Programming