The Unix Developer bootcamp teaches fundamental skills for becoming a competent Unix or Linux developer by training students to work with the command line interface and write shell scripts in a Unix environment. The bootcamp also provides a through comprehensive introduction to the ANSI C language, emphasizing portability and structured design. Students can choose from either C++ or Java programming as their final course to complete the track.
You’ll learn the important commands, file system structure and navigation, process creation and management as well as comprehensive practice writing Korn and Bash shell scripts. You will be introduced to all major C language elements including fundamental data types, flow control, and standard function libraries.
Program Highlights:
- Navigating the file system
- Controlling file access
- Manipulating files and links
- Controlling the Terminal
- Working with vi
- Working with secure shells
- How to write and run shell scripts
- Using the C preprocessor
- Using standard runtime libraries
- Using make to build programs
- Declaring and initializing arrays and multidimensional arrays
- Writing programs in either C++ or Java
Required Courses:
- UNIX/Linux Fundamentals and Shell Scripting (35 hours)
- C Programming (35 hours)
Choose One Course:
- C++ Programming for C Programmers (28 hours)
- Java Programming (35 hours)
Optional Course: Object Oriented Analysis & Design with UML (28 hours)
Course Track Options:
- 3-course track: $3,600
- 4-course track: $4,800
Note: This is an on-demand class and the student can start anytime after purchase. Date posted is just a tentative start date
UNIX/Linux Fundamentals and Shell Scripting
This hands on course provides training on standard UNIX/Linux commands and utilities used for day to day tasks including file manipulation, program execution and control, and effective use of the shell and desktop environments. The course presents the concepts necessary to understand the way UNIX works as well as the system's most commonly used commands. Data manipulation utilities and shell syntax for synthesizing command pipelines are emphasized. Bourne shell, Bash shell and Korn shell programming techniques are introduced so students will be able to read and modify existing shell scripts as well as create their own. Desktop environments are also introduced from a user's perspective, including common window managers, Open Office utilities and an introduction to configuration tools. Comprehensive hands on exercises are integrated throughout to reinforce learning and develop real competency.
Duration: 35 hours
Prerequisites: None.
Students Will Learn:
- Introduction to UNIX
- UNIX Login Session
- Text Editing
- The File System
- UNIX Processes
- Introduction to Shell Syntax
- Backing Up Files
- Printing
- Communicating Over the Network
- UNIX GUI Fundamentals
- KDE Desktop
- GNOME Desktop
- Korn and Bash Shell Enhancements
- Writing Scripts
- Programming Logic
- Manipulating Strings
- Command-Line Processing
- Text File Manipulation
- Functions
- Compound Commands
- Process Management
- Advanced Customization of the Shell Environment
- Advanced I/O with Streams
- Security
- Performance and Porting Issues
Course Overview:
Introduction to UNIX
- Design Philosophy
- System Components
- The Shell and Command Entry
- Documentation
Basic User Commands
- Logging In and Logging Out
- Command Line Editing
- Navigating the File System
- Viewing and Copying Files
- Controlling the Terminal
- Sending and Receiving Mail
Text Editing
- Types of Editors
- From ed to ex to vi
- Basic Editor Tasks with vi
- Editing Multiple Files
- Named Buffers
- vi Startup File
UNIX Processes
- The UNIX Process Model
- Process States
- Monitoring and Controlling Processes
The File System
- File System Organization
- File Types
- File and Directory Naming Rules and Conventions
- Commands for Navigating the File System
- Introduction to Inodes
- Ownership, Permissions, and Dates
- Manipulating Files and Links
- Manipulating Directories
- Determining Disk Usage
- Other File System Utilities
Introduction to Shells: sh, bash, and ksh
- Shell Functions
- I/O Redirection and Pipes
- Command Separation and Grouping
- Background Execution
- Filename Expansion
- Shell Variables
- Command Substitution
- Quoting and Escaping Metacharacters
- Bash Shell Features
- Korn Shell Features
- Command Execution
- Startup Files
- Customizing the User Environment
Printing
- Printing Under AT&T UNIX
- Printing Under BSD UNIX
Multitasking and Batch Processing
- Multitasking
- Scheduled Execution Using cron
- The at and batch Commands
Shell Programming
- Shell Script Features and Capabilities
- Creating and Running a Script
- Working With Variables
- Environment Variables
- Working With Data Types
- Formatting
- Base Conversion
- Setting Special Attributes - Input/Output Techniques
- Conditional Constructs
- if/then
- else/elif - Looping Constructs
- for, while, until - Math Operators
Advanced Shell Features
- Manipulating Strings
- Writing and Calling Functions
- Controlling Process Priorities
- Interpreting Command Line Arguments
- Making Scripts Interactive
- Special Shell Variables
- Advanced I/O with Streams
- Improving Performance of Scripts
Text Manipulation Utilities
- Editing a File from a Script
- Scripting with ed or sed
- UNIX and Linux Utilities to Manipulate Files
- Regular Expressions
- grep and egrep
- The Stream Editor sed
- Sorting in Scripts
- Generating Reports with awk
- Splitting Large Files
- Counting Words, Lines, and Characters
- Transforming File Contents
- Extracting Text Strings
File Processing Utilities
- Examining and Comparing Files
- Reporting Differences Between Files
- Comparing Files of Any Format
- Displaying Data in Octal and Hex
- Compressing Data
- Converting File Formats
Backing Up Files
- Backup Media
- UNIX Device Names
- tar and cpio
- File Transport and Conversion with dd
Networking Commands
- UNIX Network Applications
- Remote Execution Commands
- Remote Activity Reporting
- Communicating with Remote Users - Internet Applications
- ftp, tftp, telnet - Remote Access Control Mechanisms
- Using the Secure Shell(ssh)
C Programming
This hands on C programming course provides a comprehensive introduction to the ANSI C language, emphasizing portability and structured design. Students are introduced to all major language elements including fundamental data types, flow control, and standard function libraries. Thorough treatment is given to the topics of string and character manipulation, dynamic memory allocation, standard I/O, macro definition, and the C runtime library. The course explains the use of aggregate structures, unions, and pointers early on so the students can practice extensively in the hands on labs. Structured programming constructs and varargs functions are also covered. Emphasis is given to the processing of command line arguments and environment variables so students will be able to write flexible, user-friendly programs. The course also includes coverage of portability tips drawn from experienced programmers working in production environments. Comprehensive hands on exercises are integrated throughout to reinforce learning and develop real competency.
Duration: 35 hours
Prerequisites: Prior experience with a scripting or programming language is required.
Students Will Learn:
- C Language Basics and Development Environment
- Fundamental Data Types, Storage Classes and Scope
- typedef and Macros
- Operators and Expressions
- Flow Control Constructs
- Basic Character and Formatted I/O
- Pointers and Dynamic Allocation
- Functions
- Arrays
- Strings and Character Manipulation
- Structures
- Advanced Structures and Unions
- Accessing Command Line Arguments and Environment Variables
- Advanced Macro Design
- C Runtime Library Standard I/O Functions
Course Overview:
Overview of C
- Operating System Independence
- Design Goals and Capabilities
- Flavors of C
Compiler Directives and the C Preprocessor
- Compile-Time Directives
- Use of typedef
- C Preprocessor Syntax
Fundamental Data Types, Storage Classes, and Scope
- Fundamental Data Types and Qualifiers
- Constants and Strings
- Storage Classes
- Scope and Block Structure
- Scope and Data Hiding
- Data Initialization
Pointers and Dynamic Allocation
- Advantages of Pointers
- User of Pointers
- Pointer and Address Arithmetic
- Dynamic Storage Allocation
- sizeof Operator
- Double Indirection
Macros
- Functions vs. Inlining
- Purpose of Macros
- Use of Macros
- Making Code More Readable
- Auto Adjustment of Compile Time Values
- Conditional Compilation
- Making Code Portable
- Simplifying Complex Access Calculations - Advanced Micro Design Tips
- Using Macros to Help Write Portable Programs
- When to Use a Macro instead of a Function
- Using Macros for Debugging
Arrays
- Purpose of Arrays
- Declaring an Array
- Initializing an Array
- Addressing Elements
- Stepping Through an Array
- Variable Size Arrays
- Arrays of Pointers
- Arrays of Strings
- Passing an Array to a Function
- Dynamic Memory Allocation
- Multidimensional Arrays
Basic Formatted I/O
- Standard I/O Library
- Character Set Encoding
- Standard Input and Output
- Character I/O Functions
- Formatted I/O Functions
- String Constants
Program Debugging
- Problem Analysis
- Instrumenting with printif
- Instrumenting with ctrace
- The Purpose of Debuggers
- How Not to Use Debuggers
- Symbolic Debuggers
Operators and Expressions
- Arithmetic, Logical, and Bit Operators
- Precedence and Associativity
- Assignment and Casting
- The Conditional Operator
Flow Control Constructs
- Conditional Constructs: if, switch
- Looping Constructs: while, do, for
- Programming Style
Functions (Subroutines)
- Purpose of Functions
- Functions vs. Inlining
- Automatic Variables
- The Argument Stack
- Passing By Value
- Passing By Reference
- Declaring External Functions
- Function Prototyping
- ANSI Prototyping
- The _NO_PROTO Compiler Symbol
- Varargs Functions
- Passing a Function as an Argument
- Designing Functions for Reusability
- Calling a Function from Another Language
- Returning a Dynamically Allocated Value Using Double Indirection
- Casting the Return Value of a Function
- Recursion and Reentrancy
Structures
- Purpose of Structures
- Defining and Declaring Structures
- Accessing Members
- Pointers to Structures
- Dynamic Memory Allocation
- Passing a Structure to a Function
- As a Pointer
- Passing the Actual Structure
Advanced Structures and Unions
- Nested Structures
- Arrays of Structures
- Bit Fields
- Unions
- Linked Lists
C Runtime Library Standard Functions
- Character I/O
- Unformatted File I/O
- Formatted File I/O
- Math Functions
- Miscellaneous Functions
Strings and Character Manipulation
- Strings as Character Arrays
- String Library Functions
- Reading and Writing Strings
Accessing Command Line Arguments and Environment Symbols
- argc and argv
- Parsing Command Line Options
- Accessing the Environment Array
Structured Programming
- Structuring Code for Quality, Reliability, Maintainability
- Designing for Modularity and Reusability
Advanced Programming Consideration
- Writing Portable Code
- Use of Macros
- ANSI C Limits
- Feature Test Macros
- Client/Server Design
- Performance Considerations
Course Choice: C++ Programming for C Programmers
This hands on C++ training course presents a thorough introduction to object-oriented programming in C++ for experienced C programmers. The central concepts of C++ syntax and style are taught in the context of using object-oriented methods to achieve reusability, adaptability and reliability. Emphasis is placed on the features of C++ that support abstract data types, inheritance, and polymorphism. Students will learn to apply the process of data abstraction and class design. Practical aspects of C++ programming including efficiency, performance, testing, and reliability considerations are stressed throughout. Comprehensive hands on exercises are integrated throughout to reinforce learning and develop real competency.
Duration: 28 hours
Prerequisites: Prior programming experience with C.
Students Will Learn:
- Fundamental Features in C++
- Object-Oriented Concepts
- Encapsulation in C++: Introduction to Classes
- Constructors and Destructors
- Operator Overloading
- Inheritance
- Virtual Functions, Polymorphism and Multiple Inheritance
- Streaming I/O
- Templates
- The Standard Library
- Strings in C++
- Exception Handling
Course Overview:
Moving from C to C++
- New Compiler Directives
- Stream Console I/O
- Explicit Operators
- Standard Libraries
- Data Control Capabilities
Handling Data
- New Declaration Features
- Initialization and Assignment
- Enumerated Types
- The bool Type
- Constant Storage
- Pointers to Constant Storage
- Constant Pointers
- References
- Constant Reference Arguments
- Volatile Data
- Global Data
Functions
- Function Prototypes and Type Checking
- Default Function Data Types
- Function Overloading
- Problems with Function Overloading
- Name Resolution
- Promotions and Conversions
- Call by Value
- Reference Declarations
- Call-by-Reference and Reference Types
- References in Function Return
- Constant Argument Types
- Conversion of Parameters Using Default Initializers
- Providing Default Arguments
- Inline Functions
Creating and Using Objects
- Creating Automatic Objects
- Creating Dynamic Objects
- Calling Object Methods
- Constructors
- Initializing Member consts
- Initializer List Syntax
- Allocating Resources in Constructor
- Destructors
- Block and Function Scope
- File and Global Scope
- Class Scope
- Scope Resolution Operator ::
- Using Objects as Arguments
- Objects as Function Return Values
- Constant Methods
- Containment Relationships
Dynamic Memory Management
- Advantages of Dynamic Memory Allocation
- Static, Automatic, and Heap Memory
- Free Store Allocation with new and delete
- Handling Memory Allocation Errors
Controlling Object Creation
- Object Copying and Copy Constructor
- Automatic Copy Constructor
- Conversion Constructor
- Inheritance
Inheritance and Reuse
- Composition vs. Inheritance
- Inheritance: Centralized Code
- Inheritance: Maintenance and Revision
- Public, Private and Protected Members
- Redefining Behavior in Derived Classes
- Designing Extensible Software Systems - Syntax for Public Inheritance
- Use of Common Pointers
- Constructors and Initialization
- Inherited Copy Constructors
- Destructors and Inheritance
- Public, Protected, Private Inheritance
Streaming I/O
- Streams and the iostream Library
- Built-in Stream Objects
- Stream Manipulators
- Stream Methods
- Input/Output Operators
- Character Input
- String Streams
- Formatted I/O
- File Stream I/O
- Overloading Stream Operators
- Persistent Objects
Introduction to Object Concepts
- The Object Programming Paradigm
- Object-Orientated Programming Definitions
- Information Hiding and Encapsulation
- Separating Interface and Implementation
- Classes and Instances of Objects
- Overloaded Objects and Polymorphism
Templates
- Purpose of Template Classes
- Constants in Templates
- Templates and Inheritance
- Container Classes
- Use of Libraries
Strings in C++
- Character Strings
- The String Class
- Operators on Strings
- Member Functions of the String Class
Exceptions
- Types of Exceptions
- Trapping and Handling Exceptions
- Triggering Exceptions
- Handling Memory Allocation Errors
C++ Program Structure
- Organizing C++ Source Files
- Integrating C and C++ Projects
- Using C in C++
Reliability Considerations in C++ Projects
- Function Prototypes
- Strong Type Checking
- Constant Types
- C++ Access Control Techniques
Polymorphism in C++
- Definition of Polymorphism
- Calling Overridden Methods
- Upcasting
- Accessing Overridden Methods
- Virtual Methods and Dynamic Binding
- Virtual Destructors
- Abstract Base Classes and Pure Virtual Methods
Multiple Inheritance
- Derivation from Multiple Base Classes
- Base Class Ambiguities
- Virtual Inheritance
- Virtual Base Classes
- Virtual Base Class Information
Declaring and Defining Classes
- Components of a Class
- Class Structure
- Class Declaration Syntax
- Member Data
- Built-in Operations
- Constructors and Initialization
- Initialization vs. Assignment
- Class Type Members
- Member Functions and Member Accessibility
- Inline Member Functions
- Friend Functions
- Static Members
- Modifying Access with a Friend Class
Operator Overloading
- Advantages and Pitfalls of Overloading
- Member Operator Syntax and Examples
- Class Assignment Operators
- Class Equality Operators
- Non-Member Operator Overloading
- Member and Non-Member Operator Functions
- Operator Precedence
- The this Pointer
- Overloading the Assignment Operator
- Overloading Caveats
The Standard Template Library
- STL Containers
- Parameters Used in Container Classes
- The Vector Class
- STL Algorithms
- Use of Libraries
Course Choice: Java Programming
This hands on course introduces experienced programmers to Java™ technology and Java programming techniques. The Java platform provides an object-oriented, portable and robust framework for application development. Included are core language concepts including fundamental data types, flow control, and standard function libraries. The course emphasizes object oriented programming and modular design to support distributed development environments. Included are the design of classes and objects, inheritance and polymorphism, and the details about creating programs for use on a distributed network, with emphasis on JSP, Servlets, and JDBC.The course also includes coverage of the Java Collections API, fundamental I/O, exceptions, and exception handling.
The course is designed to leverage the participants' existing programming skills and to highlight the new and extended features of the Java programming framework as compared to other common languages. Comprehensive hands on exercises are integrated throughout to reinforce learning and develop real competency.
Duration: 35 hours
Prerequisites: Basic programming skills in a structured language. Knowledge and experience with Object-Oriented Design (OOD) is helpful, but not required.
Students Will Learn:
- Introduction to Java
- Developing Software With Java SE
- Java Fundamentals
- Flow of Control
- Data Types and Operators
- Using Java Objects
- Arrays
- Developing Java Classes
- Inheritance and Interfaces
- Type Safety
- The Collections Framework
- Exceptions and Exception Handling
- Basic Input and Output (I/O
- Network Programming
- Threads
- Java Database Connectivity (JDBC)
- Introduction to Java Web Applications
- Rich Internet Applications with Java
Course Overview:
Introduction to Java
- Cornerstones of the Java Platform
- Java Advantages
- The Java Programming Language
- The Java Virtual Machine (JVM)
- Core Java Libraries
- Extension Libraries
Developing Software Using Java
- Applications, Applets, Web Components
- Java SE, Java EE, Java ME
- Installing the JDK
- Compiling and Running Java from the Command Line
- The main() Method
- package and import Statements
- JAR Files
- Class Loading and CLASSPATH
- Online API Documentation
- JDK Tools
- Java Integrated Development Environments (IDEs)
Java Syntax Fundamentals
- Comments
- Identifiers
- Reserved Words
- Classes
- Statements and Blocks
- Variables, Constants, Literals
- Scope of Variables
- Methods
- Method Overloading
- static Members
- Static Import (Java SE 5+)
- Naming Conventions
Data Types and Operators
- Primitive Types
- Boolean, Integer, Floating-Point and Character Types
- Unicode Characters and Strings
- Type Conversion and Casting
- Expressions and Operators
- Arithmetic Operators
- Increment/Decrement Operators
- Division and Remainder Operators
- Assignment Operators
- Relational Comparison and Logical Operators
- Conditional Operator
- Bitwise Operators
- Order of Evaluation
- Operator Precedence and Associativity
Flow of Control
- if/else Statement
- Combining ifs
- while and do/while Loops
- for Loop and Loop Counters
- break and continue
- Break to Labeled Loops
- switch Statement
- return Statement
- Exit Status
Using Java Classes and Objects
- Classes as Data Types
- Objects and References
- Memory in the JVM
- Object Initialization
- Objects as Arguments to Methods
- Objects as Return Values
- Garbage Collection
- Primitive Wrapper Classes - Integer, Double, etc.
- Autoboxing and Unboxing (Java SE 5+)
Strings
- String Manipulation
- StringBuffer and StringBuilder
- Simple Number/String Conversion
Arrays
- Declaring and Allocating Arrays
- Multi-Dimensional Array
- Array Literals
- The java.util.Arrays Class
- Command-Line Arguments
- Enhanced for Loop (Java SE 5+)
- Arrays as Method Arguments
- Variable-Length Arglists (varargs) (Java SE 5+)
- Autoboxing and varargs
Developing Java Classes
- Object-Oriented (OO) Concepts
- Methods, Member Variables
- Accessing Members
- Tight Encapsulation
- Access Control Modifiers
- Constructors and Finalizer
- Using this
- Class Variables - Static Members and Static Blocks
- Instance Variables
- Local Variables
- Variables and Initialization
- Inner Classes
- Anonymous Classes
- JavaBeans
- Driver Classes
Inheritance
- Extending Java Classes
- Accessing Superclass Constructors and Members
- Overriding Methods
- Abstract CLasses and Methods
- Polymorphism
- Overriding Methods of java.lang.Object
- equals(), toString(), hashCode()
- Final Classes and Methods
- Multiple Inheritance
- Interfaces
- Casting Object References
- Documenting Classes with the javadoc Utility
- Unit Testing
Type Safety
- Annotations (Java SE 5+)
- Java SE Built-In Annotations
- Defining New Annotations
- Enumerated Types (Java SE 5+)
- Constants and Constrained Values
- Defining and Declaring enums
- enum Values
- enums and switch Statements
- values() and valueOf()
- Generic Classes (Java SE 5+)
- Generic Type Parameters
- Using Type Parameters inClass, Variable and Method Declarations
- Using a Generic Class
- Bounded Type Parameters
The Collections Framework
- The java.util Package
- Container Objects
- Arrays as Containers
- Legacy Container Classes - Vector, Hashtable, Enumeration
- Legacy Container Generic Forms (Java SE 5+)
- Collections Interfaces - Collection, List, Set, SortedSet
- Map Interfaces - Map
- Coding to the Interface
- List, Set, Queue and Map implementations
- Iterating Collections with the Iterator Interface
- Collections and the Enhanced for Loop
- Choosing the Correct Implementation and Interface
- The java.util.Collections Utility Class
- Sorting Using the Comparable Interface
Exceptions and Exception Handling
- The Throwable Hierarchy: Error, RuntimeException and Checked Exception
- Methods that Throw Exceptions
- Handling Exceptions with try-catch-finally Blocks
- Application-Defined Exceptions
- Throwing an Exception
- Assertions (Java 1.4+)
- Enabling Assertions at Run-Time
Basic Input and Output (I/O)
- The java.io Package
- Using Stream Classes
- Combining Streams
- flush() and close()
- Console Input and Output
- Navigating the File System
- File Streams
- Character File Input and Output
- Reader and Writer Interfaces
- BufferedReader and BufferedWriter
- Binary File I/O - DataOutputStream and DataInputStream
- Object Streams - ObjectInputStream and ObjectOutputStream
- Serialization and Versioning
- Random Access Files
- Formatted Input and Output
- Formatter (Java SE 5+)
- Format specifiers, printf() and format()
- java.text Classes for Formatting Dates, Numbers, Currencies
- Input with Scanner (Java SE 5+)
Network Programming
- The java.net Package
- IP Addresses and Port Numbers
- Client/Server Socket Programming
- URL and URLConnection Classes
- Communicating with Web Servers
- HTTP GET and POST Operations
- Posting to a Server-Side Program
Threads
- Life and States of a Thread
- Creating and Starting a Thread
- java.lang.Runnable and java.lang.Thread
- Stopping a Thread
- Inter-Thread Communication
- Thread-Safe Access to Shared Objects and Variables
- Synchronized Code
- Sleeping
- Interrupting a Blocked Thread
- wait(), notify(), notifyAll() Example
- Thread Scheduling
- Thread Groups
- Writing a Multithreaded Server
Java Database Connectivity
- The java.sql Package
- JDBC Architecture and Drivers
- SQL Exceptions
- DriverManager, Connection, Statement and ResultSet Interfaces
- Examining Database MetaData
- Basic Query and Update
- Improving Performance with PreparedStatement and CallableStatement Interfaces
- JDBC Transaction Management
Java Web Applications
- Java Enterprise Edition
- Java EE Application Servers
- Web Application Directory and WAR files
- Deploying a Web Application - The web.xml File
- Servlet Architecture
- The javax.servlet Package
- Servlet Classes and Interfaces
- Writing a Servlet
- HttpServletRequest and HttpServletResponse
- Handling HTML Forms
- Retrieving Request Parameters
JavaServer Pages (JSPs)
- JSP Lifecycle
- Elements of a JSP
- Directives, Declarative, Scriptlets
- Writing a JSP
- Objects Available in a JSP
- Repeated content in JSPs
- Translation-Time and Request-Time Includes
- Using JavaBeans in a JSP
- Session Management
- Mixing JSPs and Servlets
- Installing and Using Tag Libraries
- The JSP taglib Directive
- The Tag Library Descriptor
Optional Course: Object Oriented Analysis & Design with UML
This OOA&D training course presents the key concepts and methodologies required to perform quality object-oriented software engineering, with particular attention to practical techniques such as use-case and CRC analysis, UML diagramming, and patterns. Students practice applying object oriented analysis during the course to improve software designs and to see how software objects can be altered to build software systems that are more robust and less expensive. Students use several methods for analyzing software systems, finding and refining useful classes and relationships between objects. Care is taken not to focus on any one language so that all students can participate in the design exercises without relying on specific programming skills. The course emphasizes the most practical analysis and design methods, including the application of use case analysis, CRC analysis, problem domain analysis, activity diagramming, interaction diagramming, and class diagramming.
The Unified Modeling Language (UML) is presented in detail and is used in the exercises and case studies. Practical aspects of project management and implementation are presented from the perspective of experienced object system designers. Special emphasis is given to the use of object patterns in developing software systems. The students apply their skills in labs that are mini design sessions, during which the instructor helps the students identify and overcome common obstacles that occur during group sessions.
Duration: 28 hours
Prerequisites: Knowledge of structured programming concepts.
Students Will Learn:
- Object-Oriented Principles
- Introduction to the OOAD Project Lifecycle
- Use Case Analysis
- Class Analysis
- State Machine Diagrams and System Operation Analysis
- Modeling Interactions
- Specification Class Diagramming
- Organizing Large Scale Software Applications
Course Overview:
The Object Paradigm
- Objects and Classes
- Abstraction and Encapsulation
- Methods and Messages
- Interfaces, Inheritance, and Polymorphism
- Access Control
- The Business Case for OO Development
Managing and Participating in the OOA&D Approach
- Information Gathering Techniques
- Group Orientated Problem Solving
- Brainstorming, Role-Playing
- Managing Complexity via the "Iterative and Incremental" Approach
- Managing Design Sessions
- Design vs. Implementation
- Quick Prototyping
- Validation and Quality
Diagramming & Notational Techniques Using the UML
- Overview of Analysis and Design Phases
- UML Notation
- Analysis Diagramming Techniques
- Design Diagramming Techniques
- Generalization/Specialization
- Aggregation and Composition
- Association, Cardinality, Navigability
- Package and Deployment Diagrams
- Icons, Relationships, and Adornments
Requirements and Analysis Phase
- System Functions, Features and Constraints
- Behavioral Analysis
- Domain Analysis
- Identifying Use Cases
- Use Case Descriptions
- Using CRC Cards
- Containment and Composition
- Referential Aggregation
- Inheritance, SubTypes and Is-A Hierarchies
- Association and Link Relationships
- Diagramming System Events
- State Transition Diagramming
Design Phase
- Translating Analysis Concepts into Software Classes
- Optimizing Classes and Objects: The Multi-Tiered Architecture View
- Mapping System Functions to Objects
- Object to Object Visibility
- Collaboration Diagrams
- Sequence Diagrams
- Specifying Object Interfaces
- Specification Class Diagrams
Patterns
- Benefits of Patterns
- Using Patterns During Analysis
- Using Patterns During Design
- Design Patterns (Gang-of-Four Format)
- GRASP Patterns
- Model-View-Controller Pattern
- Persistence Patterns
- Patterns as Internal Documentation
Design Refinement
- Designing for Extensibility
- Designing for Reusability
- Partitioning the Class Space
- Checking Completeness and Correctness
- Testing Business Processes
- Design Metrics
- Discovering Reusable Patterns
Project Management and Implementation Issues
- Planning for Reusability
- Transition Strategies and Planning Legacy System Integration
- Managing the Development Cycle
- Partitioning Work
- Source Code Organization
- Choosing Tools and Languages
- Software Quality Metrics
OO Languages and Tools
- Survey of OO Languages
- The Role of Class Libraries
- The Role of OOA&D Tools
Advanced Design Concepts
- Expanding Inheritance Hierarchies
- Abstract Classes and Virtual Methods
- Overriding and Overloading
- Multiple Inheritance
- Interface versus Implementation Inheritance
Persistent Object and Database Issues
- The Coad Data Management Domain
- Object Persistence
- Object-Orientated Database Management Systems (ODBMS)
- Object Orientated versus Relational Databases
- Mapping Objects to Relational Data Structures