As we refine and improve use cases we are careful to make sure that we don't impact any of these things that are key to their popularity and success. Use cases as we deal with them today have gone through a major face-lift. Without really changing the key ideas, the impact of the changes is dramatic. The result is a fundamentally more efficient way of developing software than the original use cases.
What is new about use cases?
The impact comes essentially from two areas: user stories and aspect-orientation. The result is that we adapt them for backlog-driven development and managing cross-cutting concerns.
In the past we had two concepts – use cases and scenarios. Scenarios were a kind of user story. In 2003 we introduced the concept use-case module (published in a paper  and in the aspect book ). A use-case module was a slice through the system. It included a use case (or a part of a use case), its analysis counterpart, its design, its code and its test. Influenced by Scrum and user stories we sharpened these concepts and improved the terminology. Now we talk about use cases, stories and use-case slices. Thus we have now:
1) Use cases are, as they have always been, sets of structured stories (user stories if you want) in the form of flows of events, special requirements and test scenarios.
2) Each story is managed and implemented as a use-case slice, which takes the story from its identification through its realization, implementation and test allowing the story to be executed.
3) Thus a use-case slice is all the work that goes together with a particular story. Each story and thus its slice is designed to be a proper backlog element, and realized within an iteration or a sprint.
4) The use-case strategy (starting from a use-case model) makes it significantly easier compared to the traditional user story strategy to identify the right user stories to work with and to understand how the ones selected make up the whole system. As the use cases are now developed slice-by-slice, the size of the use cases is not any longer a problem!
Thus, use cases are what they always have been. Stories are abstract scenarios a la user stories. Use-case slices are use-case modules made smaller, suitable as backlog entries. The terms scenario and use-case module will thus be replaced by story to remove the ambiguity between the abstract story-like scenarios and the concrete test scenarios and use-case slice.
Note: this can be compared with the user story approach where:
1) The stories are captured as a set of unstructured user stories.
2) Each user story is managed and implemented as one-or-more user story slices, which take the story from its identification through its realization, implementation and test allowing the user story to be executed.
3) If a user story is too much too implement in one go the story is sliced up into a number of smaller user stories and the original user story disposed of. This illustrates how it is the user story slices that are implemented and not the user stories.
4) Additional story types, such as Epic and Theme, are added to act as placeholders for user stories that we know will have to be sliced before they can be implemented.
Aspect-orientation has inspired us to deal with not just application-specific use cases (functional requirements), but also with infrastructure use cases (non-functional use cases). The latter are dealt with as cross-cutting concerns, allowing us to add behavior to an existing system without actually changing the code of the existing system. Examples of such non-functional behavior are persistency, logging of transactions, security. This has helped us to deal with requirements (and their realizations) for systems of systems (enterprise systems, product lines, service-oriented architectures), and for partial systems such as frameworks and patterns. See our book on aspects [ref. 2]
Thus, the key ideas have not changed, but they have been augmented with features that support backlog-driven development and working with non-functional requirements.
Use cases with stories and story slices address many of the issues now raised with the sole user story strategy. Use cases with cross-cutting concerns address many of the problems analysts have raised with non-functional requirements. To people, who already had adopted use cases, the new changes are not seen as large, but its impact on the way we develop software is dramatic.
 Jacobson Ivar, Use cases and aspects - working seamlessly together, Journal of object technology, July-Aug 2003
 Jacobson Ivar, Ng Pan Wei, Aspect-oriented software development with use cases, Addison-Wesley, 2005.