There are two computers, each runs an identical software stack (operating system, Virtual Machine, application). Some quality facts:

Transcription

1 Problem 1: (30 points) Here you are asked to determine some simple A o numbers. Show your work, else there is no possibility of partial credit! There are two computers, each runs an identical software stack (operating system, Virtual Machine, application). Some quality facts: The computers are not subject to any hardware failures, as long as they have power. The OS has an MTTF of 168 hrs, with an MTTR (reboot) of 1 minute. The VM has MTTF of 1000 hours, and an MTTR of 1 minute. The application has an MTTF of 24 hrs and a MTTR of 1 minute. (a) (6 pts) What is the A o of each of the three components of the stack, considered independently? (b) (4 pts) What is the A o of each computer software stack? (c) (5 pts) On average, how long does the software stack stay up between failures? (d) (8 pts) Using a work-duplicator and response-combiner function of some kind, the two computers are placed in parallel to attempt to improve system availability. What is the resulting availability? (e) (8 pts) Both computers are plugged into the same electrical socket. The building power has an MTBF of 2000 hours and an MTTR of 3 hrs. What is the A o of the parallel system configuration? MTTF hrs MTTF minutes MTTR minutes Ao 1/MTTF minutes 1/MTTF hrs OS VM app b) 1c) MTBO = MTTF sys =1/(sum above) stack Series A 0 = (A 0 OS) * (A 0 VM) * d) put two stacks in parallel Unav of 1 stack = 1 - A 0 = Ao dual = 1- (U1 * U2) = e) put power A 0 in series with 1-of-2 stack A 0 power combined=

2 Problem 2: (10 points) You are given the code fragment below; rewrite it so that the function of the code does not change at all, but the Halstead Effort number is reduced. (The resulting code will be slightly shorter.) Don t make any changes that do not reduce the Halstead Effort number. public class HalTest { public class haltest { public int methodwithlongname(int x, int longnamevariable) { System.out.println("x = " + x); System.out.println("the other param = " + longnamevariable); // this is a long comment to explain // what I am thinking about int x1 = x + longnamevariable; System.out.println("x1 = " + x1); int x2 = x - longnamevariable; System.out.println("x2 = " + x2); return x1 + x2; Rewriting E in terms of the 4 basic numbers, n1 = unique operators, n2 = unique operands n = n1 + n2 (vocabulary) N1 = total operators, N2 = total operands N = N1 + N2 (also called L for Length) V = N * log2(n) (Volume, number of bits to represent program) D = (n1/2) * (N2/n2) E = D * V = (n1/2 * N2/n2) * (N log2 n) = (n1/2 * N2/n2) * ( (N1 + N2) log2 (n1 + n2)) Lowering 3 out of the 4 (n1, N1, N2) is risk free; lowering n2 (distinct operands) looks like it needs a bit of thought. So, we just look for opportunities to lower n1 (distinct operators), N1 (total operators) or N2 (total operands). I ll show some numbers from a tool, but you don t need the numbers, just the what should I change thinking. Different tools use different conventions for what is an operator and such, so the absolute numbers tend to vary wildly but they all show the same trends. Note that you don t change the E number by either changing the length of the name of a variable or method (so keep those descriptive names!), nor by adding/removing comments. So, my further edits will drop the comments.

3 As we start, we have: First, let s try using the println() operation a little less, by combining the first two: System.out.println( "x = " + x + "/nthe other param = " + longnamevariable); From my tool (CodePro Studio) this gives us these numbers: Good, we re moving in the desired direction. But stop and think about the value of a metric is this module now easier to understand with combined println()s? Well, let s try collapsing the second set of printlns: int x1 = x + longnamevariable; int x2 = x - longnamevariable; System.out.println("x1 = " + x1 + "/nx2 = " + x2); 2 nd println Better yet! Looking at the code, we see that the return value is really just x + x. Interesting making that change doesn t alter the Halstead values here, but it means we don t need x1 and x2 at all! Let s try dumping the temps and just putting the calculations inline: System.out.println("x1 = " + (x + longnamevariable) + "/nx2 = " + (x - longnamevariable)); return x + x; 2 nd println inline

4 Well, since that worked, then maybe we can re-apply the combine-println strategy: System.out.println( "x = " + x + "/nthe other param = " + longnamevariable + "/nx1 = " + (x + longnamevariable) + "/nx2 = " + (x - longnamevariable)); 2 nd println inline one println to get to my final response public int methodwithlongname(int x, int longnamevariable) { System.out.println( "x = " + x + "/nthe other param = " + longnamevariable + "/nx1 = " + (x + longnamevariable) + "/nx2 = " + (x - longnamevariable)); return x + x; vs the original, shown here with better formatting than it originally had: public int methodwithlongname(int x, int longnamevariable) { int x1 = x + longnamevariable; int x2 = x - longnamevariable; System.out.println("x = " + x); System.out.println("the other param = " + longnamevariable); System.out.println("x1 = " + x1); System.out.println("x2 = " + x2); return x1 + x2; Do you think it s a clearer and easier program now? The metric says it s half the effort! What if you got a change request for this module, or were trying to debug it is the lower-e version with caclulation embedded in println()s easier or harder to deal with? The moral here is that metrics are fairly easy to get acrried away with, and should be used as guides, not a hard-and-fast rules. Put the metric ( Halstead E ) on the door and get it optimized but take it off the door when that optimization starts to hurt something else! Scoring guide: 5 pts for realizing you could collapse println statements; 5 pts for realizing you could dump temp vars.

5 Problem 3: (15 points) Draw a UML structure diagram for an AbstractFactory design for getting an object which implements a Connection. The Connection has four methods on it: connect(string destination) which returns a boolean, sendmessage(string s) which transmits a message, getmessage() which returns a String, and disconnect() which has a void return. There are two concrete Connections you might serve up: a TcpConnection, and a TelephoneConnection. To get you started: the client will get the AbstractFactory by calling MyConnectionFactory.getInstance(). This method (which you do not have to code!) looks at a property value and returns either a TcpConnectionFactory or a TelephoneConnectionFactory. ConnectionFactory +getinstance():connection +createconnection():connecti client TcpConnection Connection +connect(destination:string) +sendmessage(msg:string):voi +getmessage():string +disconnect():void creates TcpConnectionFactory +CreateConnection():Connec TelephoneConnectionFactory +CreateConnection():Connec creates TelephoneConnection

6 Problem 4: (25 points) You are given a design as indicated in the UML structure chart below. Re-design this into a composition/delegation design that avoids inheritance. You will probably need to define a small number of s or abstract classes, and a small number of implementing classes. Keep in mind that relationships can exist between s, abstract classes, or concrete classes. * ICustomer +problem:string=0 +getproblem():stri Customer -famname:string +getproblem():str 0..1 identity SSN 0..1 identity +getidentity():ssn Person -famname:string 1 IEmployeeRole +getidentity():ssn * works for 1 IManager Manager Employee -mycustomers:hashmap=null IClerk Clerk +getproblemkeywords(custid:ssn):str