Categories

There are currently no items in your shopping cart.

User Panel

Forgot your password?.

Udacity Software Development Process


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