Appendix: Basic Programming Elements

A Complete Program

• Headers
• Old-style declarations vs.
  int main(int argc, char *argv[]);
  
• getopt
• strcmp return value. Common idiom:
  #define STREQ(a, b) (*(a) == *(b) && strcmp((a), (b)) == 0)
  
• Java argv processing:
  if (isConfig) {
      configFile = args[i];
      isConfig = false;
  } else if (args[i].equals("-config")) {
      isConfig = true;
  } else if (args[i].equals("-debug")) {
      debug = true;
  } else if (args[i].equals("-nonaming")) {
  
• Variable initialization (nflag)
• printf and format specifications
• printf and putchar return value
  if (ferror(stdout))
      err(1, "stdout");
  

Expand: A Larger Example

Declarations and visibility

• Global functions and variables
• Declare before use
• Use of the static keyword

Functions and Global Variables

To find what a function does:

Guess, based on the function name.
Read the comment at the beginning of the function.
Examine how the function is used.
Read the code in the function body.
Consult external program documentation.

while Loops, Conditions, and Blocks

• while statement
• statement blocks
• The perils of wrong indentation
  for (ntp = nettab; ntp != NULL; ntp = ntp->next) {
      if (ntp->status == MASTER)
          rmnetmachs(ntp);
          ntp->status = NOMASTER;
  }
  
• assignment expressions
  if ((line = input.readLine()) == null) /* [...] */
      return errors;
  
• Parentheses and evaluation precedence
• API documentation

switch Statements

• Example: expand getopt processing
• The use of fallthrough:
  case 'a':
      fts_options |= FTS_SEEDOT;
      /* FALLTHROUGH */
  case 'A':
      f_listdot = 1;
      break;
  
• Defensive handling of default statements:
      switch (program) {
      case ATQ:
  /* [...] */
      case BATCH:
          writefile(time(NULL), 'b');
          break;
      default:
          panic("Internal error");
          break;
      }
  

for Loops

• Typical case:
      for (i = 0; i < len; i++) {
  
• Atypical cases
  •     for ( i = 0; i <= extrknt; i++ )
    
  •     for (i = 1; i < month; i++)
    
  •     for (i = 1; i <= nargs; i++)
    
  •     for (code = 255; code >= 0; code--) {
    
• Library function loops:
      if ((dd = opendir(dir)) == NULL)
          return (CC_ERROR);
      for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) {
  
• Use of multiple expressions:
      for (cnt = 1, t = p; cnt <= cnt_orig; ++t, ++cnt) {
  
• Infinite loop:
      for (;;) {
          s = (state_t) (*s)();
          quiet = 0;
      }
  

Loop Control Statements

• break: exit loop
• continue: restart loop
• Perl equivalents: last, next
• continue as placeholder
      for (; *string && isdigit(*string); string++)
          continue;
  
• Java's labeled loops and control statements:
  skip:
      for ( /* [...] */ ) {
          if ( ch == limit.charAt(0) ) {
              for (int i = 1 ; i < limlen ; i++) {
                  if ( /* [...] */ )
                      continue skip;
              }
              return ret;
          }
      }
  
• Used for clarity:
      comp : while(prev < length) {
          /* [...] */
          if (pos >= length || pos == -1) {
              /* [...] */
              break comp;
          }
      }
  

Character Expressions

• Range membership:
      while ('0' <= *cp && *cp <= '9')
  
• Case conversion:
      if ('a' <= *s && *s <= 'z')
          *s -= ('a' - 'A');
  
• Both examples above illustrate non-portable code.
• A more complex example:
          i = 0;
          while (*cp >= '0' && *cp <= '9')
                  i = i * 10 + *cp++ - '0';
  

Boolean Expressions

• De Morgan's rules
• Convert expression into range membership
  Disjunctive expression:
                  if (i <= 0 || i > 256) {
  
  conversion into conjunction:
      i <= 0 || i > 256  <=>
      !(!(i <= 0) && !(i > 256)) <=>
      !(i > 0 && i <= 256) <=>
      !(0 < i && i <= 256) <=>
  
• Short-circuit evaluation
  • Conjunction:
    if (t != NULL && t->type != TEOF && interactive && really_exit)
            really_exit = 0;
    
  • Disjunction:
    if (argv == NULL || argv[1] == NULL || argv[2] == NULL)
        return -1;
    

goto Statements

• Can lead to spaghetti code
• Not supported in Java
• Used to exit after an error:
          for (;;) {
                  i = 0;
                  while (*cp >= '0' && *cp <= '9')
                          i = i * 10 + *cp++ - '0';
                  if (i <= 0 || i > 256) {
  bad:
                          fprintf(stderr, "Bad tab stop spec\n");
                          exit(1);
                  }
                  if (nstops > 0 && i <= tabstops[nstops-1])
                          goto bad;
                  tabstops[nstops++] = i;
                  if (*cp == 0)
                          break;
                  if (*cp != ',' && *cp != ' ')
                          goto bad;
                  cp++;
          }
  
• Execute code again:
  struct servent *
  getservent()
  {
          char *p;
          register char *cp, **q;
  
          if (servf == NULL && (servf = fopen(_PATH_SERVICES, "r" )) == NULL)
                  return (NULL);
  again:
          if ((p = fgets(line, BUFSIZ, servf)) == NULL)
                  return (NULL);
          if (*p == '#')
                  goto again;
          cp = strpbrk(p, "#\n");
          if (cp == NULL)
                  goto again;
          *cp = '\0';
          serv.s_name = p;
          p = strpbrk(p, " \t");
          if (p == NULL)
                  goto again;
          *p++ = '\0';
          while (*p == ' ' || *p == '\t')
                  p++;
          cp = strpbrk(p, ",/");
  
• Exit from deep control structures (instead of break):
          for (;;) {
                  /* [...] */
                  /* Gather incoming message bytes if needed. */
                  if ((sc->sc_state & NCR_DROP_MSGIN) == 0) {
                          if (n >= NCR_MAX_MSG_LEN) {
                                  ncr_sched_msgout(sc, SEND_REJECT);
                                  sc->sc_state |= NCR_DROP_MSGIN;
                          } else {
                                  *sc->sc_imp++ = *sc->sci_data;
                                  n++;
                                  /*
                                   * This testing is suboptimal, but most
                                   * messages will be of the one byte variety, so
                                   * it should not affect performance
                                   * significantly.
                                   */
                                  if (n == 1 && IS1BYTEMSG(sc->sc_imess[0]))
                                          goto have_msg;
                                  if (n == 2 && IS2BYTEMSG(sc->sc_imess[0]))
                                          goto have_msg;
                                  if (n >= 3 && ISEXTMSG(sc->sc_imess[0]) &&
                                          n == sc->sc_imess[1] + 2)
                                          goto have_msg;
                          }
                  }
                  /* [...] */
  
                  /* back to nextbyte */
          }
  
  have_msg:
          /* We now have a complete message.  Parse it. */
  

Refactoring in the Small

• Keep code's functional properties, while improving non-functional properties
  • Readability
  • Maintainability
  • Portability
  • Reliability
• Can be performed in the large (architecture), or in the small (code elements)

Illustrative Example

Refactoring Example

Original Code

More Readable Representation

Re-implementation

Other Implementation

Other Refactoring Changes

• Add brackets in expressions
• Add missing comments
• But "don't comment bad code, rewrite it"
• Use better variable names
• Fix/improve indentation
• The indent program may be helpful (apply with care)
• Beware of forks; do it only on code you own
• Use a version control system
• Separate style commits from functional commits

Assignment Expressions

• Assignment in an if statement:
  if ((p = q))
      q[-1] = '\n';
  
• Avoided with explicit comparison:
      if ((p = strchr(name, '=')) != NULL) {
          p++;
  
• Made explicit with a non-modifiable lvalue:
      if (0 == serconsole)
          serconsinit = 0;
  
• In Java and C# the above matter only for boolean expressions

Bit Manipulation

• Example:
          do {
                  putchar(' ');
                  column++;
          } while (column & 07);
  
  Rule:
  a & b /* is sometimes used for */ a % (b + 1) /* b = 2**n - 1 */
  
• Example:
      n = ((dp - cp) << 2) + 1; /* 4 times + NULL */
  
  Rule:
  a << n /* is sometimes used for */ a * k /* k = 2**n */
  
• Example:
  bp = bp1 + ((bp2 - bp1) >> 1);
  
  Rule:
  a >> n /* is sometimes used for */ a / k /* k = 2**n */
  

Reading Control Structures

• Treat the contents of a loop as a separate block.
  Read
  while (xenum.hasMoreElements()) {
      /* [...] */
      if (object instanceof Resource) {
          /* [...] */
          if (!copy(is, os))
              /* [...] */
      } else if (object instanceof InputStream) {
          /* [...] */
          if (!copy((InputStream) object, os))
              /* [...] */
      } else if (object instanceof DirContext) {
          /* [...] */
      }
  }
  
  as
  while (xenum.hasMoreElements()) {
      /* [...] */
  }
  
• In a body of a structure, consider its controlling expression as an asserion
      if (!links.contains(next)) {
          links.add(next);
      }
  
• The above may not hold for sequences that include
  • return
  • goto
  • break
  • continue
  • exceptions

Further Reading

• Edsger Wybe Dijkstra. Go to statement considered harmful. Communications of the ACM, 11(3):147–148, March 1968.

• Martin Fowler. Refactoring: Improving the Design of Existing Code. Addison-Wesley, Boston, MA, 2000. With contributions by Kent Beck, John Brant, William Opdyke, and Don Roberts.

• C. A. R. Hoare. Proof of a program: Find. Communications of the ACM, 14(1):39–45, January 1971.

• Brian W. Kernighan and P. J. Plauger. The Elements of Programming Style. McGraw-Hill, New York, second edition, 1978.

• Brian W. Kernighan and Dennis M. Ritchie. The C Programming Language. Prentice-Hall, Englewood Cliffs, NJ, second edition, 1988.

• Donald E. Knuth. The Art of Computer Programming, volume 3: Sorting and Searching. Addison-Wesley, Reading, MA, second edition, 1998.

• Peter Van Der Linden. Expert C Programming, pages 226–231. Prentice-Hall, 1994.

• Richard J. Miara, Joyce A. Musselman, Juan A. Navarro, and Ben Shneiderman. Program indentation and comprehensibility. Communications of the ACM, 26(11):861–867, 1983.

• Microsoft Corporation. Microsoft C# Language Specifications. Microsoft Press, Redmond, WA, 2001.

• Paul W. Oman and Curtis R. Cook. Typographic style is more than cosmetic. Communications of the ACM, 33(5):506–520, May 1990.

• Dennis M. Ritchie. The C programming language—reference manual. In Unix Programmer's Manual [Unix Programmer's Manual, 1979]. Also available online http://plan9.bell-labs.com/7thEdMan/.

• Diomidis Spinellis. Code Reading: The Open Source Perspective, pages 19–60. Effective Software Development Series. Addison-Wesley, Boston, MA, 2003.

• Bjarne Stroustrup. The C++ Programming Language. Addison-Wesley, Reading, MA, third edition, 1997.

• Ted Tenny. Program readability: Procedures versus comments. IEEE Transactions on Software Engineering, 14(9):1271–1279, September 1988.

• Edward J. Thomas and Paul W. Oman. A bibliography of programming style. ACM SIGPLAN Notices, 25(2):7–16, February 1990.

• UNIX Programmer's Manual. Volume 2—Supplementary Documents. Bell Telephone Laboratories, Murray Hill, NJ, seventh edition, 1979. Also available online http://plan9.bell-labs.com/7thEdMan/.

• Larry Wall, Tom Christiansen, Randal L. Schwartz, and Stephen Potter. Programming Perl. O'Reilly and Associates, Sebastopol, CA, third edition, 2000.

Exercises and Discussion Topics

1. Experiment to find-out how your C, C++, and Java compilers deal with uninitialized variables. Outline your results and propose an inspection procedure for locating uninitialized variables.
2. Look in the course's source code repository for programs that do not verify the result of library calls. Propose practical fixes.
3. Examine the visibility of functions and variables in programs in your environment. Can it be improved (made more conservative)?
4. Discover how the editor you are using can identify matching braces and parentheses. If it can not, consider to start using another editor.
5. Provide five examples from the course's source code collection where the code structure can be improved to make it more readable.
6. You can find tens of intentionally unreadable C programs at the International Obfuscated C Code Contest web site (http://www.ioccc.org). Most of them use several layers of obfuscation to hide their algorithms. See how gradual code changes can help you untangle their code. If you are not familiar with the C preprocessor try to avoid programs with a large number of #define lines.
7. The Perl language mandates the use of braces for all its control structures. Comment on how this affects the readability of Perl programs.
8. The code body of switch statements in the course's source code collection is formatted differently from the other statements. Express the formatting rule used, and explain its rationale.
9. The for statement in the C language family is very flexible. Examine the source code provided to create a list of ten different uses.
10. Locate ten occurrences of break and continue in the source code provided with the course. For each case indicate the point where execution will transfer after the corresponding statement is executed, and explain why the statement is used. Do not try to understand in full the logic of the code; simply provide an explanation based on the statement's use pattern.
11. Find, simplify, and reason about five non-trivial boolean expressions in the source-code base. Do not spend time on understanding what the expression elements mean, concentrate on the conditions that will make the expression become true or false. Where possible, identify and utilize the properties of short-circuit evaluation.
12. Study Section 2.11 from the book. Provide a proof about the correctness of a sort algorithm, found in the course's soruce repository.

• Contents

 Last change: Tuesday, April 11, 2006 8:11 am
 Unless otherwise expressly stated, all original material on this page created by Diomidis Spinellis is licensed under a Creative Commons Attribution-Share Alike 3.0 Greece License.