Week 5 Final
docx
keyboard_arrow_up
School
Ashford University *
*We aren’t endorsed by this school
Course
301
Subject
Information Systems
Date
Feb 20, 2024
Type
docx
Pages
10
Uploaded by LionDetroyer22
Software Engineering Concept Map and Paper
Software Engineering Concept Map and Paper
By Thomas Pedersen
University of Arizona Global Campus
CST301: Software Technology & Design
Professor: Pete Limon
February 18, 2024 1
Software Engineering Concept Map and Paper
Software is everywhere, influencing various aspects of human life globally. It is developed for a myriad of reasons, such as personal hobbies involving the generation or manipulation of personal information, aiding organizations in business operations, or catering to mass consumption
and use by businesses. Software is not just complex code; it extends beyond mere computer programming. It encompasses hardware, business policies, attached systems, and various associated components. Understanding this broader context, known as the software context, is crucial for creating organized and methodical software.
Software engineering is the structured approach to developing software in phases tailored to meet specific goals. It acknowledges that software is more than just code, considering hardware, business policies, and associated systems. This process, known as software engineering, varies for each project, as there's no one-size-fits-all approach. It enables organizations to determine the most
efficient path to software development.
The systematic approach of software engineering involves breaking the development cycle into processes and activities. These activities fall under four fundamental processes: 1.
Software Specification:
Defining how the software should function and any constraints it might have.
2.
Software Development: Assembling the software to meet the previously specified requirements.
3.
Software Validation:
Testing the software to ensure it meets all desired requirements and functionalities.
2
Software Engineering Concept Map and Paper
4.
Software Evolution:
Adapting existing software based on user feedback and industry advancements to meet new demands.
These fundamental processes guide the structured development of software, ensuring it aligns with goals and evolves efficiently in response to changing needs.
The various approaches to software development processes are known as software process models or Software Development Life Cycle (SDLC). Depending on project goals and specific needs, organizations may opt for planned or iterative approaches.
Here's a succinct breakdown:
Software Process Models:
These represent different ways software organizations approach development.
Software Development Life Cycle (SDLC):
It refers to the overall process of software development.
Planned Approach:
Sequential and systematic progression through stages of development.
Iterative Approach:
Cyclical process involving repetitions and refinements, allowing for flexibility and adaptation to changing requirements.
Choosing between these approaches depends on project requirements, goals, and the organization's preferred methodology.
The waterfall approach is a model based on planning and documentation. It suits traditional
organizations where management requires progress tracking and goal setting for developers. It's also suitable for embedded systems with stable requirements, minimizing the need for changes during development.
3
Your preview ends here
Eager to read complete document? Join bartleby learn and gain access to the full version
- Access to all documents
- Unlimited textbook solutions
- 24/7 expert homework help
Software Engineering Concept Map and Paper
The incremental development process, commonly used in methodologies such as Agile, is prevalent today due to its adaptability and ability to make quick corrections. Unlike the waterfall approach, incremental development relies on constant feedback from customers and users to shape the software's design and behavior. Progress could be more easily tracked due to the absence of static goals and timetables. Completed components may be revised or removed based on feedback, making this approach highly favorable for companies developing apps, insurance management systems, online video games, etc., where user feedback significantly impacts the user interface and software behavior.
The crucial initial stage in software engineering involves collaboration between developers and customers to establish system requirements. This stage significantly shapes the software's appearance and functionality. Mistakes made here can be costly and time-consuming to correct, especially in plan-based approaches. A study in the Journal of Scientific Programming explains that "if the [Software Requirements Specification] document contains ambiguous, incomplete, or contradictory requirements, it results in erroneous software" (Ashfaq, pg. 2). I really enjoyed how they described this and brought it out to the means and understanding of scientific programming and the requirements.
When developing software, it is essential to identify and define both functional and non-
functional requirements. Functional requirements define what the software should do or how it should function for the users, while non-functional requirements specify how the software should perform in terms of speed, memory usage, responsiveness, availability, etc. Non-functional requirements also include aspects such as availability, reliability, scalability, flexibility, and compatibility with other systems and technologies. The inclusion of both functional and non-
4
Software Engineering Concept Map and Paper
functional requirements helps to create a complete picture of the system and ensures better software development.
Yes, a detailed and comprehensive requirements document is essential for successful software development. Developers use different modeling techniques, such as UML diagrams, to visualize various levels of software and ensure a shared understanding of the requirements between
the developer and customer. The three most common diagram types are Activity Diagram, Use Case Diagram, and Sequence Diagram, which are tailored to the specific aspects of the software and different types of requirements. There are various variations of these diagrams that need to be chosen for each project, and they are all meant to communicate and visualize the idea behind the software effectively.
Context modeling is a crucial part of software development. It helps to define the boundaries between the system, or part of a system, and its environment, showing the entities that interact with it. This model is usually a high-level diagram showing the system as a single process with its relationship to external entities. It's important because it helps to understand the interactions and dependencies between the system and its environment. It can also help identify potential sources of requirements and understand the scope of the system. By focusing on a specific part of the system, developers can better understand its functionality and how it interacts with other parts of the system. According to Sahlab, "[a]s the human analysis and decision-making takes place under varying and uncertain circumstances, awareness of contextual data and situational factors for knowledge transfer is essential" (Sahlab, 1435). Even under ideal conditions, where the entire programming team understands the entire project, goals, and plans, these details must be communicated with 5
Software Engineering Concept Map and Paper
management to ensure seamless synergy between the team and management. This ensures that everyone who works on the project is on the same page, understands the objectives and milestones,
and is aligned with the overall vision. Good communication is essential for effective project management and successful development.
Interaction models, including sequence diagrams and case modeling, are used to illustrate the interaction between objects, the system, and external forces.
Sequence diagrams depict the interactions between separate systems or entities, while case modeling provides a timeline or cause-and-effect representation of the system and external forces. These models are useful in depicting different perspectives of the system and its interactions with external factors. They provide a visual representation of the system's behavior and its relationship with other components.
1.
Class Diagrams:
These depict the classes within a system, their attributes, methods, and the relationships among them. They are fundamental for object-oriented systems.
2.
Generalization Hierarchies (also known as Inheritance Diagrams):
These show the inheritance relationships between classes, where a child class inherits attributes and behaviors from a parent class. The parent class is a generalization of the child class, and
the child class is a specialization of the parent class.
These diagrams help in understanding the static structure of the system, including the organization of its data and its component structure. They are crucial for designing and building the
system, as well as for maintaining and evolving it over time.
Behavioral models, including the activity model and state diagram, show how the different objects interact within the software. The activity model appears as a timeline that illustrates the 6
Your preview ends here
Eager to read complete document? Join bartleby learn and gain access to the full version
- Access to all documents
- Unlimited textbook solutions
- 24/7 expert homework help
Software Engineering Concept Map and Paper
execution of tasks and their interactions, while the state diagram depicts the different state changes within the system.
These two models provide valuable insights into how the software works, how different tasks are executed, and how different states are transitioned between them. Understanding these models is essential for good design and implementation of the software.
Behavioral modeling also includes other diagrams, such as use case diagrams and sequence
diagrams.
Object-oriented design (OOD) is the process that comes after software requirements and model selection. It helps to create a framework for implementing the software and defining how different components, classes, and objects will interact with each other. The primary goal of OOD is to establish the software's design and architecture and design models that illustrate how the different components will interact.
There are various processes to OOD, including defining the context of the software, designing its architecture, identifying principal objects, developing the design models, and specifying the interfaces.
After the object-oriented design (OOD) has been established and the software has been developed, it must undergo testing to determine that it meets all of the requirements set out in the first phase of the life cycle. This process of integration testing is the final stage before the software is accepted and implemented, and so it must be tested thoroughly. Generally, the software is tested the system by the system or with a larger context that contains several systems before the software, on the whole, is tested. This is a very important process in the software development cycle.
7
Software Engineering Concept Map and Paper
The primary purposes of testing are to identify bugs and verify that the software meets the specified requirements. While it's indeed impossible to test every single possible input due to the vastness of the input space, there are strategies to make testing more effective:
1.
Boundary Value Analysis: This involves testing at the extreme ends or boundaries of input ranges, as errors often occur at these boundaries.
2.
Equivalence Partitioning: This involves dividing the input space into equivalent classes and testing with representative values from each class. This ensures broad coverage without needing to test every single input.
3.
Error Guessing: This involves using experience to guess where errors might occur and testing these areas more thoroughly.
4.
Negative Testing: This involves testing with inputs that are outside the valid input domain to ensure that the system handles them gracefully and fails correctly.
These strategies, along with others like stress testing, performance testing, and security testing, help ensure that the software is robust, reliable, and secure.
The evolution phase of the software development life cycle involves maintaining and updating the software to meet new requirements or adapt to changes in the business environment, hardware updates, or other events that necessitate software updates. This phase can be lengthy and may involve ongoing maintenance and enhancements to ensure the software remains effective and relevant over time. It may or may not be completed by the same organization that developed the software originally.
Each new change to the software to meet new requirements contributes to the degradation of the software and increases the possibility of bugs and errors. It is essential to implement these new changes carefully and selectively, making only those necessary for the software to function 8
Software Engineering Concept Map and Paper
properly. The changes should be made only to the extent necessary and should avoid unnecessary complexity or new dependencies that could cause additional issues. The goal is to ensure the software's functionality and performance while minimizing the effect of changes on it.
Degradation can be partially avoided through refactoring, but the danger of it cannot be completely avoided. The software's longevity and business value can be used to measure the extent
to which it has been impacted over time. However, it is important to note that a business must always be vigilant about measuring these metrics and deciding when the software has reached the end of its viability.
Eventually, all software becomes legacy software that, while it still serves a purpose, is no longer the principal software within the business.
This life cycle of software development is the same for every software system.
In conclusion, software engineering is indeed a complex and challenging process that requires a deep understanding of various systems, adaptability, and problem-solving skills. Mistakes are inevitable, but they provide opportunities for learning and improvement. Despite the challenges, the importance of software in today's digital age makes these efforts worthwhile. The ability to create effective and efficient software systems is a valuable skill that has a significant impact on various aspects of society, including business, education, healthcare, and entertainment. Therefore, continuous learning, staying updated with the latest technologies, and adopting best practices in software development are crucial for success in this field.
9
Your preview ends here
Eager to read complete document? Join bartleby learn and gain access to the full version
- Access to all documents
- Unlimited textbook solutions
- 24/7 expert homework help
Software Engineering Concept Map and Paper
References:
Ashfaq, F., Bajwa, I. S., Kazmi, R., Khan, A., & Ilyas, M. (2021). "An intelligent analytics approach to minimize complexity in ambiguous software requirements." Scientific Programming. 1-20. Retrieved from
https://doi-org.proxy-library.ashford.edu/10.1155/2021/6616564
Sahlab, N., Jazdi, N., & Weyrich, M. (2020). "Dynamic Context Modeling for Cyber-Physical Systems Applied to a Pill Dispenser." (2020). 25th IEEE International Conference on Emerging Technologies and Factory Automation (ETFA). Retrieved from
https://doi-org.proxy-library.ashford.edu/10.1109/ETFA46521.2020.9211876
10