Principles of Programming

Principles of Programming
Principles of Programming
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 6h 19m | 0.98 GB

Hear the legendary Bill Inmon discuss the key principles of programming. Not only will Bill teach you about the foundational knowledge required for every successful developer, he will give you dozens of exercises and explain the answers as if you are in the classroom with him! Topics covered include:

  • Computer Components. Explores the various components and stakeholders of a computer to go from a programming language to a machine language. Compilers, system handlers, the database manager, and more.
  • It is the programmer that allows the business requirements of the organization to be translated into code.
    Basic Programming Part 1. Covers the very basics of programming, including declaration statements, variables (numeric, string, and integer), and arrays.
  • Basic Programming Part 2. Covers the sequence of execution and some of the considerations in running a program, such as the assignment statement and mathematical operators.
  • Basic Programming Part 3. Covers some more sophisticated ways we create programs, including arrays and do-loops. We cover some common program mistakes involving arrays and loops.
  • Basic Programming Part 4. Covers the IF statement. We cover more complex nested if-statements as well. Common mistakes using this construct are covered as well.
  • Basic Programming Part 5. Expands on the Do statement, covering more complex operations such as nested Do statements and control parameters.
  • Basic Programming Part 6. Covers the complex logic in programming. We discuss how to make it simpler and the reasons for simplicity.
  • Basic Programming Part 7. Focuses on simplifying variables in your programming logic. We talk about the reasons for simplification, including programming, debugging, performance, error analysis, and maintenance.
  • Basic Programming Part 8. Explores call procedures. The code is written once and called many times.
  • Basic Programming Part 9. Covers the system library. This is the place where common code is stored. We discuss how the system library is accessed and used.
  • Basic Programming Part 10. Covers arrays. Arrays are a very powerful way to organize code and data.
  • File Processing. Discusses how a program reads a file. This is how data gets in and out of our programs.
  • Print and Trace Messages. Covers print and trace messages. These messages help us debug code and understand what the program is doing.
  • Advanced String Processing. Covers some of the advanced features available in strings, such as concatenations and substrings.
  • Special Characters. Explores special characters such as line feeds, end of lines, tabs, new pages, and many more. Some of the challenges are discussed, such as that there are no print specifications for special characters.
  • Database DDL. Explains Data Definition Language (DDL) and how it relates to programming.
  • Program Errors. Covers examples of different types of program errors including code malfunction, infinite loop, and incorrect logic.
  • An Example. Provides an example of a simple program so that you can see how all of the previous concepts comes together.
  • Merging Files. Shows two files that need to be merged based upon common data, into a third file.
  • Documentation. Explores indentation and documentation. This helps greatly with support and maintenance.
  • Index Insert (System). Explains the concept of an index. This clip covers the system-controlled index.
  • Index Insert (Application). Explains the concept of an index. This clip covers the application-controlled index.
  • Editing Part 1. Covers the types of editing of data that might take place prior to loading into a database.
  • Editing Part 2. Builds on the prior clip. We cover the types of editing that can occur during maintenance.
  • Program to Screen Interface. Explores how to define the screen to the system itself. We discuss how the program interacts with the screen.
  • Testing. Explores the function of testing. Testing is one of the most essential aspects of coding.
  • Referential Integrity. Discusses how data is related together. For example an order needs to reference a valid product number.
  • Dynamic Processing Display. Covers dynamic processing display. As your program is executing, sometimes the program runs for a long time and you will need to signal to the end user the status of running so that the user knows something is still happening.
  • Architectural Performance. Explains architectural performance. There are many ways to view performance of the program, but perhaps the most important to gauge program success is architectural performance. How fast does your program run and how satisfied is your end user with the program results?
  • Program Modularity. Explores factors to consider in organizing your code into logical modules.
Table of Contents

01 Computer Components
02 Basic Programming Part 1
03 Basic Programming Part 2
04 Basic Programming Part 3
05 Basic Programming Part 4
06 Basic Programming Part 5
07 Basic Programming Part 6
08 Basic Programming Part 7
09 Basic Programming Part 8
10 Basic Programming Part 9
11 Basic Programming Part 10
12 File Processing
13 Print and Trace Messages
14 Advanced String Processing
15 Special Characters
16 Database DDL
17 Program Errors
18 An Example
19 Merging Files
20 Documentation
21 Index Insert (System)
22 Index Insert (Application)
23 Editing Part 1
24 Editing Part 2
25 Program to Screen Interface
26 Testing
27 Referential Integrity
28 Dynamic Processing Display
29 Architectural Performance
30 Program Modularity