How to Implement Best Coding Practices

🚨 When transformation logic is spread all over the repository, it becomes a nightmare to modify, debug, and test. This scattered approach leads to duplicated code, inconsistencies, and a significant increase in maintenance time. Developers waste precious hours searching for where transformations occur, leading to frustration and decreased productivity. 🔮 Imagine having a single place to check for each column's transformation logic—everything is colocated and organized. This setup makes it quick to debug, simple to modify, and easy to maintain. No more digging through multiple files or functions; you know exactly where to go to understand or change how data is transformed. 🔧 The solution is to create one function per column and write extensive tests for each function. 👇 1. One Function Per Column: By encapsulating all transformation logic for a specific column into a single function, you achieve modularity and clarity. Each function becomes the authoritative source for how a column is transformed, making it easy to locate and update logic without unintended side effects elsewhere in the codebase. 2. Extensive Tests for Each Function: Writing thorough tests ensures that each transformation works as intended and continues to do so as the code evolves. Tests help catch bugs early, provide documentation for how the function should behave, and give you confidence when making changes. By organizing your code with dedicated functions and supporting them with robust tests, you create a codebase that's easier to work with, more reliable, and ready to scale. --- Transform your codebase into a well-organized, efficient machine. Embrace modular functions and comprehensive testing for faster development and happier developers. #CodeQuality #SoftwareEngineering #BestPractices #CleanCode #Testing #dataengineering

You inherit someone else’s bioinformatics code. No comments. No structure. Variable names like x1, foo, temp2. And now it’s your problem. Let’s talk about that experience—and how to do better. 1/ Ever opened someone’s script and felt instant regret? No README No comments Hard-coded paths Copy-pasted blocks No functions You’re not alone. Code without structure is like a freezer full of unlabelled tubes. Sure, it runs. But good luck figuring out what anything does. 3/ Bad practices hurt you the most. Even if you wrote the code. You: “I’ll remember this later.” Also you (6 weeks later): “Who wrote this garbage?” Still you. 4/ On the flip side: Well-structured code feels like a gift. Functions are defined. Comments explain the logic. Each section is modular. You can re-use it. You can trust it. 5/ Here’s what I’ve learned from writing and inheriting messy code: Bad code punishes future you. Good code rewards collaborators. 6/ What are some good coding practices in bioinformatics? Use clear variable names Comment your logic, not just what each line does Break repetitive steps into functions Keep a README and usage example Use relative paths and config files 7/ Avoid this: x1 <- read.table("data.txt") temp2 <- x1[which(x1[,3] > 10), ] Prefer this: expression_data <- read.table("data.txt", header=TRUE) high_expr <- subset(expression_data, expression > 10) Make it obvious what’s happening. 8/ Turn repeated blocks into functions: filter_by_threshold <- function(data, column, threshold) { subset(data, data[[column]] > threshold) } Now your code is DRY (Don’t Repeat Yourself) and reusable. 9/ Keep outputs organized: mkdir -p results/qc mkdir -p results/plots If your outputs are sprinkled across your desktop, it’s time to rethink. 10/ Bonus: write a run_pipeline.sh that chains all your steps. Use snakemake or nextflow if it gets too big. Even a bash script with clear comments beats scattered commands. 11/ Want to learn how to write better code? Read other people’s good code. You’ll learn tricks no tutorial teaches. 12/ Good code is a form of respect. For yourself. For your collaborators. For the person who inherits your project next. Write like someone else has to read it. Because they will. 13/ Bioinformatics isn’t just about solving problems. It’s about communicating how you solved them. Your code is your paper in progress. Write it like you’re proud of it. I hope you've found this post helpful. Follow me for more. Subscribe to my FREE newsletter chatomics to learn bioinformatics https://lnkd.in/erw83Svn

🚨 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!

Every developer has an opinion. But, the software you build shouldn’t look that way. Every software team should agree on a preferred way to build software and stick to it. The ultimate goal is to have a software system that is so consistent, it looks like it was built by a single developer. It's a great way to: - Enforce architectural decisions - Ensure security and audit tracking - Increase development efficiency - Improve maintainability - Reduce mistakes How? - Have a well-defined technology stack: the technologies your team uses to build software should be well understood and easy to use. The base technologies should be easy to extend when necessary. - Follow well-known patterns: published patterns are well understood making it quick and easy for developers to grasp the idea and use them. Don't make it a contest for how many patterns you can use, but certainly use them when it makes sense. - Eliminate boiler-plate code whenever possible: boiler-plate is repetitive code that gets copied throughout the codebase increasing complexity. Create utilities or a framework that handles the common behavior. - Automate cross-cutting behaviors: these are the repetitive behaviors like security, performance timing, auditing, trace logging, etc, that always apply. Some basic level of these behaviors should be handled automatically without the need for a developer to explicitly code anything. - Clearly define responsibilities: have a clearly defined architecture and project structure. Developers should understand where things like models, repositories, controllers, configuration files, etc belong. Leaving this up to each individual guarantees a mess. - Make it easy to write tests and enforce test coverage: if you want tests written, it better be easy to write them. Most developers don't enjoy writing tests and will come up with any excuse not to. Enforce test coverage with tools to make sure developers don't slip up. - Analyze the code for best practices: this is done through static analysis tools that check things like code structure and conventions. This should be automatically performed during a build to ensure it happens. So remember… Every developer has an opinion, but your software system should look like they all agree. #softwareengineering #softwaredevelopment #coding

Here at Avantsoft I've had the chance to follow over 100 projects from inception to completion and here are a few important lessons I've learnt in developing good maintainable code: 1 - Be consistent! Especially in large codebases, attempt to keep your coding standards exactly the same everywhere. If X is done with a helper in previous parts of the code, use the helper in new parts of the code. If you use operation classes, use operation classes everywhere. etc 2 - Be careful with DRY. This one may go against some best practice guides: Don't generalize your code too early. In some cases it is better to refactor later than end up with weird abstractions that will stop making sense when business needs inevitably shift. Take time to fully understand the business and how it may evolve before abstracting. 3 - Write excessive amounts of automated tests. Everything no mater how trivial should be tested at the usage layer (integration more than unit test). Every API should have tests simulating every single possible scenario. You will thank yourself when you need to update something 6 months later. 4 - Plan before doing! It is better to spend 3 months planning and 3 months executing than 6 months just coding. There is even a chance (albeit small) the project ends in the same amount of time, however, the cost will decrease and quality will be substantially higher if you take the time to plan everything first. #softwareengineering #softwaredevelopment #development #software