* Python *

* Python Programming *

Part 1: Product Class

Write a class named Product that holds data about an item in a retail store.   The class should store the following data in attributes: product id, item description, units in inventory, and price. Write the __init__ method to require all four attributes. Also write a __str__ method for debugging output.   

Once you have written the class, write a main() function that creates three Product objects and stores the following data in them. Use the __str__ method to confirm the data is stored properly.

ID         Description              Quantity        Price
1          Jacket                          12                    59.95
2          Designer Jeans            40                    34.95
3          Shirt                             20                    24.95

Submit your python file (.py) to Sakai

Part 2: Inventory Module

Create an Inventory module by moving the Product Class definition to another file called inventory.py.   Add three __doc__ strings: one that describe the inventory module (include your name and the date here), one that describes the Product class, and one that describes the Product class __init__ method.

Rename your main() function to test_inventory.py
Add an import at the top of the file to read the Product class definition.
Add these print statements to test the __doc__ string:

Print(inventory.__doc__)

Print(Product.__doc__)

Print(Product.__init__..__doc__)

Test the program to be sure it still works. NOTE: If using IDLE, you will have to explicitly save the inventory.py file after making changes.  

FOR JAVA

Write a method called findNum that takes a two-dimension array of integers and an int as parameters and returns the number of times the integer parameter appears in the array.

For example, if the array (as created by the program below) is

10 45 3 8

2 42

3 21 44

And the integer parameter is 3, the value returned would be 2 (the number 3 appears two times in the array)

public class HomeworkA {

public static void main(String args[]){

int arr[][] = {{10, 45, 3, 8}, {2, 42}, {3, 21, 44}};

System.out.println(“The number time 3 appears is “+findNums(arr,3)); }

public static int findNum (int [][] myArray) {

..........

6) Solving for method Newton-Rapson starting from (1,1,1) in matlab (with algorithm)

1) sin(x) + y^2 + ln(z) – 7 = 0

2) 3x + 2^y – z^3 + 1 = 0

3) x + y + z – 5 = 0

Write a function named mirror_tree that accepts a pointer to the root of a binary tree of integers. Your function should rearrange the nodes into a mirror tree of the original tree. The mirror tree has the left and right subtrees reversed for each node.

Constraints: You must implement your function recursively and without using loops. Do not construct any new BST objects in solving this problem (though you may create as many NODE* pointer variables as you like). Do not use any auxiliary data structures to solve this problem (no array, vector, stack, queue, string, etc).

Assume that you are using the NODE structure as defined below:

struct NODE {
int Key;
NODE* Left;
NODE* Right;
};

If you run mirror_tree on a BST, is your new tree still a BST?

Code to edit:

/ util.h

#include <iostream>
#include "bst.h"
using namespace std;

// mirror_tree:
//
// Your function should rearrange the nodes into a mirror tree
// of the original tree. The mirror tree has the left and right
// subtrees reversed for each node.
//
void mirror_tree(NODE* node) {
// TO DO: Write this function.
}

Find the runtime of this function, where n is an integer.

int function(int n) {
  int a = 0;
  for (int i = n; i > 0; i--) {
    for (int j = 0; j < i; j++) {
      a = a + i + j;
    }
  }
  return a;
}

Find the runtime of this function, where m and n are two integers.

int f(int m, int n) {
  if (m==1 || n==1) {
    return 1;
  }
  return f(m, n-1) + f(m-1, n);
}

Please explain to me each of the steps and how you receive the answer.

Thank you

Please include all inputs and outputs in details with pictures:

General rules: Create homework, compose specifications or any text by using a common document-creation tool, such as Microsoft^® Word.

Detailed Hints: Refer to the wwweb or lecture notes for this class to design, implement, and debug solid SW solutions. Be concise, complete, and precise.

Abstract: Compute the performance data for the schedulers of three types of Operating Systems. Do not get scared! Only the timing for each scheduler is of interest. You can compute these timing data by hand or by actually implementing a simulator. Either solution is feasible and permitted. The simulator measures key performance data, such as throughput, wait time, and turn-around time. You may also manually compute these numbers without having to run them in a simulation environment.

If you chose to “manually” compute the data, i.e. without implementing a SW simulator, the amount of “generated performance data” is allowed to be way less detailed than what is suggested here.

One OS is a strict batch system with a non-preemptive First Come First Serve (FCFS) scheduler. The second OS uses a non-preemptive, high-priority first (HPF) scheduler, while the third OS uses a preemptive round robin (RR) scheduler with a variable time-quantum with varying context switch overhead. Design meaningful input data, run them through all schedulers, generate output data, and interpret and discuss the results. To start your simulations, use the sample data from this HW assignment. In addition, provide 2 additional, meaningful input scenarios, more complex than the samples given here.

Detail: HomeWork 1 consists of the following parts with equal weight each:

• Compute performance data for the scheduler of a non-preemptive FCFS batch system
• Ditto for a non-preemptive HPF batch system, and
• Ditto for a preemptive RR scheduler; you’ll vary time quantum and overhead.
• Invent meaningful input data; run them through your schedulers to produce output
• Discuss the generated data. Hand in your discussion in typed form

Input: Input to the schedulers is a list of processes, for which you happen to know the execution time in milliseconds. For your program input, each process is represented by a triple of decimal numbers id, time, priority. These multiple processes are scheduled and compete for the CPU resource. Here id is the name of the process; time is the time in milliseconds that process id needs to run to completion, and priority is the priority of process id. A plausible input sample for two processes with process id 1 and process id 4 is:

1          2          3

4          50        6

Depending on the scheduler, priority may be ignored. The meaning of triples is as follows:

1   2 3          process 1 uses 2 milliseconds to run, has priority 3

4 50 6           process 4 uses 50 milliseconds, has priority 6, with 0 being the highest

Use the definitions below to compute for each process Throughput, Wait Time, and Turn-around Time. Compute these for each of the 3 schedulers; also compute the average for all processes.

For the preemptive RR scheduler, vary the time quantum q from 1 to 5 milliseconds (ms). Also, for each q selected, vary the overhead o of a context switch from 0 ms up to q itself. There is no need to vary the o beyond q. When a process scheduled by the RR system has received all time needed to completion, do not add a final o unit in the computation of the total time for that process. Also the first time around, act as if the initial schedule overhead o is 0. Use the sample outputs below as a guide for the detail you should generate for this HW.

Definitions:

Throughput:                    Number of jobs (processes) completed per time unit

Waiting Time:                  The total time a process is in Ready Queue

Average Waiting Time:    Average Waiting Time of n processes is: total waiting time by n

Turn-around Time:          span of time of submission to completion time

Example 1:

Enter triples: process id, time in ms, and priority:

For example:

1 12 0

3 9 1

2 99 9

process 1 needs 12 ms and has priority 0, very high,

process 3 needs 9 ms and has priority 1.

and so on ...

1 2 3

2 1 2

Process list in FCFS order as entered:

1 2 3

2 1 2

End of list.

fcfs wait of p1 = 0

fcfs wait of p2 = 2

average wait for 2 procs = 1

fcfs turn-around time for p1 = 2

fcfs turn-around time for p2 = 3

average turn-around for 2 procs = 2.5

fcfs throughput for 2 procs = 0.666667 proc/ms

<><> end FCFS <><>

Process list in HPF order:

2 1 2

1 2 3

End of list.

hpf wait of p2 = 0

hpf wait of p1 = 1

average wait time for 2 procs = 0.5

hpf turn-around for p2 = 1

hpf turn-around for p1 = 3

average turn-around for 2 procs = 2

hpf throughput for 2 procs = 0.666667 proc/ms

<><> end HPF schedule <><>

Process list for RR in order entered:

1 2 3

2 1 2

End of list.

preemptive RR schedule, quantum = 1 overhead = 0

RR TA time for finished p2 = 2, needed: 1 ms, and: 1 time slices.

RR TA time for finished p1 = 3, needed: 2 ms, and: 2 time slices.

RR Throughput, 2 p, with q: 1, o: 0, is: 0.666667 p/ms, or 666.667 p/us

Average RR TA, 2 p, with q: 1, o: 0, is: 2.5

preemptive RR schedule, quantum = 1 overhead = 1

RR TA time for finished p2 = 3, needed: 1 ms, and: 1 time slices.

RR TA time for finished p1 = 5, needed: 2 ms, and: 2 time slices.

RR Throughput, 2 p, with q: 1, o: 1, is: 0.4 p/ms, or 400 p/us

Average RR TA, 2 p, with q: 1, o: 1, is: 4

preemptive RR schedule, quantum = 2 overhead = 0

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 3, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 0, is: 0.666667 p/ms, or 666.667 p/us

Average RR TA, 2 p, with q: 2, o: 0, is: 2.5

preemptive RR schedule, quantum = 2 overhead = 1

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 4, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 1, is: 0.5 p/ms, or 500 p/us

Average RR TA, 2 p, with q: 2, o: 1, is: 3

preemptive RR schedule, quantum = 2 overhead = 2

RR TA time for finished p1 = 2, needed: 2 ms, and: 1 time slices.

RR TA time for finished p2 = 5, needed: 1 ms, and: 1 time slices.

RR Throughput, 2 p, with q: 2, o: 2, is: 0.4 p/ms, or 400 p/us

Average RR TA, 2 p, with q: 2, o: 2, is: 3.5

<><> end preemptive RR schedule <><>

Example 2:

Enter triples: process id, time in ms, and priority:

For example:

1 12 0

3 9 1

2 99 9

process 1 needs 12 ms and has priority 0, very high,

process 3 needs 9 ms and has priority 1.

and so on ...

1 10 5

2 8 1

3 12 7

Process list in FCFS order as entered:

1 10 5

2 8 1

3 12 7

End of list.

fcfs wait of p1 = 0

fcfs wait of p2 = 10

fcfs wait of p3 = 18

average wait for 3 procs = 9.33333

fcfs turn-around time for p1 = 10

fcfs turn-around time for p2 = 18

fcfs turn-around time for p3 = 30

average turn-around for 3 procs = 19.3333

fcfs throughput for 3 procs = 0.1 proc/ms

<><> end FCFS <><>

Process list in HPF order:

2 8 1

1 10 5

3 12 7

End of list.

hpf wait of p2 = 0

hpf wait of p1 = 8

hpf wait of p3 = 18

average wait time for 3 procs = 8.66667

hpf turn-around for p2 = 8

hpf turn-around for p1 = 18

hpf turn-around for p3 = 30

average turn-around for 3 procs = 18.6667

hpf throughput for 3 procs = 0.1 proc/ms

<><> end HPF schedule <><>

Process list for RR in order entered:

1 10 5

2 8 1

3 12 7

End of list.

preemptive RR schedule, quantum = 1 overhead = 0

RR TA time for finished p2 = 23, needed: 8 ms, and: 8 time slices.

RR TA time for finished p1 = 27, needed: 10 ms, and: 10 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 12 time slices.

RR Throughput, 3 p, with q: 1, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 1, o: 0, is: 26.6667

preemptive RR schedule, quantum = 1 overhead = 1

RR TA time for finished p2 = 45, needed: 8 ms, and: 8 time slices.

RR TA time for finished p1 = 53, needed: 10 ms, and: 10 time slices.

RR TA time for finished p3 = 59, needed: 12 ms, and: 12 time slices.

RR Throughput, 3 p, with q: 1, o: 1, is: 0.0508475 p/ms, or 50.8475 p/us

Average RR TA, 3 p, with q: 1, o: 1, is: 52.3333

preemptive RR schedule, quantum = 2 overhead = 0

RR TA time for finished p2 = 22, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 26, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 2, o: 0, is: 26

preemptive RR schedule, quantum = 2 overhead = 1

RR TA time for finished p2 = 32, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 38, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 44, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 1, is: 0.0681818 p/ms, or 68.1818 p/us

Average RR TA, 3 p, with q: 2, o: 1, is: 38

preemptive RR schedule, quantum = 2 overhead = 2

RR TA time for finished p2 = 42, needed: 8 ms, and: 4 time slices.

RR TA time for finished p1 = 50, needed: 10 ms, and: 5 time slices.

RR TA time for finished p3 = 58, needed: 12 ms, and: 6 time slices.

RR Throughput, 3 p, with q: 2, o: 2, is: 0.0517241 p/ms, or 51.7241 p/us

Average RR TA, 3 p, with q: 2, o: 2, is: 50

preemptive RR schedule, quantum = 3 overhead = 0

RR TA time for finished p2 = 23, needed: 8 ms, and: 3 time slices.

RR TA time for finished p1 = 27, needed: 10 ms, and: 4 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 4 time slices.

RR Throughput, 3 p, with q: 3, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 3, o: 0, is: 26.6667

preemptive RR schedule, quantum = 3 overhead = 1

RR TA time for finished p2 = 30, needed: 8 ms, and: 3 time slices.

RR TA time for finished p1 = 36, needed: 10 ms, and: 4 time slices.

RR TA time for finished p3 = 40, needed: 12 ms, and: 4 time slices.

RR Throughput, 3 p, with q: 3, o: 1, is: 0.075 p/ms, or 75 p/us

Average RR TA, 3 p, with q: 3, o: 1, is: 35.3333

preemptive RR schedule, quantum = 4 overhead = 0

RR TA time for finished p2 = 20, needed: 8 ms, and: 2 time slices.

RR TA time for finished p1 = 26, needed: 10 ms, and: 3 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 3 time slices.

RR Throughput, 3 p, with q: 4, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 4, o: 0, is: 25.3333

preemptive RR schedule, quantum = 5 overhead = 0

RR TA time for finished p1 = 20, needed: 10 ms, and: 2 time slices.

RR TA time for finished p2 = 23, needed: 8 ms, and: 2 time slices.

RR TA time for finished p3 = 30, needed: 12 ms, and: 3 time slices.

RR Throughput, 3 p, with q: 5, o: 0, is: 0.1 p/ms, or 100 p/us

Average RR TA, 3 p, with q: 5, o: 0, is: 24.3333

some outputs I have to cut because Chegg say the question is long

{
/* Write a program in C++ to find the perfect numbers between 1 and 500.
The perfect numbers between 1 to 500 are:
6
28
496*/
   int sum = 0;
   int i = 1;
   int j = 1;
   for (i ; i <= 100; i++)
   {
       for (j; j <= 100; j++)
       {
           if (j < i)//Line 55
           {
              
           if (i % j == 0)
               sum = sum + j;
           }
          
       }

       if (sum == i)
      
           cout << i << " ";
       j = 1;//line 66
       sum = 0;
      
   }
  
   return 0;
}

Can someone please explain the code above and how it works. what is the purpose of the comparison on line 55 and I on line 66?

1. Based upon the pseudocode given in “Background”, solve the three versions of add up to K problems: ◦ all pairs of numbers that add up to K ◦ all triples (set of three) that add up to K ◦ all possible subsets of numbers that add up to K: recursive version is given, you are asked to solve it iteratively. 2. Test the three functions using given test cases. 3. Measure the running time of algorithms under various input sizes.

#include <iostream>
#include <bitset>
#include <vector>
#include <time.h>
using namespace std;

const double BILLION = 1E9;

 /* Print ALL pairs of number from the given array a[0...a_len-1] that adds up to K 
    @param intList: the list of int values 
    @param K: the sum we want to make
   */
void PairsAddupToK (int a[], int a_len,  int K)
{
 //TODO by you
}
   
/* Print ALL triples of numbers from the given array a[0...a_len-1] that adds up to K 
@param intList: the list of int values 
@param K: the sum we want to make
*/
void TriplesAddupToK (int a[], int a_len, int K)
{
        //todo by you
}
   
/* Print ALL subsets of numbers from the given array, a[0...a_len-1 that adds up to K 
this function solves the problem iteratively 
NOTE: WE assume a_len<32 (so that we can use int (which uses 32 or 64 bits) 
  as code to decide subset  
@param intList: the list of int values 
@param K: the sum we want to make
*/
void SubsetsAddupToK (int a[], int a_len, int K)
{
        //todo by you
}

            
        
//Recursive solution to SubsetAddupToK 
/* This functions tries to use numbers from a[left...right] to make sum 
 @param a[] array of int
 @n: a[left...right] is the list of numbers to use
 @currentSum: current sum we have made using numbers in numsUsed
 @finalSum: final sum that we need to make
 @numsUsed: numbers that are used to get us here */
bool SubsetsAddupToK (int  a[], int left, int right, int currentSum, int finalSum, vector<int> numsUsed)
{
        //Three base cases: 
        //case 1: what remains to make is negative: we have overshot... 
        if (currentSum>finalSum)
                return false; 

        //case 2: we made it! 
        // Result is only displayed at the base case. 
        if (currentSum==finalSum)
        {
                cout <<"Solution:";
                for (int i=0;i<numsUsed.size();i++)
                        cout <<numsUsed[i]<<",";
                cout <<endl;
                return true;
        }

        //case 3: we don't have any number to use: fails. 
        if (left>right && currentSum < finalSum)
                return false;


        //General calse: what remains to make is positive, and we have numbers to use 
        bool res1=false, res2=false;

        // Explore both possibilities: Use a[left] or not 
        //  1) include a[left] in the sum, i.e., make sum-a[left] using a[left+1...right]  
        vector<int> newNums = numsUsed;
        newNums.push_back (a[left]); //now a[left] is used ... 

        res1 = SubsetsAddupToK(a, left+1, right, currentSum+a[left], finalSum,newNums);
            // here the currentSum is increased by a[left], a[left] is added into list of 
            // numbers used... 

        //  2) do not include a[left] in the sum, i.e., make sum using a[left+1...right]  
        //     currentSum, finalSum, numsUsed is not changed 
        res2 = SubsetsAddupToK (a, left+1, right, currentSum, finalSum, numsUsed);
                                    //^+1 so that a[left] is not considered any more

        //if either of the above two succeeded, return true 
        if (res1 || res2)
                return true;
        else
                return false;
}


/* Compare the running time of three functions for input size n 
 @param n: the length of vecotr/list
 */ 
void  MeasureRunningTime (int a[], int a_len)
{
        struct timespec start, finish;
        double r1, r2, r3, r4;


           clock_gettime (CLOCK_REALTIME, &start);
           PairsAddupToK (a, a_len, 100);
           clock_gettime (CLOCK_REALTIME, &finish);
           r1 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;


           clock_gettime (CLOCK_REALTIME, &start);
           TriplesAddupToK (a, a_len, 100);
           clock_gettime (CLOCK_REALTIME, &finish);
           r2 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           clock_gettime (CLOCK_REALTIME, &start);
           SubsetsAddupToK (a, a_len, 100); 
           clock_gettime (CLOCK_REALTIME, &finish);
           r3 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           clock_gettime (CLOCK_REALTIME, &start);
           vector<int> results;
           SubsetsAddupToK (a, 0, a_len, 0, 100, results); 
                                        //^ current sum=0, final sum=100
           clock_gettime (CLOCK_REALTIME, &finish);
           r4 = (finish.tv_sec - start.tv_sec)+
                        (finish.tv_nsec-start.tv_nsec)/BILLION;

           cout <<"n="<<a_len<<"\t";
           cout <<"Pairs"<<"\t"<< r1<<"s\t";
           cout <<"Triples"<<"\t"<< r2<<"s\t";
           cout <<"Subsets"<<"\t"<< r3<<"s\t";
           cout <<"SubsetsR"<<"\t"<< r4 <<"s\t"<<endl;
}

int main()
{
        vector<int> numsUsed; //this is empty initially 

        int a5[5] = {50,90,20,30,10};
        int a10[10] = {50, 33, 90, 2, 20, 
                72, 30,10, 92, 8};
        int a20[20] = {50, 33, 11, 79, 90,
                2, 20, 72, 30,10, 
                92, 8, 99, 101, 25,
                71, 48, 72, 35, 9};
        int a30[30] = {50, 33, 11, 79, 90, 
                2, 20, 72, 30,10, 
                92, 8, 99, 101, 25, 
                71, 48, 72, 35, 9,
                37, 41, 55, 73, 67,
                66, 22, 11, 6, 4};

        //Testing 
        //Display all different ways to make 100 using a5[0...4]
        int SumToMake = 100;
        int curSum=0; 
        SubsetsAddupToK (a5, 0, 4, curSum, SumToMake, numsUsed);

        /* Measuring and comparing running time  
        MeasureRunningTime (a5, 5);
        MeasureRunningTime (a10, 10);
        MeasureRunningTime (a20, 20); */
        MeasureRunningTime (a30, 30);
}

Write a recursive function, max_in_list(my_list), which takes an non-empty list, my_list, of integers as a parameter. This function calculates and returns the largest value in the list. The base case will probably deal with the scenario where the list has just one value. The recursive case will probably call the function recursively using the original list, but with one item removed.

Note: This function has to be recursive; you are not allowed to use loops to solve this problem!

lst = [1, 4, 5, 9]
print(max_in_list(lst))

9

And

Write a recursive function, max_even_list(my_list), which takes a list, my_list, of integers as a parameter. This function calculates and returns the largest even number in the list. 0 is returned if there is no even number in the list.

Note: This function has to be recursive; you are not allowed to use loops to solve this problem!

lst = [1, 4, 5, 9]
print(max_even_list(lst))

4

Compute the 10,000th element of the pseudorandom sequence generated by the Middle-Square algorithm with seed=1003.

public class Lab1 {

public static void main(String[] args) {

int array [] = {10, 20, 31, 40, 55, 60, 65525};

System.out.println(findPattern(array));

}

private static int findPattern(int[] arr) {

for (int i = 0; i < arr.length - 2; i++) {

int sum = 0;

for (int j = i; j < i + 2; j++) {

sum += Math.abs(arr[j] - arr[j + 1]);

}

if (sum == 20)

return i;

}

return -1;

}

}

QUESTION: Modify the given code such that the input array may wrap-around or over- flow.

Given the input array: data[] = {65515,65525,9,20,31,40,55} The function shall return: 0

Assignment for Health Information Technology

Search the web for an article related to a facility using patient generated health data(PGHD). Using a minimum of 125 words, tell me the type of healthcare setting, the type of of PGHD used, and if the facility found it beneficial/successful.

Provide the URL link to your article.
Use .org websites only (Ex. AHIMA.org, nln.nih.gov...etc)

write a recursive algorithm to find the maximum element in an array of n elements and analyze its time efficiency.

(I am using c++ programming language)

3. Be creative, but realistic: Describe an example (of your own creation) of a system that would be susceptible to a race condition, and what might happen to cause the race condition in your imagined system. Then explain what might be the effect of that race condition in your particular system. The goal in this last part is to imagine a real-world system and to describe it in a way that the marker can understand as well as showing how it could be affected by a race condition.

True or False

1.An association is a description of a group of links with common behaviors and semantics.

2.An association is a logical construct, of which a reference is a generalization alternative.

3.Multiplicity specifies the number of instances of one object.

4.An association class is an association that is also a class.

5.An association class may have attributes, operation and participant in associations.

6.A qualified association is an association in which the objects in a “many” generalization are partially disambiguated by a qualifier.

7.Generalization is an important construct for both conceptual modeling and implementation.

8.To build complex systems, the developer must abstract different views of the system, build models using precise notations.

9.When analysts construct a model of the application, the detail implementation information will need to be considered.

10.The model has two dimensions – a view of a system and a stage of development.