Lowering the Level of

Size: px

Start display at page:

Download "Lowering the Level of"

Mercy Hall
5 years ago
Views:

1 Lowering the Level of

6 A goto completely invalidates the high-level structure of the code. Taligent's Guide to Designing Programs

8 / WordFriday

9 snowclone, noun clichéd wording used as a template, typically originating in a single quote e.g., "X considered harmful", "These aren't the Xs you're looking for", "X is the new Y", "It's X, but not as we know it", "No X left behind", "It's Xs all the way down", "All your X are belong to us"

11 send(to, from, count) register short *to, *from; register count; { register n=(count+7)/8; switch(count%8){ case 0: do{ *to = *from++; case 7: *to = *from++; case 6: *to = *from++; case 5: *to = *from++; case 4: *to = *from++; case 3: *to = *from++; case 2: *to = *from++; case 1: *to = *from++; }while(--n>0); } }

12 send(to, from, count) register short *to, *from; register count; { register n=(count+7)/8; switch(count%8){ case 0: do{ *to = *from++; case 7: *to = *from++; case 6: *to = *from++; case 5: *to = *from++; case 4: *to = *from++; case 3: *to = *from++; case 2: *to = *from++; case 1: *to = *from++; }while(--n>0); } } I feel a combination of pride and revulsion at this discovery. Tom Duff

13 send(to, from, count) register short *to, *from; register count; { register n=(count+7)/8; switch(count%8){ case 0: do{ *to = *from++; case 7: *to = *from++; case 6: *to = *from++; case 5: *to = *from++; case 4: *to = *from++; case 3: *to = *from++; case 2: *to = *from++; case 1: *to = *from++; }while(--n>0); } } Many people have said that the worst feature of C is that switches don't break automatically before each case label. This code forms some sort of argument in that debate, but I'm not sure whether it's for or against. Tom Duff

15 Earliest informal standard set by 1 st edition of The C Programming Language First de jure standard, included properly typed function declarations (function prototypes), const, better i18n support First international standard basically C89 rebadged Significant update with new language and library features, including better IEEE 754 support, compound literals and portable data types Support for threading, type-generic expressions and safer bounds-checking library functions

24 16-bit void * short int long

25 32-bit void * short int long

26 32-bit void * short int long long long

27 64-bit void * short int long long long

28 LP64 void * short int long long long

29 Java & C# short int long

30 LLP64 void * short int long long long

31 int8_t uint8_t int16_t uint16_t int32_t uint32_t int64_t uint64_t intptr_t uintptr_t int_least8_t uint_least8_t int_least16_t uint_least16_t int_least32_t uint_least32_t int_least64_t uint_least64_t int_fast8_t uint_fast8_t int_fast16_t uint_fast16_t int_fast32_t uint_fast32_t int_fast64_t uint_fast64_t

32 Signed magnitude A sign bit, 0 for + and 1 for, is followed by the bits representing the integer's magnitude

33 One's complement Negative integers are represented as the bitwise complement of the corresponding positive integer, i.e., i is equivalent to ~i

34 Two's complement Negative integers are represented 1 plus as the bitwise complement of the corresponding positive integer, i.e., i is equivalent to ~i + 1, which is the same as saying that it is the complement with respect to 2 N

40 undefined

42 INT_MIN - INT_MIN 0

43 INT_MIN + INT_MIN 0

44 Extra, Extra - Read All About It: Nearly All Binary Searches and Mergesorts are Broken Joshua Bloch

45 I was shocked to learn that the binary search program that Bentley proved correct and subsequently tested in Chapter 5 of Programming Pearls contains a bug.

46 Lest you think I'm picking on Bentley, let me tell you how I discovered the bug: The version of binary search that I wrote for the JDK contained the same bug.

48 (low + high) / 2

49 low / 2 + high / 2

50 low + (high low) / 2

52 time_t

53 int main(void) { const time_t end_of_time = INT_MAX; puts(asctime(gmtime(&end_of_time))); return 0; }

54 Tue Jan 19 03:14:

55 int main(void) { const time_t end_of_time = INT_MAX + 1; puts(asctime(gmtime(&end_of_time))); return 0; }

56 Fri Dec 13 20:45:

57 printf("%f", );

59 assert( == 0.3);

60 assert( == 0.3);

61 printf("%.17f", );

64 Floating-Point Numbers Aren't Real Chuck Allison

65 Real numbers have infinite precision and are therefore continuous and nonlossy; floating-point numbers have limited precision, so they are finite, and they resemble "badly behaved" integers, because they re not evenly spaced throughout their range. Chuck Allison

66 It should go without saying that you shouldn't use floating-point numbers for financial applications that's what decimal classes in languages like Python and C# are for. Chuck Allison

67 significand bias exponent

68 single precision 32-bit double precision 64-bit extended precision 64-,80- or 128-bit

69 single precision 32-bit IEEE 754 sign biased exponent significand

73 double same_birthday(int people); // Return the probability that at least 2 people out of a sample // of size 'people' share the same birthday, assuming a uniform // distribution of birthdays and ignoring leap days. int main(void) { int people = 0; while (same_birthday(people) < 0.5) ++people; printf("%i", people); return 0; }

74 double same_birthday(int people) { double probability = 0; } for (int i = 1; i < people; ++i) probability += (1 probability) * i / 365.0; return probability; int main(void) { int people = 0; while (same_birthday(people) < 0.5) ++people; printf("%i", people); return 0; }

77 Correlation doesn't imply causation, but it does waggle its eyebrows suggestively and gesture furtively while mouthing 'look over there'.

78 double same_birthday(int people) { double probability = 0; } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; return probability;

79 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; return probability;

80 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; return probability;

81 assert(same_birthday(0) == 0); assert(same_birthday(1) == 0); assert(same_birthday(2) > 0);... assert(same_birthday(365) < 1); assert(same_birthday(366) == 1); assert(same_birthday(367) == 1);... assert(same_birthday(int_max) == 1);

82 assert(same_birthday(0) == 0); assert(same_birthday(1) == 0); assert(same_birthday(2) > 0);... assert(same_birthday(365) < 1); assert(same_birthday(366) == 1); assert(same_birthday(367) == 1);... assert(same_birthday(int_max) == 1);

83 assert(same_birthday(0) == 0); assert(same_birthday(1) == 0); assert(same_birthday(2) > 0);... assert(same_birthday(183) < 1); assert(same_birthday(184) < 1);... assert(same_birthday(365) < 1); assert(same_birthday(366) == 1); assert(same_birthday(367) == 1);... assert(same_birthday(int_max) == 1);

84 The real value of tests is not that they detect bugs in the code but that they detect inadequacies in the methods, concentration, and skills of those who design and produce the code. C A R Hoare

86 double unique_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 0; } else { double probability = 1; const int nonpeople = 366 people; } } for (int i = 364; i >= nonpeople; --i) probability *= i / 365.0; return probability;

89 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; if (probability == 1) --*(uint64_t *) &probability; return probability;

90 assert(same_birthday(0) == 0); assert(same_birthday(1) == 0); assert(same_birthday(2) > 0);... assert(same_birthday(183) < 1); assert(same_birthday(184) < 1);... assert(same_birthday(365) < 1); assert(same_birthday(366) == 1); assert(same_birthday(367) == 1);... assert(same_birthday(int_max) == 1);

91 printf("%.15f", same_birthday(365)); printf("%.16f", same_birthday(365));

92 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; if (probability == 1) --*(uint64_t *) &probability; return probability;

93 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; if (probability == 1) --*(uint64_t *) &probability; return probability;

94 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; if (probability == 1) probability = nexttoward(1, 0); return probability;

95 double same_birthday(int people) { if (people < 0) { errno = EDOM; return NAN; } else if (people > 365) { return 1; } else { double probability = 0; } } for (int i = 1; i < people; ++i) probability += (1 - probability) * i / 365.0; return probability < 1? probability : nexttoward(1, 0);

97 If a plot works out exactly as you first planned, you're not working loosely enough to give room to your imagination and instincts.

99 The failure resulted in a loss of more than US$370 million.

100

101 Simple Testing Can Prevent Most Critical Failures An Analysis of Production Failures in Distributed Data-Intensive Systems

102 A majority of the production failures (77%) can be reproduced by a unit test.

103 network code() { switch (line) { case THING1: doit1(); break; case THING2: if (x == STUFF) { do_first_stuff(); if (y == OTHER_STUFF) break; do_later_stuff(); } /* coder meant to break to here... */ initialize_modes_pointer(); break; default: processing(); } /*...but actually broke to here! */ use_modes_pointer(); /* leaving the modes_pointer uninitialized */ } Peter van der Linden Expert C Programming

104 if ((err = ReadyHash(&SSLHashSHA1, &hashctx))!= 0) goto fail; if ((err = SSLHashSHA1.update(&hashCtx, &clientrandom))!= 0) goto fail; if ((err = SSLHashSHA1.update(&hashCtx, &serverrandom))!= 0) goto fail; if ((err = SSLHashSHA1.update(&hashCtx, &signedparams))!= 0) goto fail; goto fail; if ((err = SSLHashSHA1.final(&hashCtx, &hashout))!= 0) goto fail; Mike Bland "Goto Fail, Heartbleed, and Unit Testing Culture"

105 Goto Fail, Heartbleed, and Unit Testing Culture Mike Bland

106 These bugs are as instructive as they were devastating: They were rooted in the same programmer optimism, overconfidence, and haste that strike projects of all sizes and domains. Mike Bland

107 These bugs arouse my passion because I've seen and lived the benefits of unit testing, and this strongly-imprinted experience compels me to reflect on how unit testing approaches could prevent defects as highimpact and high-profile as these SSL bugs. Mike Bland

108

109 Test-Driven Development is not a testing technique, although you do write a lot of valuable automated tests. It is a way to solve programming problems. It helps software developers make good design decisions. Tests provide a clear warning when the solution takes a wrong path or breaks some forgotten constraint. Tests capture the production code s desired behavior.

110 TDD is fun! It s like a game where you navigate a maze of technical decisions that lead to highly robust software while avoiding the quagmire of long debug sessions. With each test there is a renewed sense of accomplishment and clear progress toward the goal. Automated tests record assumptions, capture decisions, and free the mind to focus on the next challenge.

111 TDD is fun!

112

113 The fastest I/O is no I/O. Nils-Peter Nelson

114 Command-line tools can be 235x faster than your Hadoop cluster Adam Drake

115 c

116

117

118

119

120

121 Low-level programming is good for the programmer's soul. John Carmack

Procedural Programming. It's Back? It Never Went

Procedural Programming. It's Back? It Never Went Procedural Programming It's Back? It Never Went Away @KevlinHenney procedural? µονόλιθος µservices µservices This is the Unix philosophy: Write programs that do one thing and do it well. Write programs