You are previewing Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®.
O'Reilly logo
Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

Book Description

So you want to be a programmer? Or maybe you just want to be able to make your computer do what YOU want for a change? Maybe you enjoy the challenge of identifying a problem and solving it. If programming intrigues you for whatever reason, Beginning Programming All-In-One Desk Reference For Dummies is like having a starter programming library all in one handy, if beefy, book.

In this practical guide, you’ll find out about compiling, algorithms, best practices, debugging your programs, and much more. The concepts are illustrated in several different programming languages, so you’ll get a feel for the variety of languages and the needs they fill. Seven minibooks cover:

  • Getting started

  • Programming basics

  • Data structures

  • Algorithms

  • Web programming

  • Programming language syntax

  • Applications

Beginning Programming All-In-One Desk Reference For Dummies shows you how to decide what you want your program to do, turn your instructions into “machine language” that the computer understands, use programming best practices, explore the “how” and “why” of data structuring, and more. You’ll even get a look into various applications like database management, bioinformatics, computer security, and artificial intelligence. Soon you’ll realize that — wow! You’re a programmer!

Table of Contents

  1. Copright
  2. About the Author
  3. Acknowledgments
  4. Introduction
    1. Who Should Buy This Book
    2. How This Book Is Organized
      1. Book I: Getting Started
      2. Book II: Programming Basics
      3. Book III: Data Structures
      4. Book IV: Algorithms
      5. Book V: Web Programming
      6. Book VI: Programming Language Syntax
      7. Book VII: Applications
    3. How to Use This Book
    4. Icons Used in This Book
    5. Getting Started
  5. I. Getting Started
    1. I.1. Getting Started Programming a Computer
      1. I.1.1. How Computer Programming Works
        1. I.1.1.1. Identifying the problem
        2. I.1.1.2. Defining the steps
      2. I.1.2. The History of Computer Programming
        1. I.1.2.1. Talking to a processor in machine language
        2. I.1.2.2. Using assembly language as a shortcut to machine language
        3. I.1.2.3. Hiding the details of a computer with a high-level language
        4. I.1.2.4. Combining the best of both worlds with the C programming language
        5. I.1.2.5. Pros and cons of programming languages
      3. I.1.3. Figuring Out Programming
        1. I.1.3.1. Desire beats technical training every time
        2. I.1.3.2. Picking a computer and an operating system
        3. I.1.3.3. Writing programs with an editor
        4. I.1.3.4. Converting source code with an assembler or compiler
        5. I.1.3.5. Translating source code with an interpreter
        6. I.1.3.6. Combining a compiler with an interpreter to create p-code
        7. I.1.3.7. Taking the time to understand
      4. I.1.4. Getting Started with Programming
        1. I.1.4.1. Starting with Windows
        2. I.1.4.2. Starting with Mac OS X
        3. I.1.4.3. Starting with Linux
        4. I.1.4.4. Starting with Java
      5. I.1.5. Knowing Programming versus Knowing Programming Language
    2. I.2. Different Methods for Writing Programs
      1. I.2.1. Spaghetti Programming without a Plan
      2. I.2.2. Planning Ahead with Structured Programming
        1. I.2.2.1. The three parts of structured programming
        2. I.2.2.2. Top-down programming
      3. I.2.3. Making User Interfaces with Event-Driven Programming
        1. I.2.3.1. Designing a user interface
        2. I.2.3.2. Writing event handlers
        3. I.2.3.3. Writing your program
      4. I.2.4. Organizing a Program with Object-Oriented Programming
        1. I.2.4.1. Objects isolate data
        2. I.2.4.2. Objects simplify modifications
      5. I.2.5. Designing Programs with Today's Methodology
    3. I.3. Types of Programming Languages
      1. I.3.1. Choosing Your First Language
        1. I.3.1.1. C the BASIC choices
        2. I.3.1.2. Having second thoughts
      2. I.3.2. Teaching Languages
        1. I.3.2.1. Getting back to BASIC
        2. I.3.2.2. Turtle graphics with Logo
        3. I.3.2.3. The philosophy of Pascal
        4. I.3.2.4. Other teaching languages
      3. I.3.3. "Curly Bracket" Languages
        1. I.3.3.1. The power of C
        2. I.3.3.2. The efficiency of C
        3. I.3.3.3. The portability of C
        4. I.3.3.4. Adding object-oriented programming with C++
        5. I.3.3.5. True portability with Java
        6. I.3.3.6. Safer programming with C#
        7. I.3.3.7. Choosing a curly bracket language
      4. I.3.4. Artificial Intelligence Languages
      5. I.3.5. Scripting Languages
        1. I.3.5.1. Automating a program
        2. I.3.5.2. Customizing a program
        3. I.3.5.3. Transferring data among multiple programs
        4. I.3.5.4. Creating separate applications
      6. I.3.6. Database Programming Languages
        1. I.3.6.1. The dBASE programming language
        2. I.3.6.2. Adding database access to traditional languages
        3. I.3.6.3. Customizing database programs
      7. I.3.7. Comparing Programming Languages
    4. I.4. Programming Tools
      1. I.4.1. Choosing a Compiler
        1. I.4.1.1. Defining your needs for a compiler
        2. I.4.1.2. Evaluating the technical features of a compiler
      2. I.4.2. Finding an Interpreter
        1. I.4.2.1. Operating system interpreters
        2. I.4.2.2. Web page interpreters
      3. I.4.3. Compiling to a Virtual Machine
      4. I.4.4. Writing a Program with an Editor
        1. I.4.4.1. Editors
      5. I.4.5. Fixing a Program with a Debugger
        1. I.4.5.1. Stepping line by line
        2. I.4.5.2. Watching variables
      6. I.4.6. Saving Time with Third-Party Components
      7. I.4.7. Optimizing a Program with a Profiler
      8. I.4.8. Creating a Help File
      9. I.4.9. Installing a Program
      10. I.4.10. Dissecting Programs with a Disassembler
    5. I.5. Managing Large Projects with Software Engineering
      1. I.5.1. Software Engineering Methods
        1. I.5.1.1. Designing a program with the waterfall model
        2. I.5.1.2. Evolving a program with extreme programming
      2. I.5.2. Automating Software Engineering with CASE
        1. I.5.2.1. Modeling a large project
        2. I.5.2.2. Generating code automatically
        3. I.5.2.3. Formatting source code automatically
        4. I.5.2.4. Tracking revisions in code
      3. I.5.3. The Pros and Cons of Software Engineering
  6. II. Programming Basics
    1. II.1. How Programs Work
      1. II.1.1. Using Keywords as Building Blocks
      2. II.1.2. Organizing a Program
      3. II.1.3. Dividing a Program into Subprograms
      4. II.1.4. Dividing a Program into Objects
      5. II.1.5. Creating a User Interface
    2. II.2. Variables, Data Types, and Constants
      1. II.2.1. Declaring Variables
        1. II.2.1.1. Creating a variable
      2. II.2.2. Using Different Data Types
      3. II.2.3. Storing Data in a Variable
      4. II.2.4. Retrieving Data from a Variable
      5. II.2.5. Using Constant Values
      6. II.2.6. Defining the Scope of a Variable
        1. II.2.6.1. Handling global variables with care
        2. II.2.6.2. Restricting scope to a module
        3. II.2.6.3. Isolating variables in a subprogram
        4. II.2.6.4. Passing data among subprograms
    3. II.3. Manipulating Data
      1. II.3.1. Storing Data with the Assignment Operator
      2. II.3.2. Using Math to Manipulate Numbers
        1. II.3.2.1. Organizing equations with operator precedence
        2. II.3.2.2. Using built-in math functions
      3. II.3.3. Manipulating Strings
      4. II.3.4. Finding Strings with Regular Expressions
        1. II.3.4.1. Pattern matching with the single character (.) wildcard
        2. II.3.4.2. Pattern matching for specific characters
        3. II.3.4.3. Pattern matching with the multiple character (*) and (+) wildcards
        4. II.3.4.4. Pattern matching with ranges
      5. II.3.5. Using Comparison Operators
      6. II.3.6. Using Boolean Operators
        1. II.3.6.1. Using the Not operator
        2. II.3.6.2. Using the And operator
        3. II.3.6.3. Using the Or operator
        4. II.3.6.4. Using the Xor operator
      7. II.3.7. Converting Data Types
    4. II.4. Making Decisions by Branching
      1. II.4.1. Picking One Choice with the IF-THEN Statement
      2. II.4.2. Picking Two Choices with the IF-THEN-ELSE Statement
      3. II.4.3. Picking Three or More Choices with the IF-THEN-ELSEIF Statement
        1. II.4.3.1. Checking a condition for each set of commands
        2. II.4.3.2. Offering three or more choices
      4. II.4.4. Playing with Multiple Boolean Operators
      5. II.4.5. Making Multiple Choices with the SELECT CASE statement
        1. II.4.5.1. The switch statement in C (and similar languages)
        2. II.4.5.2. Matching multiple values in a SELECT CASE statement
        3. II.4.5.3. Checking a range of values
        4. II.4.5.4. Comparing values
        5. II.4.5.5. Running at least one command with the ELSE statement
    5. II.5. Repeating Commands by Looping
      1. II.5.1. Looping a Fixed Number of Times with the FOR-NEXT Loop
        1. II.5.1.1. Using a FOR-NEXT loop variable
        2. II.5.1.2. Counting by a different range
        3. II.5.1.3. Counting by different increments
        4. II.5.1.4. Counting backward
      2. II.5.2. Looping Zero or More Times with the WHILE Loop
      3. II.5.3. Looping at Least Once with the DO Loop
      4. II.5.4. Playing with Nested Loops
      5. II.5.5. Prematurely Exiting from a Loop
      6. II.5.6. Checking Your Loops
    6. II.6. Breaking a Large Program into Subprograms
      1. II.6.1. Creating and Using Subprograms
        1. II.6.1.1. Creating a subprogram
        2. II.6.1.2. "Calling" a subprogram
      2. II.6.2. Passing Parameters
        1. II.6.2.1. Passing parameters by reference
        2. II.6.2.2. Storing values in a subprogram name
      3. II.6.3. Repeating a Subprogram with Recursion
    7. II.7. Breaking a Large Program into Objects
      1. II.7.1. How Object-Oriented Programming Works
      2. II.7.2. Encapsulation Isolates Data and Subprograms
        1. II.7.2.1. Shielding data inside an object
        2. II.7.2.2. Grouping subprograms inside of an object
        3. II.7.2.3. Protecting code from other programmers
      3. II.7.3. Sharing Code with Inheritance
      4. II.7.4. Polymorphism: Modifying Code without Changing Its Name
      5. II.7.5. Design Patterns
      6. II.7.6. Object-Oriented Languages
        1. II.7.6.1. Hybrid languages
        2. II.7.6.2. Pure languages
        3. II.7.6.3. Disadvantages of object-oriented programming
      7. II.7.7. Real-Life Programming Examples
        1. II.7.7.1. Defining an object with a class
        2. II.7.7.2. Creating an object from a class
        3. II.7.7.3. Running subprograms stored in an object
        4. II.7.7.4. Inheriting an object
        5. II.7.7.5. Using polymorphism to rewrite an inherited subprogram
    8. II.8. Reading and Saving Files
      1. II.8.1. Storing Data in Text Files
        1. II.8.1.1. Creating a text file
        2. II.8.1.2. Reading a text file
      2. II.8.2. Storing Fixed Size Data in Random-Access Files
        1. II.8.2.1. Writing data
        2. II.8.2.2. Reading data
      3. II.8.3. Storing Varying Size Data in Untyped Files
        1. II.8.3.1. Writing data
        2. II.8.3.2. Reading data
      4. II.8.4. Using Database Files
        1. II.8.4.1. Structure of a database
        2. II.8.4.2. Connecting to a database
    9. II.9. Documenting Your Program
      1. II.9.1. Adding Comments to Source Code
        1. II.9.1.1. Line comments
        2. II.9.1.2. Block comments
        3. II.9.1.3. Describing code and algorithms
        4. II.9.1.4. Documentation
        5. II.9.1.5. Debugging
      2. II.9.2. Writing Software Documentation
        1. II.9.2.1. Documentation types
        2. II.9.2.2. Documentation tools
        3. II.9.2.3. Help files
    10. II.10. Principles of User Interface Design
      1. II.10.1. The Evolution of User Interfaces
        1. II.10.1.1. Command-line interface
        2. II.10.1.2. Menus
        3. II.10.1.3. Graphical user interface
      2. II.10.2. Elements of a User Interface
        1. II.10.2.1. Displaying commands to a user interface
        2. II.10.2.2. Giving data to the user interface
        3. II.10.2.3. Showing information back to the user
        4. II.10.2.4. Organizing a user interface
      3. II.10.3. Designing a User Interface
        1. II.10.3.1. Know the user
        2. II.10.3.2. Hide unusable options
        3. II.10.3.3. Tolerate mistakes
        4. II.10.3.4. Be consistent
        5. II.10.3.5. Focus on the task
        6. II.10.3.6. Make navigation easy
  7. III. Data Structures
    1. III.1. Structures and Arrays
      1. III.1.1. Using Structures
        1. III.1.1.1. Storing data
        2. III.1.1.2. Retrieving data
      2. III.1.2. Using an Array
        1. III.1.2.1. Defining the size
        2. III.1.2.2. Storing data
        3. III.1.2.3. Retrieving data
      3. III.1.3. Working with Resizable Arrays
        1. III.1.3.1. BASIC
        2. III.1.3.2. C++
      4. III.1.4. Working with Multi-Dimensional Arrays
        1. III.1.4.1. Creating a multi-dimensional array
        2. III.1.4.2. Storing and retrieving data
      5. III.1.5. Using Structures with Arrays
      6. III.1.6. Drawbacks of Arrays
        1. III.1.6.1. Sizing
        2. III.1.6.2. Data types
        3. III.1.6.3. Searching and sorting
        4. III.1.6.4. Adding and deleting
    2. III.2. Sets and Linked Lists
      1. III.2.1. Using Sets
        1. III.2.1.1. Adding (and deleting) data in a set
        2. III.2.1.2. Checking for membership
        3. III.2.1.3. Manipulating two sets
      2. III.2.2. Using Linked Lists
        1. III.2.2.1. Creating a linked list
        2. III.2.2.2. Modifying a linked list
        3. III.2.2.3. Creating a double linked list
      3. III.2.3. Drawbacks of Sets and Linked Lists
        1. III.2.3.1. Problems with pointers
        2. III.2.3.2. Problems with accessing data
    3. III.3. Collections and Dictionaries
      1. III.3.1. Using a Collection
        1. III.3.1.1. Adding data to a collection
        2. III.3.1.2. Deleting data from a collection
        3. III.3.1.3. Identifying data with keys
        4. III.3.1.4. Searching and retrieving data
      2. III.3.2. Using Dictionaries
        1. III.3.2.1. Adding data to a dictionary
        2. III.3.2.2. Searching and retrieving data from a dictionary
      3. III.3.3. Understanding Hash Tables
        1. III.3.3.1. Converting keys with a hash function
        2. III.3.3.2. Hash function collisions
    4. III.4. Stacks, Queues, and Deques
      1. III.4.1. Using a Stack
        1. III.4.1.1. Adding data to a stack
        2. III.4.1.2. Removing data from a stack
        3. III.4.1.3. Counting and searching a stack
      2. III.4.2. Using Queues
        1. III.4.2.1. Adding data to a queue
        2. III.4.2.2. Removing data from a queue
        3. III.4.2.3. Counting and searching a queue
      3. III.4.3. Using Deques
    5. III.5. Graphs and Trees
      1. III.5.1. Understanding Graphs
        1. III.5.1.1. Types of graphs
        2. III.5.1.2. Uses for graphs
      2. III.5.2. Creating Trees
        1. III.5.2.1. Ordered trees
        2. III.5.2.2. Binary trees
        3. III.5.2.3. B-trees
      3. III.5.3. Taking Action on Trees
        1. III.5.3.1. Traversing a tree
        2. III.5.3.2. Adding new data
        3. III.5.3.3. Deleting data
        4. III.5.3.4. Pruning and grafting sub-trees
  8. IV. Algorithms
    1. IV.1. Sorting Algorithms
      1. IV.1.1. Using Bubble Sort
      2. IV.1.2. Using Selection Sort
      3. IV.1.3. Using Insertion Sort
      4. IV.1.4. Using Shell Sort
      5. IV.1.5. Using Heap Sort
      6. IV.1.6. Using Merge Sort
      7. IV.1.7. Using Quick Sort
      8. IV.1.8. Comparing Sorting Algorithms
    2. IV.2. Searching Algorithms
      1. IV.2.1. Sequential Search
        1. IV.2.1.1. Backward or forward searching
        2. IV.2.1.2. Block searching
        3. IV.2.1.3. Binary searching
        4. IV.2.1.4. Interpolation searching
      2. IV.2.2. Using Indexes
        1. IV.2.2.1. Creating an index
        2. IV.2.2.2. Clustered and unclustered indexes
        3. IV.2.2.3. Problems with indexes
      3. IV.2.3. Adversarial Search
        1. IV.2.3.1. Depth versus time
        2. IV.2.3.2. Alpha-beta pruning
        3. IV.2.3.3. Looking up a library of good moves
    3. IV.3. String Searching
      1. IV.3.1. Sequential Text Search
        1. IV.3.1.1. The Boyer-Moore algorithm
        2. IV.3.1.2. The Rabin-Karp algorithm
        3. IV.3.1.3. The Shift Or algorithm
        4. IV.3.1.4. The finite automaton string search algorithm
      2. IV.3.2. Searching with Regular Expressions
        1. IV.3.2.1. Searching for single character patterns
        2. IV.3.2.2. Searching for multiple character patterns
        3. IV.3.2.3. Searching for alternate patterns
      3. IV.3.3. Searching Phonetically
    4. IV.4. Data Compression Algorithms
      1. IV.4.1. Lossless Data Compression Algorithms
        1. IV.4.1.1. Run-length encoding
        2. IV.4.1.2. The Burrows-Wheeler transform algorithm
        3. IV.4.1.3. Dictionary encoding
      2. IV.4.2. Lossy Data Compression
    5. IV.5. Encryption Algorithms
      1. IV.5.1. The Basics of Encryption
        1. IV.5.1.1. Stream ciphers
        2. IV.5.1.2. Block ciphers
      2. IV.5.2. Symmetric/Asymmetric Encryption Algorithms
      3. IV.5.3. Cracking Encryption
        1. IV.5.3.1. Brute force attack
        2. IV.5.3.2. Dictionary attacks
        3. IV.5.3.3. Plaintext and ciphertext attacks
  9. V. Web Programming
    1. V.1. HyperText Markup Language
      1. V.1.1. The Structure of an HTML Document
        1. V.1.1.1. Creating a title
        2. V.1.1.2. Creating the body text
        3. V.1.1.3. Aligning text
        4. V.1.1.4. Emphasizing text
        5. V.1.1.5. Adding color
        6. V.1.1.6. Changing the font size
        7. V.1.1.7. Adding comments
      2. V.1.2. Adding Graphics
      3. V.1.3. Defining the Background
      4. V.1.4. Creating Hyperlinks
        1. V.1.4.1. Defining an anchor point
        2. V.1.4.2. Linking to an anchor point
      5. V.1.5. Making Tables
        1. V.1.5.1. Defining a table
        2. V.1.5.2. Defining a table heading
        3. V.1.5.3. Creating table rows and data
        4. V.1.5.4. Displaying a table caption, header, and footer
    2. V.2. CSS
      1. V.2.1. The Structure of a Stylesheet
      2. V.2.2. Creating Style Classes
      3. V.2.3. Separating Styles in Files
      4. V.2.4. Cascading Stylesheets
    3. V.3. JavaScript
      1. V.3.1. The Structure of a JavaScript Program
      2. V.3.2. Creating Comments
      3. V.3.3. Declaring Variables
      4. V.3.4. Using Operators
        1. V.3.4.1. Increment and decrement operators
      5. V.3.5. Assignment operators
      6. V.3.6. Branching Statements
      7. V.3.7. Looping Statements
      8. V.3.8. Creating Functions
      9. V.3.9. Using Arrays
      10. V.3.10. Designing User Interfaces
        1. V.3.10.1. Creating dialog boxes
        2. V.3.10.2. Creating windows
    4. V.4. PHP
      1. V.4.1. The Structure of a PHP Program
      2. V.4.2. Creating Comments
      3. V.4.3. Declaring Variables
      4. V.4.4. Using Operators
        1. V.4.4.1. Increment and decrement operators
        2. V.4.4.2. Assignment operators
      5. V.4.5. Branching Statements
      6. V.4.6. Looping Statements
      7. V.4.7. Creating Functions
      8. V.4.8. using Arrys
      9. V.4.9. Creating Objects
    5. V.5. Ruby
      1. V.5.1. The Structure of a Ruby Program
      2. V.5.2. Creating Comments
      3. V.5.3. Declaring Variables
      4. V.5.4. Using Operators
      5. V.5.5. Branching Statements
      6. V.5.6. Looping Statements
      7. V.5.7. Creating Functions
      8. V.5.8. Using Data Structures
      9. V.5.9. Creating Objects
  10. VI. Programming Language Syntax
    1. VI.1. C and C++
      1. VI.1.1. The Structure of a C/C++ Program
      2. VI.1.2. Creating Comments
      3. VI.1.3. Declaring Variables
        1. VI.1.3.1. Declaring string data types
        2. VI.1.3.2. Declaring integer data types
        3. VI.1.3.3. Declaring floating point data types
        4. VI.1.3.4. Declaring Boolean values
      4. VI.1.4. Using Operators
        1. VI.1.4.1. Increment and decrement operators
        2. VI.1.4.2. Assignment operators
      5. VI.1.5. Branching Statements
      6. VI.1.6. Looping Statements
      7. VI.1.7. Creating Functions
      8. VI.1.8. Data Structures
        1. VI.1.8.1. Creating a structure
        2. VI.1.8.2. Creating enumerated variables
        3. VI.1.8.3. Creating an array
      9. VI.1.9. Using Objects
    2. VI.2. Java and C#
      1. VI.2.1. The Structure of a Java/C# Program
      2. VI.2.2. Creating Comments
      3. VI.2.3. Declaring Variables
        1. VI.2.3.1. Declaring string data types
        2. VI.2.3.2. Declaring integer data types
        3. VI.2.3.3. Declaring floating point data types
        4. VI.2.3.4. Declaring Boolean variables
      4. VI.2.4. Using Operators
        1. VI.2.4.1. Increment and decrement operators
        2. VI.2.4.2. Assignment operators
      5. VI.2.5. Branching Statements
      6. VI.2.6. Looping Statements
      7. VI.2.7. Creating Functions
      8. VI.2.8. Data Structures
        1. VI.2.8.1. Creating a C# structure
        2. VI.2.8.2. Creating an array
        3. VI.2.8.3. Creating a Java linked list
        4. VI.2.8.4. Creating C## data structures
      9. VI.2.9. Using Objects
    3. VI.3. Perl and Python
      1. VI.3.1. The Structure of a Perl/Python Program
      2. VI.3.2. Creating Comments
      3. VI.3.3. Defining Variables
      4. VI.3.4. Using Operators
        1. VI.3.4.1. Increment and decrement operators
        2. VI.3.4.2. Assignment operators
      5. VI.3.5. Branching Statements
      6. VI.3.6. Looping Statements
      7. VI.3.7. Creating Functions
      8. VI.3.8. Perl Data Structures
        1. VI.3.8.1. Creating a Perl array
        2. VI.3.8.2. Creating a Perl hash array
      9. VI.3.9. Python Data Structures
        1. VI.3.9.1. Creating a Python tuple
        2. VI.3.9.2. Creating a Python list
        3. VI.3.9.3. Creating a Python dictionary
      10. VI.3.10. Using Objects
    4. VI.4. Pascal and Delphi
      1. VI.4.1. The Structure of a Pascal Program
      2. VI.4.2. Creating Comments
      3. VI.4.3. Declaring Variables
        1. VI.4.3.1. Declaring string data types
        2. VI.4.3.2. Declaring integer data types
        3. VI.4.3.3. Declaring decimal data types
        4. VI.4.3.4. Declaring Boolean values
      4. VI.4.4. Declaring Constants
      5. VI.4.5. Using Operators
      6. VI.4.6. Branching Statements
      7. VI.4.7. Looping Statements
      8. VI.4.8. Creating Subprograms and Functions
      9. VI.4.9. Data Structures
        1. VI.4.9.1. Creating a record
        2. VI.4.9.2. Creating an array
        3. VI.4.9.3. Creating a set
      10. VI.4.10. Creating Objects
    5. VI.5. Visual Basic and REALbasic
      1. VI.5.1. The Structure of a BASIC Program
        1. VI.5.1.1. Using windows files
        2. VI.5.1.2. Using module files
        3. VI.5.1.3. Using class files
      2. VI.5.2. Creating Comments
      3. VI.5.3. Declaring Variables
        1. VI.5.3.1. Declaring string data types
        2. VI.5.3.2. Declaring integer data types
        3. VI.5.3.3. Declaring decimal data types
        4. VI.5.3.4. Declaring Boolean values
        5. VI.5.3.5. Declaring generic values
      4. VI.5.4. Declaring Constants
      5. VI.5.5. Using Operators
      6. VI.5.6. Branching Statements
      7. VI.5.7. Looping Statements
      8. VI.5.8. Creating Subprograms and Functions
      9. VI.5.9. Data Structures
        1. VI.5.9.1. Creating a structure
        2. VI.5.9.2. Creating an array
        3. VI.5.9.3. Creating a collection and a dictionary
      10. VI.5.10. Creating Objects
  11. VII. Applications
    1. VII.1. Database Management
      1. VII.1.1. The Basics of Databases
        1. VII.1.1.1. Free-form databases
        2. VII.1.1.2. Flat-file databases
        3. VII.1.1.3. Relational databases
      2. VII.1.2. Manipulating Data
        1. VII.1.2.1. Writing database commands
        2. VII.1.2.2. The SQL language
        3. VII.1.2.3. Data integrity
        4. VII.1.2.4. Data mining
      3. VII.1.3. Database Programming
    2. VII.2. Bioinformatics
      1. VII.2.1. The Basics of Bioinformatics
        1. VII.2.1.1. Representing molecules
        2. VII.2.1.2. Manipulating molecules in a computer
      2. VII.2.2. Searching Databases
      3. VII.2.3. Bioinformatics Programming
    3. VII.3. Computer Security
      1. VII.3.1. Stopping Malware
        1. VII.3.1.1. Viruses
        2. VII.3.1.2. Worms
        3. VII.3.1.3. Trojan horses
        4. VII.3.1.4. Spyware
      2. VII.3.2. Stopping Hackers
        1. VII.3.2.1. Intrusion detection systems
        2. VII.3.2.2. Rootkit detectors
        3. VII.3.2.3. Forensics
      3. VII.3.3. Secure Computing
        1. VII.3.3.1. Patching as an afterthought
        2. VII.3.3.2. Security in coding
        3. VII.3.3.3. Security by design
    4. VII.4. Artificial Intelligence
      1. VII.4.1. Problem Solving
        1. VII.4.1.1. Game-playing
        2. VII.4.1.2. Expert systems
        3. VII.4.1.3. Natural language processing
        4. VII.4.1.4. Speech recognition
        5. VII.4.1.5. Image recognition
      2. VII.4.2. Machine Learning
        1. VII.4.2.1. Bayesian probability
        2. VII.4.2.2. Neural networks
      3. VII.4.3. Applications in Artificial Intelligence
    5. VII.5. The Future of Computer Programming
      1. VII.5.1. Picking a Programming Language
      2. VII.5.2. Picking an Operating System
      3. VII.5.3. Cross-Platform Programming
        1. VII.5.3.1. The portability of C
        2. VII.5.3.2. Cross-platform languages
        3. VII.5.3.3. Virtual machines
        4. VII.5.3.4. Software as service
        5. VII.5.3.5. Rich Internet applications (RIA)
        6. VII.5.3.6. Robotics programming
      4. VII.5.4. The Programming Language of the Future
        1. VII.5.4.1. Low-level languages
        2. VII.5.4.2. The next generation: C++, Objective-C, C#, and Java
        3. VII.5.4.3. REALbasic and Visual Basic
        4. VII.5.4.4. The scripting languages
        5. VII.5.4.5. The best programming language