Beginning Software Engineering

Cover
Title Page
Copyright Page
About the Author
Acknowledgments
Contents
Introduction
	What Is Software Engineering?
	Why Is Software Engineering Important?
	Who Should Read This Book?
	Approach
	What This Book Covers (and What It Doesn’t)
	What Tools Do You Need?
	Conventions
	Errata
	Important URLs
	Contacting the Author
	Disclaimer
Part I Software Engineering Step-by-Step
	Chapter 1 Software Engineering from 20,000 Feet
		Requirements Gathering
		High-Level Design
		Low-Level Design
		Development
		Testing
		Deployment
		Maintenance
		Wrap-up
		Everything All at Once
		Summary
		What You Learned in This Chapter
	Chapter 2 Before the Beginning
		Document Management
		Historical Documents
		Email
		Code
		Code Documentation
		Application Documentation
		Summary
		What You Learned in This Chapter
	Chapter 3 The Team
		Team Features
			Clear Roles
			Effective Leadership
			Clear Goals
			Consensus
			Open Communication
			Support for Risk-Taking
			Shared Accountability
			Informal Atmosphere
			Trust
		Team Roles
			Common Roles
			More-Specialized Roles
			Informal Roles
			Roles Wrap-Up
		Team Culture
		Interviews
			Interview Puzzles
			The Bottom Line
		Physical Environment
			Creativity
			Office Space
			Ergonomics
			Work-Life Balance
		Collaboration Software
			Searching
			Overload
		Outsourcing
		Summary
		What You Learned in This Chapter
	Chapter 4 Project Management
		Executive Support
		Project Management
			PERT Charts
			Critical Path Methods
			Gantt Charts
			Scheduling Software
			Predicting Times
				Get Experience
				Break Unknown Tasks into Simpler Pieces
				Look for Similarities
				Expect the Unexpected
				Track Progress
			Risk Management
		Summary
		What You Learned in This Chapter
	Chapter 5 Requirements Gathering
		Requirements Defined
			Clear
			Unambiguous
			Consistent
			Prioritized
			Verifiable
			Words to Avoid
		Requirement Categories
			Audience-Oriented Requirements
				Business Requirements
				User Requirements
				Functional Requirements
				Nonfunctional Requirements
				Implementation Requirements
			FURPS
			FURPS+
			Common Requirements
		Gathering Requirements
			Listen to Customers (and Users)
			Use the Five Ws (and One H)
				Who
				What
				When
				Where
				Why
				How
			Study Users
		Refining Requirements
			Copy Existing Systems
			Clairvoyance
			Brainstorm
		Recording Requirements
			UML
			User Stories
			Use Cases
			Prototypes
			Requirements Specification
		Validation and Verification
		Changing Requirements
		Digital Transformation
			What to Digitize
			How to Digitize
		Summary
			Exercises
		What You Learned in This Chapter
	Chapter 6 High-Level Design
		The Big Picture
		What to Specify
			Security
			Hardware
			User Interface
			Internal Interfaces
			External Interfaces
			Architecture
				Monolithic
				Client/Server
				Component-Based
				Service-Oriented
				Data-Centric
				Event-Driven
				Rule-Based
				Distributed
				Mix and Match
			Reports
			Other Outputs
			Database
				Audit Trails
				User Access
				Database Maintenance
				NoSQL
				Cloud Databases
			Configuration Data
			Data Flows and States
			Training
		UML
			Structure Diagrams
			Behavior Diagrams
				Activity Diagrams
				Use Case Diagram
				State Machine Diagram
			Interaction Diagrams
				Sequence Diagram
				Communication Diagram
				Timing Diagram
				Interaction Overview Diagram
				UML Summary
		Summary
		What You Learned in This Chapter
	Chapter 7 Low-Level Design
		Design Approaches
			Design-to-Schedule
			Design-to-Tools
			Process-Oriented Design
			Data-Oriented Design
			Object-Oriented Design
			Hybrid Approaches
			High, Low, and Iterative Design
		OO Design
			Identifying Classes
			Building Inheritance Hierarchies
				Refinement
				Generalization
				Hierarchy Warning Signs
			Object Composition
		Database Design
			Relational Databases
			First Normal Form
			Second Normal Form
			Third Normal Form
			Higher Levels of Normalization
		When to Optimize
		Summary
		What You Learned in This Chapter
	Chapter 8 Security Design
		Security Goals
		Security Types
		Cybersecurity
		Shift-Left Security
		Malware Menagerie
		Phishing and Spoofing
		Social Engineering Attacks
		Crapware
		Password Attacks
		User Access
		Countermeasures
		Cyber Insurance
		Summary
		What You Learned in This Chapter
	Chapter 9 User Experience Design
		Design Mindset
			UI vs. UX
			UX Designers
			Platform
			User Skill Level
			Beginners and Beyond
			Configuration
			Hidden Configuration
			Models
			Metaphors and Idioms
			Case Study: Microsoft Word
		Design Guidelines
			Allow Exploration
			Make the Interface Immutable
			Support Commensurate Difficulty
			Avoid State
			Make Similar Things Similar
			Provide Redundant Commands
			Do the Right Thing
			Show Qualitative Data, Explain Quantitative Data
			Give Forms Purpose
			Gather All Information at Once
			Provide Reasonable Performance
			Only Allow What’s Right
			Flag Mistakes
		Form Design
			Use Standard Controls
				Decorating
				Displaying
				Arranging
				Commanding
				Selecting
				Entering
			Display Five Things
			Arrange Controls Nicely
		Summary
		What You Learned in This Chapter
	Chapter 10 Programming
		Tools
			Hardware
			Network
			Development Environment
			Source Code Control
			Profilers
			Static Analysis Tools
			Testing Tools
			Source Code Formatters
			Refactoring Tools
			Training
			Collaboration Tools
		Algorithms
		Top-Down Design
		Programming Tips and Tricks
			Be Alert
			Write for People, Not the Computer
			Comment First
			Write Self-Documenting Code
			Keep It Small
			Stay Focused
			Avoid Side Effects
			Validate Results
			Practice Offensive Programming
			Use Exceptions
			Write Exception Handlers First
			Don’t Repeat Code
			Defer Optimization
		Summary
		What You Learned in This Chapter
	Chapter 11 Algorithms
		Algorithm Study
		Algorithmic Approaches
			Decision Trees
				Knapsack
				The Eight Queens Problem
			Exhaustive Search
			Backtracking
			Pruning Trees
			Branch and Bound
			Heuristics
			Greedy
			Divide and Conquer
			Recursion
			Dynamic Programming
			Caching
			Randomization
				Monte Carlo Algorithms
				Las Vegas Algorithms
				Atlantic City Algorithms
			State Diagrams
			Design Patterns
				Creational Patterns
				Structural Patterns
				Behavioral Patterns
				Design Pattern Summary
			Parallel Programming
			Artificial Intelligence
				Definitions
				Learning Systems
				Natural Language Processing
				Artificial Neural Network
				Deep Learning
				Expert System
				Artificial General Intelligence
		Algorithm Characteristics
		Summary
		What You Learned in This Chapter
	Chapter 12 Programming Languages
		The Myth of Picking a Language
		Language Generations
			First Generation
			Second Generation
			Third Generation (3GL)
			Fourth Generation
			Fifth Generation
			Sixth Generation
			IDEs
		Language Families
			Assembly
			Imperative
			Procedural
			Declarative
			Object-Oriented
			Functional
			Specialized
			Language Family Summary
		The Best Language
		Summary
		What You Learned in This Chapter
	Chapter 13 Testing
		Testing Goals
		Reasons Bugs Never Die
			Diminishing Returns
			Deadlines
			Consequences
			It’s Too Soon
			Usefulness
			Obsolescence
			It’s Not a Bug
			It Never Ends
			It’s Better Than Nothing
			Fixing Bugs Is Dangerous
			Which Bugs to Fix
		Levels of Testing
			Unit Testing
			Integration Testing
			Regression Testing
			Automated Testing
			Component Interface Testing
			System Testing
			Acceptance Testing
			Other Testing Categories
		Testing Techniques
			Exhaustive Testing
			Black-Box Testing
			White-Box Testing
			Gray-Box Testing
		Testing Habits
			Test and Debug When Alert
			Test Your Own Code
			Have Someone Else Test Your Code
			Fix Your Own Bugs
			Think Before You Change
			Don’t Believe in Magic
			See What Changed
			Fix Bugs, Not Symptoms
			Test Your Tests
		How to Fix a Bug
		Estimating Number of Bugs
			Tracking Bugs Found
			Seeding
			The Lincoln Index
		Summary
		What You Learned in This Chapter
	Chapter 14 Deployment
		Scope
		The Plan
		Cutover
			Staged Deployment
			Gradual Cutover
			Incremental Deployment
			Parallel Testing
		Deployment Tasks
		Deployment Mistakes
		Summary
		What You Learned in This Chapter
	Chapter 15 Metrics
		Wrap Party
		Defect Analysis
			Species of Bugs
				Discoverer
				Severity
				Creation Time
				Age at Fix
				Task Type
				Defect Database
			Ishikawa Diagrams
		Software Metrics
			Qualities of Good Attributes and Metrics
			Using Metrics
				Process Metrics
				Project Metrics
			Things to Measure
			Size Normalization
			Function Point Normalization
				Count Function Point Metrics
				Multiply by Complexity Factors
				Calculate Complexity Adjustment Value
				Calculate Adjusted FP
		Summary
		What You Learned in This Chapter
	Chapter 16 Maintenance
		Maintenance Costs
		Task Categories
			Perfective Tasks
				Feature Improvements
				New Features
				The Second System Effect
			Adaptive Tasks
			Corrective Tasks
			Preventive Tasks
				Clarification
				Code Reuse
				Improved Flexibility
				Bug Swarms
				Bad Programming Practices
			Individual Bugs
			Not Invented Here
		Task Execution
		Summary
		What You Learned in This Chapter
Part II Process Models
	Chapter 17 Predictive Models
		Model Approaches
		Prerequisites
		Predictive and Adaptive
			Success and Failure Indicators for Predictive Models
			Advantages and Disadvantages of Predictive Models
		Waterfall
		Waterfall with Feedback
		Sashimi
		Incremental Waterfall
		V-model
		Software Development Life Cycle
		Summary
		What You Learned in This Chapter
	Chapter 18 Iterative Models
		Iterative vs. Predictive
		Iterative vs. Incremental
		Prototypes
			Types of Prototypes
			Pros and Cons
		Spiral
			Clarifications
			Pros and Cons
		Unified Process
			Pros and Cons
			Rational Unified Process
		Cleanroom
		Cowboy Coding
		Summary
		What You Learned in This Chapter
	Chapter 19 RAD
		RAD Principles
		James Martin RAD
		Agile
			Self-Organizing Teams
			Agile Techniques
				Communication
				Incremental Development
				Focus on Quality
		XP
			XP Roles
			XP Values
			XP Practices
				Have a Customer On-Site
				Play the Planning Game
				Use Stand-UpMeetings
				Make Frequent Small Releases
				Use Intuitive Metaphors
				Keep Designs Simple
				Defer Optimization
				Refactor When Necessary
				Give Everyone Ownership of the Code
				Use Coding Standards
				Promote Generalization
				Use Pair Programming
				Test Constantly
				Integrate Continuously
				Work Sustainably
				Use Test-Drivenand Test-First Development
		Scrum
			Scrum Roles
			Scrum Sprints
			Planning Poker
			Burndown
			Velocity
		Lean
			Lean Principles
		Crystal
			Crystal Clear
			Crystal Yellow
			Crystal Orange
		Feature-Driven Development
			FDD Roles
			FDD Phases
				Develop a Model
				Build a Feature List
				Plan by Feature
				Design by Feature
				Build by Feature
			FDD Iteration Milestones
		Disciplined Agile Delivery
			DAD Principles
			DAD Roles
			DAD Phases
		Dynamic Systems Development Method
			DSDM Phases
			DSDM Principles
			DSDM Roles
		Kanban
			Kanban Principles
			Kanban Practices
			Kanban Board
		Summary
		What You Learned in This Chapter
Part III Advanced Topics
	Chapter 20 Software Ethics
		Ethical Behavior
			IEEE-CS/ACM
			ACS
			CPSR
			Business Ethics
			NADA
			Hacker Ethics
			Hacker Terms
		Responsibility
			Gray Areas
			Software Engineering Dilemmas
				Misusing Data and the Temptation of Free Data
				Disruptive Technology
				Algorithmic Bias
				False Confidence
				Lack of Oversight
				Getting Paid
		Thought Experiments
			The Tunnel Problem
			The Trolley Problem
		Summary
		What You Learned in This Chapter
	Chapter 21 Future Trends
		Security
		UX/UI
		Code Packaging
		Cloud Technology
		Software Development
		Algorithms
		Tech Toys
		Summary
		What You Learned in This Chapter
Appendix: Solutions to Exercises
	Chapter 1
	Chapter 2
	Chapter 3
	Chapter 4
	Chapter 5
	Chapter 6
	Chapter 7
	Chapter 8
	Chapter 9
	Chapter 10
	Chapter 11
	Chapter 12
	Chapter 13
	Chapter 14
	Chapter 15
	Chapter 16
	Chapter 17
	Chapter 18
	Chapter 19
	Chapter 20
	Chapter 21
Glossary
Index
EULA