EL YAZID ISMAILI’s Post

🚀 Understanding SOLID Principles in C++ – Liskov Substitution Principle (LSP) Today, I explored one of the most important design principles in Object-Oriented Programming – the Liskov Substitution Principle (LSP). 🔍 What is LSP? LSP states that objects of a derived class should be replaceable with objects of the base class without breaking the program. 💡 What I implemented: ✔️ Designed a clean abstraction using: DepositOnlyAccount (base interface) WithdrawableAccount (extended interface) SavingAccount (concrete implementation) ✔️ Ensured proper hierarchy where: Deposit-only accounts are not forced to implement withdrawal Withdrawal functionality is only available where it logically makes sense 🔥 Key Learning: Instead of forcing all accounts to support both deposit and withdrawal (which violates LSP), we segregate responsibilities and design flexible, scalable systems. 📌 This improves: Code maintainability Extensibility Real-world modeling accuracy 💻 Tech Stack: C++, OOP, SOLID Principles #CPlusPlus #OOP #SOLIDPrinciples #LLD #SystemDesign #Programming #SoftwareEngineering #CodingJourneyRohit Negi

Built a custom string handling class in C++ from scratch — without using std::string. This project focuses on: • Dynamic memory management using new[] and delete[] • Implementation of the Rule of Three (Destructor, Copy Constructor, Copy Assignment) • Manual string manipulation algorithms (reverse, case conversion, word counting) • Operator overloading for intuitive usage (+, +=, [], (), comparison operators) The goal was to deeply understand how strings work internally rather than relying on built-in abstractions. A great exercise in mastering memory management, object-oriented programming, and low-level string operations in C++. #cpp #programming #softwareengineering #oop #learning #developers

🔹 Part 1: C++ Concepts vs SFINAE (Practical Guide) This short video is part of my "C++ Programming Topics" series 👇 And also included in my broader C++ templates playlist. 💡 The problem: SFINAE is powerful—but it often leads to complex, hard-to-read template code. This can cause: -Cryptic compiler errors -Reduced code clarity -Higher learning curve for maintainers ❌ 📌 This is where C++20 Concepts shine: 👉 They provide a clean and expressive way to constrain templates. 💡 What you’ll learn in this video: ⚙️ Step-by-step evolution from SFINAE to Concepts: 1️⃣ Using enable_if in template parameters A cleaner alternative than putting it in the return type 2️⃣ Constraining a template class (Wrapper) Allow only integral types using SFINAE 3️⃣ Generic sum function Handle different types and control the return type 4️⃣ Concepts vs SFINAE Clear comparison in readability and maintainability 5️⃣ Writing your own concept Define a requirement for types that support add and sub 6️⃣ Combining Concepts with type_traits Reuse existing utilities for powerful constraints 🎯 Key takeaway: Concepts don’t replace SFINAE—they simplify it. Use Concepts when readability matters, and SFINAE when you need lower-level control. 🎥 Watch the video: https://lnkd.in/dpiQNQcF 📚 Full playlist: https://lnkd.in/dDNVWvVC #cpp #moderncpp #programming #softwareengineering #templates #concepts #metaprogramming #cleancode

🔹 Part2: Exploring type_traits in C++ (is_integral & enable_if) This short video is part of my "C++ Programming Topics" series 👇 And also included in my broader C++ templates playlist. 💡 The problem: When writing generic C++ code, not every type should be treated the same way. This can lead to: -Invalid operations on unsupported types -Hard-to-read template errors -Fragile and unsafe generic code ❌ 📌 This is where the type_traits library becomes essential: 👉 It gives you compile-time tools to inspect and control types. 💡 The solution: Understanding and implementing core utilities like: ✔️ is_integral — detect whether a type is an integral type ✔️ enable_if — conditionally enable/disable functions ✔️ type_traits — the foundation of compile-time type logic ⚙️ Bonus insight from the video: You’ll explore simplified implementations to really understand how they work under the hood: 1️⃣ is_integral How the compiler determines if a type belongs to integral types 2️⃣ enable_if How to include/exclude functions during compilation 3️⃣ Combining both Apply constraints to templates for safer and cleaner code 🎯 Key takeaway: Don’t just use type_traits—understand how they work. That’s what unlocks the real power of modern C++ templates. 🎥 Watch the video: https://lnkd.in/d7zPHDzb 📚 Full playlist: https://lnkd.in/dDNVWvVC #cpp #moderncpp #programming #softwareengineering #templates #metaprogramming #cleancode

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

🔹 Part 1: SFINAE in C++ This short video is part of my "C++ Programming Topics" series 👇 And also included in my broader C++ templates playlist. 💡 The problem: Many developers struggle with controlling which template functions should participate in overload resolution. This can lead to: -Confusing compiler errors -Unintended function matches -Less robust generic code ❌ 📌 This is where SFINAE becomes powerful: 👉 Substitution Failure Is Not An Error allows the compiler to silently discard invalid template instantiations. 💡 The solution: Applying SFINAE techniques to a simple example: int sum(int a, int b) { return a + b; } ✔️ Constrain templates to valid types only ✔️ Prevent invalid overloads from compiling ✔️ Write safer and more expressive generic code ⚙️ Bonus insight from the video: You’ll see how SFINAE works step by step by evolving this basic function: 1️⃣ Basic function behavior Understand the baseline implementation 2️⃣ Applying SFINAE Control when the function is enabled 3️⃣ Safer templates Restrict usage to valid type combinations 🎯 Key takeaway: SFINAE helps you guide the compiler instead of fighting it. It’s a foundational technique for mastering modern C++ templates. 🎥 Watch the video: https://lnkd.in/d7zPHDzb 📚 Full playlist: https://lnkd.in/dDNVWvVC #cpp #moderncpp #programming #softwareengineering #templates #cleancode

🚀 Turning Logic into Art with C++ Today, I worked on building a pattern generation program using C++ and recursion — and the result was something visually satisfying: a perfectly aligned diamond/star pattern rendered in the console. What looks like a simple pattern actually involves: ✔️ Understanding recursion deeply ✔️ Managing multiple variables efficiently ✔️ Controlling flow for symmetrical design ✔️ Writing clean and optimized logic This small project reminded me that programming is not just about solving problems — it’s also about creativity and precision. Even a console output can feel like art when logic is applied the right way. 💡 Key takeaway: Strong fundamentals in Data Structures and recursion can help you build elegant and efficient solutions, even for problems that seem simple at first glance. Always learning. Always building. #Cplusplus #Programming #DSA #Recursion #CodingJourney #SoftwareDevelopment #ProblemSolving

🔹 Type Deduction in C++ (auto, decltype) This short video is part of my "C++ Programming Topics" series 👇 And also included in my broader learning playlist. 💡 The problem: Many developers either over-specify types or rely on guesswork when writing modern C++ code. This can lead to: -Verbose and harder-to-read code -Subtle bugs when types are not what you expect -Reduced flexibility when refactoring ❌ 📌 This is where type deduction becomes powerful: 👉 Let the compiler infer the correct type safely and efficiently. 💡 The solution: Using modern C++ features like auto, decltype, and template deduction: ✔️ Write cleaner and more concise code ✔️ Reduce redundancy ✔️ Let the compiler handle complexity ⚙️ Bonus insight from the video: You’ll see how type deduction works in different scenarios: 1️⃣ auto Great for simplifying variable declarations Improves readability when types are obvious 2️⃣ decltype Useful when you need the exact type of an expression Helps in advanced template and generic programming 3️⃣ Template Type Deduction The core concept behind generic programming Enables flexible and reusable code 🎯 Key takeaway: Don’t fight the compiler—use it. Modern C++ gives you tools to write cleaner, safer, and more maintainable code. 🎥 Watch the video: https://lnkd.in/dZSDe2Pi 📚 Full playlist: https://lnkd.in/dDNVWvVC 📚 Source code, examples, and notes: https://lnkd.in/dy2Kp-4f #cpp #moderncpp #programming #softwareengineering #templates #cleancode

#PartFour EFCore Snippets One of the most used features in Entity Framework Core is Filtered Include. Since EF Core 5.0, the Include method accepts a filter expression directly on the related collection. The filter is pushed down into the SQL query itself. Without Filtered Include, you load every child entity and filter in C#. With Filtered Include, only the rows you actually need travel over the wire. Limitations about Filtered Include: 1- Skip() inside Include is not supported and throws at runtime. 2- Already-tracked entities in the context may bypass the filter. 3- Combining with AsSplitQuery() can produce unexpected behavior. 4- Each Include is isolated — no shared filter across multiple navigation properties #dotnet #csharp #efcore #entityframeworkcore #softwareengineering #backenddevelopment #aspnetcore #cleancode #performanceoptimization #programming

Day 10 of My Dynamic Programming Journey Today I solved Edit Distance (LeetCode 72) — one of the most important and practical string DP problems. Problem Insight: Convert one string into another using minimum operations: Insert Delete Replace Core Idea: At every step, I had two scenarios: If characters match → move diagonally (no cost) If not → try all 3 operations and pick the minimum DP Thinking: Defined: dp[i][j] = minimum operations to convert first i characters of string1 into first j characters of string2 Key Realization: “Every mismatch is a choice — insert, delete, or replace — DP helps choose the cheapest one.” Optimization Learning: Started with 2D DP (O(n×m)) Optimized to 1D DP (O(m)) by tracking previous (diagonal) state What I Learned Today: Strong understanding of string DP transitions Importance of base cases (empty string conversions) How to manage state transitions in space-optimized DP Next Goal: Moving to Knapsack pattern (0/1 Knapsack & Partition problems) to explore subset-based DP #DynamicProgramming #DSA #CodingJourney #ProblemSolving #LeetCode #LearningInPublic #Day10