The Essay Explores The Relationship Between Use Cases Model And Object Oriented Programming. (70 Characters)

Use Cases

Use case is a system and software engineering term, which describes how users are required to use a system in order to accomplish particular goals. Object Oriented Programming (OOP) is however referred to as one of the most commonly followed programming paradigms that uses classes and objects that behave like real life entities (Smith 2015). This report aims at describing the relationship between the Use Cases model and Object Oriented Programming. Detailed explanation of the two terms is provided. Later into the report, it shall also be elaborated how Use Cases are necessary in the OOP approach, even though it is not considered to be inherently related to the said paradigm.

As mentioned above, Use Case is a computer-engineering term that explains how a user is supposed to use a system to achieve preferred goals. Use case is referred to as a software modeling technique, which describes the features of implementation and helps in solving any error that may be encountered. This technique is used to define the interaction between external agents and the system (Leffingwell and Widrig 2012). The basic elements that constitute use case are:

Actors: Actors or agents are the type of users who interact with the program or system.

System: The use case technique captures necessary functional requirements, which describe the behavior of the program or the system.

Goals: Fulfilling desired goals is one of the major tasks of this technique. It also aims at describing the variant and activities involved in the process to attain such goals (Kulak and Guiney 2012).

OOP is a programming paradigm that uses the concept of using objects. Objects are identifiable entities with unique data or attributes. They contain codes that specify procedures. These are known as methods. These objects are designed from the plan provided by their class of which each is an instance (Lengstrof and Wald 2016). Object Oriented Programming also offer means of safe and easy programming through inheritance, encapsulation, polymorphism, data abstraction and data hiding (Evaristus and Adeyi 2013).It helps in creating modular designs for the ease of understanding.

The object oriented design and analysis methods offer the best framework for applying real life scenarios through programming.

Use Cases is not completely an Object-Oriented methodology.  It is commonly usedin structured development too.However, the Unified Process (can be applied through the UML) encourages Object-oriented development using the use-case model (Clune et al. 2012).

A use case can be mentioned as the generic description of a complete transaction that involves multiple objects within the system. It is more concerned with the analysis of interaction between the system and the objects from outside of it that interacts directly with it.

Object Oriented Programming Approach

The OO SDLC (Object Oriented Software Development Life Cycle) contains the following three macro processes: Object Oriented Analysis, Object Oriented Design and the Object Oriented Implementation. Use case model can be applied all throughout most of the software-development activities. In the analysis phase of the OO development process, it is required to develop a model of the real world application, which shows all its necessary properties. The Object-Oriented Analysis (OOA) phase enhances the understanding of problem domains and promotes a smoother transition to the design phase. Therefore, the OO approach provides a more natural procedure to organize specifications. The extensive OO approach includes various modeling techniques in the varying stages of software development process.

In the analysis phase, the system requirements are determined alongside the identification of classes and their respective relationship with other classes inside the problem domain.  To further understand and analyze the system requirements, the users and the actors are needed to identified. Scenarios assist in designing the system by proper understanding of the requirements (Friendkvvk.files.wordpress.com 2017). Ivar Jacobson developed the concept, namely Use Cases. This was meant to be a scenario that describes the user-computer interaction. This is now considered as one of the primary elements in system development(Jacobson, Spence and Kerr 2016). The Object oriented programming community has accepted Use Case to a remarkable degree.

Scenarios are used in this process to figure out what role each object plays and how they interact with each other. This defines the interrelationships of the system (Benner et al. 2014). The intersection among objects and their roles in order to achieve destined goals is known as collaboration. However, the scenarios only portray one possible collaboration at a time. To display all potential collaborations within a system, various scenarios may be needed. These may exhibit usual behavior or may show expectations. Use Case modeling is referred to as the analysis of a scenario in which high-level processes are expressed. It represents users’ perspective of the whole system or their needs. Like any other object-oriented activity, use cases too adapt an iterative approach (Larman 2012). Therefore, once the use case model is well developed and understood, classes can then be initiated alongside their respective relationships.

Below, a simple scenario is depicted where an address book is being created and maintained through the Object Oriented approach. The Use Case diagram would be used to frame the situation and build a relationship between the user and the system (Baresi 2006). 

An initial reading of the use case diagram depicts the necessary parts of the system, as below:

• An entity or object that represents the address book, which the program is meant to work upon (AddressBook).

• Random number of objects, where each represents one person in the address book (Person).
• A boundary or module object that represents the interface between the user and the address book system(AddressBookGUI).
• Another boundary object that represents the interface between address book and the file system on the disk (FileSystem).
• A single controller object, whichfollows out the use cases in regards to the response according to user gestures on GUI (AddressBookController).

The use cases in this system work with the objects in the following manner:

• The use case- “Add a Person” gains information from the user end about the new person to add and then creates the person object and adds it to the AddressBook object’s collection.
• The “Edit a Person” use case allows the user to view a particular Person object from the system and make changes accordingly through the AddressBook object.
• The “Delete a Person” use case queries the user to confirm a deletion, and then invokes the AddressBook object to remove that person’s object from it.
• “Sort Entries by Name” and the “Sort Entries by Zip” involve asking the AddressBook object to sort its collection with respect to name and ZIP respectively.
• The “Create New Address Book” use case creates a completely new object by of AddressBook.
• “Open Existing Address Book” asks for file specifications from user. Then it commands the FileSystem object to read in a data module of the AddressBook object type.
• The use case- “Save Address Book” saves the currently accessed AddressBook object to the file.
• The use case- “Save Address Book As” takes a file specification details from user and saves the current AddressBook object to the file.
• The “Print Address Book”use case tells the AddressBook object to print its collection in their respective order.
• The “Quit Program” use case triggers the “Save AddressBook” use case and then terminates the system. 

Conclusion

The report helps to conclude that Use Case, though not inherently a part of the Object Oriented Programming concept, is however, a crucial organ of the OO approach. It is widely used in the OO analysis phase to help developers realize the goals of the project and build a robust application accordingly. The use case model helps to convey the interactive relationships between the objects and the functions used in the system. 

References

Baresi, L., 2006. Fundamental Approaches to Software Engineering: 9th International Conference, FASE 2006, Held as Part of the Joint European Conferences on Theory and Practice of Software, ETAPS 2006, Vienna, Austria, March 27-28, 2006, Proceedings. Springer Science & Business Media.

Benner, K.M., Feather, M.S., Johnson, W.L. and Zorman, L.A., 2014. Utilizing scenarios in the software development process. Information system development process, 30, pp.117-134.

Clune, R., Connor, J.J., Ochsendorf, J.A. and Kelliher, D., 2012. An object-oriented architecture for extensible structural design software. Computers & Structures, 100, pp.1-17.

Evaristus, O.E. and Adeyi, A.J., 2012.Object Oriented Programming.

Friendkvvk.files.wordpress.com. (2017). Cite a Website - Cite This For Me. [online] Available at: https://friendkvvk.files.wordpress.com/2015/08/friendkvvk-ooad.pdf [Accessed 19 Nov. 2017].

Jacobson, I., Spence, I. and Kerr, B., 2016. Use-case 2.0. Communications of the ACM, 59(5), pp.61-69.

Kulak, D. and Guiney, E., 2012. Use cases: requirements in context. Addison-Wesley.

Larman, C., 2012. Applying UML and Patterns: An Introduction to Object Oriented Analysis and Design and Interative Development. Pearson Education India.

Leffingwell, D. and Widrig, D., 2012. Managing software requirements: A Use Case approach. Addison-Wesley Professional.

Lengstorf, J. and Wald, K., 2016. Object-Oriented Programming. In Pro PHP and jQuery (pp. 85-114). Apress.

Smith, B., 2015. Object-oriented programming. In Advanced ActionScript 3 (pp. 1-23). Apress.