From Wikiversity
Jump to navigation Jump to search

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

Basic Concepts

[edit | edit source]
  • 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
  • Effective use of a BA can give waterfall an advantage.
  • Audit proof means that agile is not an option.


[edit | edit source]

The material herein are based on the 100 questions posed on this page:


[edit | edit source]
  • 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

[edit | edit source]
  • 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

[edit | edit source]
  • 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
  • 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

[edit | edit source]
  • 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


[edit | edit source]
  • 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

[edit | edit source]
  • 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

[edit | edit source]
  • 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

[edit | edit source]
  • 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


[edit | edit source]
  • 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

[edit | edit source]
  • 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.


[edit | edit source]
  • 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


[edit | edit source]
  • 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

[edit | edit source]
  • 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

[edit | edit source]
  • 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