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.

References

The material herein are based on the 100 questions posed on this page: http://www.noop.nl/2009/01/100-interview-questions-for-software-developers.html

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<string>
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: <season><seasonstart/><seasonend/><game><gamedate/><team><teamname/><score/></team></game></season>
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