Methodologies & Practices Glossary
category: General
tags: glossary, methodologies, agile, devops, practices
Agile
What it is: Set of principles and practices for software development that emphasizes collaboration, flexibility, and rapid iteration.
Why it matters: Agile helps teams respond to changing requirements, deliver value faster, and improve product quality through continuous feedback and adaptation.
Core values (Agile Manifesto):
- Individuals and interactions over processes and tools
- Working software over comprehensive documentation
- Customer collaboration over contract negotiation
- Responding to change over following a plan
Key principles:
- Customer satisfaction through early and continuous delivery
- Welcome changing requirements even late in development
- Deliver working software frequently (weeks rather than months)
- Business people and developers must work together daily
Common frameworks:
- Scrum - Most popular, uses sprints and specific roles
- Kanban - Visual workflow management with continuous flow
- Lean - Focus on eliminating waste and maximizing value
- Extreme Programming (XP) - Engineering practices focus
When you'll use it: Most modern software development teams use some form of Agile methodology.
Scrum
What it is: Agile framework that organizes work into time-boxed iterations called sprints, with specific roles, events, and artifacts.
Why it matters: Scrum provides structure for Agile development, helping teams collaborate effectively and deliver working software regularly.
Key roles:
- Product Owner - Defines requirements and priorities
- Scrum Master - Facilitates process and removes obstacles
- Development Team - Cross-functional group that builds the product
Scrum events:
- Sprint - Time-boxed iteration (usually 2-4 weeks)
- Sprint Planning - Plan work for upcoming sprint
- Daily Scrum - Brief daily coordination meeting
- Sprint Review - Demonstrate completed work to stakeholders
- Sprint Retrospective - Team reflects on process improvements
Scrum artifacts:
- Product Backlog - Prioritized list of features and requirements
- Sprint Backlog - Work selected for current sprint
- Increment - Working product at end of sprint
Benefits:
- Predictable delivery - Regular sprint cycles
- Transparency - Clear visibility into progress
- Adaptability - Can change direction between sprints
- Team empowerment - Self-organizing teams
When you'll use it: Teams that want structured Agile process with regular delivery cycles.
DevOps
What it is: Cultural and technical movement that emphasizes collaboration between development and operations teams to deliver software faster and more reliably.
Why it matters: DevOps breaks down silos between development and operations, enabling faster delivery, higher quality, and better collaboration.
Core principles:
- Culture of collaboration - Shared responsibility for outcomes
- Automation - Reduce manual, error-prone processes
- Measurement - Use metrics to drive improvements
- Sharing - Knowledge and tools across teams
Key practices:
- Continuous Integration/Continuous Deployment - Automated build and deployment
- Infrastructure as Code - Manage infrastructure like software
- Monitoring and logging - Comprehensive system observability
- Configuration management - Automated system configuration
Popular tools:
- Version control - Git, GitHub, GitLab
- CI/CD - Jenkins, GitHub Actions, Azure DevOps
- Configuration management - Ansible, Puppet, Chef
- Containerization - Docker, Kubernetes
- Monitoring - Prometheus, Grafana, ELK stack
Benefits:
- Faster time to market - Reduced deployment friction
- Higher quality - Automated testing and deployment
- Better reliability - Infrastructure as code and monitoring
- Improved collaboration - Shared tools and processes
When you'll use it: Any organization looking to improve software delivery speed and quality.
Lean
What it is: Methodology focused on maximizing customer value while minimizing waste in processes and resources.
Why it matters: Lean helps organizations become more efficient by eliminating activities that don't add value, leading to faster delivery and lower costs.
Core principles:
- Identify value - What do customers actually want?
- Map value stream - Understand the flow of work
- Create flow - Eliminate bottlenecks and delays
- Establish pull - Work is pulled by customer demand
- Pursue perfection - Continuous improvement
Types of waste (Muda):
- Overproduction - Building more than needed
- Waiting - Idle time between activities
- Transportation - Unnecessary movement of materials
- Overprocessing - More work than customer values
- Inventory - Excess work in progress
- Motion - Unnecessary movement of people
- Defects - Rework and corrections
Lean tools:
- Value stream mapping - Visualize entire process flow
- Kaizen - Continuous small improvements
- 5S - Workplace organization system
- Kanban - Visual workflow management
When you'll use it: Any process that can benefit from waste reduction and efficiency improvements.
Kanban
What it is: Visual workflow management method that uses boards and cards to represent work items and their progress through different stages.
Why it matters: Kanban provides visibility into work flow, helps identify bottlenecks, and enables teams to optimize their processes continuously.
Core principles:
- Visualize workflow - Make work and process visible
- Limit work in progress - Focus on finishing before starting new work
- Manage flow - Optimize the movement of work items
- Make policies explicit - Clear rules about how work flows
- Implement feedback loops - Regular review and improvement
- Improve collaboratively - Evolve process through experimentation
Kanban board structure:
- Columns - Represent different stages of work (To Do, In Progress, Done)
- Cards - Individual work items or tasks
- WIP limits - Maximum number of items allowed in each column
- Swimlanes - Horizontal divisions for different types of work
Benefits:
- Improved visibility - Everyone can see status of all work
- Better flow - Identify and resolve bottlenecks
- Flexibility - Easy to adapt to changing priorities
- Continuous improvement - Regular retrospectives and adjustments
When you'll use it: Teams that want visual workflow management with continuous flow rather than fixed iterations.
Test-Driven Development (TDD)
What it is: Software development practice where tests are written before the code they test, following a red-green-refactor cycle.
Why it matters: TDD improves code quality, design, and confidence in changes by ensuring comprehensive test coverage and forcing developers to think about requirements upfront.
TDD cycle:
1. Red - Write a failing test for desired functionality
2. Green - Write minimal code to make the test pass
3. Refactor - Improve code while keeping tests passing
4. Repeat - Continue cycle for next piece of functionality
Benefits:
- Better design - Forces thinking about interfaces and requirements
- High test coverage - Tests written for all functionality
- Confidence in changes - Regression testing catches breaking changes
- Documentation - Tests serve as examples of how code should work
- Debugging ease - Smaller, focused tests make issues easier to isolate
Best practices:
- Write smallest possible test - Focus on one behavior at a time
- Keep tests simple - Tests should be easy to understand
- Fast execution - Tests should run quickly for fast feedback
- Independent tests - Tests shouldn't depend on each other
When you'll use it: Any development where code quality and maintainability are important priorities.
Code Review
What it is: Systematic examination of source code changes by team members before merging into the main codebase.
Why it matters: Code reviews catch bugs, ensure code quality, share knowledge across the team, and maintain coding standards.
Review process:
1. Developer creates pull request - Proposes changes for review
2. Reviewers examine code - Check for issues and improvements
3. Feedback provided - Comments and suggestions for changes
4. Developer addresses feedback - Makes requested changes
5. Approval and merge - Code integrated into main branch
What reviewers look for:
- Correctness - Does the code work as intended?
- Style and conventions - Follows team coding standards?
- Performance - Any efficiency issues or optimizations?
- Security - Potential vulnerabilities introduced?
- Maintainability - Is code easy to understand and modify?
- Testing - Adequate test coverage for changes?
Best practices:
- Keep changes small - Easier to review and less risky
- Be constructive - Suggest improvements, don't just criticize
- Review promptly - Don't let reviews block progress
- Use automation - Linters and formatters catch style issues
- Focus on important issues - Don't nitpick minor style preferences
When you'll use it: Any team development environment. Essential for maintaining code quality.
Pair Programming
What it is: Software development technique where two programmers work together at one workstation, with one writing code while the other reviews.
Why it matters: Pair programming improves code quality, shares knowledge, and can actually increase productivity despite using two developers.
Roles:
- Driver - Types code and focuses on tactical implementation
- Navigator - Reviews code, thinks strategically, suggests improvements
- Role switching - Partners regularly switch roles
Benefits:
- Higher code quality - Real-time code review catches issues immediately
- Knowledge sharing - Both developers learn from each other
- Reduced debugging time - Fewer bugs make it into codebase
- Better design - Two perspectives lead to better solutions
- Team collaboration - Improves communication and teamwork
When it works best:
- Complex problems - Benefit from multiple perspectives
- Knowledge transfer - Senior developer mentoring junior
- Critical code - High-importance features that need extra attention
- Learning new technologies - Shared exploration of unfamiliar tools
When you'll use it: Selectively for complex problems, mentoring, or critical code sections.
Continuous Integration (CI)
What it is: Development practice where developers frequently integrate code changes into shared repository, with automated builds and tests.
Why it matters: CI catches integration issues early, provides fast feedback to developers, and maintains a always-deployable main branch.
CI process:
1. Developer commits code - Changes pushed to version control
2. Automated build triggered - Code compiled and packaged
3. Automated tests run - Unit, integration, and other tests
4. Results reported - Pass/fail status communicated to team
5. Issues addressed - Failed builds fixed immediately
Key practices:
- Frequent commits - Integrate changes multiple times per day
- Automated builds - No manual compilation steps
- Comprehensive testing - High confidence in build quality
- Fast builds - Quick feedback to developers
- Fix broken builds immediately - Maintain clean main branch
CI tools:
- Jenkins - Open-source automation server
- GitHub Actions - Integrated with GitHub repositories
- GitLab CI/CD - Built into GitLab platform
- Azure DevOps - Microsoft's CI/CD solution
- CircleCI - Cloud-based CI/CD platform
When you'll use it: Every professional software development team should implement CI.
Continuous Deployment (CD)
What it is: Extension of continuous integration where every code change that passes automated tests is automatically deployed to production.
Why it matters: CD enables faster delivery of features to users, reduces deployment risk through automation, and provides rapid feedback on changes.
Deployment pipeline stages:
1. Source control - Code changes trigger pipeline
2. Build - Compile and package application
3. Test - Automated testing at multiple levels
4. Staging deployment - Deploy to production-like environment
5. Production deployment - Automated release to users
Deployment strategies:
- Blue-green deployment - Switch between two identical environments
- Rolling deployment - Gradually replace old version with new
- Canary deployment - Deploy to small subset of users first
- Feature flags - Deploy code but control feature activation
Requirements for successful CD:
- Comprehensive test suite - High confidence in automated tests
- Monitoring and alerting - Detect issues quickly
- Rollback capability - Quick recovery from problems
- Infrastructure automation - Consistent, repeatable deployments
When you'll use it: Teams with mature CI practices and comprehensive testing who want to maximize deployment frequency.