CppNorth, The Canadian C++ Conference’s Post

💡C# Tip ✨ Simplify Your Code with Modern `switch` Expressions! In software development, **simplicity** leads to better **maintainability** and **readability**. The transition from the traditional `switch` statement to the modern `switch` expression is a great example of this evolution. 🔍 *What's the Difference?* - *Traditional `switch` Statement:* - Handles each case individually, often leading to verbose code. - Requires explicit `break` statements to prevent fall-through. - *Modern `switch` Expression:* - Condenses logic into a single, streamlined block. - Eliminates the need for `break` statements, making code cleaner and easier to read. 💡

What is DRY Development? DRY, which stands for ‘don’t repeat yourself,’ is a principle of software development that aims at reducing the repetition of patterns and code duplication in favor of abstractions and avoiding redundancy. Popularized by the book, The Pragmatic Programmer, the DRY principle states that, “every piece of knowledge must have a single, unambiguous, authoritative representation within a system.” Using the principle, logic or algorithms that have certain functionality should only appear once in an application.

We never think about the file/folder structure of a database we're developing. Why are we still obsessed about file/folder structure when writing code written in some 3GL? It doesn't make any sense. Why are we still using such incredibly primitive approach to software development?

Single Responsibility Principle (SRP) in C#: A Guide to Writing Maintainable Code The Single Responsibility Principle (SRP) is one of the five SOLID principles of object-oriented design. It was introduced by Robert C. Martin and is considered a fundamental concept for writing maintainable and scalable software. In this article, we'll delve into the Single Responsibility Principle, exploring its definition, importance, and providing practical examples in C#. Link https://lnkd.in/dZsdKVRY

In software development, especially in the .NET environment, writing clean and efficient code is essential for ensuring the quality and sustainability of projects. In this article, I share some best practices that can help developers achieve these goals.

A topic good to remember: naming things is hard. Especially in software development. You will find a list of reasonable points in the bookmark. There are only two points I would handle slightly differently: - regarding point 7: the abbreviation `ID` is well-known and okay to use - regarding point 8: I like the usage of `userList` instead of `users`

Have you seen SOLID and all those other acronyms that try to give you strict rules on how to write code ? Well, screw that. Flexibility and Creativity are key to good software development, and strict rules and paradigms won't give you that (though they can give you a nice starting point). Some basic rules of thumb (for mid-to-high level languages): - What you see in one screen should be pretty much understandable, otherwise you need to separate your code into smaller chunks. - The code should pretty much read as if telling you what it's doing, otherwise you need to improve your naming and make more constants, variables and functions (with good names too, and this also applies to file and folder structures). - You should have plenty information on the data and processes you handle, otherwise you should start typing and validating more. When you have a codebase that is properly modularized, named and typed, it's something wonderful; any modification, extension or troubleshooting becomes a breeze. When you have a codebase that has huge chunks of code thrown in some files, everything is poorly named and nothing is typed nor validated, you can expect anything from it and understanding what is going to either modify, extend or troubleshoot, is a hell.

In software development, mocking means creating fake parts of a system to test other parts of the system. This lets you focus on one bit of code and test various situations easily. Here, Grant explains how mocking works in .NET – with examples. https://lnkd.in/gvVixPSe

In the world of modern application development, APIs (Application Programming Interfaces) are the backbone that enable communication between systems. Developers often find themselves choosing between three main API paradigms: REST API, GraphQL, and RPC. Each of these approaches serves a similar purpose—facilitating communication between client and server—but they differ significantly in how they operate and in the trade-offs they present. In this article, we'll explore how each of these methodologies works, their strengths and weaknesses. Check out the full article here: [https://lnkd.in/d27bQpWh]

⚡ Single Responsibility Principle: Simplifying Complexity in Software Design ⚡ 👉 The definition and importance of SRP in software design 👉 A practical example of a journal app to illustrate SRP in action 👉 How to refactor code to adhere to SRP by introducing a PersistenceManager class 👉 The balance between applying SRP effectively and avoiding an overly fragmented codebase https://lnkd.in/euY4NN5q