Software LEIC. Lecture 23

Transcription

1 Software LEIC Lecture 23

2 Last Lecture Software Architecture Architectural Patterns Application Architectures Software Architecture in the ES+SD Project

3 Today Software Architecture Dependable System Architecture Security System Architecture Software Implementation Coding Standards Coding Rules Dependable Programming

4 Software Architecture

5 Dependable System Architectures

6 Dependable System Architectures redundancy

7 Dependable System Architectures redundancy diversity

8 Protection Systems

9 (Fig 13.3, Sommerville)

10 Self-monitoring Architectures

11 (Fig 13.4, Sommerville)

12 (Fig 13.4, Sommerville) reliability

13 (Fig 13.5, Sommerville)

14 reliability and availability (Fig 13.5, Sommerville)

15 N-version Programming

16 (Fig 13.6, Sommerville)

17 hardware diversity (Fig 13.6, Sommerville)

18 (Fig 13.7, Sommerville)

19 hardware and software diversity (Fig 13.7, Sommerville)

20 Software Diversity how independent are the implementations?

21 Security System Architecture

22 Security System Architecture protection

23 Security System Architecture protection distribution

24 (Fig 14.4, Sommerville)

25 (Fig 14.5, Sommerville)

26 design guidelines (Fig 14.6, Sommerville)

27 design guidelines tactics (Fig 14.6, Sommerville)

28 Design for Deployment

29 Design for Deployment Include support for viewing and analyzing configurations

30 Design for Deployment Include support for viewing and analyzing configurations Minimize default privileges

31 Design for Deployment Include support for viewing and analyzing configurations Minimize default privileges Localize configuration settings

32 Design for Deployment Include support for viewing and analyzing configurations Minimize default privileges Localize configuration settings Provide easy ways to fix security vulnerabilities

33 Software Implementation

34

35 Design

36 Design Code

37 Design Code

38 Design preserve design Code

39 Design preserve design take advantage of programming language Code

40 Design preserve design take advantage of programming language Code

41 Design preserve design take advantage of programming language rethink design Code

42 Design preserve design take advantage of programming language Code rethink design traceability and refactoring

43 To read or to execute?

44 Processor vs Programmer

45 Performance vs Understandability

46 Code is to be read

47 But, can we ignore performance?

48 Do profiling

49 Encapsulate optimized code

50 Never, never compromise design

51 Coding standards (conventions)

52 The best standard?

53 The best standard? this.name

54 The best standard? this.name _name

55 Following A standard

56 To comment, or not to comment?

57 Extract Method (

58 void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; // print banner System.out.printin ("************************"); System.out.printin ("**** Customer Owes *****"); System.out.printin ("************************"); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); } } //print details System.out.println("name:" + this.name); System.out.println("amount" + outstanding);

59 void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; printbanner(); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); } } //print details System.out.println("name:" + this.name); System.out.println("amount" + outstanding); void printbanner() { System.out.printin ("************************"); System.out.printin ("**** Customer Owes *****"); System.out.printin ("************************"); }

60 void printowing() { Enumeration e = this.orders.elements(); double outstanding = 0.0; printbanner(); // calculate outstanding while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); } } printdetails(outstanding); void printdetails(double outstanding) { System.out.println("name:" + this.name); System.out.println("amount" + outstanding); }

61 void printowing() { printbanner(); double outstanding = getoutstanding(); } printdetails(outstanding); double getoutstanding() { Enumeration e = this.orders.elements(); double outstanding = 0.0; while (e.hasmoreelements()) { Order each = (Order) e.nextelement(); outstanding += each.getamount(); } return outstanding; }

62 1% of the methods need to have comments

63 1% of the methods need to have comments at least agile people do think so...

64 In which cases should we comment the code?

65

66 they are being codified

67 they are being codified it is not possible to refactor

68 they are being codified it is not possible to refactor implements an algorithm which is complex or have a known name

69 they are being codified it is not possible to refactor implements an algorithm which is complex or have a known name due to performance issues it was rewritten and lost legibility

70 Coding rules

71 Coding rules there are many and are language depend

72 Design control structure should be followed

73 Encapsulate local control flow structures

74 Data structures vs Algorithms

75 For the first $10,000 of income, the tax is 10% For the next $10,000 of income above $10,000, the tax is 12% For the next $10,000 of income above $20,000, the tax is 15% For the next $10,000 of income above $30,000, the tax is 18% For any income above $40,000, the tax is 20%

76 tax = 0; if (taxable_income == 0) goto EXIT; if (taxable_income > 10000) tax = tax ; else{ tax = tax +.10*taxable_income; goto EXIT; } if (taxable_income > 20000) tax = tax ; else{ tax = tax +.12*(taxable_income-10000): goto EXIT; } if (taxable_income > 30000) tax = tax ; else{ tax = tax +.15*(taxable_income-20000); goto EXIT; } if (taxable_income < 40000){ tax = tax +.18*(taxable_income-30000); goto EXIT; } else tax = tax +.20*(taxable_income-40000); EXIT;

77 Bracket Base Percentage

78 for (int i=2, level=1; i <= 5; i++) if (taxable_income > bracket[i]) level = level + 1; tax = base[level]+percent[level]* (taxable_income-bracket[level]);

79 Code Smells (

80 An indication for further inspection

81 Code Smells Within Classes

82 Code Smells Within Classes Comments

83 Code Smells Within Classes Comments Long methods

84 Code Smells Within Classes Comments Long methods Long parameter list

85 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code

86 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code Conditional complexity

87 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code Conditional complexity Combinatorial explosion

88 Code Smells Within Classes Comments Large class Long methods Long parameter list Duplicate code Conditional complexity Combinatorial explosion

89 Code Smells Within Classes Comments Long methods Long parameter list Large class Type embedded in name Duplicate code Conditional complexity Combinatorial explosion

90 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code Large class Type embedded in name Uncommunicative Name Conditional complexity Combinatorial explosion

91 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code Conditional complexity Large class Type embedded in name Uncommunicative Name Inconsistent names Combinatorial explosion

92 Code Smells Within Classes Comments Long methods Long parameter list Duplicate code Conditional complexity Combinatorial explosion Large class Type embedded in name Uncommunicative Name Inconsistent names

93 Code Smells Between Classes

94 Code Smells Between Classes Alternative classes with different interfaces

95 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession

96 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class

97 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps

98 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps Refused bequest

99 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps Refused bequest Inappropriate intimacy

100 Code Smells Between Classes Alternative classes with different interfaces Indecent exposure Primitive obsession Data class Data clumps Refused bequest Inappropriate intimacy

101 Code Smells Between Classes Alternative classes with different interfaces Indecent exposure Feature envy Primitive obsession Data class Data clumps Refused bequest Inappropriate intimacy

102 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Indecent exposure Feature envy Lazy class Data class Data clumps Refused bequest Inappropriate intimacy

103 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Indecent exposure Feature envy Lazy class Middle man Data clumps Refused bequest Inappropriate intimacy

104 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps Indecent exposure Feature envy Lazy class Middle man Divergent change Refused bequest Inappropriate intimacy

105 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps Refused bequest Indecent exposure Feature envy Lazy class Middle man Divergent change Shotgun surgery Inappropriate intimacy

106 Code Smells Between Classes Alternative classes with different interfaces Primitive obsession Data class Data clumps Refused bequest Inappropriate intimacy Indecent exposure Feature envy Lazy class Middle man Divergent change Shotgun surgery

107 Dependable Programming

108 (Fig 13.8, Sommerville)

109 Error-prone constructs

110 Error-prone constructs Unconditional branch

111 Error-prone constructs Unconditional branch Floating-point numbers

112 Error-prone constructs Unconditional branch Floating-point numbers Pointers

113 Error-prone constructs Unconditional branch Floating-point numbers Pointers Dynamic memory allocation

114 Error-prone constructs Unconditional branch Floating-point numbers Pointers Dynamic memory allocation Parallelism

115 Error-prone constructs Unconditional branch Recursion Floating-point numbers Pointers Dynamic memory allocation Parallelism

116 Error-prone constructs Unconditional branch Floating-point numbers Recursion Interrupts Pointers Dynamic memory allocation Parallelism

117 Error-prone constructs Unconditional branch Floating-point numbers Pointers Recursion Interrupts Inheritance Dynamic memory allocation Parallelism

118 Error-prone constructs Unconditional branch Floating-point numbers Pointers Dynamic memory allocation Recursion Interrupts Inheritance Aliasing Parallelism

119 Error-prone constructs Unconditional branch Floating-point numbers Pointers Dynamic memory allocation Recursion Interrupts Inheritance Aliasing Unbounded arrays Parallelism

120 Error-prone constructs Unconditional branch Floating-point numbers Pointers Dynamic memory allocation Parallelism Recursion Interrupts Inheritance Aliasing Unbounded arrays Default input processing