14_java_software-development-models.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74309778",
   "metadata": {},
   "source": [
    "# Software Development Models\n",
    "The following page discusses some common software development models."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3568565e",
   "metadata": {},
   "source": [
    "## Application Development Lifecycle (ADLC)\n",
    "ADLC covers the entire life of a product/system from initiation to end-of-life and is divided into stages/phases. Each stage has clearly definined activities, the output from which feeds into later phases.\n",
    "1. Initiation\n",
    "2. System Concept\n",
    "3. Planning\n",
    "4. Analysis\n",
    "5. Design\n",
    "6. Development\n",
    "7. Validation\n",
    "8. Deployment\n",
    "9. Production\n",
    "10. End of Life"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17879d68",
   "metadata": {},
   "source": [
    "### Start-up Phases\n",
    "ADLC start-up phases are a subset of the overall ADLC representing the initial conception & design of the product/system. All start-up phases require stakeholder buy-in in order to proceed. Start-up phases product *Artifacts* which are input to later phases. SDLC (see below) phases can access all *artifacts* from the start-up phases.\n",
    "1. Initiation\n",
    "    - Identify a need or opportunity\n",
    "    - Driven by sponsor (often a product manager)\n",
    "2. System Concept\n",
    "    - Define scope\n",
    "    - Feasability Studies including ROI, Cost/Benefit, Risk Mgmt\n",
    "    - Competitor surveys & reports    \n",
    "3. Planning\n",
    "    - Determine resources needed\n",
    "    - Timeline\n",
    "    - Cost projection"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8a9a6f2",
   "metadata": {},
   "source": [
    "### Software Development Lifecycle (SDLC)\n",
    "The SDLC is a subset of the steps from the ADLC. Different software models implement these tasks different (e.g. the *waterfall model* and *agile* development process).\n",
    "1. Analysis (OUTPUT: *requirements document*)\n",
    "    - In-depth research & analysis\n",
    "    - Transform high-level Statement of Work (SOW) into a detailed architectural & functional __requirements document__\n",
    "2. Design (OUTPUT: *system design*)\n",
    "    - Transforms *requirements doc* into detailed __system design__\n",
    "    - Architectural design\n",
    "    - Software design\n",
    "    - Database design\n",
    "    - UI mock-ups\n",
    "    - Selection of tools\n",
    "    - Quality Assurance (QA) planning\n",
    "3. Development (OUTPUT: *working application ready for validation*)\n",
    "    - Use *system design* to implement the software\n",
    "    - Writing code\n",
    "    - Code reviews\n",
    "    - Database creation\n",
    "    - Writing test cases\n",
    "    - Setting up test environment\n",
    "4. Validation (OUTPUT: *test analysis report*)\n",
    "    - QA testing\n",
    "    - User Acceptance Testing\n",
    "    - Validate that SW meets requirements\n",
    "    - Identify bugs/defects\n",
    "5. Deployment\n",
    "    - Additional User Acceptance Testing (UAT)\n",
    "    - Procurement of any hardware & software required to deploy\n",
    "    - Operator, Administrator, and User training\n",
    "    - Set-up helpdesk/support process"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad99cf4",
   "metadata": {},
   "source": [
    "#### 1. Anaysis\n",
    "This is the most critical phase for the success of the project.\n",
    "- Understand the problem/goal\n",
    "- Define project goals\n",
    "- Build use cases\n",
    "- Identify key players (stakeholders, dev team-leaders)\n",
    "- Determine what needs to be implemented\n",
    "- Identify features & functionality\n",
    "- Identify customer expectations\n",
    "- Create requirements document"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47d4c550",
   "metadata": {},
   "source": [
    "#### 2. Design\n",
    "This phase handles the translation of requirements into specific plans for how to implement them.\n",
    "- Describe system in detail\n",
    "- High level designs\n",
    "- Detailed designs\n",
    "- Quality Assurance planning\n",
    "- Create prototypes, wireframes, and database models"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87571035",
   "metadata": {},
   "source": [
    "#### 3. Development\n",
    "This phase is responsible for the actual coding of the product/system based on information from the analysis & design phases.\n",
    "- Setup development, build, and integration environments\n",
    "- Write source code\n",
    "- Write unit tests (small self contained tests for a specific module)\n",
    "- Integration tests (brining together the small, separately developed modules and testing their combined functionality)\n",
    "- Source code is archived and controlled in a Software Configuration Mgmt system"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d32e2dba",
   "metadata": {},
   "source": [
    "#### 4. Validation\n",
    "This phase handles the testing & evaluation of the ouput from the previous phase to determine if it satisifies requirements.\n",
    "- Execute test cases\n",
    "- Functional and system requirement\n",
    "- Report bugs & defects\n",
    "- Perform User Acceptance Testing\n",
    "- Critical bug fixes\n",
    "- Create test analysis report"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97fc919f",
   "metadata": {},
   "source": [
    "#### 5. Deployment\n",
    "This phase handles the deployment of the tested product/system into the customer's production environment.\n",
    "- Additional UAT\n",
    "- Creation of supporting documentation (e.g. manuals)\n",
    "- User Training\n",
    "- Support Training\n",
    "- Procurement of any needed resources (hardware, software)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea1e7c45",
   "metadata": {},
   "source": [
    "### SDLC Umbrella Tasks\n",
    "*Umbrella Tasks* are tasks which take place during the SDLC but are not restricted to any particular phase and can span multiple (or all) phases. These include:\n",
    "- __Project Management__\n",
    "    - Timeline tracking\n",
    "    - Budget\n",
    "    - Release mgmt\n",
    "    - Coordination with external depts\n",
    "- __Documentation__\n",
    "    - Prepare & produce documents related to the project\n",
    "    - User documentation\n",
    "    - Marketing documentation\n",
    "    - Technical documentation\n",
    "- __Measurement & metrics__\n",
    "- __Software Configuration Mgmt__\n",
    "    - Version Control\n",
    "    - Build mgmt\n",
    "    - Controlled change process\n",
    "- __Reusability Mgmt__\n",
    "    - Identify re-usable Software elements\n",
    "    - Reduce cost & effort\n",
    "- __Risk Management__\n",
    "    - Identify, measure, asses, and mitigate/manage risks\n",
    "- __Change Mgmt__\n",
    "- __Quality Assurance__\n",
    "    - Functional requirements specification & compliance\n",
    "    - Non-functional requirements such as robustness, performance, and maintainability\n",
    "    - Promote best practices\n",
    "- __Training__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8e234b7",
   "metadata": {},
   "source": [
    "### SDLC Iterations\n",
    "The ADLC includes at least one (but possibly many more) SDLC. Often starting from a *Minimum Viable Product (MVP)* which represents the minimum requirements for a functional version of the product/system and then going through iterations to add extra features beyong the minimum requirements or to address bugs discovered during production use."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31a97b1e",
   "metadata": {},
   "source": [
    "### SDLC Cost of Change\n",
    "The cost of finding and fixing a defect in the requirements increases exponentially as the project progresses. This is because as the project proceeds more and more documentation, code, and test cases are being created and a change to the requirements means each of these needed to be updated, validated, and accepted again. This can of course result in:\n",
    "- Delays\n",
    "- Increase budgetary requirements"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6508dca",
   "metadata": {},
   "source": [
    "### Operation and Maintenance Phase\n",
    "The *operation and maintenance* phase starts after the initial SDLC when the product/system is deployed to the production environment. This is the longest & most expensive phase of the ADLC as an application can stay in this phase for many years.\n",
    "1. Operation\n",
    "    - In production and in use\n",
    "    - Administration & Cost of operation\n",
    "2. Maintenance\n",
    "    - Evaluation & assessment\n",
    "    - Multiple SDLCs\n",
    "        - Adaptive changes\n",
    "        - Perfective changes\n",
    "        - Corrective changes\n",
    "        - Preventative changes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2c90207",
   "metadata": {},
   "source": [
    "## Sequential vs Iterative approach to Software Development\n",
    "## Sequential\n",
    "The sequential approach provides an easy to understand project structure with easily defined milestones but is somewhat rigid compared to the iterative approach.\n",
    "\n",
    "__Pros__\n",
    "- Easy to understand, linear structure\n",
    "- Understandable milestones\n",
    "\n",
    "__Cons__\n",
    "- Requirements must be defined up-front\n",
    "- Doesn't easily adapt to changes in requirements\n",
    "- Potentially a longer wait for customer to receive project output\n",
    "- Can give a false sense of progress since testing & validation happens towards the end of the project\n",
    "\n",
    "#### Common sequential approaches\n",
    "1. Waterfall\n",
    "2. V-Model\n",
    "3. Sashimi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9431ec7",
   "metadata": {},
   "source": [
    "### The Waterfall Model\n",
    "The *waterfall* method rigidly follows the SDLC phases by:\n",
    "- Gating control moving to the next phase\n",
    "- Prevent revisiting completed phases\n",
    "- Delivering \"businesss value\" at the end of the project\n",
    "\n",
    "This makes it easy to understand & control but inflexible when dealing with shifting requirements.\n",
    "\n",
    "__A good fit when__:\n",
    "- Requirements are well understood\n",
    "- Technology used is well understood\n",
    "- Product definition is *clear* and *stable*\n",
    "\n",
    "The name derives from the waterfall like structure of each phase falling off into the next:\n",
    "<br>`|Phase 1|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Phase 2|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Phase 3|`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b7b4dbf",
   "metadata": {},
   "source": [
    "### Sashimi Model\n",
    "The *Sashimi* model is very similar to *Waterfall* but with overlapping phases that allows for some feedback from the next phase into the prior phase.\n",
    "- Allows iteration between adjourning phases\n",
    "- Encourages continuity between phases\n",
    "- Helps find defects early\n",
    "\n",
    "__A good fit for:__\n",
    "- Medium-size projects\n",
    "- With effective communication between project roles\n",
    "\n",
    "The name derives from the fact that the phases overlap like the cuts of fish on a plate of sashimi:\n",
    "<br>`|phase 1|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|phase 2|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|phase 3|`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93e8eb8a",
   "metadata": {},
   "source": [
    "### V-Model\n",
    "The V-Model method also follows the SDLC phases but puts an emphasis on verification & validation.\n",
    "- Each development phase is paired with a test & integration phase\n",
    "- Test & integration is planned in parallel with corresponding project definition phase\n",
    "- Ensures tests will exist to validate every deliverable\n",
    "- Once a phase is complete, you can't revisit it\n",
    "- Reflects management view of project\n",
    "- Inflexible to changing requirements\n",
    "\n",
    "__A good fit for__:\n",
    "- Systems requiring high-reliability\n",
    "\n",
    "The name derives from the V shape of the model outlining timeline compared to level of abstraction:\n",
    "<br>`|Planning|` &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Operation/Maintenance|`\n",
    "<br>&nbsp;&nbsp;&nbsp;`|Requirements|`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|User Acceptance Testing|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|High-level design|`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Integration tests|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Detail design|`&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Unit tests|`\n",
    "<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;`|Coding|`\n",
    "<br>*X-Axis* (left/right)= time, *Y-Axis*(up-down)=level of abstraction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "803155f7",
   "metadata": {},
   "source": [
    "## Iterative\n",
    "The *iterative* (also sometimes *adaptive*) method is a combination of iterative and incremental methods where multiple SDLC iterations feed into future iterations. The initial iteration is a minimal version which is then added to by each future iteration. As each iteration is completed & tested, the output is demonstrated to the customer/stakeholders for feedback which influences future iterations.\n",
    "- Multiple SDLC iterations\n",
    "- Lessons from one iteration feed into another\n",
    "- Redesign and implentation at each iteration\n",
    "- Customer feedback after each iteration\n",
    "- Implements highest priority requirements first\n",
    "- Adapts to changing requirements\n",
    "\n",
    "__Cons__:\n",
    "- Requires engineers skilled in planning & design\n",
    "- Requires early definition of complete system\n",
    "\n",
    "__Common iterative approaches__:\n",
    "- RAD: Rapid Application Prototype\n",
    "- RUP: Rational Unified Process\n",
    "- Spiral\n",
    "- Agile\n",
    "\n",
    "__A good fit when__:\n",
    "- You have lots of risk & complexity\n",
    "- There are evolving requirements\n",
    "- New tech is involved\n",
    "- You have marketing schedule demands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4972ed7",
   "metadata": {},
   "source": [
    "### Agile Software Models\n",
    "Agile models are a group of iterative methods which are lightweight and incremental with a focus on:\n",
    "- Individuals and interactions over processes & tools\n",
    "- Working software over comprehensive documentation\n",
    "- Customer collaboration over contract negotiation\n",
    "- Responding to change over following a plan\n",
    "\n",
    "__Pros__:\n",
    "- Adapt to changing requirements\n",
    "- Respond to unpredictability\n",
    "- Deployment possible at end of any iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13cd5321",
   "metadata": {},
   "source": [
    "#### Common practices\n",
    "The following are some common practices among the various Agile methods:\n",
    "- Test Driven Development (TDD): a test scenario is defined first and then the minimum implementation that will pass the test. Once passed the code is refactored.\n",
    "- User Stories: take the form of `as <role>, I want <feature> so that <reason>` to flesh out the what a user needs and why."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "428afdac",
   "metadata": {},
   "source": [
    "#### Agile models\n",
    "The two most comm agile models are...\n",
    "\n",
    "__XP (eXtreme Programming)__:\n",
    "- Views project from developer perspective\n",
    "- Uses TDD to focus on implementation of system rather than management of project\n",
    "- Coding standards put in place so all developers are working to the same spec\n",
    "- Pair programming is often used where two devs work together to code taking turns coding vs acting as a soundboard/guide\n",
    "- Uses continuous integration where the system is built & integrated every time a task is completed\n",
    "\n",
    "__SCRUM__:\n",
    "- Uses *sprints* which are timed iterations (usually weeks) of a complete SDLC\n",
    "- Sprints include:\n",
    "    - Planning\n",
    "    - Design\n",
    "    - Development\n",
    "    - Testing\n",
    "    - Delivery\n",
    "- After each sprint feedback is obtained which can be incorporated into future sprints\n",
    "- SCRUM contains 3 roles:\n",
    "    - Product owner - represents customers & stakeholders, captures & prioritizes requirements\n",
    "    - Self-directed team - responsible for delivering potentially shippable software at the end of each sprint\n",
    "    - SCRUM master - owns the SCRUM process and ensures it is followed, responsible for working with team and removing impediments\n",
    "- Each sprint has 5 meetings (or *ceremonies*):\n",
    "    - Backlog: review & priorize backlog items, create user stories\n",
    "    - Planning: user stories for the sprint are chosen and broken down into tasks\n",
    "    - Daily scrum: daily meeting where team members check-in, stating what was done yesterday, what will be done today, and any impediments\n",
    "    - Sprint review: the potentially shippable software from the sprint is demonstrated to customers/stakeholders\n",
    "    - Sprint retrospective: team reviews the last sprint reflecting on what went well and what didn't & how to improve going forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43f37381",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "text/x-java",
   "file_extension": ".java",
   "mimetype": "",
   "name": "Java",
   "nbconverter_exporter": "",
   "version": "1.8.0_121"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}