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