Program Structuring Techniques

If your PLC program looks like a tornado of rungs and tags… it’s time to talk code organization. One of the most overlooked (but most important) skills in automation is how you structure your logic. A good program isn’t just functional, it’s readable, maintainable, and scalable. Here’s how I like to structure mine: READ INPUTS FIRST At the top of the scan, I read and preprocess all inputs. That means: - Scaling analog values - Bit summing statuses - Conditioning values that come in externally to the respectivecomponent This makes sure everything below is based on reliable, real-time, and clean data. CONTROL LOGIC IN THE MIDDLE This is where the brain lives, sequences, states, fault conditions, timers, and logic that drives the system. I group this by function or subsystem (motors, valves, conveyors, etc.), often with clearly labeled rungs or section headers. OUTPUTS LAST At the bottom, I drive outputs based on the control decisions made above. No logic calculations down here, just clean writes like: MotorStart := Motor1.RunCommand; Minimize the logic out of the output section. It should be transparent. BIT GROUPING = SANITY SAVER If you’ve got the same 6 conditions checked 20 times across the program, wrap them into a single BOOL like SystemReady. Then everywhere else, you just check: IF SystemReady AND AutoMode THEN This avoids copy-paste errors, simplifies debugging, and makes logic more readable. REUSABILITY & NAMING - Use descriptive tag names. - Use UDTs and AOIs to encapsulate data/logic for repeated devices. - Group tags in structured ways: Motor1.b Running, Motor1.Fault, etc. Make it easy to search, comment, and troubleshoot. WHY IT MATTERS: - Faster startup & commissioning - Easier troubleshooting in the field - Smoother handoffs to other engineers - Less chance of “spaghetti logic” biting you later Clean logic doesn’t just help the machine run better. It helps the people who work on it. What’s your go-to structure when building out PLC code? #PLCProgramming #StructuredText #LadderLogic #ControlsEngineer #CodeOrganization #AutomationEngineering #IndustrialAutomation #FunctionBlocks #SmartManufacturing #SystemDesign #EngineeringBestPractices #innovation #technology #futurism #engineering

S.O.L.I.D principles explained with examples: 𝐒: 𝐒𝐢𝐧𝐠𝐥𝐞 𝐑𝐞𝐬𝐩𝐨𝐧𝐬𝐢𝐛𝐢𝐥𝐢𝐭𝐲 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 (𝐒𝐑𝐏) - A class should have one, and only one, reason to change. Example: A UserManager class that handles user authentication, user profile management, and sending email notifications violates SRP because it has multiple responsibilities. To fix this, we can separate these responsibilities into different classes: UserAuthenticator, UserProfileManager, and EmailNotifier. 𝐎: 𝐎𝐩𝐞𝐧/𝐂𝐥𝐨𝐬𝐞𝐝 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 (𝐎𝐂𝐏) - Software entities (classes, modules, functions, etc.) should be open for extension but closed for modification. Example: Modifying a ShapeCalculator class every time you add a new shape violates OCP. To fix this, use a Shape base class with specific shape classes (e.g. Rectangle, Triangle). Now you can add new shapes without changing the original calculator code. 𝐋: 𝐋𝐢𝐬𝐤𝐨𝐯 𝐒𝐮𝐛𝐬𝐭𝐢𝐭𝐮𝐭𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 (𝐋𝐒𝐏) - Objects of a superclass should be replaceable with objects of its subclasses without affecting the correctness of the program. Example: A bicycle class derived from base class Vehicle shouldn't have a start_engine method – this breaks LSP that child classes should work seamlessly in place of their parent class. To fix this, use a general start method in the Vehicle class. Now, instances of Car and Bicycle can be safely substituted for instances of Vehicle without any unexpected behavior or errors. 𝐈: 𝐈𝐧𝐭𝐞𝐫𝐟𝐚𝐜𝐞 𝐒𝐞𝐠𝐫𝐞𝐠𝐚𝐭𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 (𝐈𝐒𝐏) - Clients should not be forced to depend on interfaces they don't use. Example: Imagine a MediaPlayer interface forcing all players to handle both audio and video, even if unnecessary. This violates ISP. To fix this, create smaller interfaces like AudioPlayer and VideoPlayer. This way, classes only implement what they need, improving code flexibility and avoiding unnecessary dependencies. 𝐃: 𝐃𝐞𝐩𝐞𝐧𝐝𝐞𝐧𝐜𝐲 𝐈𝐧𝐯𝐞𝐫𝐬𝐢𝐨𝐧 𝐏𝐫𝐢𝐧𝐜𝐢𝐩𝐥𝐞 (𝐃𝐈𝐏) - High-level modules should not depend on low-level modules; both should depend on abstractions. Example: Consider an EmailService class that directly depends on a concrete GmailClient class. This violates DIP. To fix this, introduce an EmailClient interface. Now, both EmailService and specific providers (GmailClient, OutlookClient, etc.) depend on the abstraction, making your code adaptable to different email providers. Read the full article (with code): https://lnkd.in/dNZsRxQ6

𝗦𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 Software design defines a system's architecture to meet requirements, creating blueprints for development teams. Over time, reusable architecture patterns have emerged that reduce complexity, increase maintainability, and speed development. The most crucial software architecture patterns are: 𝟭. 𝗟𝗮𝘆𝗲𝗿𝗲𝗱 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲: Divides applications into logical layers (Presentation, Business, Data Access) with specific responsibilities. Promotes separation of concerns and easier maintenance. 𝟮. 𝗠𝗶𝗰𝗿𝗼𝘀𝗲𝗿𝘃𝗶𝗰𝗲𝘀: Decomposes applications into small, independent services communicating via APIs. Each implements a single business capability and can be independently deployed, enabling team autonomy and continuous delivery. 𝟯. 𝗘𝘃𝗲𝗻𝘁-𝗗𝗿𝗶𝘃𝗲𝗻: Uses events for asynchronous communication between components. The system doesn't wait for event handling to complete before continuing, making it ideal for real-time applications requiring high scalability. 𝟰. 𝗦𝗽𝗮𝗰𝗲-𝗯𝗮𝘀𝗲𝗱: Uses independent "spaces" as autonomous units across multiple servers. Eliminates single points of failure in high-volume systems and overcomes data bottlenecks and network latency. 𝟱. 𝗠𝗶𝗰𝗿𝗼𝗸𝗲𝗿𝗻𝗲𝗹 (𝗽𝗹𝘂𝗴-𝗶𝗻 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲): Provides minimal core functionality with additional services as separate modules. Developers can modify components without impacting core functionality, which is ideal for applications requiring customization. 𝟲. 𝗖𝗤𝗥𝗦 (𝗖𝗼𝗺𝗺𝗮𝗻𝗱-𝗤𝘂𝗲𝗿𝘆 𝗥𝗲𝘀𝗽𝗼𝗻𝘀𝗶𝗯𝗶𝗹𝗶𝘁𝘆 𝗦𝗲𝗴𝗿𝗲𝗴𝗮𝘁𝗶𝗼𝗻): Separates read and write operations into distinct models. Improves performance and scalability in complex domains by optimizing each path independently. 𝟳. 𝗛𝗲𝘅𝗮𝗴𝗼𝗻𝗮𝗹 (𝗣𝗼𝗿𝘁𝘀 𝗮𝗻𝗱 𝗔𝗱𝗮𝗽𝘁𝗲𝗿𝘀): Isolates business logic from external concerns. Allows applications to be driven by various sources and developed independently from runtime dependencies. Selecting the correct pattern depends on your specific requirements and constraints. Real-world applications often combine multiple patterns to address different aspects of system design. #technology #softwareengineering #programming #techworldwithmilan #softwarearchitecture

PLC Code Planning: 1. Define sequences: Before writing code, define the sequences and their triggers. 2. Use a programming ladder: Start building the program with a programming ladder. 3. Manage sequences: Work on sequences in manageable sizes. 4. Make it readable: Ensure sequences are clear and readable. 5. Avoid scattered code: Make sure the code isn't scattered. 6. Return to initial state: The program should be able to return to its initial state so it can run again. 7. Use a standard naming convention: Use a standard naming convention for inputs, outputs, variables, routines, and tags. 8. Use descriptive names: Use descriptive and consistent names for variables, functions, and modules. Avoid generic names like "x", "y", or "temp". 9. Document the project: Document the scope, inputs and outputs, logic and functionality, tests and results, and maintenance and support.

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

“Code without tests is bad code. It doesn't matter how well-written it is; it doesn't matter how pretty, object-oriented, or well-encapsulated it is.” — Micheal C. Feathers We all know we should be writing tests for our code, but why is it so common for code bases to exist with few (or no) tests? It boils down to the fact that testing bad code is hard, and people naturally avoid hard work, so they cut corners. 🏚 Poorly-Structured vs. Well-Structured Code: This “bad code is harder to test” theory applies to large code bases, and libraries. When you have poorly structured and poorly thought-out code, that code will often hide away behaviors, have a ton of re-initialized dependencies, and won't return helpful errors or exceptions on function calls. All of these things make it hard to write tests. Well-structured, well-thought-out code that considers testing makes it easier to write tests. Well-structured code has dependencies that can be passed in and mocked. Well-structured code returns errors and exceptions and doesn't hide issues from callers. Well-structured code is easier to adopt, manage, and test. 🧐 Thinking Before Writing: Before writing any code, I like to consider how to structure it for testing, simplicity, and manageability. 🏗 Structuring a Service: After creating many services, I have a standard structure I follow. But before I start churning out code, I create an empty directory structure; this acts as a skeleton for my service. Within this skeleton, I start planning what utility packages need to be created, where I will put my business logic, where I need to pass my database connections, etc. I constantly think about how to test my service while I outline this skeleton. Will I need a database? Should I mock a database or launch one in a Docker container? How will I test the business logic? Do I need to create functional tests, can I use unit tests, or both? Which is better for what I'm building? 🧰 Structuring a Package: Within Packages, I'm always thinking about the interface. I create it first, then validate how I'd test this package with a few basic tests. If the interface is complex to test, I scrap it and start over. Initialization is one of the most essential pieces of the interface. Do I need to pass in my database dependency? Can I pass in a mock for the database? Before I touch any core logic, I ensure I have a well-structured set of tests, usually table tests. That way, as I add more code, adding a few new test cases is simple and natural. ✍️ Well-Structured Code Encourages Testing: I've written a lot of bad and occasionally some good code. What I've noticed is when someone else comes along to make contributions. Pull requests for the bad code usually require me to ask for more tests to be included. Pull requests to the good code usually have tests already included. From my experience, the better the code structure, the more testing the project will naturally have.