Software & Software Engineering Vocabulary
Fundamental Definitions and Characteristics of Software
Definition of Software: Software consists of three distinct components:
Instructions: Computer programs that, when executed, provide desired features, function, and performance.
Data Structures: Structures that enable the programs to adequately manipulate information.
Documentation: Descriptive materials in hard copy and electronic formats that detail the operation and use of the programs.
Characteristics of Software:
Software is developed or engineered; it is not manufactured in the classical sense. Although operational similarities exist between software development and hardware manufacturing, the two activities are fundamentally different in approach.
Software does not "wear out." Unlike hardware, which suffers from cumulative wear-and-tear and environmental degradation over time, software degrades due to change and unmitigated side effects introduced during maintenance.
Most software continues to be custom-built, even though the software engineering industry is progressively moving toward component-based construction.
Software Application Domains and Categories
System Software:
A collection of programs written to service other programs.
Characterized by heavy interaction with computer hardware, widespread usage by multiple users, and concurrent operations requiring complex scheduling, resource sharing, and sophisticated process management.
Features complex data structures and multiple external interfaces.
Application Software:
Stand-alone programs designed to solve a specific business need.
Processes business or technical data to facilitate business operations, management decision-making, or technical problem solving.
Used to control business functions in real time, such as point-of-sale transaction processing and real-time manufacturing process control.
Engineering/Scientific Software:
Historically characterized by "number crunching" algorithms.
Application domains range broadly from astronomy to volcanology, automotive stress analysis to space shuttle orbital dynamics, and molecular biology to automated manufacturing.
Modern interactive applications in this domain, such as computer-aided design (CAD) and system simulation, have increasingly incorporated real-time and system software characteristics.
Embedded Software:
Resides within a product or system and is used to implement and control features and functions for both the end user and the system itself.
Can perform limited, highly specialized functions (e.g., keypad control for a microwave oven) or provide extensive function and control capabilities (e.g., digital systems in an automobile including fuel control, dashboard displays, and braking systems).
Product-Line Software:
Designed to provide a specific capability for use by many different customers.
Addresses niche, esoteric marketplaces (e.g., specialized inventory control products) or mass consumer markets (e.g., word processing, spreadsheets, computer graphics, multimedia, entertainment, database management, and personal or business financial applications).
Web Applications (WebApps):
A network-centric software category spanning a wide spectrum of applications.
Ranges from simple sets of linked hypertext files presenting information via text and basic graphics to highly sophisticated computing environments.
Modern WebApps provide stand-alone computing features, advanced functions, and dynamically served content, while integrating with corporate databases and enterprise business applications.
Artificial Intelligence (AI) Software:
Makes use of nonnumerical algorithms to solve complex problems that are not amenable to straightforward computation or analysis.
Primary application areas include robotics, expert systems, pattern recognition (both image and voice), artificial neural networks, automated theorem proving, and game playing.
Emerging Software Categories
Open World Computing: Pervasive, distributed computing environments operating across heterogeneous devices and systems.
Ubiquitous Computing: Continuous connectivity and computing capabilities delivered through wireless networks and mobile systems.
Netsourcing: Utilization of the Web as a centralized, distributed computing engine.
Open Source: Publicly accessible source code made freely available to the computing community, offering significant collaborative benefits alongside potential software management and security challenges.
Advanced Domain Specializations:
Data mining
Grid computing
Cognitive machines
Software for nanotechnologies
Legacy Software and Reasons for Evolution
Legacy Software: Older software systems that were developed decades ago and continue to provide critical business value.
Reasons Legacy Systems Must Change:
Adaptation: Software must be adapted to run on new computing environments, hardware platforms, or operating technology.
Enhancement: Software must be enhanced to implement evolving business requirements and rule changes.
Extension: Software must be extended to make it interoperable with modern enterprise systems or contemporary databases.
Re-architecture: Software must be re-architected to function effectively within a network or cloud-based environment.
Software Engineering Principles and Definitions
Fundamental Realities of Software Engineering:
A concerted effort must be made to fully understand the problem before any software solution is developed.
Design is a pivotal activity in the development lifecycle.
Software must exhibit high quality across all functional aspects.
Software must be designed to remain maintainable over its entire lifecycle.
Seminal Definition of Software Engineering:
Software engineering is the establishment and use of sound engineering principles in order to obtain economically software that is reliable and works efficiently on real machines.
IEEE Definition of Software Engineering:
Definition 1: The application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software; that is, the application of engineering to software.
Definition 2: The study of approaches as defined in Definition 1.
The Layered Technology of Software Engineering
Layered Structure: Software engineering is an engineering technology structured in four sequential layers:
Quality Focus (Foundational Bedrock): Any engineering approach must be resting on an organizational commitment to quality.
Process Model: The glue that holds the technology layers together; defines the framework that enables timely development of computer software.
Methods: Provides the technical "how-to's" for building software, encompassing requirements analysis, design, program construction, testing, and support.
Tools: Provides automated or semi-automated support for the process model and technical methods.
The Software Process Framework
Process Framework Elements: A general process framework encompasses:
Framework Activities: Applicable to all software projects, regardless of size or complexity.
Work tasks
Work products
Milestones & deliverables
Quality Assurance (QA) checkpoints
Umbrella Activities: Overarch the framework activities and apply throughout the entire software process.
Core Framework Activities
Communication:
Focuses on heavy communication and collaboration with the customer and other stakeholders.
Aims to understand stakeholder objectives for the project and gather requirements that define software features and functionality.
Planning:
Creates a "map" (the software project plan) to guide the development team on its project journey.
Describes technical tasks to be conducted, potential risks, required resources, work products to be produced, and the work schedule.
Modeling:
Involves creating architectural and behavioral "sketches" to understand the big picture.
Encompasses two key sub-activities:
Analysis of Requirements: Understanding problem domain specifications.
Design: Formulating the structure and organization of the software solution.
Construction:
Combines code generation (either manual writing or automated code generation) with comprehensive testing.
Testing is conducted to uncover and resolve errors present in the code.
Deployment:
Delivery of the completed software increment to the customer.
Customer evaluates the delivered product and provides feedback based on the operational evaluation.
Framework Umbrella Activities
Software Project Management: Assesses progress against the project plan and takes action to maintain the project schedule.
Formal Technical Reviews: Evaluates software engineering work products to discover and eliminate errors before they propagate to subsequent activities.
Software Quality Assurance (SQA): Defines and conducts activities required to ensure high software product quality.
Software Configuration Management (SCM): Manages and controls the impact of change across the software process lifecycle.
Work Product Preparation and Production: Encompasses activities needed to generate documentation, models, logs, forms, and lists.
Reusability Management: Defines criteria for work product reuse (including component specifications) and builds mechanisms to achieve reusable components.
Measurement: Collects process, project, and product metrics to assist the team in delivering software that meets stakeholder requirements; used concurrently with all framework and umbrella activities.
Risk Management: Identifies and evaluates risks that could negatively impact project outcomes or product quality.
Process Model Adaptation Parameters
Adaptation Variables: A process model must be adapted based on specific project characteristics, including:
The overall flow of activities, actions, and tasks, and the interdependencies among them.
The degree to which actions and tasks are explicitly defined within each framework activity.
The degree to which work products are identified and required.
The manner in which quality assurance activities are applied.
The manner in which project tracking and control activities are applied.
The overall level of detail and rigor with which the process is described.
The degree of involvement of customers and other stakeholders.
The level of autonomy granted to the software engineering team.
The degree to which team organization and specific roles are prescribed.
The Essence of Software Engineering Practice
George Polya (known as the father of modern problem solving) defined four core problem-solving principles adapted directly into software engineering practice:
1. Understand the Problem (Communication & Analysis):
Who has a stake in the solution to the problem? (Who are the stakeholders?)
What are the unknowns? What data, functions, and features are required to solve the problem?
Can the problem be compartmentalized into smaller, more easily understandable sub-problems?
Can the problem be represented graphically through an analysis model?
2. Plan the Solution (Modeling & Software Design):
Have similar problems been seen before? Are there recognizable patterns in a potential solution? Does existing software implement required data, functions, and features?
Has a similar problem been solved before? If so, are elements of that solution reusable?
Can subproblems be defined, and are solutions readily apparent for those subproblems?
Can the solution be represented in a manner that leads to effective implementation (creating a design model)?
3. Carry Out the Plan (Code Generation):
Does the implementation conform to the plan? Is source code directly traceable to the design model?
Is each component part of the solution provably correct? Have design and code been reviewed, or have algorithm correctness proofs been applied?
4. Examine the Result (Testing & Quality Assurance):
Is it possible to test each component part of the solution? Has a comprehensive testing strategy been executed?
Does the solution produce results that conform to required data, functions, and features? Has software been validated against all stakeholder requirements?
Hooker's General Principles of Software Engineering
Principle 1: The Reason It All Exists: A software system exists to provide value to its users.
Principle 2: KISS (Keep It Simple, Stupid!): All design should be as simple as possible, but no simpler.
Principle 3: Maintain the Vision: Clear architecture and cohesive vision must be preserved throughout development.
Principle 4: What You Produce, Others Will Consume: Design and code with the understanding that others will later rely on and maintain the work.
Principle 5: Be Open to the Future: Build software that can adapt to changing technology and user needs.
Principle 6: Plan Ahead for Reuse: Proactively design systems and components to facilitate reusability.
Principle 7: Think!: Place thoughtful, clear intent behind every decision made during software development.
Software Myths
Target Audience: Software myths affect managers, customers (and other non-technical stakeholders), and software practitioners.
Nature of Myths: Myths persist because they often contain subtle elements of truth.
Consequences: Relying on software myths invariably leads to flawed management, architectural, and operational decisions.
Resolution: Reality and disciplined software engineering practices must be insisted upon throughout software project lifecycles.
Software Project Origins and Business Drivers
Business Need Drivers: Software projects are triggered by specific organizational needs:
The need to correct an identified defect in an existing operational application.
The need to adapt a legacy system to a changing business environment.
The need to extend the functions and features of an existing application.
The need to build an entirely new product, service, or system.