9.1 Software Engineering Fundamentals

Software Engineering Teams

In most organizations, software is developed by a team of software engineers, as well as other people with different backgrounds and skills. To be effective, the project team must be organized in a way that maximizes the use of each person’s skills and abilities and emphasizes the importance of teamwork to address all the aspects of the projects. This is especially true for complex projects. Effective project managers focus on problem-solving and end-product quality, and thus they may organize software teams in a variety of ways. The key factors considered when selecting a team organizational model are as follows:

• difficulty of the problem to be solved
• degree to which the problem can be modularized
• required quality, reliability, and other nonfunctional requirements of the system to be built
• delivery date
• budget limitations
• team lifetime (i.e., overall period of time during which the team members will work together)

During the creation of a software solution, software engineer team members may take on various roles, such as:

• project manager, who is responsible for making sure that the project gets completed on time and on budget
• enterprise or solution portfolio architect, who makes high-level design decisions on high-level modeling or solution design building blocks and their interconnections to best address functional requirements as well an nonfunctional ones such as performance and usability
• user experience (UX) designer, who plans how users will interact with the software system; this involves tasks like designing the user interface (UI), making wireframes and prototypes, and conducting user testing to ensure the software is user-friendly and meets user needs
• software developer, who analyzes requirements, refines the design, writes and tests code, and collaborates with the operations team to deploy the software into testing and production environments
• quality assurance tester, who checks for bugs and validates that the system meets the requirements

It is common for one team member to act in several roles (for example, a solution architect might also be a software developer), and some roles may be filled by multiple team members (for example, there are typically multiple software developers on a project). Additionally, a software engineer may work directly with other people, including:

• product owners, who are generally project sponsors and provide the requirements and overall guidance on what is expected from the solution
• subject matter experts (SMEs), who are specialists in areas such as business, technology, products, or other topics as needed
• database administrators, who focus on areas such as data storage, organization, and access associated with a software solution
• operations specialists, who are IT and/or DevOps professionals with a focus on computer hardware and software operations

Because projects can involve a large number of people working in many different roles, communication and interaction among team members is critical for a project to succeed. To keep the team running smoothly, projects are ideally structured so they include the following:

• deadlines that provide sufficient time for team members to fully complete their tasks and ensure results that match the requirements
• standards for how business and technology decisions are made to avoid business or technology-related disagreements
• processes and procedures that make it easy for team members to coordinate their activities
• clear definitions of each team members’ role and authority so that everyone knows who is accountable for each task and where questions should be directed

Cost Management

An important part of the role of a software engineer is to handle the project management triangle of timeliness, quality, and cost. The goal is to deliver projects as quickly as possible with the highest quality and the lowest cost. Doing this requires good communication, planning, and focus as well as the setting of realistic expectations. Furthermore, because the cost of maintaining a software solution over time can be significant, various cost-management strategies must be used to manage costs effectively. These strategies include the use of estimation techniques, resource allocation, and cost tracking tools. Estimation techniques help create accurate estimates of project scope and effort, and cost, which helps with budgeting and resource allocation. Resource allocation involves assigning the right people (i.e., those with the necessary skills) to complete each task, and this helps optimize efficiency and cost. Cost tracking tools help track project costs and identify areas for potential savings.

The ongoing evolution of computing technology, such as web, mobile, and cloud computing, has had a significant impact on the way modern software engineering is done. Nevertheless, it is still common to get into trouble when designing and developing high-quality software on time and within budget. The major reasons for that are as follows:

• Software systems are the most complex types of systems humans create.
• The pace of change in computer and software technology is high. The programming techniques and related processes that work well when used individually or in a small team fail when applied in a large team developing a large complex system.
• There are not enough qualified software engineers, and thus software systems are designed and developed by people who have insufficient backgrounds or experience.

Software Engineering and Computer Science

Where does software engineering fit within computer science? Both software engineering and computer science deal with the creation of software, and while there appears to be an overlap between these two disciplines, software engineering tends to focus on software applications, more specifically, on the design and development of software solutions. This makes software engineering a branch or subarea of computer science.

Computer science focuses on the study of algorithms and their realization in terms of computers, computer systems, and related computational processes. It focuses heavily on the theoretical and mathematical principles involved with the creation of algorithms and data structures. While computer science includes software engineering, it also covers a variety of other disciplines. In comparison, software engineering focuses specifically on the application of engineering principles to understand, design, construct, and deploy production software. It starts with eliciting and analyzing requirements and results in providing a practical software solution that meets those requirements. Computer science goes beyond just creating software solutions, and includes software design and development. While software engineers need to have a solid knowledge of fundamental computer science (e.g., the basics of algorithms and data structures), they are not expected to exhibit the same level of theoretical knowledge as that of a computer scientist. For example, while a computer scientist would need to be able to establish the asymptotic time complexity of the algorithms they pick, a software engineer would not.

Software engineering departs from the general focus of computer science and is complementary in the following ways:

• Software engineering tends to focus on applying technology to create solutions, whereas computer science tends to focus much more on understanding the technology itself.
• Software engineering tends to focus on software. Computer science can focus on software, hardware, and the interaction between the two.
• A software engineer tends to focus on developing solutions that meet the requirements of an organization or project. A computer scientist tends to focus on the underlying computational processes required to create solutions in the optimal or most efficient ways.

The essence of the software engineering practice is based on the work of numerous researchers such as the mathematician George Pólya. Pólya’s heuristic for generalized problem-solving includes the following steps:

1. Understand the problem.
2. Devise a plan.
3. Carry out the plan.
4. Look back and examine the solution.

Categories of Software

There are three main categories of software. Software that enables you to control hardware and provides an environment in which other software can run is called system software. An example of this is an operating system, such as Microsoft Windows, Android, and MacOS, which runs on a laptop or a mobile phone and typically controls and provides access to the computer’s basic functionality. This system software also includes driver software, which is the code used by hardware devices to interact with the operating system.

Software that enables you to fulfill common tasks, such as creating a text document, drawing a picture, or playing music, is called application software. Examples include Microsoft Word and Paint, MacOS Pages, and iOS Files. Application software may include specialized categories of software such as scientific (or engineering) software, which is software that aids you in solving mathematical, scientific, and engineering problems, such as finding the roots of an equation. It can also include software services, which are software programs that provide specific responses or actions based on a request, such as returning stock quotes, obtaining weather conditions, or finding what current jobs are available.

Software that is integrated with hardware and can include both application and system software features is called embedded software. Examples include software in a smartwatch, an automobile control system, or microwave. Interaction with embedded software is usually limited, and users are often unaware that they are interacting with software. With the increased popularity of the Internet of Things (IoT), embedded software development is increasing.

Software engineers must often deal with legacy software that has been written in the past, relies on obsolete technology, and is still in use today. This software presents special challenges to those who maintain it, especially when they need to adapt it to a new computing environment or technology and when they are to extend its functionality so that it is interoperable with new software systems. The need for software maintenance of legacy software stems from the rapid changes that have taken place in hardware. For example, a common smartphone contains a more powerful processor and more memory than computers that were used just twenty years ago. Changes in hardware are accompanied by changes in software technologies, and these are quickly adopted by users who are then reluctant to use legacy software in its original shape. For example, the graphical user interface of a software system that was developed twenty years ago now looks outdated and leads to an unpleasant user experience.

There have also been dramatic changes in processor technology. Twenty years ago, most processors consisted of a single core, while now it is common for a processor to have multiple cores and coprocessors. This requires changes in how software is programmed because software that can utilize multiple processor cores has a competitive advantage compared with software that uses only a single core. To support these new capabilities, major programming languages have evolved toward supporting multithreading, which makes maintenance of a legacy code base even more challenging.

Software Requirements

Software is developed based on requirements, which are categorized as functional and nonfunctional, as shown in Figure 9.2. Functional requirements state what the software needs to do in terms of tangible functionality, such as the login or registration functionality that allows users to access a given piece of software such as their Facebook account. Nonfunctional requirements are measurable qualities of a piece of software, such as usability, performance, and other quality aspects.

Figure 9.2 The various types of software requirements can be organized in hierarchies as functional and nonfunctional requirements based on aspects that relate to what the software does along with the qualities of the software. (attribution: Copyright Rice University, OpenStax, under CC BY 4.0 license)

As noted earlier, a functional requirement relates to the services the system provides to the users. It reflects the user’s expectation about the inherent characteristics of the software, (i.e., the functions it must perform). Functional requirements can include those phenomena that are generally seen or done when using a software solution, such as the information that is entered or that is generated by the software, the authenticating rules for using the software, or whether there should be an audible alert (such as a beep) when an action is selected. A nonfunctional requirement describes a desired quality or feature (i.e., constraint) and covers aspects of the software such as flexibility, maintainability, performance, portability, reliability, scalability, security, and more. For example, a nonfunctional requirement could specify that responses from the software must occur within a specific time frame, or that a software system must be able to handle a certain number of transactions at any given time. Another example of a constraint that a nonfunctional requirement may express is the need to use a specific programming language or follow a particular standard.

Nonfunctional features are sometimes categorized in terms of static or dynamic qualities. A static quality is a nonfunctional feature that is unchangeable and thus might be associated, for example, with the source code and related documentation, or with legal or project-environment specific requirements. A dynamic quality is a nonfunctional feature that relates to the qualitative behavior of software while it is in use, which means that is also depends on the hardware that the system runs on. Both quality types are measurable features rather than functions that are present or absent. Examples of static qualities include:

• maintainability, which is a measure of the amount of work required to fix bugs, improve performance, and keep the system running
• extensibility, which is a measure of the amount of work and cost of adding new features to software
• flexibility, which is a measure of the difficulty of updating the system to meet changing requirements
• portability, which is a measure of the amount of work and cost of migrating software solutions
• usability, which is a measure of how intuitive the user interface is

Examples of dynamic qualities are:

• performance, which is a measurement of how quickly the system responds to requests it receives
• throughput, which is a measure of how much input the system can process within a given time frame
• availability, which is a measure of how often the system will be ready and active for users
• scalability, which is the measurement of the work and cost to increase a system’s throughput
• security, which is a measure of confidence that data is protected from unauthorized disclosure and that systems are protected from unauthorized access

The relative importance of the preceding characteristics depends on the solution requirements and the environment in which they are to be used. For example, in an Internet banking application, availability and usability are typically key features advertised to customers. Security would also be important, as the software solution would need to comply with regulatory requirements. In a brokerage system, performance would be an important requirement because the software system will need to display prices and process users’ orders in real time.