Since their inception some 30 years ago, use cases have been used to identify, organize, synthesize and clarify system requirements for organizations across the globe. In most recent years, they have been used in techniques such as user stories. Use-Case 2.0 is the new generation of use-case driven development – light, agile and lean – inspired by user stories, Scrum and Kanban.
Although they are much more agile and lean, they still embody the same popular values from the past while expanding to architecture, design, test, user experience, and also instrumental in business modeling and software reuse. But, for the adoption of use cases to be seamless, there should be a balance of principles applied.
A Continued Legacy
Nearly three decades have passed and there are still whitepapers, books, and guides being written that utilize parts of the idea to improve software systems, user experience, business systems (such as embedded systems) and systems of systems. Furthermore, today’s trends such as the Internet of Things and Industrial Internet incorporate use cases.
The ideas of thousands, if not millions of individuals, has taken this methodology and etched it into the fabric of modern and evolving infrastructures.
At Ivar Jacobson, we understand that use cases can and should be used to drive the development. While they do not prescribe how you should plan or manage your development work, or how you should design, develop or test your system, they do provide a structure for the successful adoption of your selected management and development practices.
6 Principles For Successful Adoption
Principle 1: Tell A Story
The simplest form of communication is storytelling. For thousands of years, it was through storytelling that civilizations thrived and progressed because it helped spread knowledge from one person to the next.
Storytelling not only produces collaboration, it dictates roles, responsibilities and duties so that everyone working on a system can focus on the same objectives.
In short, use cases encapsulate the goals of a system. Use cases are used to identify a story or a of collection stories that are related and build upon one another to allow system’s requirements to be easily captured, shared and understood.
Principle 2: Understand the Big Picture
It doesn’t matter whether the system you are developing is large or small, or whether it is a software system or a business system, you must see the big scheme of things for it work properly.
If you are lacking the sum of all parts, it may prove difficult to make uniform decisions on what should be included in the system, what should be left out, the cost, and the benefits it will provide.
A use case diagram can be implemented to present an overview of system requirements.
Principle 3: Focus on Value
This principle hones in on a very important aspect to any system, what is its overall value. Not simply to the organization, but to stakeholders and users.
It is better to focus on how a system will be used than producing a litany of functions and features it will offer.
Use cases are used to ascertain the value of a system based on the required goals for a particular use. They encompass many ways of using the system; those that successfully achieve the goals, and those that handle any problems that may occur.
Principle 4: Build the System in Slices
Most of you wouldn’t eat an entire pizza pie without slicing it first. This is the same method that is used by Use-Case 2.0 for system requirements. Each system requirement works in its own way but is still dependent upon others, most of which are also dependent and require them to be implemented before they can be fulfilled and value delivered. This can be achieved in a five-step process and the recipe is quite simple:
System Slice Process
- Step 1: Identify and focus on the most useful thing that the system does and do it.
- Step 2: Slice that one thing into smaller slices.
- Step 3: Identify test cases that represent acceptance of those slices.
- Step 4: Select the most central slice that navigates the entire concept from end to end. (or as exact to that as possible).
- Step 5: Estimate it as a team and start building it.
Although use cases have been used to help understand and capture system requirements, they can function as so much more. Use cases can be used throughout all the other aspects of the system and its documentation, including the design, implementation, test cases and test results, most especially when they are sliced.
Principle 5: Deliver the System In Increments
What if all software systems understood and valued evolution? That is what you get with Use-Case 2.0. Through incremental series, each increment of a software system can provide a demonstrable or usable version of the system.
By slicing the system requirements, you are allowing for evolution to take place over time “naturally”. When increments are used to add value to one another they can build upon on another to be useful enough to release when the time comes. This is a cornerstone of agile, lean, and light software development.
Principle 6: Adapt to Meet the Teams Needs
In this fast-evolving world, there isn’t a one-size-fits-all solution to the problems that face software development. And, honestly, there shouldn’t be. There are myriads of teams and situations that dictate varied styles, ideas, and levels of detail. No matter the requirements or situation one thing is a universal truth: your development process should meet the needs of the team.
Use-Case 2.0 has been designed with those details in mind. It doesn’t matter the size or range of your group, the lightweight use-case narratives can meet the most basic needs, to the most complex. The power is up to your team.
Software development (or any development process) doesn’t have to be painstaking or grueling. Use-Case 2.0 has proven itself as a lean, agile and light solution to software practices. In addition, it uses stories to create an environment that is conducive to any team be they small or large and work in a waterfall or agile environment. To learn more about use cases, download Use-Case 2.0: The Hub of Software Development.