This report provides an introduction to various software engineering diagrams and models and also implements the same for a networking system for the project team personnel. This system is a Facebook-like social interaction system for the team members working on a single project through group interaction. Then, it provides them various functionalities like chat, talking board, task commenting, and other forms of interaction in user groups. It has been found that it is of vital importance to use all of the different software engineering models and diagrams available to develop a comprehensive system that meets all of the requirements of different users.
2. Software engineering diagrams and models
2.1. Activity diagram
The activity diagrams show the sequence of activities that are carried out by a person or the user of the software or the system (Sommerville, 2011). Then, it shows how the user or the administrator interacts with the system. The first activity diagram shows the most basic activity of logging into the system and using the posting system available on the dashboard of the person using the system. Then, this activity diagram shows that the user first logs into the system with his or her login and password. Then, the user directly goes to the posting board and reads the various postings that are available there. These have been put by the employees working on different projects. Then, he or she can also mark the posting as read, once it has been read. Finally, the user has to log out of the system once he or she is done with his or her readings of the postings. Likewise, the other activity diagram shows that the user can also make his or her own post. Then, he or she can also view tasks and mark his or her availability. Finally, they are able to comment on the project schedule and mark their beginning of the work on the project.
2.2. Use case diagram
The use case diagrams show interaction between the system and its environment (Sommerville, 2011). The first use case shows that tasks, project, and posts are available to the user. Then, the user is outside of the system and is able to log into the system, use the system and its entire components, and then again log out of the system. Then, the user remains outside of the system and only interacts to process his or her jobs. Finally, the third use case shows that the administrative user is able to log into the system, add new users and groups, alter them, and delete the user groups and users.
2.3. Sequence diagram
The sequence diagrams show the interaction between the users and the system components. Then, these depict the logic of activities and processes that go on in the system through the users (Sommerville, 2011). The first sequence diagram shows that various users are able to log into the system and read the posts available on the board. Then, they are also able to reply to the same posts. On the contrary, it is also possible that the user might not want to reply to the post. Then, that is up to his or her discretion. Likewise, the second sequence diagram shows that the administrative user is able to perform multiple tasks in the system. Then, the administrator adds users and also alters them (i.e. their descriptions and rights). Then, he or she also adds tasks in a live project and subsequently adds users to those tasks. Finally, the administrator is able to remove the posts that he or she feels are inappropriate and can also add more user groups in the system.
2.4. State diagram
The state diagram shows the reaction of the system to different events that occur in the system (Sommerville, 2011). The first state diagram depicts that when a user is added, the system creates a log in for that user and assigns him or her to some group. On the contrary, when a user is removed, the system automatically deactivates the account of the user and also removes all posts that had been put by him or her. Similarly, the second state diagram shows that, when a task is added to a project, the system allocates board space to it and also allocates members to it by default. Contrarily, when a task is removed from a project, the system automatically removes the board space available to it as well as removes all of the members associated with it.
2.5. Context model
A context model shows the environment of an information system. Then, it shows as to what is included within the boundaries of the system and what exists outside of the boundary walls of the system (Sommerville, 2011). Here, the context model shows that the tasks, groups, and posts by the group members occur inside the boundary walls of the system. On the contrary, it is also true that the suppliers and customers of a project are also able to post their comments regarding their ambit of project work. However, they do this remotely through email notification, which is posted on the system board wall. Then, these users exist outside of the system and do interact with the system. Then, they are external users of the system and exist outside of its boundaries.
2.6. Process model
A process model shows how the system is used by its environment and what are the business processes in the system (Sommerville, 2011). The first process model shows that the system has several processes. These include saving the tasks, saving the posts, saving the projects and their schedules, and saving project resources assigned to them. The second process model delineates that there are several other processes that the system performs. These include providing group membership and resources to the new and existing users, providing group tasks to the users, tracking the progress on the assigned tasks (such as percentage of work completed etc.), and adding tasks to existing projects on the user's request. The last process involves adding all of the fields that are available to tasks, including the functions.
2.7. Interaction models
2.7.1. Use case diagram
A use case diagram in an interaction model shows the relationship between external actors and the system components. Then, these depict the interaction between the actor and the system components (Sommerville, 2011). The first use case shows the actor interacting with the system through putting up a post, altering it, or removing it. Then, the system saves these steps that are performed by the user. The second use case shows another interaction between an actor and the system, which is when the administrator adds a user group in the system. The system provides the ability to create user groups and then also saves the actions of the administrative user.
2.7.2. Sequence diagram
The sequence diagram in the interaction model shows the interaction of different processes in the system (Sommerville, 2011). Then, the first diagram shows that when a user is added, the system asks for his or her bio-data and assigns a group to it. Then, a log in and password is provided to the user and tasks are added to the user. Finally, posting rights, project schedule, and commenting rights are provided to the user. The second sequence diagram shows that when a task is added to a project, the system updates the task details and connects it with the project. Then, task members are added and their work contribution is assessed. Finally, available equipment resources are added to the task and they are incorporated into the project schedule through their own timeline and deliverables, which are its milestones.
2.8. Behavioral models
2.8.1. Data-driven model
Behavioral models depict the dynamic behavior of the system as it executes the various programs. The data-driven model shows how data enters the system and is processed, and output to external or internal data stores (Sommerville, 2011). The first data flow diagram shows that when a user is added in the system, the system ascertains and stores the user name and user details. Then, the system assigns the user to a user group, and his or her membership details are stored in the system directory and database. Likewise, the second data flow diagram shows that when a task is added in the system in an existing project, the system ascertains and stores the task name and other details in the system repository. Then, members are allocated to the new task and member contributions are also stored by the system.
2.8.2 Event-driven model
An event-driven model is a behavioral model that shows how different events occur in the system and are processed by the system (Sommerville, 2011). The first event-driven model depicts the event of the creation of a new user who is then sent automatic e-mail and SMS notifications by the system. Likewise, when a user is removed, the system automatically informs the user through e-mail and SMS. The second event-driven model shows that once a task is created in the system, the system shows dialog boxes to the user, which require him or her to add members and a schedule to the newly created task. Similarly, when a task is updated by the user, the system automatically calculates and shows the project delay resulting from task modification and associated changes in resources usage.
2.9. Structural models
2.9.1. Class diagram
Structural models depict the structure of the system. The class diagram shows the interaction between various classes in the system (Sommerville, 2011). Then, the given class diagram shows the relationship between the classes of user and project, where the relationship is 1:N. Then, one user is only working on a single project at a time, while a project has numerous users. Here, the user and the project are independent classes that have their own unique attributes and functions. Then, these classes also have their objects and instances of those objects.
2.9.2. Object diagram
The object diagram depicts the relationship between a class and its object (Sommerville, 2011). According to the given diagram, the user class will have an object which is an individual user object. This object inherits all of the attributes and functions of the class. It is clear that the relationship between a class and its object is 1:N. This is because a class will have multiple objects, while the object will belong to only a single class, most of the times. Furthermore, these objects can have multiple instances (Sommerville, 2011). Then, the given diagram shows that the user class will have multiple objects of the user type. These could be general users and administrative users.
2.9.3. Package diagram
A package diagram depicts the system as a package for the user where a single user or actor interacts with multiple processes of the system at once. There are multiple functionalities of the system that are available to a single actor outside the system (Sommerville, 2011). The given diagram shows the user in the middle of the system, where he or she is able to interact with multiple processes and functionalities of the system. These include his or her ability to interact with tasks, projects, groups, and the system common board. Hence, the system acts as a complete package for the system user.
2.9.4. Component diagram
The component diagram shows the details of the implementation of a class in object-oriented programming. Then, it specifies the various components of a class, which include the class name, its attributes, and functions (Sommerville, 2011). The diagram shows the class of the user. Here, the attributes of the user class include name, age, group, project, and tasks. There are also functions of the user class. These include saving the posts, comments, and the checks that the user puts at various places in the system. For example, the user may check the box in the task to indicate that the task has been completed.
2.10. Conclusions and recommendations
Different software engineering diagrams provide a comprehensive method to document the system functionality that will be implemented by the software. These are effective requirements engineering and systems design tools. Especially, the UML modeling is very popular for object-oriented programming techniques and methods. These various types of diagrams show the complete functionality and design requirements of the system under development.
Accordingly, we considered different types of software engineering diagrams, including activity, sequence, class, and state diagrams. Then, we also considered other types of software engineering diagram models, which included context models, process models, interaction models with use case and sequence diagrams, behavioral models with data-driven and event-driven models, and structural models with class, object, package, and component diagrams.
Resultantly, it is strongly recommended that any systems analysis and design phase of the software development lifecycle must always use the various types of software engineering design models that are available. This is because these are effective tools for requirements engineering and system design. Then, these identify all of the components and elements of the information system that exist both inside and outside of the system boundaries.