Best Programming Practices for Clean Code

Git is a distributed version control system that tracks changes in your code over time. It allows multiple developers to work on the same project without stepping on each other's toes. Key Git Commands: 1. git init    Initializes a new Git repository. It's like saying, "Hey Git, start keeping an eye on this project!" 2. git clone [url]    Creates a copy of a remote repository on your local machine. It's how you download a project to start contributing. 3. git add [file]    Stages changes for commit. Think of it as putting your changes in a shopping cart before checkout. 4. git commit -m "[message]"    Commits your staged changes with a descriptive message. This is like taking a snapshot of your project at a specific point in time. 5. git push    Uploads your committed changes to a remote repository. Share your work with the world (or at least your team)! 6. git pull    Fetches changes from a remote repository and merges them into your current branch. Keep your local copy up-to-date. 7. git branch    Lists all local branches. Useful for seeing what feature branches you have. 8. git checkout -b [branch-name]    Creates a new branch and switches to it. Perfect for working on new features without affecting the main code. 9. git merge [branch]    Combines the specified branch with the current branch. This is how you integrate your new feature back into the main code. 10. git status    Shows the status of changes as untracked, modified, or staged. Your project's health check! 11. git log    Displays a log of all commits. Like a time machine for your code. 12. git stash    Temporarily shelves changes you've made to your working copy so you can work on something else, and then come back and re-apply them later. Pro Tips: - Use meaningful commit messages. Future you (and your teammates) will thank you. - Commit often. Small, frequent commits are easier to manage than big, infrequent ones. - Use branches for new features or experiments. Keep your main branch clean and stable. - Always pull before you push to avoid conflicts. Whether you're a seasoned developer or just starting out, mastering Git is crucial in today's collaborative coding environment. It's not just about tracking changes; it's about streamlining workflows, facilitating collaboration, and maintaining code integrity. What's your favorite Git workflow trick?

🚨 Data professionals NEED to utilize software engineering best practices. Gone are the days of a scrappy jupyter notebook or quick SQL queries to get stuff done. 👀 While both of those scrappy methods serve a purpose, the reality is that our industry as a whole has matured where data is no longer a means to an end, but actual products with dependencies for critical business processes. 👇🏽 What does this look like? - Clean code where each action is encapsulated in a specific function and or class. - Version control where each pull request has a discrete purpose (compared to 1k+ line PRs). - Clear documentation of business logic and reasoning (on my SQL queries I would leave comments with Slack message links to show when public decisions were made). - Unit tests that test your above functions as well as the data when possible. - CI/CD on your pull requests, which is very approachable now with GitHub actions. 💻 In my LinkedIn learning course I was adamant about not just teaching you dbt, but instead how to create a dbt project that was production ready and utilized engineering best practices. Specifically, it's hands on where you will learn: - How to use the command line - How to setup databases - Utilizing requirements.txt files for reproducibility - Creating discrete PRs for building a your project - Documentation as code - Utilizing the DRY principle (don't repeat yourself) - Implementing tests on your code - Creating a dev and prod environment - Setting up GitHub Actions workflows (CI/CD) 🔗 Link to the course in the comments!

About five years ago, I had a junior engineer on my team who was brilliant but struggled so much he was about to have a low performance review. Let’s call him Anthony He was fresh out of college and eager to prove himself, but his code reviews often came back with extensive feedback. The root of the issue wasn’t his intelligence or effort it was his approach. Anthony had this habit of jumping straight into the deep end. He wanted his code to be optimized, elegant, and perfect from day one. But in that pursuit, he often got stuck either over-engineering a solution or ending up with something too complex to debug. Deadlines were slipping, and his confidence was taking a hit. One day, during a particularly rough code review, I pulled him aside and shared a principle that had profoundly shaped my own career: “Make it work, make it right, make it fast.” I explained it like this: 1. Make it work – First, solve the problem. Forget about how pretty or efficient your code is. Focus on meeting the acceptance criteria. If it doesn’t work, nothing else matters. 2. Make it right – Once it works, step back. Refactor the code, and make it clean, modular, and maintainable. Code is for humans who’ll work with it in the future. 3. Make it fast – Finally, if performance is critical, optimize. But don’t sacrifice clarity or maintainability for marginal speed gains. The next sprint, he followed this approach on a tricky API integration task. When we reviewed his work, the difference was night and day. Not only had he delivered on time, but the code was a joy to read. Even he admitted it was the least stressful sprint he’d had in months. Six months later, Anthony came to me and said, “That principle you shared, it’s changed everything. Thank you for pulling me aside that day.” Today, Anthony is a senior engineer leading his team, mentoring others, and applying the same principle that once helped him. We’re still on good terms though he moved to another org. Sometimes, the most impactful advice is the simplest. As engineers, we often get caught up in trying to do everything perfectly all at once But stepping back and breaking it into manageable steps can make all the difference.

5 𝐂𝐨𝐦𝐦𝐨𝐧 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐣𝐞𝐜𝐭𝐢𝐨𝐧 𝐌𝐢𝐬𝐭𝐚𝐤𝐞𝐬 𝐢𝐧 .𝐍𝐄𝐓 (𝐀𝐧𝐝 𝐇𝐨𝐰 𝐭𝐨 𝐀𝐯𝐨𝐢𝐝 𝐓𝐡𝐞𝐦) DI in .NET is powerful, but missteps can cause headaches. Here are common mistakes, fixes, and examples to level up your DI game: ❌ Mistake 1: Overusing Service Locator ✅ Fix: Use constructor injection. ❌ Mistake 2: Registering Too Many Singletons ✅ Fix: Use appropriate lifetimes. ❌ Mistake 3: Injecting Too Many Dependencies ✅ Fix: Refactor responsibilities. ❌ Mistake 4: Ignoring Lifetimes ✅ Fix: Use factories for mismatched lifetimes. ❌ Mistake 5: Circular Dependencies ✅ Fix: Introduce a mediator or event-driven design. Use DI wisely for cleaner, testable, and scalable code. What’s a DI mistake you’ve fixed recently? Share below! 🚀

One of the best advice I’ve received from a senior early in my career was to read Clean Code by Robert C. This is one of the most impactful books I’ve ever read. It forever changed how I used to code. If I had to summarize the 10 most important principles from the book, they would be: 1. Meaningful Names - Choose clear, descriptive names that reveal the intent of your code. - Names should help others understand the purpose without extra context. - Example: Use `totalCost` instead of `x` for clarity. 2. Small Functions - Keep functions small and focused on a single task. - If a function exceeds 20 lines, consider refactoring. - Example: A `calculateTotal()` function should only handle calculations, not logging. 3. DRY Principle (Don’t Repeat Yourself) - Avoid code duplication to reduce maintenance complexity and potential bugs. - Aim for reusability and modularity in your code. - Example: Use a `processUserInput()` function rather than repeating the same logic multiple times. 4. Avoid Comments - Write self-explanatory code to minimize the need for comments. - Outdated comments can mislead, so focus on making the code itself clear. - Example: Refactor a complicated `for` loop into a well-named function rather than explaining it with comments. 5. Error Handling - Separate error handling from business logic to keep code clean. - Handle exceptions gracefully to maintain resilience. - Example: Use a `try-catch` block around critical operations and log errors in a dedicated function. 6. Readable Code - Prioritize readability over cleverness to make the code easy to understand. - Consistent formatting and naming conventions enhance code clarity. - Example: Use clear indentation and consistent variable names like `userName` and `userAge`. 7. Single Responsibility Principle (SRP) - Ensure each class and function has one responsibility or reason to change. - This principle makes the code more modular and easier to test. - Example: A `User` class should only handle user-related data, not database operations. 8. Dependency Injection - Rely on interfaces or abstractions rather than concrete implementations. - This approach decouples components and makes the code more flexible and testable. - Example: Inject a `PaymentProcessor` interface into a `Checkout` class rather than using a specific payment gateway directly. 9. Testing - Write automated tests to validate your code and catch bugs early. - Tests act as a safety net, ensuring code behaves as expected after changes. - Example: Use unit tests to verify that a `calculateDiscount()` function returns the correct value for various input scenarios. 10. Refactoring - Continuously improve your code through refactoring to maintain quality. - Refactoring should be an ongoing process, not a one-time task. - Example: Regularly revisit old code to simplify logic or reduce duplication, like merging similar methods into one.

How to tackle legacy system modernization at scale: How Booking(.)com tackled a legacy API that had gotten completely out of hand: The situation: A 14-year-old API in their Perl monolith had grown from handling simple app updates to managing 21 different features across 7 teams. Instead of a quick migration to Java, the team took a thoughtful approach to breaking down this complex system. Key insights from their successful modernization: 1. Map before you migrate. The team created visual diagrams to understand how 1,500 lines of code connected to various parts of their system. 2. Know your stakeholders. Using repository history, they identified every team dependent on the API and included them in the planning process. 3. Split strategically. They separated the system into focused services based on functionality and platform requirements, making it more maintainable. 4. Test thoroughly. When they encountered unexpected issues with marketing metrics, they used A/B testing to identify and fix problems without disrupting service. The biggest lesson? Modernizing legacy systems isn't just rushing to new technology. It's about understanding what you have and carefully restructuring it into something better. Follow Pratik Daga for daily informative posts on software engineering.

I used to think adding more comments made me a better developer. Every time something got complicated… I’d type out 3–4 lines of explanation. It felt safe. Like I was doing the right thing. But over time, I realized something... If your code is too confusing to read, it’s not the comments that need fixing... it’s the code itself. Here’s what I started doing instead: ✅ I broke long methods into smaller ones. ✅ I gave variables names that made sense. ✅ I wrote logic that spoke for itself. And guess what? My code got cleaner. My team stopped asking “what does this do?”. Reviews were smoother and faster. 👉 Clear code is better than clever code. 👉 Readable logic wins over long explanations. Anyone can write complex code. But writing simple code that works? That takes real skill. If you're a junior dev reading this, focus on clarity. It’s not about how many lines you write. It’s about how easy it is for someone else to read them. What’s one code habit you had to unlearn? #softwareengineer #faithwilkinsel

After Training a group of Embedded C programmers TDD, we usually have to deal with the fact that most their development work involves existing code. We have to go from the training environment and put the ideas in existing code. My Legacy Code Workshop is where we transition from the ideal training environment to the reality of adding tests to the code that is paying the bills. In the workshop, we get the test environments set up and write a single test case to prove the test runner is under our control (pass a test, fail a test). After that the fun begins. Embedded C/C++, with target HW and RTOS dependencies, can be very hard to drag into the test environment. Often people want to give up after about 15 minutes. Sorry, that is not an option if I am there. We choose a function to call, and start pulling the code into the test environment one build error at a time. We look at the first error, solve it, then continue. By focusing on only one error at a time, we find the natural order to solve the problem that "this code is not in the test environment". Usually, the code under test is not designed to be tested, and knows too much about the target system. So, build errors are expected and can be discouraging. Naturally, we first must track down header files dependencies, with an intermediate goal of compiling production code header file in the test case. Sometimes we also bump into vendor specific compiler problems, like non-standard header files for sizing datatypes and keywords that give access to hardware registers. Once the test case compiles, we celebrate. Then we add the production code to the test build. Now we get to chase compile problems again. Eventually we get to linker errors, another milestone to celebrate. With the code under test's linker errors, we must decide do we want the real depended upon code or a test-stubs. My legacy-build script makes the choice easy for C code. The script will plug each external dependency with an exploding-fake. An exploding-fake is a test-stub that announces the function's name and fails the test. Now we can run the code and guess what, it explodes on the first call to an exploding-fake. Decision time: should we add the real depended upon code, or make a better fake? On the first test's encounters with exploding-fakes, we keep the fake dumb, hard code a return value and let the test run. Eventually, the code builds and we have a test that is executing a path through the function we called. The main frustration in the process is dealing with compiler and linker problems. Once those are solved, we turn our attention to designing tests that force the code through one path at a time, making test-subs smarter as needed. That first test is expensive. The next tests are a lot cheaper. We consider the cost of adding that first test, the cost of doing business. It is a cost associated with the change we are about to make.

Forget bugs. Fragile dependencies are the real system killers. One tiny change shouldn’t break ten other parts of your system. Yet it happens all the time. Not because of bad code, but because of "bad connections". Here’s how to stop the silent sabotage. 1. Follow the Law of Demeter: objects talk only to their friends, never strangers. 2. Push logic to the right place. Let each class own its responsibility. 3. Rely on interfaces + dependency injection instead of hardcoding dependencies. This isn’t theory. It’s the difference between code you fear touching and code that’s safe to evolve. 👉 Read the article here: https://lnkd.in/eMVd9cRJ Question for you: What’s the worst dependency chain you’ve ever had to untangle?

Bad code doesn’t show up overnight. It’s the result of a broken code review culture. It’s the result of months or years of speed over quality. And no, focusing on small things like, “Move this hardcoded string to a constant,” isn’t enough. Code reviews should be where growth happens: • Refactor for clarity. • Catch edge cases early. • Challenge design decisions. • Improve tests, not just add them. • Reinforce clean principles like DRY. When done right, code reviews improve not just the code but the entire team. Thoughts?