Software Process
104 items tagged with "software-process"
Best Practices13
IBM Garage Methodology
End-to-end practices merging agile, DevOps, and design thinking for cloud transformation.
Continuous Modernization Playbook
Iterative roadmap for refactoring, re-platforming, and replacing legacy systems using automation and AI.
Microsoft Security Development Lifecycle (SDL)
A set of security practices integrated across every phase of software development, from training and design through implementation, verification, and response.
Release Train Model
A delivery cadence where releases ship on a fixed schedule and any change not ready in time simply catches the next train, decoupling release timing from feature completion.
Behavior-Driven Development (BDD)
A collaborative practice that expresses requirements as concrete, executable examples in plain language shared by business, development, and testing.
Code Review Best Practices
Guidance for effective, fast, and respectful code review, drawn from Google's engineering practices, to improve code health over time.
Definition of Done
A shared, explicit checklist of conditions a work item must meet to be considered complete, ensuring consistent quality across a team.
Scrum Framework
Scrum is a lightweight agile framework for delivering products in short, fixed-length iterations called sprints, using empirical inspection and adaptation to manage complex work.
Kanban Method
The Kanban Method is an evolutionary approach to managing knowledge work that visualizes flow, limits work in progress, and improves delivery continuously without prescribing fixed iterations.
Lean Software Development
Lean Software Development applies Lean manufacturing principles to software, emphasizing eliminating waste, amplifying learning, deferring decisions, and delivering fast to maximize customer value.
Team Topologies
Team Topologies is a model for organizing business and technology teams using four team types and three interaction modes to optimize fast flow and reduce cognitive load.
Platform Engineering
Platform engineering builds and runs internal self-service platforms and paved roads that let product teams ship software faster with lower cognitive load and consistent guardrails.
Internal Developer Platform
An Internal Developer Platform (IDP) is the self-service product built by platform teams that gives developers golden paths to provision, build, deploy, and operate software with built-in guardrails.
Anti-Patterns26
Premature Optimization
Optimizing code or architecture before understanding actual performance requirements
Not Invented Here (NIH)
Rejecting perfectly good external solutions in favor of building custom ones
Cargo Cult Programming
Using patterns or practices without understanding why they work
Big Ball of Mud
A system with no discernible architecture, where code is haphazardly structured, tangled, and duct-taped together, making every change risky and slow.
Accidental Complexity
Complexity introduced by the solution rather than the problem — overbuilt tooling, layers, and abstractions that obscure logic that is actually simple.
Inner-Platform Effect
Building a configurable system so general it becomes a poor reimplementation of the platform it runs on, reinventing a language, database, or framework badly.
Reinventing the Wheel
Building from scratch a solved, well-supported capability — like crypto, date handling, or an ORM — instead of using a proven, maintained library or standard.
Boat Anchor
Keeping a piece of obsolete software, hardware, or a dependency that no longer serves a purpose but is retained and maintained out of inertia or sunk-cost thinking.
Dependency Hell
A tangle of conflicting, version-pinned, or transitive dependencies that makes upgrading or even installing software fragile, slow, and unpredictable.
Over-Engineering
Building more generality, flexibility, or sophistication than the problem requires, adding cost and complexity for capabilities that are never actually needed.
Premature Abstraction
Extracting abstractions before enough concrete cases exist to know what they should be, locking in the wrong shape and adding indirection that obstructs change.
Copy-Paste Programming
Duplicating blocks of code instead of factoring out shared logic, so every fix and change must be repeated across each copy, and some are missed.
Hardcoding
Embedding values that should be configurable, such as URLs, paths, credentials, and limits, directly in source, forcing code changes to adapt.
Analysis Paralysis
Overanalyzing a decision or design to the point that no decision is made and no progress occurs, trading action for endless deliberation.
Bikeshedding (Law of Triviality)
Spending disproportionate time debating trivial, easy-to-understand details while important, complex decisions receive little scrutiny.
Hero Culture
A team that depends on a few individuals heroically saving the day, rewarding firefighting over the boring, systemic work that prevents fires.
Bus Factor of One
Critical knowledge or capability concentrated in a single person, so the project halts if that person becomes unavailable.
Knowledge Silos
Information and expertise trapped within individuals or teams, blocking collaboration and forcing others to rediscover what is already known.
Water-Scrum-Fall
A hybrid where agile ceremonies are bolted onto a waterfall lifecycle, with up-front planning and big-bang release bookending a thin layer of Scrum.
Big Design Up Front (BDUF)
Specifying a complete, detailed design before any implementation begins, betting that requirements are fully known and will not change.
Gold Plating
Adding features, polish, or sophistication beyond what was requested or needed, spending effort on value no stakeholder asked for.
Technical Debt Denial
Refusing to acknowledge or pay down accumulated technical debt, treating short-term delivery speed as if it carried no compounding cost.
Rubber-Stamp Code Reviews
Approving pull requests without meaningful inspection, performing the ceremony of code review while providing none of its protective value.
Meeting Overload
Filling calendars with so many meetings that there is little uninterrupted time left for the focused work the meetings are meant to coordinate.
Blame Culture
An environment that responds to failures by finding someone to punish rather than understanding causes, driving problems underground.
Resume-Driven Development
Choosing technologies for their appeal on a resume or their hype rather than their fit for the problem, optimizing careers over systems.
Playbooks4
Strangler-Fig Modernization Program Playbook
A program for incrementally replacing a legacy system by routing functionality to new services until the legacy is fully strangled.
Tech-Debt Paydown Program Playbook
A measurable program to quantify, prioritize, and systematically pay down technical debt across a backend portfolio.
Framework Upgrade Program Playbook
A repeatable program for keeping backend frameworks current through routine, low-risk major-version upgrades across a portfolio.
Frontend Monolith Decomposition Program Playbook
A program for breaking a large single-page-app monolith into modular, independently maintainable boundaries without a full rewrite.
Checklists3
Dependency Upgrade Safety Checklist
Safety checks for upgrading application dependencies, covering semver risk, testing, security, and staged rollout.
Oracle Forms Modernization Assessment Checklist
Assess an Oracle Forms application for modernization to a modern web stack, covering inventory, business logic, and data access.
Frontend Monolith Decomposition Checklist
Plan the decomposition of a large frontend monolith into modular, independently maintainable parts before splitting it.
FAQs6
What is technical debt?
Technical debt is the implied future cost of choosing a quick or easy solution now instead of a better approach that would take longer. Like financial...
What is the test pyramid?
The test pyramid is a guideline for balancing automated tests by type and quantity. Its wide base is many fast, cheap unit tests; the middle is a smal...
What is the difference between unit, integration, and end-to-end tests?
Unit tests verify a single function or class in isolation, often with dependencies mocked, and run very fast. Integration tests check that multiple co...
What is Test-Driven Development (TDD)?
Test-Driven Development (TDD) is a practice where you write a failing automated test before writing the code that makes it pass. The cycle is 'red, gr...
What is a feature flag?
A feature flag (or feature toggle) is a configuration switch that turns functionality on or off at runtime without deploying new code. It lets teams d...
What is the difference between imperative and declarative programming?
Imperative programming describes how to achieve a result through explicit step-by-step instructions that change program state, as in a typical for-loo...
Glossaries51
Migration
The process of moving data, applications, or infrastructure from one environment to another
Lift and Shift
Moving an application to a new environment with minimal or no changes to its architecture
Replatforming
Making targeted modifications to an application to take advantage of cloud capabilities without changing core architecture
Refactoring
Restructuring existing code without changing its external behavior to improve quality and maintainability
Technical Debt
The implied cost of additional rework caused by choosing an easy solution now instead of a better approach
Strangler Fig
A migration pattern where new functionality wraps and gradually replaces the legacy system
Backward Compatibility
The ability of new versions to work with data or interfaces from older versions
Modernization
The process of updating legacy systems, applications, or infrastructure to leverage current technologies and best practices
Automation
The use of technology to perform tasks with minimal human intervention, often applied to testing, deployment, and infrastructure management
Canary Deployment
A deployment strategy that rolls out changes to a small subset of users before deploying to the entire infrastructure
Cloud Migration
The process of moving data, applications, and workloads from on-premises infrastructure to cloud-based services
Code Cleanup
The process of improving code quality by removing dead code, fixing style issues, and improving readability without changing functionality
Compatibility
The ability of systems, software, or data formats to work together without modification or special adaptation
Dark Launching
A deployment technique where new features are released to production but hidden from users, allowing testing in real conditions
Database Per Service
A microservices pattern where each service owns and manages its own database, ensuring loose coupling between services
Domain-Driven Design
A software design approach that focuses on modeling software based on the business domain and its logic
Deployment
The process of releasing and installing software applications to a target environment where they can be accessed by users
Deprecation
The process of marking features, APIs, or components as outdated and planned for removal in future versions
Digital Transformation
The integration of digital technology into all areas of a business, fundamentally changing how it operates and delivers value
Facade Pattern
A structural design pattern that provides a simplified interface to a complex subsystem, hiding its complexity from clients
Feature Toggle
A technique that allows teams to modify system behavior without changing code, enabling features to be turned on or off dynamically
Go-Live
The moment when a system, application, or migration goes into production use, marking the transition from development to operational status
Incremental Migration
A migration approach that moves systems or data in small, manageable pieces rather than all at once
Legacy Modernization
The process of updating or replacing outdated legacy systems with modern technologies to improve performance and maintainability
Lift, Tinker, and Shift
A migration approach that combines lift-and-shift with minor modifications to optimize applications for the target environment
Optimization
The process of improving system performance, efficiency, or resource utilization through code changes, configuration, or architecture modifications
Pipeline
An automated sequence of processes that move code from development through testing and into production deployment
Rehosting
A migration strategy that moves applications to a new infrastructure with minimal or no changes, also known as lift-and-shift
Sidecar Pattern
A design pattern where a helper container runs alongside the main application container to provide supporting features like logging or networking
Switchover
The process of transferring operations from one system to another, typically during migration or disaster recovery scenarios
Transition
The process of moving from one state, system, or approach to another, often describing the period during a migration
Undo
The capability to reverse changes or operations, returning a system to a previous state
Adapter Pattern
A structural design pattern that allows incompatible interfaces to work together by wrapping an object in an adapter
Anti-Corruption Layer
A pattern that isolates a system from external systems by translating between their models, preventing corruption of internal domain models
API
Application Programming Interface - a set of definitions and protocols that allows software components to communicate with each other
Blue-Green Deployment
A release strategy that maintains two identical production environments, allowing instant switching between versions with zero downtime
Breaking Change
A modification to software that causes existing functionality or integrations to stop working as expected
DevOps
A set of practices combining software development and IT operations to shorten development cycles and deliver high-quality software continuously
Interoperability
The ability of different systems, devices, or applications to connect and exchange information effectively
Parallel Run
A migration strategy where old and new systems operate simultaneously to validate the new system before full cutover
Phased Migration
A migration approach that divides the transition into distinct phases, each with specific goals and deliverables
Version Control
A system for tracking and managing changes to files and code over time, enabling collaboration and history tracking
Branching
Creating parallel lines of development in version control to work on features or fixes independently
Documentation
Written materials that describe how software works, including guides, references, and specifications
Integration
The process of combining different systems, components, or software applications to work together as a unified system
Planning
The process of defining goals, strategies, and steps to achieve successful project outcomes
Standards
Established norms, specifications, or requirements that ensure consistency and interoperability
Domain-Driven Design
Domain-driven design (DDD) is a software design approach that models software closely on the business domain, using a shared language between developers and domain experts and organizing the system around bounded contexts.
Dependency Injection
Dependency injection is a design technique in which an object receives the other objects it depends on from an external source rather than creating them itself, improving testability and decoupling.
Test-Driven Development
Test-driven development (TDD) is a software practice in which developers write a failing automated test before writing the code to make it pass, then refactor, repeating in short cycles.
Mocking
Mocking is a testing technique that replaces a real dependency with a controllable stand-in object, letting a test isolate the code under test and verify how it interacts with that dependency.