Software Development Process (Udacity)

The goal of this class is to equip you with the skills necessary to define requirements, set up an integrated development environment (IDE), learn Git (and Github!) and use Unified Modeling Language (UML) to design and build an Android application. We will also examine several testing practices and refactoring techniques that are helpful before the launch of your software project.
While everyone working with software should have these skills, they are particularly important for Software Engineers and Engineering Managers.
Software engineering isn’t just about programming. It isn’t just about building a technology stack.
This course introduces the idea of software engineering as an iterative, systematic process. You will learn to use Github and Eclipse as you get introduced to the development life cycle, design processes and software testing.
Software Development Processes will show you the skills and processes needed to complement technical understanding of software products in order to make you a more effective developer in an engineering team.

What You Will Learn

Lesson 1
Introduction and Overview
Importance of Software Engineering
Discipline of Software Engineering
The Software Crisis
Software Phases

Lesson 2
Life Cycle Models
Introduction with Barry Bohem
Requirements Engineering
Design
Maintenance
Software Process Model Introduction
Waterfall Process
Spiral Process
Evolutionary Prototyping Process
Rational Unified Process
Agile Process
Choosing a Model
Lifecycle Documents

Lesson 3
Integrated Development Environment
Eclipse Introduction
IDE Overview
Plug-Ins
Eclipse Demo: Create Java Project
Eclipse Demo: Create a Class
Eclipse Demo: Run Configuration
Eclipse Demo: Debugging

Lesson 4
Version Control Systems
Interview with John Britton
Version Control System Introduction
Two Main Types of VCS
Introduction to Git
Git Workflow
Git Demo: Intro to Git
Git Demo: Git + Eclipse
Git Demo: Github
Git Recap: Local Repositories
Git Recap: Remote Repositories

Lesson 5
Requirements Engineering
Interview with Jane Cleland-Huang
General RE Definition
Software Intensive Systems
Functional and Nonfunctional Requirements
User and System Requirements
Modeling Requirements
Analyzing Requirements
Requirements Prioritization
Requirements Engineering Process

Lesson 6
OO Software and UML
Object Orientation Introduction
UML Structural Diagrams: Class Diagrams
Class Diagram: Creation Tips
UML Structural Diagrams: Component Diagram
UML Structural Diagram: Deployment Diagram
UML Behavioral Diagram: Use Case
Use Case Diagram: Creation Tips
UML Behavioral Diagrams: Sequence
UML Behavioral Diagrams: State Transition Diagram

Lesson 7
Software Architecture
Interview with Nenad Medvidovic
What is Software Architecture?
Prescriptive vs. Descriptive Architecture
Architectural Evolution
Architectural Degradation
Architectural Recovery
Architectural Elements
Components, Connectors, and Configuration
Deployment Architectural Perspective

Lesson 8
A Tale of Analysis and Design
Analyzing Requirements
Refining Classes and Attributes
Adding Attributes
Identifying Operations
Refining the Class Diagram

Lesson 9
Design Patterns
Patterns Catalogue
Pattern Format
Factory Method Pattern
Strategy Pattern
Choosing a Pattern
Negative Design Patterns

Lesson 10
Unified Software Process
Use-Case Driven
Inception Phase
Elaboration Phase
Construction Phase
Transition Phase
Phases and Iterations

Lesson 11
General Concepts
Failure, Fault and Error
Verification Approaches
Pros and Cons of Approaches
Testing Introduction
Testing Granularity Levels
Alpha and Beta Testing
Black and White Box Testing Introduction

Lesson 12
Black-Box Testing
Systematic Functional Testing Approach
Test Data Selection
Category Partition Method
Produce and Evaluate Test Case Specifications
Generate Test Cases from Test Case Specifications
Model Based Testing
Finite State Machines

Lesson 13
White-Box Testing
Coverage Criteria Intro
Statement Coverage
Control Flow Graphs
Test Criteria Subsumption
MC/DC Coverage

Lesson 14
Agile Development Methods
Cost of Change
Agile Software Development
Extreme Programming (XP)
XP’s Values and Principles
Test First Development
Refactoring
Pair Programming
Continuous Integration
Testing Strategy
High Level Scrum Process

Lesson 15
Software Refactoring
Reasons to Refactor
Refactoring Demo
Refactoring Risks
Cost of Refactoring
When Not to Refactor

Prerequisites and Requirements
A strong familiarity with Android development (perhaps through Developing Android Apps) is expected.