Version Control Systems in Engineering

Recently, I posted about how I use Git version control for my TIA Portal projects. You can also use the TIA Portal built-in Git connector. It has pros and cons. I don’t really use it, but you might find it interesting. Here is how. - Create a separate folder for your Git repo (not inside the TIA project). - Create a Git repo in this folder (git init C:\folder_name or use Git GUI). - In TIA → Version control interface (VCI): create a workspace → Configure workspace → point to the repo. Before V20 you needed the Git connector add-in; V20 supports it natively. - Drag your PLC from the project tree into the workspace. This adds your PLC project to the repo scope. - If objects are up to date, the status column is green. When objects change, changed and related ones show blue‑gray. Changed items get || in Action. Click it → Export. Then click Sync to update the repo. Important: VCI only stages exports. You still commit in Git (CLI or GUI). To restore a commit: checkout in Git, then Import in VCI. The old Git connector UI was confusing/buggy for me; native Git is simpler. Why use built‑in Git support if you still need Git anyway, instead of “just Git the TIA project folder”? Because “Git the whole project folder” runs into: - Binary File Format. TIA projects are mostly binary. - Opaque to Git — you can’t see what changed. - Git can’t merge binary conflicts. - Commits bloat the repo (big files stored again). Unreadable Diffs - One small ladder change flips the whole binary file. Git shows “Binary files differ” — useless for review. - Merge Conflicts Hard to Resolve Two engineers can’t reliably merge different areas of a binary file. You may need to manually recreate changes. - No Real Code Review PRs can’t show logic diffs. Can’t comment on specific rungs/FBs. Weak audit trail. What VCI Actually Does VCI converts program blocks to text (XML for ladder; SCL stays plain text) and organizes them by project structure. That’s the game‑changer: Text-based: readable diffs. Granular: each OB/FB/FC/DB/UDT/tag list is its own file → only changed files commit. Mergeable: engineers can work on different blocks; Git merges cleanly unless same block edited. Code review friendly: PRs show actual logic changes; team comments; proper history. Smaller repo: only changed XML/text files per commit, not a 500MB project. Disadvantages Extra steps in TIA (Export/Sync + commit in Git). VCI versions OBs/FBs/FCs/DBs/tags/UDTs, but not full project, hardware, HMIs. My workaround: for milestones, I create a TIA project archive and store it in OneDrive/SharePoint (versioned). VCI covers day‑to‑day code changes. I personally still use Git directly in the project folder. But now that VCI works natively in TIA V20, I may switch to this interface plus SharePoint archives — it covers my version control needs without the old add‑in. #otomakeit #efficiency #industrialautomation #controlsystems #controlpanel #Siemens #PLC

⭐ Ignition 8.3 Feature Highlight: Version Control with Git ⭐ One of the most powerful updates in Ignition 8.3 is that all configuration is now stored as clean, human-readable JSON files. This means Ignition projects are fully compatible with modern source control systems like Git. No more opaque binary files—just transparent, trackable configurations. Developers and IT teams can now bring the same best practices from software engineering into Ignition projects. 🚀 What this unlocks: - Full version control & change tracking of Ignition’s configuration - Seamless collaboration with Git for parallel development, conflict resolution, and code reviews - DevOps automation and CI/CD workflows - Better traceability and accountability across teams - Easier IT management and simplified compliance (including 21-CFR-11) 👍 The Benefits: - Complete visibility into changes - Stronger development collaboration - Automated flows and DevOps enablement - Enhanced regulatory compliance Ignition 8.3 takes configuration management to the next level—making your systems more agile, auditable, and future-ready. Inductive Automation #ignition #travisignitionfeature

📢 Git Isn't Just for Developers! After implementing Git for our network configuration management, I'm convinced every network team should be using version control. Here's why: ✅ Track configuration changes across your entire network infrastructure ✅ Roll back to previous configurations when something breaks ✅ Create "golden configs" for consistent device deployments ✅ Document WHY changes were made, not just what changed ✅ Collaborate without overwriting each other's work ✅ Automate validations and testing before configs go live ✅ Create branches to test configuration changes before production Gone are the days of "who changed this config?" and "where's the backup from last month?" If your network team is not using GIT you're missing out! Let me know who is taking advantage of version control from a netops perspective! #txfiber #deepnetworks #git #versioncontrol #telecom #broadband #configuration #changes #netops #operations #engineering #gitlab #netdevops #networkengineering #datacenters #southtexas #letsgo

#Day105 Why is Versioning Important in DevOps? 1. Traceability: Helps track specific changes or updates in code, configurations, or artifacts. 2. Collaboration: Ensures multiple teams can work on the same project without conflicts. 3. Reproducibility: Facilitates the ability to reproduce a specific state of the application for debugging, testing, or deployment. 4. Rollbacks: Makes it easier to roll back to a stable version in case of failures. 5. Automation: Enables tools to automatically identify and deploy the correct versions in CI/CD pipelines. Types of Versioning in DevOps 1. Code Versioning: • Managed using tools like Git, SVN, or Mercurial. • Tracks changes to source code over time. • Example: Git commits with unique hashes or version tags like v1.2.3. 2. Artifact Versioning: • Artifacts (e.g., binaries, container images) are assigned versions when they are built. • Versioning ensures that the right artifacts are deployed to production. • Example: Container image tags (myapp:v1.0) or package versions (1.0.0 in PyPI). 3. Infrastructure Versioning: • Uses Infrastructure as Code (IaC) tools like Terraform, CloudFormation, or Ansible. • Tracks changes in infrastructure configurations. • Example: Storing infrastructure definitions in version-controlled repositories. 4. API Versioning: • Assigns version numbers to APIs to manage backward compatibility and changes. • Example: GET /v1/users vs. GET /v2/users. Best Practices for Versioning in DevOps 1. Semantic Versioning (SemVer): • Format: MAJOR.MINOR.PATCH (e.g., 1.2.3). • MAJOR: Breaking changes. • MINOR: New features, backward-compatible. • PATCH: Bug fixes, backward-compatible. • Example: Versioning a library (v1.0.0) or an API. 2. Git Tags: • Use meaningful Git tags (v1.0, v1.2-beta) for marking release versions in code. 3. Immutable Artifacts: • Avoid overwriting or reusing artifact versions; once built, the artifact version should never change. 4. Automate Versioning: • Use tools like GitVersion, Maven, or Gradle to automate version number generation based on commit history or build metadata. 5. Document Changes: • Maintain a CHANGELOG to record what changes are included in each version. Tools Supporting Versioning in DevOps • Git: For source code versioning. • Docker: For container image tagging (e.g., myapp:v1.0). • Artifactory/Nexus: For managing versioned artifacts. • Terraform State: Tracks infrastructure versions. • CI/CD Tools: Jenkins, GitLab CI/CD, and others often include versioning capabilities in pipelines.

A folder full of PLC backups is not version control. Almost every controls engineer has encountered files named something like: Machine_Final Machine_Final2 Machine_Final_UseThisOne Machine_Final_ActuallyUseThisOne A backup gives you a copy of the program from one point in time. It does not automatically tell you what changed, why it changed, who made the change, which version is currently running, or whether that backup has ever been tested. That traceability is the real value of version control. PLC platforms do not all fit neatly into traditional software-development workflows, but that does not remove the need for change discipline. At minimum, there should be a controlled master copy, a clear revision history, documented online edits, verified backups, and a known restoration process. The worst time to discover that nobody knows which file is correct is while production is down. Controls teams do not need to operate exactly like software companies. We should probably stop treating “I think that is the newest one” as a disaster-recovery strategy, though. #PLCProgramming #VersionControl #ControlsEngineering #IndustrialAutomation

🔄 Why Revision Control and Change Management Matters More Than Ever 🔍 In product development, change is constant—designs evolve, suppliers shift, requirements grow. But here's the kicker: the old ways of managing these changes (hello, spreadsheets and shared folders) simply don’t cut it anymore. 🚨 Why Revision Control Is Critical Revision control isn’t just about tracking edits—it’s about building a reliable system to manage product evolution. It provides full traceability, ensures consistency, and supports compliance across the lifecycle of your product. Without it, you're flying blind. 🤝 The Modern Twist: Collaborative, Multi-Team Development Modern product development involves mechanical, electrical, and software teams all working in parallel. Changes in one domain impact the others. A robust revision system must not only track changes—but synchronize them across disciplines, ensuring everyone stays aligned. 💡 How OpenBOM Makes It Work. At OpenBOM, we reimagined revision control for today’s collaborative, connected teams. Our Collaborative Workspace lets multiple contributors work on structured product data—Items, BOMs, CAD files—in real-time, with full version and revision tracking. ✅ Instant visibility into updates ✅ Baseline snapshots for audit and compliance ✅ Structured ECO workflows to manage formal change With OpenBOM, you're managing a virtual collaborative data space where users can make changes simultaneously and once not just managing revisions—you’re building a connected digital thread across design, engineering, and manufacturing. 📘 Read the full article here [link in the comments] 🔁 Interested to discuss how to support mechanical, electronics, and software teams to work together and control changes? Let's talk. #PLM #PDM #RevisionControl #DigitalThread #OpenBOM #Collaboration #Engineering #Manufacturing #ProductDevelopment #ChangeManagement