Refresher/SDLC

This is a refresher course for those who need to review basic knowledge of Software Development Life Cycle (SDLC).

Basic Concepts

 * Key development models: waterfall, spiral, evolutionary and agile
 * Key development phases: planning, implementation and deployment
 * Key planning activities: gathering, analyzing and estimating requirements
 * Key implementation activities: coding, testing and documenting
 * Key deployment activities: installation, customization and maintenance

FAQ

 * Effective use of a BA can give waterfall an advantage.
 * Audit proof means that agile is not an option.

Requirements

 * Non-functional requirement: Execution qualities and Evolution qualities
 * Execution qualities: observable at run time, e.g. security and usability
 * Evolution qualities: embodied in the software static structure, e.g. testability, maintainability, extensibility and scalability
 * High performance: C++ providing close to real time processing
 * High usability: best practices in UI, e.g. WPF
 * WPF business case: massive increase in testability through separation of program logic fron the UI
 * High security: SSL, DMZ, and a dozen other best practices in security
 * Techniques for requirements: user stories, functional specification, and UI mockups
 * Requirements tracing: documenting the life of and tracking the changes to requirements
 * Forward tracing: ability to show system impact when a requirement is changed
 * Backward tracing: ability to show user impact when the system is changed
 * Sample requirements tool: Open Source Requirements Management Tool

Requirements - Part 2

 * How to deal with changing requirements: agile -- Scrum & XP
 * Sources for requirements: stakeholders and best practices
 * Requirements prioritization techniques: MoSCoW Analysis -- Must, Should, Could and Won't be part of the final solution.
 * User responsibilities in requirements process: requirements articulation and validation
 * Customer responsibilities in requirements process: requirements gathering and prioritization
 * Developer responsibilities in requirements process: requirements analysis and definition
 * Incomplete or incomprehensible requirements: ask for clarification, or approval of a revised version

Functional Design

 * Metaphor: the use of a vehicle (e.g. stage) to visualize a tenor (e.g. the world)
 * Design: relationship between users with problems to solve and designers with solutions to offer
 * Successful metaphor examples are a menu or a mouse
 * Progress bar: reducing the user's perception of waiting
 * Dropdown: big list in small space
 * Data entry QA measures: show examples, validate entry, check DB, minimize typing, progressive lookup, autocomplete
 * Sample prototyping techniques: sequence diagram, UI mockups, and throw-away code
 * How to anticipate user behavior: modeling based on usage and prediction based on models
 * Access to countless features: menu controls, ribbon interfaces, query language
 * Editor for few items of many fields: listbox for items, tab controls for fields
 * Editor for many items of few fields: use grid control or add logic for grouping, paging, filtering or autocomplete
 * Too many colors: untidy, unprofessional and hard to read
 * Web environment: easier to deploy, more collaboration, slower performance
 * Desktop environment: harder to deploy, less collaboration, faster performance

OOP

 * Programming paradigm (fundamental style): OOP, imperative (emphasizing state changes) and functional (emphasizing use of functions)
 * Functional programming example: int sum = Enumerable.Range(1, 9).Where(i => i % 2 == 0).Sum;
 * Imperative programming example: for (int i = 1; i < 10; i++) if (i % 2 == 0) sum += i;
 * OOP: using objects in programming with object data fields, methods and their interaction
 * OOP features: data abstraction, encapsulation, message passing, modularity, polymorphism, and inheritance
 * Abstraction: what to expose, what to hide
 * Data abstraction: factoring out details
 * Information hiding: the principle of segregation of the design decisions
 * Information hiding example: Weights.Compare(Weight argWeight1, Weight argWeight1)
 * Encapsulation: enclosing in a capsule or object, a technique in information hiding
 * Encapsulation example: Box box1 = new Box; if (box1.Heavier(box2)) { }
 * Messaging passing: objects or processes can wait for messages from others
 * Process synchronization: multiple processes agreeing to a sequence of action
 * Modularity: separation of concerns (features and behaviors)
 * Coupling: degree of interdependencies between modules or classes
 * Cohesion: how much functions or methods within a module are related to another
 * Low coupling: classes should loosely dependent like lego pieces
 * High cohesion: methods highly related like jigsaw puzzle pieces
 * Low coupling and high cohesion: classes like lego, methods like jigsaw puzzle
 * Polymorphism: objects from different types responding to calls by the same name, e.g. operator overloading for addition
 * Inheritance: code reuse by establishing a subtype from an existing object
 * Inheritance example: class Employee extends Resident extends Person
 * Method overriding: providing a method with same name, signature, and return type as that of the parent class
 * Keyword 'internal' in C#: Friend in C++ is not your friend

Technical Design

 * Concurrency control: pessimistic or optimistic locking
 * Pessimistic locking: immediate locking upon request
 * Optimistic locking: clearing at commit time
 * Software design patterns: solution template for many situations
 * OO design pattern: relationships and interactions between classes or objects
 * Mutable: prone to frequent change
 * Creational design patterns: Lazy initialization, Multiton, Singleton, etc.
 * Structural design patterns: Adapter, Composite, Decorator, etc.
 * Behavioral design patterns: Chain of responsibility, Iterator, Memento, etc.
 * Concurrency design patterns: Lock, Scheduler, Thread pool, etc.
 * Iterator design patterns: Collections -- List
 * Stateless protocol: each request a transaction independent of previous requests
 * Stateless object: no attributes, only methods, lower invocation overhead
 * Multi-tier architecture: presentation, application processing, and data management are separate processes
 * Business Logic Layer (BLL): business process objects and business entities
 * Stateless business layer: minimal overhead for long-running transactions
 * Entity Data Model (EDM) diagrams: scalar properties, navigation properties, etc.
 * Sequence diagram: interaction diagram showing how processes operate with one another and in what order
 * ArchiMate: an open and independent enterprise architecture modeling language
 * Component-based design (CBD): a reuse approach to defining, implementing and composing loosely coupled independent components into systems
 * Software component: a software package, a Web service, or a module that encapsulates a set of related functions
 * Service-orientation: a design paradigm to build computer software in the form of services
 * Service-oriented architecture: a set of principles and methodologies for designing and developing software in the form of interoperable services
 * SOA principles: reuse, granularity, modularity, composability, componentization and interoperability
 * CBD or SOA: application of OOP at a higher level, e.g. to encapsulate a service as provided by an independent vendor

Construction

 * How to handle error situations: Identify and unit-test normal error conditions (positive, negative and exception). Wrap all in try and catch blocks, ending in a generic Exception block.
 * TDD: tiny cycle repetition of red, green and refector -- failing test script, code to pass, refactor to standards
 * XP key principles: rapid feedback, incremental change and assuming simplicity
 * Code review: systematic examination of source code through peer review
 * Code review tools: style checkers, static checkers, unit-testing suites
 * Review forms: pair programming, informal walkthroughs or formal inspections
 * Essential tools outside of IDE: version control, scripting languages, google, unit testing frameworks, continuous integration systems
 * Safe and fast: basic security, time complexity, then micro improvement

Abstract and Interface

 * Abstract class (in C++, pure virtual method): blueprint for a class without any implementation and thus cannot be instantiated
 * Abstract class methods: not all must be abstract, some can be concrete
 * Abstract class required: when at least one of the methods in the class is abstract
 * Abstract method: require non-abstract derived classes to provide their own implementation of this method
 * Interface class: an abstract class with public abstract methods all of which must be implemented in the inherited classes
 * Interface class methods: all must be abstract and public and thus accessibility modifiers not needed
 * Multiple interfaces: can be inherited
 * Namespace class: classes are declared inside a namespace

Delegate and Polymorphism

 * Polymorphism or Delegate: method overloading or method passing
 * Late binding: method looked up by name at run-time and exact behavior determined at run-time
 * Early binding: method name and signature stored in the virtual method table (v-table) at compile time
 * Polymorphism: objects from different types responding to calls by the same name, e.g. operator overloading for addition delegate (function pointers in C++): an object encapsulates reference to a method
 * multicast delegate: a delegate that points to and eventually fires off several methods
 * Delegate: a class -- usable if declared and instantiated
 * Delegate use: passed around as a parameter, and invoked by the receiving object
 * Delegate example 1: success = MyAddressProvider.HandleCampaign(WhatToDoWithAddresses)
 * Delegate example 2: MyMenuItem.Click += new System.Windows.RoutedEventHandlerMyMenuItem_Click)

Construction - Part 4

 * Static class: for objectless methods
 * Singleton design pattern: interface allowing a class to enforce single instantiation
 * Anticipating changing requirements: unit test suites, in-code comments, object-oriented design
 * Coding process: study the requirement, figure out an approach, create a unit test, code to pass, commit, pass through code review, refactoring, commit again, internal release, pass through QA challenges

Algorithms

 * Even number if (number % 2 == 0)
 * Odd number if (number % 2 != 0)
 * X is power of 2 if ((x != 0) && ((x & -x) == x))
 * Middle item of a string LinkedList: mylist.ElementAt(mylist.Count/2)
 * Regular expression in C#: Regex Replace FormatWith in correct syntax
 * Sample recursive solution: private void ExpandNode { foreach (TreeViewItem node in Nodes) { ExpandNode(node); } }
 * SortedList: mySL = new SortedList; mySL.Add(key1,value1);
 * Hashtable: openWith = new Hashtable; openWith.Add("txt","notepad.exe");
 * Hashtable speed: faster than SortedList
 * String reversal: private static string rwr(string argSource, int argLen) { if (argLen == 1) return argSource; else return rwr(argSource.Substring(1, argSource.argLength-1),--argLen) + argSource[0].ToString; }
 * Find duplicate value: map int array to HashTable
 * Travelling salesman problem: a special case of the Traveling purchaser problem
 * Traveling purchaser problem: route with minimum combined cost of purchases and travelling given marketplaces, travel costs, available goods and their prices

Data Structures

 * Structure of a subway system: object classes for railways, stations and trams
 * RGB triplet: efficient representation for color value
 * Queue: FIFO enqueued then dequeued
 * Stack: LIFO pushed then popped
 * Scalable Vector Graphics (SVG): a family of specifications of an XML-based file format for two-dimensional vector graphics, both static and dynamic (i.e., interactive or animated)
 * C#: personally preferred language for writing complex data structures
 * 21 in decimal: 15 in hex or 10101 in binary
 * XML for sport competition:
 * Universal Character Set (UCS): a standard set of characters upon which many character encodings are based
 * UTF-8 (UCS Transformation Format—8-bit): variable-width encoding to represent every character in the Unicode character set
 * Unicode: a computing industry standard for the consistent encoding, representation and handling of text expressed in most of the world's writing systems.

Testing

 * Regression test: testing that looks for regressions after enhancement
 * Requirements traceability matrix: completeness of many to many relationship between two baselined documents
 * Test Coverage Matrix: Feature, Module, Case Type, Test Case
 * Case Type: Default Case, Negative, Boundary
 * Integration test: unit test with dependencies between business and data layers
 * Unit test: integration test using mocked up business objects and database mockups
 * Unit testing framework: toolset essential for testing the code quality
 * Integration and configuration errors: types of problems frequently encountered in production
 * Code coverage: a measure used in software testing showing the code proportion tested
 * Types of code coverage: function, statement, decision, etc.
 * Black-box testing: test the functionality of an application
 * White-box testing: test internal structures of an application
 * Functional testing: a type of black box testing that bases its test cases on the specifications
 * Exploratory testing: a black box testing technique, free-lance testing, cognitive engagement of the tester
 * Test suite: a collection of test cases showing a specified set of behaviors in the software
 * Test case: a set of conditions or variables to be considered in testing
 * Test plan: definition of workflow for testers
 * Test organization: based on available testing human resources, including developers available for testing
 * Web testing: basic functionality, security testing, load testing, performance testing, etc.
 * Ecommerce smoke test: at first round-trip testing involving all vendor web services
 * Reducing acceptance testing surprises: involve the customer in design of acceptance test

Maintenance

 * Product update: service interruption should be avoided or announced in advance, backward compatibility, database conversion
 * Debug strategy: isolating the code, adding trace logic, and optimizing problem recreation
 * Regression tests: making sure other parts, components not broken by the new code
 * Sandcastle: a documentation generator from Microsoft via reflection information of .NET assemblies and XML documentation comments found in the source code of these assemblies.
 * More easily maintainable: follow best practices and internal standards for coding, logging, commenting, etc. Using OOP plays a major role.
 * Debug in production: turn on debug logging, monitor the database in real time
 * Load balancing: methodology to distribute workload across multiple devices to achieve optimal resource utilization, maximize throughput, minimize response time, and avoid overload
 * Types of Load Balancing: DNS load balancing, Bridged load balancing, and Routed load balancing
 * Maintenance most expensive: each change goes through the whole SDLC yet requires all-out regression testing
 * Reengineering: examination and alteration of a system to reconstitute it in a new form
 * Reverse engineering: discovering the technological principles of a system through analysis of its structure, function, and operation

Configuration Management

 * Baseline: the marking of a significant system state where we can go back to
 * Freezing: versioning the source code as well as the database
 * Under version control: source code, tests, database and other scripts, sample data, documentation, anything changed by developers over time
 * Version control systems (VCS): letting team members know who changed what
 * VCS Tag: a static snapshot
 * VCS Branch: for development outside the trunk
 * Changes to Technical Documentation: tracked under VCS, maintained on enterprise wiki
 * Redmine: free and open source, web-based project management and bug-tracking tool
 * Patch management: what patches should be applied to which systems at a specified time
 * New version: pushing forward, shooting for new heights
 * New release: pushing backward, aiming for stability
 * Text file changes: versioned by line
 * Binary file changes: full replacement

Project Management

 * Iron triangle in software development: scope, time and cost
 * Scope: features, functionality
 * Time: schedule
 * Cost: resources, budget
 * Estimates: by team members
 * Deadline: by the management team
 * Agile: iterative and incremental development
 * Iterations and Increments: periodic evaluation of new deliverables
 * Work breakdown structure (WBS): deliverable-oriented decomposition of a project into smaller components
 * Rolling wave planning: progressive elaboration to add detail to the Work Breakdown Structure (WBS) on an ongoing basis
 * Burn down chart: graphical representation of work left to do versus time
 * Dynamic systems development method (DSDM): generic approach to project management and solution delivery
 * PRojects IN Controlled Environments 2 (PRINCE2): a structured project management method endorsed by the UK government as the project management standard for public projects.
 * Scrum: an iterative and incremental agile software development method for managing software projects and product or application development
 * Customer wants too much: show them alternative outcomes and ask for their help with prioritization