book

Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

Name: Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®
Author: Wallace Wang
ISBN: 9780470108543

by Wallace Wang

June 2008

Beginner

695 pages

14h 9m

English

For Dummies

Read now

Unlock full access

Copright
About the Author
Acknowledgments
Introduction
Who Should Buy This BookHow This Book Is OrganizedBook I: Getting StartedBook II: Programming BasicsBook III: Data StructuresBook IV: AlgorithmsBook V: Web ProgrammingBook VI: Programming Language SyntaxBook VII: ApplicationsHow to Use This BookIcons Used in This BookGetting Started
I. Getting Started
I.1. Getting Started Programming a Computer
I.1.1. How Computer Programming WorksI.1.1.1. Identifying the problemI.1.1.2. Defining the stepsI.1.2. The History of Computer ProgrammingI.1.2.1. Talking to a processor in machine languageI.1.2.2. Using assembly language as a shortcut to machine languageI.1.2.3. Hiding the details of a computer with a high-level languageI.1.2.4. Combining the best of both worlds with the C programming languageI.1.2.5. Pros and cons of programming languagesI.1.3. Figuring Out ProgrammingI.1.3.1. Desire beats technical training every timeI.1.3.2. Picking a computer and an operating systemI.1.3.3. Writing programs with an editorI.1.3.4. Converting source code with an assembler or compilerI.1.3.5. Translating source code with an interpreterI.1.3.6. Combining a compiler with an interpreter to create p-codeI.1.3.7. Taking the time to understandI.1.4. Getting Started with ProgrammingI.1.4.1. Starting with WindowsI.1.4.2. Starting with Mac OS XI.1.4.3. Starting with LinuxI.1.4.4. Starting with JavaI.1.5. Knowing Programming versus Knowing Programming Language
I.2. Different Methods for Writing Programs
I.2.1. Spaghetti Programming without a PlanI.2.2. Planning Ahead with Structured ProgrammingI.2.2.1. The three parts of structured programmingI.2.2.2. Top-down programmingI.2.3. Making User Interfaces with Event-Driven ProgrammingI.2.3.1. Designing a user interfaceI.2.3.2. Writing event handlersI.2.3.3. Writing your programI.2.4. Organizing a Program with Object-Oriented ProgrammingI.2.4.1. Objects isolate dataI.2.4.2. Objects simplify modificationsI.2.5. Designing Programs with Today's Methodology
I.3. Types of Programming Languages
I.3.1. Choosing Your First LanguageI.3.1.1. C the BASIC choicesI.3.1.2. Having second thoughtsI.3.2. Teaching LanguagesI.3.2.1. Getting back to BASICI.3.2.2. Turtle graphics with LogoI.3.2.3. The philosophy of PascalI.3.2.4. Other teaching languagesI.3.3. "Curly Bracket" LanguagesI.3.3.1. The power of CI.3.3.2. The efficiency of CI.3.3.3. The portability of CI.3.3.4. Adding object-oriented programming with C++I.3.3.5. True portability with JavaI.3.3.6. Safer programming with C#I.3.3.7. Choosing a curly bracket languageI.3.4. Artificial Intelligence LanguagesI.3.5. Scripting LanguagesI.3.5.1. Automating a programI.3.5.2. Customizing a programI.3.5.3. Transferring data among multiple programsI.3.5.4. Creating separate applicationsI.3.6. Database Programming LanguagesI.3.6.1. The dBASE programming languageI.3.6.2. Adding database access to traditional languagesI.3.6.3. Customizing database programsI.3.7. Comparing Programming Languages
I.4. Programming Tools
I.4.1. Choosing a CompilerI.4.1.1. Defining your needs for a compilerI.4.1.2. Evaluating the technical features of a compilerI.4.2. Finding an InterpreterI.4.2.1. Operating system interpretersI.4.2.2. Web page interpretersI.4.3. Compiling to a Virtual MachineI.4.4. Writing a Program with an EditorI.4.4.1. EditorsI.4.5. Fixing a Program with a DebuggerI.4.5.1. Stepping line by lineI.4.5.2. Watching variablesI.4.6. Saving Time with Third-Party ComponentsI.4.7. Optimizing a Program with a ProfilerI.4.8. Creating a Help FileI.4.9. Installing a ProgramI.4.10. Dissecting Programs with a Disassembler
I.5. Managing Large Projects with Software Engineering
I.5.1. Software Engineering MethodsI.5.1.1. Designing a program with the waterfall modelI.5.1.2. Evolving a program with extreme programmingI.5.2. Automating Software Engineering with CASEI.5.2.1. Modeling a large projectI.5.2.2. Generating code automaticallyI.5.2.3. Formatting source code automaticallyI.5.2.4. Tracking revisions in codeI.5.3. The Pros and Cons of Software Engineering

II. Programming Basics
II.1. How Programs Work
II.1.1. Using Keywords as Building BlocksII.1.2. Organizing a ProgramII.1.3. Dividing a Program into SubprogramsII.1.4. Dividing a Program into ObjectsII.1.5. Creating a User Interface
II.2. Variables, Data Types, and Constants
II.2.1. Declaring VariablesII.2.1.1. Creating a variableII.2.2. Using Different Data TypesII.2.3. Storing Data in a VariableII.2.4. Retrieving Data from a VariableII.2.5. Using Constant ValuesII.2.6. Defining the Scope of a VariableII.2.6.1. Handling global variables with careII.2.6.2. Restricting scope to a moduleII.2.6.3. Isolating variables in a subprogramII.2.6.4. Passing data among subprograms
II.3. Manipulating Data
II.3.1. Storing Data with the Assignment OperatorII.3.2. Using Math to Manipulate NumbersII.3.2.1. Organizing equations with operator precedenceII.3.2.2. Using built-in math functionsII.3.3. Manipulating StringsII.3.4. Finding Strings with Regular ExpressionsII.3.4.1. Pattern matching with the single character (.) wildcardII.3.4.2. Pattern matching for specific charactersII.3.4.3. Pattern matching with the multiple character (*) and (+) wildcardsII.3.4.4. Pattern matching with rangesII.3.5. Using Comparison OperatorsII.3.6. Using Boolean OperatorsII.3.6.1. Using the Not operatorII.3.6.2. Using the And operatorII.3.6.3. Using the Or operatorII.3.6.4. Using the Xor operatorII.3.7. Converting Data Types
II.4. Making Decisions by Branching
II.4.1. Picking One Choice with the IF-THEN StatementII.4.2. Picking Two Choices with the IF-THEN-ELSE StatementII.4.3. Picking Three or More Choices with the IF-THEN-ELSEIF StatementII.4.3.1. Checking a condition for each set of commandsII.4.3.2. Offering three or more choicesII.4.4. Playing with Multiple Boolean OperatorsII.4.5. Making Multiple Choices with the SELECT CASE statementII.4.5.1. The switch statement in C (and similar languages)II.4.5.2. Matching multiple values in a SELECT CASE statementII.4.5.3. Checking a range of valuesII.4.5.4. Comparing valuesII.4.5.5. Running at least one command with the ELSE statement
II.5. Repeating Commands by Looping
II.5.1. Looping a Fixed Number of Times with the FOR-NEXT LoopII.5.1.1. Using a FOR-NEXT loop variableII.5.1.2. Counting by a different rangeII.5.1.3. Counting by different incrementsII.5.1.4. Counting backwardII.5.2. Looping Zero or More Times with the WHILE LoopII.5.3. Looping at Least Once with the DO LoopII.5.4. Playing with Nested LoopsII.5.5. Prematurely Exiting from a LoopII.5.6. Checking Your Loops
II.6. Breaking a Large Program into Subprograms
II.6.1. Creating and Using SubprogramsII.6.1.1. Creating a subprogramII.6.1.2. "Calling" a subprogramII.6.2. Passing ParametersII.6.2.1. Passing parameters by referenceII.6.2.2. Storing values in a subprogram nameII.6.3. Repeating a Subprogram with Recursion
II.7. Breaking a Large Program into Objects
II.7.1. How Object-Oriented Programming WorksII.7.2. Encapsulation Isolates Data and SubprogramsII.7.2.1. Shielding data inside an objectII.7.2.2. Grouping subprograms inside of an objectII.7.2.3. Protecting code from other programmersII.7.3. Sharing Code with InheritanceII.7.4. Polymorphism: Modifying Code without Changing Its NameII.7.5. Design PatternsII.7.6. Object-Oriented LanguagesII.7.6.1. Hybrid languagesII.7.6.2. Pure languagesII.7.6.3. Disadvantages of object-oriented programmingII.7.7. Real-Life Programming ExamplesII.7.7.1. Defining an object with a classII.7.7.2. Creating an object from a classII.7.7.3. Running subprograms stored in an objectII.7.7.4. Inheriting an objectII.7.7.5. Using polymorphism to rewrite an inherited subprogram
II.8. Reading and Saving Files
II.8.1. Storing Data in Text FilesII.8.1.1. Creating a text fileII.8.1.2. Reading a text fileII.8.2. Storing Fixed Size Data in Random-Access FilesII.8.2.1. Writing dataII.8.2.2. Reading dataII.8.3. Storing Varying Size Data in Untyped FilesII.8.3.1. Writing dataII.8.3.2. Reading dataII.8.4. Using Database FilesII.8.4.1. Structure of a databaseII.8.4.2. Connecting to a database
II.9. Documenting Your Program
II.9.1. Adding Comments to Source CodeII.9.1.1. Line commentsII.9.1.2. Block commentsII.9.1.3. Describing code and algorithmsII.9.1.4. DocumentationII.9.1.5. DebuggingII.9.2. Writing Software DocumentationII.9.2.1. Documentation typesII.9.2.2. Documentation toolsII.9.2.3. Help files
II.10. Principles of User Interface Design
II.10.1. The Evolution of User InterfacesII.10.1.1. Command-line interfaceII.10.1.2. MenusII.10.1.3. Graphical user interfaceII.10.2. Elements of a User InterfaceII.10.2.1. Displaying commands to a user interfaceII.10.2.2. Giving data to the user interfaceII.10.2.3. Showing information back to the userII.10.2.4. Organizing a user interfaceII.10.3. Designing a User InterfaceII.10.3.1. Know the userII.10.3.2. Hide unusable optionsII.10.3.3. Tolerate mistakesII.10.3.4. Be consistentII.10.3.5. Focus on the taskII.10.3.6. Make navigation easy
III. Data Structures
III.1. Structures and Arrays
III.1.1. Using StructuresIII.1.1.1. Storing dataIII.1.1.2. Retrieving dataIII.1.2. Using an ArrayIII.1.2.1. Defining the sizeIII.1.2.2. Storing dataIII.1.2.3. Retrieving dataIII.1.3. Working with Resizable ArraysIII.1.3.1. BASICIII.1.3.2. C++III.1.4. Working with Multi-Dimensional ArraysIII.1.4.1. Creating a multi-dimensional arrayIII.1.4.2. Storing and retrieving dataIII.1.5. Using Structures with ArraysIII.1.6. Drawbacks of ArraysIII.1.6.1. SizingIII.1.6.2. Data typesIII.1.6.3. Searching and sortingIII.1.6.4. Adding and deleting
III.2. Sets and Linked Lists
III.2.1. Using SetsIII.2.1.1. Adding (and deleting) data in a setIII.2.1.2. Checking for membershipIII.2.1.3. Manipulating two setsIII.2.2. Using Linked ListsIII.2.2.1. Creating a linked listIII.2.2.2. Modifying a linked listIII.2.2.3. Creating a double linked listIII.2.3. Drawbacks of Sets and Linked ListsIII.2.3.1. Problems with pointersIII.2.3.2. Problems with accessing data
III.3. Collections and Dictionaries
III.3.1. Using a CollectionIII.3.1.1. Adding data to a collectionIII.3.1.2. Deleting data from a collectionIII.3.1.3. Identifying data with keysIII.3.1.4. Searching and retrieving dataIII.3.2. Using DictionariesIII.3.2.1. Adding data to a dictionaryIII.3.2.2. Searching and retrieving data from a dictionaryIII.3.3. Understanding Hash TablesIII.3.3.1. Converting keys with a hash functionIII.3.3.2. Hash function collisions
III.4. Stacks, Queues, and Deques
III.4.1. Using a StackIII.4.1.1. Adding data to a stackIII.4.1.2. Removing data from a stackIII.4.1.3. Counting and searching a stackIII.4.2. Using QueuesIII.4.2.1. Adding data to a queueIII.4.2.2. Removing data from a queueIII.4.2.3. Counting and searching a queueIII.4.3. Using Deques
III.5. Graphs and Trees
III.5.1. Understanding GraphsIII.5.1.1. Types of graphsIII.5.1.2. Uses for graphsIII.5.2. Creating TreesIII.5.2.1. Ordered treesIII.5.2.2. Binary treesIII.5.2.3. B-treesIII.5.3. Taking Action on TreesIII.5.3.1. Traversing a treeIII.5.3.2. Adding new dataIII.5.3.3. Deleting dataIII.5.3.4. Pruning and grafting sub-trees
IV. Algorithms
IV.1. Sorting Algorithms
IV.1.1. Using Bubble SortIV.1.2. Using Selection SortIV.1.3. Using Insertion SortIV.1.4. Using Shell SortIV.1.5. Using Heap SortIV.1.6. Using Merge SortIV.1.7. Using Quick SortIV.1.8. Comparing Sorting Algorithms
IV.2. Searching Algorithms
IV.2.1. Sequential SearchIV.2.1.1. Backward or forward searchingIV.2.1.2. Block searchingIV.2.1.3. Binary searchingIV.2.1.4. Interpolation searchingIV.2.2. Using IndexesIV.2.2.1. Creating an indexIV.2.2.2. Clustered and unclustered indexesIV.2.2.3. Problems with indexesIV.2.3. Adversarial SearchIV.2.3.1. Depth versus timeIV.2.3.2. Alpha-beta pruningIV.2.3.3. Looking up a library of good moves
IV.3. String Searching
IV.3.1. Sequential Text SearchIV.3.1.1. The Boyer-Moore algorithmIV.3.1.2. The Rabin-Karp algorithmIV.3.1.3. The Shift Or algorithmIV.3.1.4. The finite automaton string search algorithmIV.3.2. Searching with Regular ExpressionsIV.3.2.1. Searching for single character patternsIV.3.2.2. Searching for multiple character patternsIV.3.2.3. Searching for alternate patternsIV.3.3. Searching Phonetically
IV.4. Data Compression Algorithms
IV.4.1. Lossless Data Compression AlgorithmsIV.4.1.1. Run-length encodingIV.4.1.2. The Burrows-Wheeler transform algorithmIV.4.1.3. Dictionary encodingIV.4.2. Lossy Data Compression
IV.5. Encryption Algorithms
IV.5.1. The Basics of EncryptionIV.5.1.1. Stream ciphersIV.5.1.2. Block ciphersIV.5.2. Symmetric/Asymmetric Encryption AlgorithmsIV.5.3. Cracking EncryptionIV.5.3.1. Brute force attackIV.5.3.2. Dictionary attacksIV.5.3.3. Plaintext and ciphertext attacks
V. Web Programming
V.1. HyperText Markup Language
V.1.1. The Structure of an HTML DocumentV.1.1.1. Creating a titleV.1.1.2. Creating the body textV.1.1.3. Aligning textV.1.1.4. Emphasizing textV.1.1.5. Adding colorV.1.1.6. Changing the font sizeV.1.1.7. Adding commentsV.1.2. Adding GraphicsV.1.3. Defining the BackgroundV.1.4. Creating HyperlinksV.1.4.1. Defining an anchor pointV.1.4.2. Linking to an anchor pointV.1.5. Making TablesV.1.5.1. Defining a tableV.1.5.2. Defining a table headingV.1.5.3. Creating table rows and dataV.1.5.4. Displaying a table caption, header, and footer
V.2. CSS
V.2.1. The Structure of a StylesheetV.2.2. Creating Style ClassesV.2.3. Separating Styles in FilesV.2.4. Cascading Stylesheets
V.3. JavaScript
V.3.1. The Structure of a JavaScript ProgramV.3.2. Creating CommentsV.3.3. Declaring VariablesV.3.4. Using OperatorsV.3.4.1. Increment and decrement operatorsV.3.5. Assignment operatorsV.3.6. Branching StatementsV.3.7. Looping StatementsV.3.8. Creating FunctionsV.3.9. Using ArraysV.3.10. Designing User InterfacesV.3.10.1. Creating dialog boxesV.3.10.2. Creating windows
V.4. PHP
V.4.1. The Structure of a PHP ProgramV.4.2. Creating CommentsV.4.3. Declaring VariablesV.4.4. Using OperatorsV.4.4.1. Increment and decrement operatorsV.4.4.2. Assignment operatorsV.4.5. Branching StatementsV.4.6. Looping StatementsV.4.7. Creating FunctionsV.4.8. using ArrysV.4.9. Creating Objects
V.5. Ruby
V.5.1. The Structure of a Ruby ProgramV.5.2. Creating CommentsV.5.3. Declaring VariablesV.5.4. Using OperatorsV.5.5. Branching StatementsV.5.6. Looping StatementsV.5.7. Creating FunctionsV.5.8. Using Data StructuresV.5.9. Creating Objects
VI. Programming Language Syntax
VI.1. C and C++
VI.1.1. The Structure of a C/C++ ProgramVI.1.2. Creating CommentsVI.1.3. Declaring VariablesVI.1.3.1. Declaring string data typesVI.1.3.2. Declaring integer data typesVI.1.3.3. Declaring floating point data typesVI.1.3.4. Declaring Boolean valuesVI.1.4. Using OperatorsVI.1.4.1. Increment and decrement operatorsVI.1.4.2. Assignment operatorsVI.1.5. Branching StatementsVI.1.6. Looping StatementsVI.1.7. Creating FunctionsVI.1.8. Data StructuresVI.1.8.1. Creating a structureVI.1.8.2. Creating enumerated variablesVI.1.8.3. Creating an arrayVI.1.9. Using Objects
VI.2. Java and C#
VI.2.1. The Structure of a Java/C# ProgramVI.2.2. Creating CommentsVI.2.3. Declaring VariablesVI.2.3.1. Declaring string data typesVI.2.3.2. Declaring integer data typesVI.2.3.3. Declaring floating point data typesVI.2.3.4. Declaring Boolean variablesVI.2.4. Using OperatorsVI.2.4.1. Increment and decrement operatorsVI.2.4.2. Assignment operatorsVI.2.5. Branching StatementsVI.2.6. Looping StatementsVI.2.7. Creating FunctionsVI.2.8. Data StructuresVI.2.8.1. Creating a C# structureVI.2.8.2. Creating an arrayVI.2.8.3. Creating a Java linked listVI.2.8.4. Creating C## data structuresVI.2.9. Using Objects
VI.3. Perl and Python
VI.3.1. The Structure of a Perl/Python ProgramVI.3.2. Creating CommentsVI.3.3. Defining VariablesVI.3.4. Using OperatorsVI.3.4.1. Increment and decrement operatorsVI.3.4.2. Assignment operatorsVI.3.5. Branching StatementsVI.3.6. Looping StatementsVI.3.7. Creating FunctionsVI.3.8. Perl Data StructuresVI.3.8.1. Creating a Perl arrayVI.3.8.2. Creating a Perl hash arrayVI.3.9. Python Data StructuresVI.3.9.1. Creating a Python tupleVI.3.9.2. Creating a Python listVI.3.9.3. Creating a Python dictionaryVI.3.10. Using Objects
VI.4. Pascal and Delphi
VI.4.1. The Structure of a Pascal ProgramVI.4.2. Creating CommentsVI.4.3. Declaring VariablesVI.4.3.1. Declaring string data typesVI.4.3.2. Declaring integer data typesVI.4.3.3. Declaring decimal data typesVI.4.3.4. Declaring Boolean valuesVI.4.4. Declaring ConstantsVI.4.5. Using OperatorsVI.4.6. Branching StatementsVI.4.7. Looping StatementsVI.4.8. Creating Subprograms and FunctionsVI.4.9. Data StructuresVI.4.9.1. Creating a recordVI.4.9.2. Creating an arrayVI.4.9.3. Creating a setVI.4.10. Creating Objects
VI.5. Visual Basic and REALbasic
VI.5.1. The Structure of a BASIC ProgramVI.5.1.1. Using windows filesVI.5.1.2. Using module filesVI.5.1.3. Using class filesVI.5.2. Creating CommentsVI.5.3. Declaring VariablesVI.5.3.1. Declaring string data typesVI.5.3.2. Declaring integer data typesVI.5.3.3. Declaring decimal data typesVI.5.3.4. Declaring Boolean valuesVI.5.3.5. Declaring generic valuesVI.5.4. Declaring ConstantsVI.5.5. Using OperatorsVI.5.6. Branching StatementsVI.5.7. Looping StatementsVI.5.8. Creating Subprograms and FunctionsVI.5.9. Data StructuresVI.5.9.1. Creating a structureVI.5.9.2. Creating an arrayVI.5.9.3. Creating a collection and a dictionaryVI.5.10. Creating Objects
VII. Applications
VII.1. Database Management
VII.1.1. The Basics of DatabasesVII.1.1.1. Free-form databasesVII.1.1.2. Flat-file databasesVII.1.1.3. Relational databasesVII.1.2. Manipulating DataVII.1.2.1. Writing database commandsVII.1.2.2. The SQL languageVII.1.2.3. Data integrityVII.1.2.4. Data miningVII.1.3. Database Programming
VII.2. Bioinformatics
VII.2.1. The Basics of BioinformaticsVII.2.1.1. Representing moleculesVII.2.1.2. Manipulating molecules in a computerVII.2.2. Searching DatabasesVII.2.3. Bioinformatics Programming
VII.3. Computer Security
VII.3.1. Stopping MalwareVII.3.1.1. VirusesVII.3.1.2. WormsVII.3.1.3. Trojan horsesVII.3.1.4. SpywareVII.3.2. Stopping HackersVII.3.2.1. Intrusion detection systemsVII.3.2.2. Rootkit detectorsVII.3.2.3. ForensicsVII.3.3. Secure ComputingVII.3.3.1. Patching as an afterthoughtVII.3.3.2. Security in codingVII.3.3.3. Security by design
VII.4. Artificial Intelligence
VII.4.1. Problem SolvingVII.4.1.1. Game-playingVII.4.1.2. Expert systemsVII.4.1.3. Natural language processingVII.4.1.4. Speech recognitionVII.4.1.5. Image recognitionVII.4.2. Machine LearningVII.4.2.1. Bayesian probabilityVII.4.2.2. Neural networksVII.4.3. Applications in Artificial Intelligence
VII.5. The Future of Computer Programming
VII.5.1. Picking a Programming LanguageVII.5.2. Picking an Operating SystemVII.5.3. Cross-Platform ProgrammingVII.5.3.1. The portability of CVII.5.3.2. Cross-platform languagesVII.5.3.3. Virtual machinesVII.5.3.4. Software as serviceVII.5.3.5. Rich Internet applications (RIA)VII.5.3.6. Robotics programmingVII.5.4. The Programming Language of the FutureVII.5.4.1. Low-level languagesVII.5.4.2. The next generation: C++, Objective-C, C#, and JavaVII.5.4.3. REALbasic and Visual BasicVII.5.4.4. The scripting languagesVII.5.4.5. The best programming language

Content preview from Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

Chapter II.4. Making Decisions by Branching

The simplest program lists commands one after another in a sequence, much like following the steps of a recipe. Follow a recipe step by step and you always create the same dish. If a program lists commands step by step, the computer always produces the same result.

In some cases, you may want a program to do the exact same thing over and over again, such as a simple program to display traffic signals. However for most programs, you want the computer to react to outside data. To make a computer respond in different ways, a program needs to offer two or more choices for the computer to follow.

When you quit a program, the program may ask, "Do you really want to exit?" At this point, the program is giving the computer a choice of two possible actions to take based on your answer.

If you answer Yes, the computer quits the program. If you answer No, the computer keeps running the program.

When a program gives the computer a choice of two or more commands to follow, that's called a branching or decision statement.

All branching statements work the same way:

A comparison operator (or a conditional expression) compares an expression (such as A > 45) to determine a True or False value.
The branching statement offers at least two groups of commands for the computer to follow based on whether its comparison is True or False.

Picking One Choice with the IF-THEN Statement

The simplest branching statement is an IF-THEN statement, which looks like this:

IF (Something ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Designing Data-Intensive Applications, 2nd Edition

Publisher Resources

ISBN: 9780470108543Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Beginning Programming ALL-IN-ONE DESK REFERENCE FOR DUMMIES®

by Wallace Wang

Chapter II.4. Making Decisions by Branching

Picking One Choice with the IF-THEN Statement

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.