Font size:

Description:

This is a bundled training package. It contains training for each of the bundled items below:

Course Price
Programming Techniques and Strategies $74.95
General Coding Best Practices $74.95
Object-oriented Coding Best Practices $74.95
Maintaining Quality Code $74.95
Getting Started with Software Programming $74.95
Software Program Control Flow Fundamentals $74.95

Bundle Price: $219.00
Total Savings: $230.70


Programming Techniques and Strategies

To outline the high-level considerations for producing good code
  • Tackling software complexity - recognize examples of strategies and tasks for minimizing software complexity.
  • The people factor in programming - identify the characteristics of egoless programming.
  • Defining software quality - recognize the software quality attributes for a given software application.
  • The evolution of programming techniques - recognize the benefits of structured programming, OOP, and design by contract.
  • Defensive programming - distinguish between examples of defensive programming techniques.
  • Agile programming - identify the main tenets of Extreme Programming.
  • Programming for success - recognize project implementations that are compatible with agile and defensive programming strategies.

General Coding Best Practices

To outline the best practices for writing high quality methods, expressions, variables, arrays, loops, and if statements, and to describe recommended practices for writing readable code
  • Writing readable code - recognize techniques for enhancing program readability in a given scenario.
  • Documenting code - determine an appropriate comment for a given piece of code.
  • Evaluating code for readability - recognize code readability standards.
  • Writing good lines of code - recognize breaches of best practice guidelines for writing expressions and ordering lines of code.
  • Variables and types - recognize whether given examples comply with best practice guidelines for using types, arrays, variables, and alternatives to hard-coded values.
  • Structured flow-control - recognize whether given examples comply with well-structured flow-control best practice guidelines.
  • Writing well-structured code - determine suitable structuring solutions to improve given code examples.
  • Building good methods - recognize ways to improve a given method.
  • Handling arguments and return values - recognize if given examples comply with best practice guidelines on handling arguments and return values.
  • Exceptions - recognize examples that comply with best practice guidelines for using exceptions.
  • Writing well-structured methods - evaluate given method samples for their adherence to best practice guidelines.

Object-oriented Coding Best Practices

To outline the best practices for defining and using classes, and determining how best to use inheritance or its alternatives
  • Defining classes - recognize whether a given class complies with best practice guidelines for abstraction and encapsulation.
  • Constructors and destructors - recognize best practices for using constructors and destructors, and creating objects.
  • Advanced classes - identify steps to make a class immutable and recognize examples of uses for static classes.
  • Building classes - determine appropriate class designs for a given scenario.
  • Rules for good inheritance - recognize how best to implement inheritance.
  • Determining suitable class relationships - assess whether appropriate class relationships have been used in given scenarios, and determine more suitable ones.
  • Replacing inheritance - identify a suitable method for defining relationships between classes in a given scenario.

Maintaining Quality Code

To outline the primary techniques of refactoring, and to discuss the best practices for reviewing, testing, and debugging code
  • Introducing refactoring - recognize symptoms of code issues that require refactoring.
  • Refactoring techniques - recognize suitable situations for applying different refactoring techniques.
  • Conducting peer reviews of code - recognize the guidelines for performing inspections of code.
  • Categorizing and avoiding bugs - identify steps to minimize programming bugs in code.
  • Testing and debugging - identify the recommended practices for testing and debugging.
  • Establishing code maintenance processes - identify suitable steps to include in code maintenance processes.

Getting Started with Software Programming

Today’s computers are powerful tools capable of accomplishing sophisticated tasks, but not without the assistance of skilled software developers. This course introduces the learner to the magic behind computer software development, beginning with a brief history of computer languages and how these languages have evolved into powerful programming environments, and ending with the actual creation of simple algorithms. Specific topics covered include the Software Development Life Cycle (SDLC), best practices for developing computer programs, the tools available for software developers, and the basics of computer algorithms. This course doesn’t focus on any one programming language, and instead demonstrates algorithms using pseudocode, a nonspecific method of writing code that is easily converted into practically any programming language.
  • identify stages in the evolution of software programming languages
  • recognize the main types of programming languages that evolved
  • recognize the steps in the software development life cycle
  • identify the differences between the waterfall and extreme programming software development methodologies
  • recognize the features of common programming methodologies
  • recognize the features of a good program
  • recognize the functions of common program development tools
  • demonstrate basic knowledge of computer languages, programs and programmer tools
  • demonstrate knowledge of software methodologies and programming approaches
  • recognize factors to consider when writing an algorithm using the top-down approach
  • recognize how to structure algorithms
  • recognize examples of sequence, selection, and repetition
  • express inputs, processes and outputs as an algorithm
  • create a letter-counting algorithm
  • create a tax-calculating algorithm

Software Program Control Flow Fundamentals

Computer software works because programmers create algorithms, which when broken down, are nothing more than a collection of logical constructs. This course introduces the learner to the logic behind computer software, including using defining tables to solve a problem, conditional statements like IF…THEN, and repetition using FOR and WHILE loops. This course doesn’t focus on any one programming language and example code will be provided in the syntax of popular programming languages such as Pascal, C++, VisualBasic and Java.
  • recognize the features of IF statements
  • recognize how programming languages process IF statements
  • identify the features of CASE statements
  • identify the steps in solving a basic programming problem
  • complete branching statements in C code
  • complete IF statements in a given example
  • complete CASE statements in a given example
  • complete a program based on a defining table in a given example
  • sequence the operations in a FOR loop
  • recognize how to use the FOR loop in computer programs
  • recognize how to use the WHILE loop in computer programs
  • recognize where to use the WHILE loop
  • analyze the use of a WHILE loop in PASCAL code in given examples
  • create a defining table to determine inputs, processes, and outputs
  • structure an algorithm containing a FOR loop
  • complete a WHILE loop in an algorithm
Register Now
Best Practices for Software Programming e-learning bundle
  • Course ID:
    252620
  • Duration:
    12 hours
  • Price:
    $219