Software Engineering Practice
(Redirected from software development methodology)
Jump to navigation
Jump to search
A Software Engineering Practice is a systems engineering practice within software engineering that aims to enhance the software development process and software product quality.
- AKA: Software Development Practice, Software Engineering Method, Software Development Methodology.
- Context:
- It can typically implement Software Engineering Development Lifecycle Management through software engineering process controls and software engineering milestone tracking.
- It can typically maintain Software Engineering Code Quality Assurance via software engineering static analysis and software engineering dynamic testing.
- It can typically enforce Software Engineering Architecture Standards through software engineering design patterns and software engineering component structures.
- It can typically support Software Engineering Team Collaboration Processes via software engineering communication protocols and software engineering knowledge sharing.
- It can typically provide Software Engineering Project Risk Management through software engineering mitigation strategys and software engineering contingency planning.
- ...
- It can often establish Software Engineering Documentation Frameworks through software engineering technical writing and software engineering code documentation.
- It can often utilize Software Engineering Version Control Systems via software engineering code repositorys and software engineering branch management.
- It can often implement Software Engineering Code Review Processes through software engineering peer reviews and software engineering automated checks.
- It can often manage Software Engineering Technical Debt via software engineering refactoring strategys and software engineering code improvement.
- It can often support Software Engineering Continuous Integration through software engineering build automation and software engineering deployment pipelines.
- ...
- It can range from being a Software Engineering Best-Practice to being a Software Engineering Past-Practice, depending on its software engineering current effectiveness.
- It can range from being a Development Software Engineering Practice to being a Production Software Engineering Practice, depending on its software engineering lifecycle stage.
- It can range from being an Individual Software Engineering Practice to being an Organization Software Engineering Practice, depending on its software engineering adoption scope.
- It can range from being a Project Software Engineering Practice to being an Enterprise Software Engineering Practice, depending on its software engineering implementation scale.
- It can range from being a Traditional Software Engineering Practice to being an AI-Enhanced Software Engineering Practice, depending on its software engineering technology integration.
- ...
- It can influence the choice of Programming Paradigms such as object-oriented programming, functional programming, or procedural programming.
- It can emphasize following Security Programming Practices through software engineering vulnerability prevention.
- It can incorporate Testing Strategys via software engineering unit tests and software engineering integration tests.
- It can establish Release Processes through software engineering deployment protocols and software engineering rollback procedures.
- It can implement Monitoring Systems via software engineering performance tracking and software engineering error logging.
- ...
- Examples:
- Testing and Quality Assurance Software Engineering Practices, such as:
- Unit Testing Practices: A practice that involves software testing individual units of source code to ensure they function as intended.
- Test-Driven Development (TDD) Methodology: A practice that involves writing test cases first and then developing software to pass those tests.
- Automated Acceptance Testing Practices / Specification by Example Practices: Practices that use examples and automatable tests for specifying and verifying software requirements.
- Chaos Engineering Practices: A practice that involves testing the resilience of software systems by introducing chaos or unexpected conditions.
- Software Reliability Engineering Practices: A practice focused on designing and developing software systems that are reliable, maintainable, and fault-tolerant.
- Integration and Deployment Software Engineering Practices, such as:
- Continuous Integration Practices: A practice that involves regularly merging all developers' working copies into a shared mainline.
- Continuous Deployment Practices: A practice that ensures every change to the software passes all stages of the production pipeline.
- Feature Branching Strategy Practices: Facilitates parallel development by creating separate branches for each new feature.
- Pull Request Workflow Practices: Enhances code quality and team collaboration by reviewing and discussing code changes.
- Infrastructure and Configuration Management Software Engineering Practices, such as:
- Infrastructure as Code Practices: A practice that involves managing and provisioning computing infrastructure through machine-readable definition files.
- Configuration Management Practices: A practice that involves automating the configuration of software and systems.
- Policy as Code Practices: A practice where organizational policies are encoded within the software and enforced programmatically.
- AI-Enhanced Software Engineering Practices, such as:
- AI Development Practices, such as:
- Responsible AI Development Practice implementing responsible ai development principles.
- AI Model Version Control Practice managing AI model artifacts and AI model lineage.
- AI Testing Practice validating AI model performance and AI model fairness.
- AI Safety-by-Design Practice integrating AI safety requirements from inception.
- AI-Assisted Coding Practices, such as:
- ML Engineering Practices, such as:
- MLOps Practice implementing ml model deployment and ml model monitoring.
- Feature Engineering Practice creating ml feature pipelines and ml feature stores.
- ML Pipeline Automation Practice orchestrating ml workflows and ml experiment tracking.
- AI Development Practices, such as:
- Agile Software Engineering Practices, such as:
- Agile Programming Practices: Practices centered on iterative development, continuous feedback, and adaptability.
- Scrum Framework Practices: A practice within Agile methodology focusing on time-boxed iterations (sprints).
- Kanban Practices: A practice involving visual boards to manage work and limit work-in-progress.
- Extreme Programming (XP) Practices: A practice focusing on enhancing software quality and responsiveness.
- Collaboration and Process Improvement Software Engineering Practices, such as:
- Collective Code Ownership Practices: A practice that allows the entire team to take responsibility for the codebase.
- Communication and Collaboration Practices: A practice that emphasizes effective communication among team members.
- Operate What You Build Practices: A practice in which developers are responsible for operating the software they build.
- Platform Engineering Practices: A practice that involves designing and constructing robust and scalable platforms.
- Monitoring and Analysis Software Engineering Practices, such as:
- Monitoring and Logging Practices: A practice that involves continuously tracking application and infrastructure performance.
- Observability Practices: A practice implementing comprehensive system visibility through metrics, logs, and traces.
- Site Reliability Engineering Practices: A practice applying software engineering principles to infrastructure and operations problems.
- Design and Architecture Software Engineering Practices, such as:
- Software Design Pattern Practices: A practice that involves applying common solutions to recurring design problems.
- Domain-Driven Design (DDD) Methodology: A practice centering the software design around the core domain.
- Service-Oriented Architecture (SOA) Practices: A practice that involves designing software in the form of interoperable services.
- Microservices Architecture Practices: A practice structuring applications as collections of loosely coupled services.
- Code Quality and Standards Software Engineering Practices, such as:
- Code Review Practices: Practices involving systematically examining software source code by peers.
- Static Code Analysis Practices: A practice that employs tools to automatically analyze source code.
- Coding Standards Practices: Following predefined guidelines for writing and structuring code.
- Technical Debt Management Practices: A practice that involves strategies for balancing immediate deliverables.
- Security and Compliance Software Engineering Practices, such as:
- Secure Coding Practices: A practice that emphasizes writing code that guards against security vulnerabilities.
- DevSecOps Practices: A practice integrating security practices throughout the software development lifecycle.
- Compliance Auditing Practices: A practice that ensures software complies with legal and regulatory standards.
- Threat Modeling Practices: A practice that involves identifying and addressing potential security threats.
- User Experience and Accessibility Software Engineering Practices, such as:
- User-Centered Design Practices: A practice that prioritizes user needs and usability in the software design.
- Accessibility Standards Practices: A practice that ensures software is accessible by people with various abilities.
- Responsive Design Practices: A practice that involves creating user interfaces that adapt to various device sizes.
- Interaction Design Practices: A practice designing engaging and effective interactions between users and interfaces.
- Cloud-Native Software Engineering Practices, such as:
- Containerization Practices: A practice using container technology for application deployment.
- Serverless Architecture Practices: A practice building applications without managing server infrastructure.
- Cloud Cost Optimization Practices: A practice managing cloud resources for cost efficiency.
- Multi-Cloud Strategy Practices: A practice distributing applications across multiple cloud providers.
- ...
- Testing and Quality Assurance Software Engineering Practices, such as:
- Counter-Examples:
- Hardware Engineering Practice, which focuses on physical component design rather than software development processes.
- Business Process Practice, which addresses organizational workflows rather than software engineering methodologys.
- Data Science Practice, which emphasizes statistical analysis and data exploration rather than software engineering disciplines.
- IT Operations Practice, which manages system administration rather than software development methodologys.
- See: ML Engineering Practice, Programming Practice, AI Development Practice, DevOps Practice, Systems Engineering Practice, Software Architecture Practice, Software Testing Practice, Agile Methodology.
References
2017
- 14 Essential software engineering practices for your agile project."
- QUOTE: Agile initiatives are found in almost any company that build software. ... Flexibility (agility) can only happen when you are able to make changes to your product in an easy, fast, and flexible way. That is why: ... there are a set of software engineering practices that will help your team to deliver a high-quality product in a flexible state. These practices are not limited to building software, they cover the whole process until actual delivery of working software to the end user. ...
... Your organization will need to invest in these software engineering practices by training, infrastructure, tools, coaching and continuous improvement when you want your agile initiatives to actually able to deliver agility.
- 1. Unit Testing: The purpose of unit testing is not for finding bugs. It is a specification for the expected behaviors of the code under test. The code under test is the implementation for those expected behaviors. So unit test and the code under test are used to check the correctness of each other and protect each other. Later when someone changed the code under test, and it changed the behavior that is expected by the original author, the test will fail. If you code is covered by a reasonable amount of unit tests, you can maintain the code without breaking the existing feature. That’s why Michael Feathers define legacy code in his book as code without unit tests. Without unit tests your refactoring efforts will be a major risk every time you do it.
- 2. Continuous Integration: Martin Fowler defines Continuous Integration (CI) in his key article as follows: "Continuous Integration is a software development practice where members of a team integrate their work frequently, usually each person integrates at least daily - leading to multiple integrations per day. Each integration is verified by an automated build (including test) to detect integration errors as quickly as possible. Many teams find that this approach leads to significantly reduced integration problems and allows a team to develop cohesive software more rapidly." You see, without unit tests and test automation, it is impossible to do CI right. And only when you do CI right you might be able to succeed at Continuous Deployment.
- 3. Collective Code Ownership: Collective Ownership encourages everyone to contribute new ideas to all segments of the project. Any developer can change any line of code to add functionality, fix bugs, improve designs or refactor. No one person becomes a bottle neck for changes. This is easy to do when you have all your code covered with unit tests and automated acceptance tests.
- 4. Refactoring: Code should be written to solve the known problem at the time. Often, teams become wiser about the problem they are solving, and continuously refactoring and changing code ensures the code base is forever meeting the most current needs of the business in the most efficient way. In order to guarantee that changes do not break existing functionality, your regression tests should be automated. I.e. unit tests are essential.
- 5. Test Driven Development: Test-driven development is a development style that drives the design by tests developed in short cycles of:
- Write one test,
- Implement just enough code to make it pass,
- Refactor the code so it is clean.
- Ward Cunningham argues that test-first coding is not testing. Test-first coding is not new. It is nearly as old as programming. It is an analysis technique. We decide what we are programming and what we are not programming, and we decide what answers we expect. Test-first is also a design technique.
- 6. Automated Acceptance Testing: Also known as Specification by Example. Specification by Example or Acceptance test-driven development (A-TDD) is a collaborative requirements discovery approach where examples and automatable tests are used for specifying requirements—creating executable specifications. These are created with the team, Product Owner, and other stakeholders in requirements workshops. I have written about a successful implementation of this technique within Actuarial Modeling.
- 7. Chaos Engineering: Even when all of the individual services in a distributed system are functioning properly, the interactions between those services can cause unpredictable outcomes. Unpredictable outcomes, compounded by rare but disruptive real-world events that affect production environments, make these distributed systems inherently chaotic. You need to identify weaknesses before they manifest in system-wide, aberrant behaviors. Systemic weaknesses could take the form of: improper fallback settings when a service is unavailable; retry storms from improperly tuned timeouts; outages when a downstream dependency receives too much traffic; cascading failures when a single point of failure crashes; etc. You must address the most significant weaknesses proactively before they affect our customers in production. You need a way to manage the chaos inherent in these systems, take advantage of increased flexibility and velocity, and have confidence in your production deployments despite the complexity that they represent. An empirical, systems-based approach addresses the chaos in distributed systems at scale and builds confidence in the ability of those systems to withstand realistic conditions. We learn about the behavior of a distributed system by observing it during a controlled experiment. This is called Chaos Engineering. A good example of this would be the Chaos Monkey of Netflix.
- 8. Continuous Deployment: Continuous delivery is a series of practices designed to ensure that code can be rapidly and safely deployed to production by delivering every change to a production-like environment and ensuring business applications and services function as expected through rigorous automated testing. Since every change is delivered to a staging environment using complete automation, you can have confidence the application can be deployed to production with a push of a button when the business is ready. Continuous deployment is the next step of continuous delivery: Every change that passes the automated tests is deployed to production automatically. Continuous deployment should be the goal of most companies that are not constrained by regulatory or other requirements.
- 9. Micro Services: The micro services architecture runs a set of small services in a single application. These services are independent of each other and communication between these services is by means of a well-defined interface that uses a lightweight mechanism, for example, a REST API. Each service has a single function which matches micro services with business needs. There are different frameworks or programming languages that can be used to write micro services and they can also be set to either function as a single or group of services.
- 10. Infrastructure as Code: Code and software development techniques like version control and continuous integration are used to merge and provision infrastructure under this practice. The interaction with infrastructure is programmer based and at scale rather than a manual setup and configuration resource. The API-driven model of its cloud makes it possible for system administrators and developers to interact with the infrastructure as such. Code-based tools are used by engineers to interface with infrastructure; hence it is treated like an application code. There being code based makes it possible for infrastructure and servers to be quickly deployed, using fixed standards, also the latest patches and versions can either be updated or repetitively duplicated.
- 11. Configuration Management: The operating system, host configuration, operational tasks etc. are automated with codes by developers and system administrators. As codes are used, configuration changes become standard and repeatable. This relieves developers and system administrators of the burden of configuring the operating system, system applications or server software manually.
- 12. Policy as Code: The configuration of infrastructure and infrastructure itself are codified with the cloud. This makes it possible for organizations to dynamically monitor and enforce compliance. It enables the automatic tracking, validation, and reconfiguration of infrastructure. In that way, organizations can easily control changes over resources and security measures are properly and distributively enforced. The fact that resources that do not comply can be flagged automatically for further investigation or automatically restarted to comply, increases the speed level of teams within an organization.
- 13. Monitoring and Logging: To gauge the impact that the performance of application and infrastructure have on consumers, organizations monitor metrics and logs. The data and logs generated by applications and infrastructure are captured, categorized and then analyzed by organizations to understand how users are impacted by changes or updates. This makes it easy to detect sources of unexpected problems or changes. It is necessary that there be a constant monitoring, to ensure a steady availability of services and an increment in the speed at which infrastructure is updated. When these data are analyzed in real-time, organizations proficiently monitor their services
- 14. Communication and Collaboration: This is the key feature of any Agile and/or DevOps model; as development, test, security, and operations come together and share their responsibilities, team spirit is enhanced and communication skills are facilitated. Chat applications, project tracking systems, and wikis are some of the tools that can be used by not just developers and operations but also other teams like marketing or sales. This brings all parts of the organization closely together as they cooperate to see to the realization of goals and projects.
- QUOTE: Agile initiatives are found in almost any company that build software. ... Flexibility (agility) can only happen when you are able to make changes to your product in an easy, fast, and flexible way. That is why: ... there are a set of software engineering practices that will help your team to deliver a high-quality product in a flexible state. These practices are not limited to building software, they cover the whole process until actual delivery of working software to the end user. ...