How good is your code? How does it stack up against industry best practices? How could you write code that's more readable and more maintainable? In this two-day seminar you will learn standards, conventions, and strategies for writing good code, and you will have the opportunity to evaluate your own code against these criteria. This class is based on Construx's one-day Code Complete Essentials class, and it provides much more time for lab work, personal code reviews, and tutoring from the instructor. Students are asked to bring a few pages of their own code to this class, which they will not be required to share with other students. (Open Source code will be available for students who do not bring their own code.) 2-day seminar

Benefits

Attendees will learn effective software construction practices including techniques that shorten development time, reduce errors, make debugging easier, and produce code that is easier to maintain and revise. Attendees will learn both time-tested techniques and state-of-the-art construction practices through dozens of examples in Java, C++, and Visual Basic. Attendees will have numerous opportunities to evaluate their own code against these techniques and practices.

Who Should Attend

This seminar will be useful to software developers, self-taught programmers, testers who write extensive code for test automation, and anyone who wants to learn best coding practices. This seminar will be most useful for developers with 0-5 years of professional experience.

Introduction

  • Construction and other software development activities
  • Accidental and essential software development difficulties
  • Construction themes

Defensive Programming Practices

  • Naming variables, routines, and classes
  • Pseudocode programming process
  • vAssertions
  • Code stepping
  • Variations in error processing approaches
  • A defensive strategy for code optimization
  • Effective strategies for anticipating change

Managing Complexity

  • The critical role of complexity in software construction
  • Complexity and global data
  • Role of coding conventions and coding standards
  • Design practices that combat complexity
  • Actively managing essential difficulties
  • Preventing proliferation of accidental difficulties
  • Prioritizing read-time convenience over write-time convenience

Creating High Quality Designs

  • Programming "into" a language compared to programming "in" a language
  • Focusing on semantics vs. focusing on syntax
  • Keys to generating good design ideas
  • Hierarchies
  • Information hiding and modularization
  • Separation of concerns
  • Abstraction and encapsulation
  • Coupling and cohesion

Special Naming Topics

  • Naming and design quality
  • Status variables
  • Loop indices
  • "Temporary" variables
  • Function and routine names
  • General principles

Creating High-Quality Routines

  • A low-quality routine
  • Valid and invalid reasons to create a routine
  • Program layout techniques
  • Low-effort, high-payoff commenting techniques

Error Processing

  • Central role of error processing in production code
  • Common error processing approach
  • Robustness vs. correctness
  • What is the best approach to error processing?

Debugging

  • Debugging by superstition
  • A scientific approach to debugging
  • Tips for finding hard-to-find defects
  • Brute-force error-finding techniques
  • Tips for fixing defects

Quality Overview

This seminar is not offered publicly.

Steve Tockey

Steve Tockey is the Principal Consultant at Construx Software. During more than three and a half decades in the software industry, he has worked as a programmer, ...