The use case is the sequence/flow of actions and events performed by an actor to achieve a business goal. The actor could be an end-user using the system or the system or device itself interacting with some other system. There will be many use cases for a given product under development.
The user story, the term used in the agile SDLC process and is a simple description of a software requirement in the end user’s perspective and his/her business job function. It should be scoped for an iteration and should provide a business value or add the value to the overall product once implemented.
SDLC stands for Software Development Life Cycle. It is the process of developing any software. There are many processes around from a traditional “Waterfall model” to the latest “Agile” processes. There are many types in Agile itself such as XP (eXtreme Programming), Scrum, TDD (Test Driven Development), etc.
Testing is the part of the SDLC and understanding it will help effective testing of a software product. The testing is the process that comes as verification phase in Waterfall model and in testing part of agile Scrum.
In general, below are the Project stakeholders in a product development organization.
- Acts as a bridge between product and customers
- Responsible to create PRD (Product Requirement Document) or BRD (Business Requirement Document).
Project Manager/Dev Manager/Dev Director
- Owner of the product execution (who creates and executes the Project Plan)
- Acts as a driver for successful project release.
- Coordinates with all stakeholders during the project execution and helps project driver.
- Conducts release meetings
- Responsible for performing product architecture considering the big and strategic goals like scaling, availability, performance, security, technology, etc.
- Creates architectural diagrams and documents.
- Work closely with the design/development teams for making the implementation successful.
- Responsible for the product design and work closely with Architects and developers.
- Creates FSD/FS (Functional Specification Document)
- Please note that sometimes Architects can act as designers or senior developers can be designers.
- Responsible for implementation (coding) as per FS.
- Do bug fixes
- Conducts unit testing
- Responsible for Testing ( tasks like write test code, execute tests, file bugs, create Test Plan and Test Specification).
- Review documents – release notes, manuals/guides
- Responsible for all sorts of documentation like user guides/manuals/help content.
Release Engineers (RE)/Devops
- Responsible for doing the integration of modules and creating the builds.
- The DevOps would host and monitor the stage and production sites.
Support Engineers/Front-end support (customer facing)
- This team would triage the customer issue and pass on to backend support if needed.
Support Engineers/Backend support
- They would triage and fix the customer issues escalated by front-end support engineers.
The Release criteria are the minimum checklist or list of goals to be achieved to release the product. This effort is driven by RE team, and all the project stakeholders would contribute to making this release to happen.
Below is a sample release criteria/checklist and can be taken as a template if none is available.
- Bugs criteria
- Quality criteria
- 100% feature coverage and test development
- 100% test execution
- 95-100% pass rate
- >90% automation for regressions
- Stress/Load/Concurrency criteria
- Performance criteria
- Minimum throughput numbers related to the product.
- Comparison to other competitive products
- Code coverage
- >90% class level
- >50% method level
- >40% instruction/statement level
- Internationalization (I18N) & Localization (L10N)
- Internationalization support
- Specific languages to translate
- NOTE: I18N is short form as there are 18 characters between I and N in the “InternationalizatioN”. Similarly, L10N is short form as there are 10 characters between L and N in the “LocalizatioN”.
- Documentation (books/online)
- Release notes
- User Manuals
- Installation Guide, Admin Guide, Developer Guide, Troubleshooting guide, etc.
- License and license text
- Support/Maintenance plan
Refactoring is the general software engineering process in coding and is to make code changes in such a way that it can improve readability, structure, and optimization while keeping the use case/behavior intact.
This refactoring process is very typical in the software programming and also especially in the agile process as it is iterative because getting the perfect code is not possible with all optimizations at a time.
The Software or Computer Software is a set of programs and data that process information and controls underlying hardware. It includes programs, libraries, and non-executable data.
Some of the examples include the following.
- Operating Systems such as Windows, MacOS, Linux, Solaris, etc.
- Browser software such as Firefox, Chrome, Internet Explorer, Safari, etc.
- Office software such as Microsoft Office, Star Office, etc.
- IDE software such as Eclipse, NetBeans, IntelliJ, etc.
- Any other programs that operate on devices and data.
The main purpose of software is to have the flexibility to control a general purpose solution, business solution or devices such as mobile, desktop or large computers.
The software is everywhere in the Today’s evolving technologies. Understanding and gaining of software skills would help in professional advanced technology careers.
Yes. In general, applying the core engineering principles such as measurement consistency, repeatability, reliability, and correctness during the application of testing techniques is essential.
It is difficult to do the above principles merely with the manual approach because of limitations such as human errors in producing consistent actions & output, testing coverage with quick, agile product development cycles and making sure each build is verified for regressions. Working on individual manual work, one can’t scale to handle massive work!
The Quality Automation is one of the important things to address this continuous regression testing. The automation effort needs programming skills in the same software domain and relevant skills to achieve the high automation, which saves time and test coverage.
Any mundane activities (setups/installs/monitoring/operations etc.) should be automated and let the devices such as computers do this kind of work once we code it. You can get and invest more time in learning and creation of the new and interesting things!