rootfs的专栏

ontents Preface . . . . . . . . . . . . . xi 1. The Power and Perils of Concurrency . . . . . . 1 1.1 Threads: The Flow of Execution 1 1.2 The Power of Concurrency 2 1.3 The Perils of Concurrency 5 1.4 Recap 10 Part I — Strategies for Concurrency 2. Division of Labor . . . . . . . . . . . 15 2.1 From Sequential to Concurrent 15 2.2 Concurrency in IO-Intensive Apps 18 2.3 Speedup for the IO-Intensive App 25 2.4 Concurrency in Computationally Intensive Apps 25 2.5 Speedup for the Computationally Intensive App 31 2.6 Strategies for Effective Concurrency 33 2.7 Recap 34 3. Design Approaches . . . . . . . . . . 35 3.1 Dealing with State 35 3.2 Exploring Design Options 36 3.3 Shared Mutable Design 37 3.4 Isolated Mutable Design 37 3.5 Purely Immutable Design 38 3.6 Persistent/Immutable Data Structures 39 3.7 Selecting a Design Approach 42 3.8 Recap 43 Part II — Modern Java/JDK Concurrency 4. Scalability and Thread Safety . . . . . . . . 47 4.1 Managing Threads with ExecutorService 48 4.2 Coordinating Threads 49 4.3 Exchanging Data 58 4.4 Java 7 Fork-Join API 61 4.5 Scalable Collections 63 4.6 Lock vs. Synchronized 66 4.7 Recap 71 5. Taming Shared Mutability . . . . . . . . . 73 5.1 Shared Mutability != public 73 5.2 Spotting Concurrency Issues 74 5.3 Preserve Invariant 75 5.4 Mind Your Resources 76 5.5 Ensure Visibility 79 5.6 Enhance Concurrency 80 5.7 Ensure Atomicity 82 5.8 Recap 85 Part III — Software Transactional Memory 6. Introduction to Software Transactional Memory . . . 89 6.1 Synchronization Damns Concurrency 89 6.2 The Deficiency of the Object Model 90 6.3 Separation of Identity and State 91 6.4 Software Transactional Memory 92 6.5 Transactions in STM 96 6.6 Concurrency Using STM 97 6.7 Concurrency Using Akka/Multiverse STM 102 6.8 Creating Transactions 104 6.9 Creating Nested Transactions 111 6. 10 Configuring Akka Transactions 120 6. 11 Blocking Transactions—Sensible Wait 122 6. 12 Commit and Rollback Events 126 6. 13 Collections and Transactions 129 6. 14 Dealing with the Write Skew Anomaly 133 6. 15 Limitations of STM 136 6. 16 Recap 140 ? viii 7. STM in Clojure, Groovy, Java, JRuby, and Scala . . . 141 7.1 Clojure STM 142 7.2 Groovy Integration 142 7.3 Java Integration 146 7.4 JRuby Integration 149 7.5 Choices in Scala 156 7.6 Recap 158 Part IV — Actor-Based Concurrency 8. Favoring Isolated Mutability . . . . . . . . 163 8.1 Isolating Mutability Using Actors 164 8.2 Actor Qualities 165 8.3 Creating Actors 166 8.4 Sending and Receiving Messages 173 8.5 Working with Multiple Actors 178 8.6 Coordinating Actors 182 8.7 Using Typed Actors 190 8.8 Typed Actors and Murmurs 195 8.9 Mixing Actors and STM 201 8. 10 Using Transactors 202 8. 11 Coordinating Typed Actors 210 8. 12 Remote Actors 216 8. 13 Limitations of the Actor-Based Model 218 8. 14 Recap 219 9. Actors in Groovy, Java, JRuby, and Scala . . . . . 221 9.1 Actors in Groovy with GPars 221 9.2 Java Integration 235 9.3 JRuby Akka Integration 235 9.4 Choices in Scala 239 9.5 Recap 239 Part V — Epilogue 10. Zen of Programming Concurrency . . . . . . 243 10. 1 Exercise Your Options 243 10. 2 Concurrency: Programmer’s Guide 244 10. 3 Concurrency: Architect’s Guide 245 10. 4 Choose Wisely 246 ? ix A1. Clojure Agents . . . . . . . . . . . 249 A2. Web Resources . . . . . . . . . . . 255 A3. Bibliography . . . . . . . . . . . . 259 Index . . . . . . . . . . . . . 261

Contents at a Glance Introduction 1 I: An Overview of Android 1 Introducing Android 7 2 Setting Up Your Android Development Environment 29 3 Writing Your First Android Application 43 II: Android Application Design Essentials 4 Understanding the Anatomy of an Android Application 69 5 Defining Your Application Using the Android Manifest File 81 6 Managing Application Resources 97 III: Android User Interface Design Essentials 7 Exploring User Interface Screen Elements 133 8 Designing User Interfaces with Layouts 173 9 Drawing and Working with Animation 205 IV: Using Common Android APIs 10 Using Android Data and Storage APIs 231 11 Sharing Data Between Applications with Content Providers 259 12 Using Android Networking APIs 287 13 Using Android Web APIs 301 14 Using Location-Based Services (LBS) APIs 315 15 Using Android Multimedia APIs 335 16 Using Android Telephony APIs 353 17 Using Android 3D Graphics with OpenGL ES 367 18 Using the Android NDK 397 19 Using Android’s Optional Hardware APIs 407 V: More Android Application Design Principles 20 Working with Notifications 423 21 Working with Services 437 22 Extending Android Application Reach 451 23 Managing User Accounts and Synchronizing User Data 489 24 Handling Advanced User Input 499 25 Targeting Different Device Configurations and Languages 523 VI: Deploying Your Android Application to the World 26 The Mobile Software Development Process 551 27 Designing and Developing Bulletproof Android Applications 571 28 Testing Android Applications 585 29 Selling Your Android Application 597 VII: Appendixes A The Android Emulator Quick-Start Guide 613 B The Android DDMS Quick-Start Guide 635 C The Android Debug Bridge Quick-Start Guide 647 D Eclipse IDE Tips and Tricks 661 E The SQLite Quick-Start Guide 669 Index 683

Part 1: Development Kit Walk-Through Chapter 1. Getting to Know Android Chapter 2. Setting Up Your Android Development Environment Chapter 3. Using the Android Development Environment for Real Applications Chapter 4. Under the Covers: Startup Code and Resources in the MJAndroid Application Chapter 5. Debugging Android Applications Chapter 6. The ApiDemos Application Chapter 7. Signing and Publishing Your Application Part 2: Programming Topics Chapter 8. Persistent Data Storage: SQLite Databases and Content Providers Chapter 9. Location and Mapping Chapter 10. Building a View Chapter 11. A Widget Bestiary Chapter 12. Drawing 2D and 3D Graphics Chapter 13. Inter-Process Communication Chapter 14. Simple Phone Calls Chapter 15. Telephony State Information and Android Telephony Classes Appendix A. Wireless Protocols Section A.1. Prehistory Section A.2. The Dawn of Second Generation (2G) Digital Cellular Section A.3. Improved Digital Cellular (2.5G) Section A.4. The Rise of 3G Section A.5. The Future: 4G

Part One Fundamentals ........1 Chapter 1 Networks and Protocols ...... . 3 Chapter 2 Functions.......... . 41 Chapter 3Socket Programming ....... . 65 Chapter 4 Protocols, Sessions, and State... . . 85 Part Two Design and Architecture . . . . . . 97 Chapter 5 Client-Server Architecture ....99 Chapter 6 Implementing Custom Protocols ... . . 137 Chapter 7 Design Decisions.......155 Chapter 8 Debugging and Development Cycle ..173 Chapter 9 Case Study: A Networked Application . . . 185 Part Three Security . . . 229 Chapter 10 Securing Network Communication... . 231 Chapter 11 Authentication and Data Signing ..261 Chapter 12 Common Security Problems ..... 281 Chapter 13Case Study: A Secure Networked Appendix IPv6 ........... . . 341

1 You Write Software; You have Bugs . . . . . . . . . 1 2 A Systematic Approach to Debugging . . . . . . . 5 2.1 Why Follow a Structured Process? . . . . . . . 5 2.2 Making the Most of Your Opportunities . . . . . . 5 2.3 13 Golden Rules . . . . . . . . . . . . . 7 2.3.1 Understand the Requirements . . . . . . 8 2.3.2 Make it Fail . . . . . . . . . . . . 8 2.3.3 Simplify the Test Case . . . . . . . . . 9 2.3.4 Read the Right Error Message . . . . . . 9 2.3.5 Check the Plug . . . . . . . . . 9 2.3.6 Separate Facts from Interpretation . . . . . 10 2.3.7 Divide and Conquer . . . . . . . . 10 2.3.8 Match the Tool to the Bug . . . . . . . . . 12 2.3.9 One Change at a Time . . . . . . . . . 12 2.3.10 Keep an Audit Trail . . . . . . . . 12 2.3.11 Get a Fresh View . . . . . . . . . . . 13 2.3.12 If You Didn’t Fix it, it Ain’t Fixed . . . . . 13 2.3.13 Cover your Bugfix with a Regression Test . . . . . 13 2.4 Build a Good Toolkit . . . . . . . . . . . . 14 2.4.1 Your Workshop . . . . . . . . . 15 2.4.2 Running Tests Every Day Keeps the Bugs at Bay . . 15 2.5 Know Your Enemy – Meet the Bug Family . . . . . . 17 2.5.1 The Common Bug . . . . . . . . . . 17 2.5.2 Sporadic Bugs . . . . . . . . . . 18 2.5.3 Heisenbugs. . . . . . . . . . 18 2.5.4 Bugs Hiding Behind Bugs . . . . . . . . . 19 2.5.5 Secret Bugs – Debugging and Confidentiality . . . . . 20 2.5.6 Further Reading . . . . . . . . . 21 3 Getting to the Root – Source Code Debuggers . . . . . . 23 3.1 Visualizing Program Behavior . . . . . . . . 23 3.2 Prepare a Simple Predictable Example . . . . . . . 24 3.3 Get the Debugger to Run with Your Program . . . . . . . 24 3.4 Learn to do a Stack Trace on a Program Crash . . . . . . 27 3.5 Learn to Use Breakpoints . . . . . . . . . 28 3.6 Learn to Navigate Through the Program. . . . . . 28 3.7 Learn to Inspect Data: Variables and Expressions . . . . 29 3.8 A Debug Session on a Simple Example . . . . . . 30 4 Fixing Memory Problems . . . . . . . . . . . . 33 4.1 Memory Management in C/C++ – Powerful but Dangerous . . . . 33 4.1.1 Memory Leaks . . . . . . . . . 34 4.1.2 Incorrect Use of Memory Management . . . . 34 4.1.3 Buffer Overruns . . . . . . . . . . . 34 4.1.4 Uninitialized Memory Bugs . . . . . . . . 34 4.2 Memory Debuggers to the Rescue . . . . . . . . 35 4.3 Example 1: Detecting Memory Access Errors . . . . . . . 36 4.3.1 Detecting an Invalid Write Access . . . . . 36 4.3.2 Detecting Uninitialized Memory Reads . . . . 37 4.3.3 Detecting Memory Leaks . . . . . . . 38 4.4 Example 2: Broken Calls to Memory Allocation/Deallocation . . 38 4.5 Combining Memory and Source Code Debuggers . . . . . . 40 4.6 Cutting Down the Noise – Suppressing Errors . . . . . . . 40 4.7 When to Use a Memory Debugger . . . . . . . 41 4.8 Restrictions . . . . . . . . . . . . . . 42 4.8.1 Prepare Test Cases with Good Code Coverage . . . . 42 4.8.2 Provide Additional Computer Resources . . . . . . 42 4.8.3 Multi-Threading May Not be Supported . . . . . . 42 4.8.4 Support for Non-standard Memory Handlers . . . 42 5 Profiling Memory Use . . . . . . . . . . . . 45 5.1 Basic Strategy – The First Steps . . . . . . . . . 45 5.2 Example 1: Allocating Arrays . . . . . . . . 46 5.3 Step 1: Look for Leaks . . . . . . . . . . . 46 5.4 Step 2: Set Your Expectations . . . . . . . . 47 5.5 Step 3: Measure Memory Consumption . . . . . . 47 5.5.1 Use Multiple Inputs . . . . . . . . 48 5.5.2 Stopping the Program at Regular Intervals . . . . . 48 5.5.3 Measuring Memory Consumption with Simple Tools . . 49 5.5.4 Use top . . . . . . . . . . . . 49 5.5.5 Use the Windows Task Manager . . . . . . . 50 5.5.6 Select Relevant Input Values for testmalloc . . . 51 5.5.7 Determine how Memory is Deallocated on Your Machine . 51 5.5.8 Use a Memory Profiler . . . . . . . . . 53 5.6 Step 4: Identifying Greedy Data Structures . . . . . . 54 5.6.1 Instrumenting Data Structures . . . . . . 55 5.7 Putting it Together – The genindex Example. . . . . . 55 5.7.1 Check that There are No Major Leaks . . . . . 56 5.7.2 Estimate the Expected Memory Use . . . . . . . 56 5.7.3 Measure Memory Consumption . . . . . . . 57 5.7.4 Find the Data Structures that Consume Memory . . . 57 6 Solving Performance Problems . . . . . . . . . . 63 6.1 Finding Performance Bugs – A Step-by-Step Approach . . . . . 63 6.1.1 Do an Upfront Analysis . . . . . . . . 64 6.1.2 Use a Simple Method of Measuring Time . . . . . 64 6.1.3 Create a Test Case . . . . . . . . . . 65 6.1.4 Make the Test Case Reproducible . . . . . . 65 6.1.5 Check the Program for Correctness . . . . . . . 66 6.1.6 Make the Test Case Scalable . . . . . . . 66 6.1.7 Isolate the Test Case from Side Effects . . . . 67 6.1.8 Measurement with time can have Errors and Variations . 68 6.1.9 Select a Test Case that Exposes the Runtime Bottleneck . . 68 6.1.10 The Difference Between Algorithm and Implementation . . 70 6.2 Using Profiling Tools . . . . . . . . . . . . 72 6.2.1 Do Not Write Your Own Profiler . . . . . . . 72 6.2.2 How Profilers Work . . . . . . . . 73 6.2.3 Familiarize Yourself with gprof . . . . . . 74 6.2.4 Familiarize Yourself with Quantify . . . . . 79 6.2.5 Familiarize Yourself with Callgrind . . . . . . . 81 6.2.6 Familiarize Yourself with VTune . . . . . . 82 6.3 Analyzing I/O Performance . . . . . . . . . . 84 6.3.1 Do a Sanity Check of Your Measurements . . . . . 85 7 Debugging Parallel Programs . . . . . . . . . 87 7.1 Writing Parallel Programs in C/C++ . . . . . . . . . 87 7.2 Debugging Race Conditions . . . . . . . . . . 88 7.2.1 Using Basic Debugger Capabilities to Find Race Conditions . . . . . . . . . . 89 7.2.2 Using Log Files to Localize Race Conditions . . . . . 91 7.3 Debugging Deadlocks . . . . . . . . . . . . 93 7.3.1 How to Determine What the Current Thread is Executing . 94 7.3.2 Analyzing the Threads of the Program . . . . . 95 7.4 Familiarize Yourself with Threading Analysis Tools . . . . . 96 7.5 Asynchronous Events and Interrupt Handlers . . . . . . . 98 8 Finding Environment and Compiler Problems . . . . . . 101 8.1 Environment Changes – Where Problems Begin . . . . . 101 8.1.1 Environment Variables . . . . . . . . . 101 8.1.2 Local Installation Dependencies . . . . . . . 102 8.1.3 Current Working Directory Dependency . . . . . . 102 8.1.4 Process ID Dependency . . . . . . . . 102 8.2 How else to See what a Program is Doing . . . . . . . 103 8.2.1 Viewing Processes with top . . . . . . . 103 8.2.2 Finding Multiple Processes of an Application with ps . . . 103 8.2.3 Using /proc/<pid> to Access a Process . . . . 104 8.2.4 Use strace to Trace Calls to the OS . . . . . 104 8.3 Compilers and Debuggers have Bugs too . . . . . . . . 106 8.3.1 Compiler Bugs . . . . . . . . . 106 8.3.2 Debugger and Compiler Compatibility Problems . . 107 9 Dealing with Linking Problems . . . . . . . . . . 109 9.1 How a Linker Works . . . . . . . . . . 109 9.2 Building and Linking Objects . . . . . . . . 110 9.3 Resolving Undefined Symbols . . . . . . . . 111 9.3.1 Missing Linker Arguments . . . . . . . . 111 9.3.2 Searching for Missing Symbols . . . . . . . . 112 9.3.3 Linking Order Issues . . . . . . . . . . 113 9.3.4 C++ Symbols and Name Mangling . . . . . 114 9.3.5 Demangling of Symbols . . . . . . . . 115 9.3.6 Linking C and C++ Code . . . . . . . 115 9.4 Symbols with Multiple Definitions . . . . . . . 116 9.5 Symbol Clashes . . . . . . . . . . . 117 9.6 Identifying Compiler and Linker Version Mismatches . . . 118 9.6.1 Mismatching System Libraries . . . . . . . . 119 9.6.2 Mismatching Object Files . . . . . . . . . 119 9.6.3 Runtime Crashes . . . . . . . . . . . 120 9.6.4 Determining the Compiler Version . . . . . 120 9.7 Solving Dynamic Linking Issues . . . . . . . . . 122 9.7.1 Linking or Loading DLLs . . . . . . . . . 122 9.7.2 DLL Not Found . . . . . . . . . 124 9.7.3 Analyzing Loader Issues . . . . . . . 125 9.7.4 Setting Breakpoints in DLLs . . . . . . . 126 9.7.5 Provide Error Messages for DLL Issues . . . . 127 10 Advanced Debugging . . . . . . . . . . . . . 129 10.1 Setting Breakpoints in C++ Functions, Methods, and Operators . 129 10.2 Setting Breakpoints in Templatized Functions and C++ Classes . 131 10.3 Stepping in C++ Methods . . . . . . . . . 133 10.3.1 Stepping into Implicit Functions . . . . . . . 134 10.3.2 Skipping Implicit Functions with the Step-out Command . 135 10.3.3 Skipping Implicit Functions with a Temporary Breakpoint 136 10.3.4 Returning from Implicit Function Calls . . . . 136 10.4 Conditional Breakpoints and Breakpoint Commands . . . . 137 10.5 Debugging Static Constructor/Destructor Problems . . . . . 140 10.5.1 Bugs Due to Order-Dependence of Static Initializers . . 140 10.5.2 Recognizing the Stack Trace of Static Initializers . . 141 10.5.3 Attaching the Debugger Before Static Initialization . . . 142 10.6 Using Watchpoints . . . . . . . . . . . 143 10.7 Catching Signals . . . . . . . . . . . . . 144 10.8 Catching Exceptions . . . . . . . . . . 147 10.9 Reading Stack Traces . . . . . . . . . . . . 148 10.9.1 Stack Trace of Source Code Compiled with Debug Information . . . . . . . . 148 10.9.2 Stack Trace of Source Code Compiled Without Debug Information . . . . . . . . 149 10.9.3 Frames Without Any Debug Information . . . . . . 149 10.9.4 Real-Life Stack Traces . . . . . . . . . 150 10.9.5 Mangled Function Names . . . . . . . . . 151 10.9.6 Broken Stack Traces . . . . . . . . 151 10.9.7 Core Dumps . . . . . . . . . . . . 152 10.10 Manipulating a Running Program . . . . . . . . 153 10.10.1 Changing a Variable . . . . . . . . 156 10.10.2 Calling Functions . . . . . . . . . . 156 10.10.3 Changing the Return Value of a Function . . . . . . 157 10.10.4 Aborting Function Calls . . . . . . . . 157 10.10.5 Skipping or Repeating Individual Statements . . . . . 158 10.10.6 Printing and Modifying Memory Content . . . . . 159 10.11Debugging Without Debug Information . . . . . . 161 10.11.1 Reading Function Arguments From the Stack . . . . . 163 10.11.2 Reading Local/Global Variables, User-Defined Data Types 165 10.11.3 Finding the Approximate Statement in the Source Code . . 165 10.11.4 Stepping Through Assembly Code . . . . . 166 11 Writing Debuggable Code . . . . . . . . . . . . 169 11.1 Why Comments Count . . . . . . . . . . . 169 11.1.1 Comments on Function Signatures . . . . . 170 11.1.2 Comments on Workarounds . . . . . . . . 171 11.1.3 Comments in Case of Doubt . . . . . . . 171 11.2 Adopting a Consistent Programming Style . . . . . . 171 11.2.1 Choose Names Carefully . . . . . . . 171 11.2.2 Avoid Insanely Clever Constructs . . . . . . 172 11.2.3 Spread Out Your Code . . . . . . . . . 172 11.2.4 Use Temporary Variables for Complex Expressions . . . 172 11.3 Avoiding Preprocessor Macros . . . . . . . . . . 173 11.3.1 Use Constants or Enums Instead of Macros . . . . 173 11.3.2 Use Functions Instead of Preprocessor Macros . . . . 175 11.3.3 Debug the Preprocessor Output . . . . . . . . 176 11.3.4 Consider Using More Powerful Preprocessors . . . . 177 11.4 Providing Additional Debugging Functions . . . . . . 179 11.4.1 Displaying User-Defined Data Types . . . . . . 179 11.4.2 Self-Checking Code . . . . . . . . 180 11.4.3 Debug Helpers for Operators . . . . . . . 181 11.5 Prepare for Post-Processing . . . . . . . . . . 181 11.5.1 Generate Log Files . . . . . . . . . 181 12 How Static Checking Can Help . . . . . . . . . . 183 12.1 Using Compilers as Debugging Tools . . . . . . . . 183 12.1.1 Do not Assume Warnings to be Harmless . . . . . 184 12.1.2 Use Multiple Compilers to Check the Code . . . . 186 12.2 Using lint . . . . . . . . . . . . . . 186 12.3 Using Static Analysis Tools . . . . . . . . . . 187 12.3.1 Familiarize Yourself with a Static Checker . . . . 187 12.3.2 Reduce Static Checker Errors to (Almost) Zero . . . 189 12.3.3 Rerun All Test Cases After a Code Cleanup . . . 190 12.4 Beyond Static Analysis . . . . . . . . . . . 190 13 Summary . . . . . . . . . . . . . . 191 A Debugger Commands . . . . . . . . . . . . . 193 B Access to Tools . . . . . . . . . . . . . 195 B.1 IDEs, Compilers, Build Tools . . . . . . . . 195 B.1.1 Microsoft Visual Studio . . . . . . . . 195 B.1.2 Eclipse . . . . . . . . . . . . . 196 B.1.3 GCC . . . . . . . . . . . . 196 B.1.4 GNU Make . . . . . . . . . . . . 196 B.2 Debuggers . . . . . . . . . . . . 196 B.2.1 dbx . . . . . . . . . . . . . 196 B.2.2 DDD . . . . . . . . . . . . 197 B.2.3 GDB . . . . . . . . . . . . 197 B.2.4 ARM RealView . . . . . . . . . 197 B.2.5 TotalView Debugger . . . . . . . . 197 B.2.6 Lauterbach TRACE32 . . . . . . . . . 197 B.3 Environments . . . . . . . . . . . . . 198 B.3.1 Cygwin . . . . . . . . . . . . . 198 B.3.2 VMware . . . . . . . . . . . . 198 B.4 Memory Debuggers . . . . . . . . . . . 198 B.4.1 Purify . . . . . . . . . . . 198 B.4.2 Valgrind . . . . . . . . . . . . 199 B.4.3 KCachegrind . . . . . . . . . . . 199 B.4.4 Insure++ . . . . . . . . . . . . 199 B.4.5 BoundsChecker . . . . . . . . . 200 B.5 Profilers . . . . . . . . . . . . . . 200 B.5.1 gprof . . . . . . . . . . . . 200 B.5.2 Quantify . . . . . . . . . . . . 200 B.5.3 Intel VTune . . . . . . . . . . . . 200 B.5.4 AQtime . . . . . . . . . . . . . 201 B.5.5 mpatrol . . . . . . . . . . . . . 201 B.6 Static Checkers . . . . . . . . . . . 201 B.6.1 Coverity . . . . . . . . . . . . 201 B.6.2 Lint . . . . . . . . . . . . . 201 B.6.3 Splint . . . . . . . . . . . 202 B.6.4 /analyze option in Visual Studio Enterprise Versions . . 202 B.6.5 Klocwork . . . . . . . . . . . 202 B.6.6 Fortify . . . . . . . . . . . . . 202 B.6.7 PC-lint/FlexeLint . . . . . . . . . . 203 B.6.8 QA C++ . . . . . . . . . . . . 203 B.6.9 Codecheck . . . . . . . . . . 203 B.6.10 Axivion Bauhaus Suite . . . . . . . . . 203 B.6.11 C++ SoftBench CodeAdvisor . . . . . . 203 B.6.12 Parasoft C++test . . . . . . . . . . . 204 B.6.13 LDRA tool suite . . . . . . . . . . . 204 B.6.14 Understand C++ . . . . . . . . . . . 204 B.7 Tools for Parallel Programming . . . . . . . . . . 204 B.7.1 Posix Threads . . . . . . . . . . 204 B.7.2 OpenMP . . . . . . . . . . . . 204 B.7.3 Intel TBB . . . . . . . . . . . 205 B.7.4 MPI . . . . . . . . . . . . . 205 B.7.5 MapReduce . . . . . . . . . . . . 205 B.7.6 Intel Threading Analysis Tools . . . . . . . . 205 B.8 Miscellaneous Tools . . . . . . . . . . 206 B.8.1 GNU Binutils . . . . . . . . . . . 206 B.8.2 m4 . . . . . . . . . . . . . . 206 B.8.3 ps . . . . . . . . . . . . . . 206 B.8.4 strace / truss . . . . . . . . . . 207 B.8.5 top. . . . . . . . . . . . . 207 B.8.6 VNC . . . . . . . . . . . . 207 B.8.7 WebEx . . . . . . . . . . . . . 207 C Source Code . . . . . . . . . . . . . . . 209 C.1 testmalloc.c . . . . . . . . . . . . . . 209 C.2 genindex.c . . . . . . . . . . . . 210 C.3 isort.c . . . . . . . . . . . . . 214 C.4 filebug.c . . . . . . . . . . . . . . 216 References . . . . . . . . . . . . . . 217 Index . . . . . . . . . . . . . . . . 219

Part I: What is Android—The Big Picture Chapter 1: Targeting Android Chapter 2: Development environment Part II: Learning Android’s Key Technologies Chapter 3: User Interfaces Chapter 4: Intents and Services Chapter 5: Storing and Retrieving Data Chapter 6: Networking Chapter 7: Telephony Chapter 8: Notification and Alarms Chapter 9: Graphics and Animation Chapter 10: Multimedia Chapter 11: Location Based Services Part III: Android applications for the Real Device Chapter 12: Putting it all together: A Field Service Application Chapter 13: Hacking Android Appendix: Installing the Android SDK

Python 3 is the best version of the language yet: It is more powerful, convenient, consistent, and expressive than ever before. Now, leading Python programmer Mark Summerfield demonstrates how to write code that takes full advantage of Python 3's features and idioms. The first book written from a completely "Python 3" viewpoint, Programming in Python 3 brings together all the knowledge you need to write any program, use any standard or third-party Python 3 library, and create new library modules of your own. Summerfield draws on his many years of Python experience to share deep insights into Python 3 development you won't find anywhere else. He begins by illuminating Python's "beautiful heart": the eight key elements of Python you need to write robust, high-performance programs. Building on these core elements, he introduces new topics designed to strengthen your practical expertise–one concept and hands-on example at a time. This book's coverage includes Developing in Python using procedural, object-oriented, and functional programming paradigms Creating custom packages and modules Writing and reading binary, text, and XML files, including optional compression, random access, and text and XML parsing Leveraging advanced data types, collections, control structures, and functions Spreading program workloads across multiple processes and threads Programming SQL databases and key-value DBM files Utilizing Python's regular expression mini-language and module Building usable, efficient, GUI-based applications Advanced programming techniques, including generators, function and class decorators, context managers, descriptors, abstract base classes, metaclasses, and more Programming in Python 3serves as both tutorial and language reference, and it is accompanied by extensive downloadable example code–all of it tested with the final version of Python 3 on Windows, Linux, and Mac OS X. TOC Chapter 1. Rapid Introduction to Procedural Programming Creating and Running Python Programs Python's "Beautiful Heart" Chapter 2. Data Types Identifiers and Keywords Integral Types Floating-Point Types Strings Chapter 3. Collection Data Types Sequence Types Set Types Mapping Types Iterating and Copying Collections Chapter 4. Control Structures and Functions Control Structures Exception Handling Custom Functions Chapter 5. Modules Modules and Packages Overview of Python's Standard Library Chapter 6. Object-Oriented Programming The Object-Oriented Approach Custom Classes Custom Collection Classes Chapter 7. File Handling Writing and Reading Binary Data Writing and Parsing Text Files Writing and Parsing XML Files Random Access Binary Files Chapter 8. Advanced Programming Techniques Further Procedural Programming Further Object-Oriented Programming Functional-Style Programming Chapter 9. Processes and Threading Delegating Work to Processes Delegating Work to Threads Chapter 10. Networking Creating a TCP Client Creating a TCP Server Chapter 11. Database Programming DBM Databases SQL Databases Chapter 12. Regular Expressions Python's Regular Expression Language The Regular Expression Module Chapter 13. Introduction to GUI Programming Dialog-Style Programs Main-Window-Style Programs

Part I Uml State Machines Chapter 1 Getting Started with UML State Machines and Event-Driven Programming Chapter 2 A Crash Course in UML State Machines Chapter 3 Standard State Machine Implementations Chapter 4 Hierarchical Event Processor Implementation Chapter 5 State Patterns Part Ii Real-Time Framework Chapter 6 Real-Time Framework Concepts Chapter 7 Real-Time Framework Implementation Chapter 8 Porting and Configuring QF Chapter 9 Developing QP Applications Chapter 10 Preemptive Run-to-Completion Kernel Chapter 11 Software Tracing for Event-Driven Systems Chapter 12 QP-nano: How Small Can You Go? A Licensing Policy for QP and QP-nano B Guide to Notation

Introduction . . . . . . . . . . . xvii Chapter 1: Hello, Android . . . . . . . . 1 Chapter 2: Getting Started . . . . . . . . . 19 Chapter 3: Creating Applications and Activities . . . . . . 45 Chapter 4: Creating User Interfaces . . . . . . . 75 Chapter 5: Intents, Broadcast Receivers, Adapters, and the Internet . . 113 Chapter 6: Data Storage, Retrieval, and Sharing . . . . . 159 Chapter 7: Maps, Geocoding, and Location-Based Services . . . . . 207 Chapter 8: Working in the Background . . . . . . . . 249 Chapter 9: Peer-to-Peer Communication . . . . . . . 279 Chapter 10: Accessing Android Hardware . . . . . . 315 Chapter 11: Advanced Android Development . . . . . . . . 353 Index . . . . . . . . . . . . 399

Chapter 1 explains how to install Python and makes sure all readers have the closest,standardized environment. I almost removed this chapter since the book is not intended for beginners. But it was kept because there are definitely some experienced Python programmers out there who are not aware of some of the things presented. If you are, don't feel frustrated about it, as the rest of the book will probably meet your needs. Chapter 2 is about syntax best practices, below the class level. It presents iterators, generators, descriptors, and so on, in an advanced way. Chapter 3 is also about syntax best practices, but focuses above the class level. Chapter 4 is about choosing good names. It is an extension to PEP 8 with naming best practices, but also gives tips on designing good APIs. Chapter 5 explains how to write a package and how to use code templates and then focuses on how to release and distribute your code. Chapter 6 extends Chapter 5 by describing how a full application can be written. It demonstrates it through a small case study called Atomisator. Chapter 7 is about zc.buildout, a system for managing a development environment and releasing applications, which is widely used in the Zope and Plone community and is now used outside the Zope world. Chapter 8 gives some insight on how a project code base can be managed and explains how to set up continuous integration. Chapter 9 presents how to manage software life cycle through an iterative and incremental approach. Chapter 10 is about documentation and gives tips on technical writing and how Python projects should be documented. Chapter 11 explains Test-Driven Development and the tools that can be used to do it. Chapter 12 is about optimization. It gives profiling techniques and an optimization strategy guideline. Chapter 13 extends Chapter 12 by providing some solutions to speed up your programs. Chapter 14 ends the book with a set of useful design patterns.

PART I Meet Ubuntu 1 Ubunt-Who? Get to Know Ubuntu ........ . 3 2 Exploring the Ubuntu Desktop ........17 3 Make It Personal—Fine-Tune the Look of Ubuntu to Your Taste .. . . 33 PART II Manage Ubuntu 4 Housekeeping: Update and Maintain Ubuntu ...... 53 5 Installing Peripherals ..........65 6 Beyond the Basics: Install Extra Software ......75 7 Time to Upgrade: Installing New Hardware ...... . 85 8 Keep It Safe—Securing Ubuntu ........93 PART III Open the Door to OpenOffice 9 The Write Stuff ............ 111 10 Spread It Out with Calc .......... . 125 11 I’m Impressed ............ 139 12 All Your Base ............ . 149 13 Drawn to Open Source .......... . . 163 PART IV Reach Out 14 Share and Share Alike—Networking Ubuntu ...... . 175 15 Can We Talk? Communications and the Internet ..... . 189 16 Master of Your Domain—Web Design Tools ...... . . 203 17 Playing Nice with Windows ......... . . 215 PART V Having Fun with Ubuntu 18 Fun and Games—Play Games with Ubuntu ...... . . 231 19 Play that Funky Music—Making the Most of Multimedia ...245 20 Get Smart! Using Educational Software ....... . 269 PART VI Advanced Ubuntu 21 Coming Out of Your Shell—A Guide to GNU/Linux Shell Commands ........ . 281 22 The Emacs Text Editor .......... . . 297 A Install Ubuntu ............ 307 Index .............. 321

Introduction ........ . . xxvii Chapter 1: Introduction and Overview ..... . . . . . 1 Chapter 2: ProcessManagement and Scheduling .... . 35 Chapter 3: Memory Management ..... . . . . . . . 133 Chapter 4: Virtual ProcessMemory ..... . . . . . 289 Chapter 5: Locking and Interprocess Communication ... . . . . 347 Chapter 6: Device Drivers ...... . . . . . . 391 Chapter 7: Modules ....... . . . 473 Chapter 8: The Virtual Filesystem ..... . . . . . . . 519 Chapter 9: The Extended Filesystem Family .... . . . . . 583 Chapter 10: Filesystems without Persistent Storage ... . . . . 643 Chapter 11: Extended Attributes and Access Control Lists .. . . . . . . . 707 Chapter 12: Networks ....... . 733 Chapter 13: System Calls ...... . . . . . . 819 Chapter 14: Kernel Activities ...... . . 847 Chapter 15: Time management ...... 893 Chapter 16: Page and Buffer Cache..... . . . . . 949 Chapter 17: Data Synchronization ..... . . . . . . 989 Chapter 18: Page Reclaim and Swapping.... . . . . . . . 1023 Chapter 19: Auditing ....... . 1097 Appendix A: Architecture Specifics ..... . . . . 1117 Appendix B:Working with the Source Code .... . . . . 1141 Appendix C: Notes on C ...... . . . . . . . 1175 Appendix D: System Startup ...... . . 1223 Appendix E: The ELF Binary Format ..... . . . . 1241 Appendix F: The Kernel Development Process .... . . 1267 Bibliography ........ . 1289 Index ........1293

Preface . . . . . . . . . ix 1. Introduction . . . . . . . . 1 Definitions 2 Real Life and Embedded Linux Systems 5 Design and Implementation Methodology 27 2. Basic Concepts . . . . . . . 33 Types of Hosts 33 Types of Host/Target Development Setups 39 Types of Host/Target Debug Setups 41 Generic Architecture of an Embedded Linux System 43 System Startup 47 Types of Boot Configurations 48 System Memory Layout 51 3. Hardware Support . . . . . . 55 Processor Architectures 56 Buses and Interfaces 64 I/O 72 Storage 79 General-Purpose Networking 81 Industrial-Grade Networking 83 System Monitoring 85 4. Development Tools . . . . . . . 87 A Practical Project Workspace 89 GNU Cross-Platform Development Toolchain 91 C Library Alternatives 115 Java 129 Perl 131 Python 134 Other Programming Languages 135 Eclipse: An Integrated Development Environment 135 Terminal Emulators 147 5. Kernel Considerations . . . . . . 155 Selecting a Kernel 156 Configuring the Kernel 161 Compiling the Kernel 165 Installing the Kernel 167 In the Field 169 6. Root Filesystem Content . . . . . . 173 Basic Root Filesystem Structure 173 Libraries 177 Kernel Modules 183 Kernel Images 183 Device Files 184 Main System Applications 193 Custom Applications 201 System Initialization 201 7. Storage Device Manipulation . . . . . . 209 MTD-Supported Devices 209 Disk Devices 231 To Swap or Not To Swap 234 8. Root Filesystem Setup . . . . . . 235 Filesystem Types for Embedded Devices 235 Writing a Filesystem Image to Flash Using an NFS-Mounted Root Filesystem 254 Placing a Disk Filesystem on a RAM Disk 254 Rootfs and Initramfs 255 Choosing a Filesystem’s Type and Layout 258 Handling Software Upgrades 261 9. Setting Up the Bootloader . . . . . . 273 Embedded Bootloaders 274 Server Setup for Network Boot 278 Using the U-Boot Bootloader 285 10. Setting Up Networking Services . . . . . . 301 Network Settings 302 Busybox 303 Dynamic Configuration Through DHCP 303 The Internet Super-Server 305 Remote Administration with SNMP 309 Network Login Through Telnet 312 Secure Communication with SSH 314 Serving Web Content Through HTTP 317 Provisioning 321 11. Debugging Tools . . . . . . 325 Eclipse 326 Debugging Applications with gdb 328 Tracing 333 Performance Analysis 336 Memory Debugging 344 A Word on Hardware Tools 348 12. Introduction to Real-Time Linux . . . . . 351 What Is Real-Time Processing? 351 Should Your Linux Be Real-Time? 352 Common Real-Time Kernel Requirements 356 Some Typical Users of Real-Time Computing Technology 358 The Linux Paths to Real-Time 360 13. The Xenomai Real-Time System . . . . . . 365 Porting Traditional RTOS Applications to Linux 366 The Xenomai Architecture 368 How Xenomai Works 375 The Real-Time Driver Model 379 Xenomai, Chameleon by Design 385 14. The RT Patch . . . . . . . . 387 Interrupts As Threads 388 Priority Inheritance 398 Configuring the Kernel with the RT Patch 401 High-Resolution Timers 407 The Latency Tracer 410 Conclusion 417 Index . . . . . . . . . 419

Ubuntu Unleashed 2008 Edition Copyright © 2009 by Sams Publishing Introduction 1 Part I Installation and Configuration 1 Installing Ubuntu..........11 2 Post-Installation Configuration ........25 3 Working with Gnome...........51 4 Command Line Quickstart .........79 Part II Desktop Ubuntu 5 On the Internet...........113 6 Productivity Applications .........133 7 Multimedia Applications ..........153 8 Printing with Ubuntu .........185 9 Games............197 Part III System Administration 10 Managing Users...........209 11 Automating Tasks..........233 12 System-Monitoring Tools..........289 13 Backing Up............301 14 Networking............325 15 Remote Access with SSH and Telnet.......371 Part IV Ubuntu as a Server 16 File and Print...........381 17 Apache Web Server Management.......407 18 Remote File Serving with FTP.........439 19 Handling Electronic Mail..........471 20 Proxying and Reverse Proxying ........489 21 Administering Database Services ........499 22 LDAP............525 Part V Programming Linux 23 Using Perl ............537 24 Working with Python .........561 25 Writing PHP Scripts...........579 26 C/C++ Programming Tools for Ubuntu......613 27 Mono.............625 Part VI Ubuntu Housekeeping 28 Securing Your Machines .........639 29 Performance Tuning..........651 30 Command Line Masterclass........663 31 Managing Software ...........689 32 Kernel and Module Management.......701 Part VII Appendixes A Ubuntu Under the Hood ..........727 B Installation Resources .........737 C Ubuntu and Linux Internet Resources .......759 Index ............???

1 Introduction to IPv6 . . . . . . . . . . . .1 2 IPv6 Protocol for Windows Server 2008 and Windows Vista. . . 17 3 IPv6 Addressing. . . . . . . . . . . . . . 49 4 The IPv6 Header . . . . . . . . . . . . . 83 5 ICMPv6 . . . . . . . . . . . . . . 109 6 Neighbor Discovery . . . . . . . . . . . . 123 7 Multicast Listener Discovery and MLD Version 2. . . . . . 171 8 Address Autoconfiguration . . . . . . . . . 191 9 IPv6 and Name Resolution . . . . . . . . . 209 10 IPv6 Routing . . . . . . . . . . . . 231 11 IPv6 Transition Technologies. . . . . . . . . . . 259 12 ISATAP. . . . . . . . . . . . . . . 275 13 6to4. . . . . . . . . . . . . . 295 14 Teredo. . . . . . . . . . . . . . . 317 15 IPv6 Security Considerations. . . . . . . . . . . 355 16 Deploying IPv6 . . . . . . . . . . . . . 363 A Link-Layer Support for IPv6. . . . . . . . . 381 B Windows Sockets Changes for IPv6 . . . . . . . . 401 C IPv6 RFC Index. . . . . . . . . . . . . . 411 D Testing for Understanding Answers . . . . . . . . 417 E Setting Up an IPv6 Test Lab. . . . . . . . . 441 F Mobile IPv6 . . . . . . . . . . . . . 453 G IPv6 Reference Tables . . . . . . . . . . . 509 Index

I The Python Language 1 A Tutorial Introduction 2 Lexical Conventions and Syntax 3 Types and Objects 4 Operators and Expressions 5 Control Flow 6 Functions and Functional Programming 7 Classes and Object-Oriented Programming 8 Modules and Packages 9 Input and Output 10 Execution Environment II The Python Library 11 Introduction to the Python Standard Library 12 Built-in Functions and Exceptions 13 Python Runtime Services 14 Mathematics 15 Data Structures and Algorithms 16 String and Text Handling 17 Data Management and Object Persistence 18 File Handling 19 Operating System Services 20 Threads 21 Network Programming 22 Internet Application Protocols 23 Internet Data Handling and Encoding 24 Cryptographic Services 25 Miscellaneous Modules 26 Debugging, Profiling, and Testing III Extending and Embedding 27 Extending and Embedding Python Index

1 The Big Picture 9 2 C++ Programming Basics 29 3 Loops and Decisions 75 4 Structures 131 5 Functions 161 6 Objects and Classes 215 7 Arrays and Strings 263 8 Operator Overloading 319 9 Inheritance 371 10 Pointers 429 11 Virtual Functions 503 12 Streams and Files 567 13 Multifile Programs 633 14 Templates and Exceptions 681 15 The Standard Template Library 725 16 Object-Oriented Software Development 801 A ASCII Chart 849 B C++ Precedence Table and Keywords 859 C Microsoft Visual C++ 863 D Borland C++Builder 871 E Console Graphics Lite 881 F STL Algorithms and Member Functions 895 G Answers to Questions and Exercises 913 H Bibliography 977 Index 981

Part I: Introduction to Professional C++ Chapter 1: A Crash Course in C++ Chapter 2: Designing Professional C++ Programs Chapter 3: Designing with Objects Chapter 4: Designing with Libraries and Patterns Chapter 5: Designing for Reuse Chapter 6: Maximizing Software Engineering Methods Part II: C++ Coding the Professional Way Chapter 7: Coding with Style Chapters 8 and 9: Classes and Objects Chapter 10: Discovering Inheritance Techniques Chapter 11: Writing Generic Code with Templates Chapter 12: Understanding C++ Quirks and Oddities Part III: Mastering Advanced Features of C++ Chapter 13: Effective Memory Management Chapter 14: Demystifying C++ I/O Chapter 15: Handling Errors Part IV: Ensuring Bug-Free Code Chapter 16: Overloading C++ Operators Chapter 17: Writing Efficient C++ Chapter 18: Developing Cross-Platform and Cross-Language Applications Chapter 19: Becoming Adept at Testing Chapter 20: Conquering Debugging Part V: Using Libraries and Patterns Chapters 21, 22, and 23: The Standard Template Library Chapter 24: Exploring Distributed Objects Chapter 25: Incorporating Techniques and Frameworks Chapter 26: Applying Design Patterns

Chapter 1. Introduction Chapter 2. A Peek Inside the Kernel Chapter 3. Kernel Facilities Chapter 4. Laying the Groundwork Chapter 5. Character Drivers Chapter 6. Serial Drivers Chapter 7. Input Drivers Chapter 8. The Inter-Integrated Circuit Protocol Chapter 9. PCMCIA and Compact Flash Chapter 10. Peripheral Component Interconnect Chapter 11. Universal Serial Bus Chapter 12. Video Drivers Chapter 13. Audio Drivers Chapter 14. Block Drivers Chapter 15. Network Interface Cards Chapter 16. Linux Without Wires Chapter 17. Memory Technology Devices Chapter 18. Embedding Linux Chapter 19. Drivers in User Space Chapter 20. More Devices and Drivers Chapter 21. Debugging Device Drivers Chapter 22. Maintenance and Delivery Chapter 23. Shutting Down Appendix A. Linux Assembly Appendix B. Linux and the BIOS Appendix C. Seq Files Index

Part I - The Science of Computing's Three Methods of Inquiry Chapter 1 - What is the Science of Computing? Chapter 2 - Abstraction: An Introduction to Design Chapter 3 - Proof: An Introduction to Theory Chapter 4 - Experimentation: An Introduction to the Scientific Method Part II - Program Design Chapter 5 - Conditionals Chapter 6 - Designing with Recursion Chapter 7 - Analysis of Recursion Chapter 8 - Creating Correct Iterative Algorithms Chapter 9 - Iteration and Efficiency Chapter 10 - A Case Study in Design and Analysis: Efficient Sorting Part III - Introduction to Data Structures Chapter 11 - Lists Chapter 12 - Queues and Stacks Chapter 13 - Binary Trees Chapter 14 - Case Studies in Design: Abstracting Indirection Part IV - The Limits of Computer Science Chapter 15 - Exponential Growth Chapter 16 - Limits to Performance Chapter 17 - The Halting Problem Appendix A - Object-oriented Programming in Java Appendix B - About the Web Site Index List of Figures List of Tables List of Listings, Theorems and Lemmas List of Sidebars

Preface xv Changes From the First Edition xvi Chapter Overview xvii Part I: C++ Basics 1 Chapter 1. Introduction to C++ 1 Why Study C++? 1 Section 1.1. Our First C++ Program 3 Section 1.2. Integers and Arithmetic 20 Section 1.3. Solving a Problem with Integers 32 Section 1.4. Other Integer Data Types 36 Chapter Review 42 Chapter 2. Real Numbers 45 Section 2.1. Real Numbers 45 Section 2.2. Solving Problems with Real Numbers 52 Section 2.3. More on Arithmetic 64 Section 2.4. Three Difficulties When Displaying Decimal Numbers with cout 75 Chapter Review 78 Chapter 3. Iteration 80 Section 3.1. Relation Conditions 80 Section 3.2. Indefinite Iteration: The while and do Statements 83 Section 3.3. Solving a Problem with Indefinite Iteration 96 Section 3.4. Definite Iteration 105 Section 3.5. Nested Loops 118 Chapter Review 126 Chapter 4. Decision Making 128 Section 4.1. Basic Decision Making 128 Section 4.2. Compound ConditionsThe Logical Operators 139 Section 4.3. Nested if Statements 146 Section 4.4. The switch Statement 161 Chapter Review 172 Chapter 5. Functions 174 Section 5.1. The Function Concept 175 Section 5.2. User-Defined Functions that Return a Value 191 Section 5.3. Programs that Use Functions 203 Section 5.4. The C++ Math Library Functions 227 Chapter Review 231 Chapter 6. Arrays 234 Section 6.1. Basic Concepts 234 Section 6.2. Processing an Array: for Loops 242 Section 6.3. Sorting an Array 250 Section 6.4. Multidimensional Arrays 256 Chapter Review 264 Chapter 7. Pointers and C-Strings 266 Section 7.1. Pointers 266 Section 7.2. C-Strings 277 Section 7.3. Arrays of Strings and Pointers 290 Chapter Review 297 Chapter 8. Pointers, Arrays, and Functions 299 Section 8.1. Pointers, Reference Variables, and Functions 299 Section 8.2. Arrays and Functions 309 Section 8.3. Strings and Functions 318 Section 8.4. The Standard Library String Functions 326 Section 8.5. Character Classification and Conversion Functions 336 Section 8.6. Dynamic Memory Allocation 351 Chapter Review 360 Chapter 9. User-Defined Data Types and Tables 363 Section 9.1. The typedef and enum Statements 364 Section 9.2. Structures 371 Section 9.3. Arrays of Structures: Tables 379 Section 9.4. Structures, Functions, and Pointers 407 Chapter Review 424 Part II: Object-Oriented Programming 426 Chapter 10. The string Class: An Introduction to Classes and Objects 426 Section 10.1. Objects, Classes, and Object-Oriented Systems 427 Section 10.2. Introduction to string Objects 430 Section 10.3. Operations on string Objects 438 Section 10.4. Making Decisions with Strings 444 Section 10.5. Functions and string Objects 446 Section 10.6. Manipulating string Objects 451 Section 10.7. Putting Strings to Work 458 Section 10.8. Arrays of Strings 470 Chapter Review 473 Chapter 11. Programmer-Defined Classes and Objects 476 Section 11.1. Declaring Objects and Classes 476 Section 11.2. A More Useful Class Accessor and Mutator Methods 487 Section 11.3. Constructor Overloading and Destructors 496 Section 11.4. Default Arguments and Object Assignment 504 Section 11.5. General Function Overloading and Function Templates 511 Chapter Review 517 Chapter 12. Manipulating Objects 519 Section 12.1. Using Arrays, Pointers, and Dynamic Memory Allocation 520 Section 12.2. The Copy Constructor 528 Section 12.3. Using const with Classes 540 Section 12.4. Objects, Functions and Pointers 556 Section 12.5. Dynamic Allocation of Objects 581 Section 12.6. Static Data Members and Functions 588 Chapter Review 598 Chapter 13. Inheritance 600 Section 13.1. Inheritance 601 Section 13.2. Functions in Class Hierarchies 618 Section 13.3. Polymorphism 629 Section 13.4. Abstract Base Classes 649 Chapter Review 661 Chapter 14. Files 664 Section 14.1. Input/Output Streams 665 Section 14.2. Processing a File One Character at a Time 686 Section 14.3. Random File Access 692 Section 14.4. Binary Sequential File Processing 699 Section 14.5. Random Record Input/Output 709 Chapter Review 727 Chapter 15. Special Topics: Friends, Operator Overloading, Macros, and Inline Functions 730 Section 15.1. friend Functions 731 Section 15.2. Overloading Basic Arithmetic Operators 738 Section 15.3. Overloading Assignment and the this Pointer 745 Section 15.4. Overloading the Insertion and Extraction Operators 754 Section 15.5. Overloading Compound Assignment Operators 763 Section 15.6. Overloading Relational Operators 768 Section 15.7. Overloading Unary Operators 775 Section 15.8. Macros and Inline Functions 779 Chapter Review 788 Appendix A. Computers and Data 791 Section A.1. A Model Computer System 791 Section A.2. Data RepresentationCharacters 794 Section A.3. Data RepresentationIntegers 797 Section A.4. Data RepresentationReal Numbers 799 Exercises Appendix A 800 Appendix B. Program Control 802 Section B.1. Sequence 802 Section B.2. Selection 803 Section B.3. Iteration 808 Section B.4. Combinations 812 Index

Chapter 1: Starting the Journey Chapter 2: Descending Deeper…into Chapter 3: Taking Command with Control Chapter 4: Writing Functions Chapter 5: Fighting with OOP Chapter 6: Moving to Advanced Data Types Chapter 7: Building Namespaces Chapter 8: Introducing Inheritance Chapter 9: Using Templates Chapter 10: Using Streams and Files Chapter 11: Errors and Exception Chapter 12: Programming with Windows Chapter 13: Using DirectX Chapter 14: Creating the Pirate Adventure Apppendix A: Answers to Chapter Challenges Appendix B: Using the Octal, Hexadecimal, Binary, and Decimal Systems Appendix C: Using the Standard ASCII Table Appendix D: The C++ Keywords Appendix E: What’s on the CD

Contents xi Preface xxxv 1 Welcome to Linux 1 PART I Installing Ubuntu Linux 21 2 Installation Overview 23 3 Step-by-Step Installation 45 PART II Getting Started with Ubuntu Linux 85 4 Introduction to Ubuntu Linux 87 5 The Linux Utilities 145 6 The Linux Filesystem 183 7 The Shell 219 PART III Digging into Ubuntu Linux 249 8 Linux GUIs: X and GNOME 251 9 The Bourne Again Shell 275 10 Networking and the Internet 353 11 Programming the Bourne Again Shell 395 PART IV System Administration 483 12 System Administration: Core Concepts 485 13 Files, Directories, and Filesystems 553 14 Downloading and Installing Software 583 15 Printing with CUPS 611 16 Building a Linux Kernel 635 17 Administration Tasks 657 18 Configuring a LAN 693 PART V Using Clients and Setting Up Servers 705 19 OpenSSH: Secure Network Communication 707 20 FTP: Transferring Files Across a Network 729 21 exim4: Setting Up Mail Servers, Clients, and More 755 22 NIS: Network Information Service 781 23 NFS: Sharing Filesystems 799 24 Samba: Linux and Windows File and Printer Sharing 823 25 DNS/BIND: Tracking Domain Names and Addresses 845 26 firestarter and iptables: Setting Up a Firewall 885 27 Apache: Setting Up a Web Server 915 PART VI Appendixes 969 A Regular Expressions 971 B Help 981 C Security 991 D The Free Software Definition 1011 E The Linux 2.6 Kernel 1015 Glossary 1021 Index 1071

A Brief History of Qt Part I: Basic Qt Chapter 1. Getting Started Hello Qt Making Connections Laying Out Widgets Using the Reference Documentation Chapter 2. Creating Dialogs Subclassing QDialog Signals and Slots in Depth Rapid Dialog Design Shape-Changing Dialogs Dynamic Dialogs Built-in Widget and Dialog Classes Chapter 3. Creating Main Windows Subclassing QMainWindow Creating Menus and Toolbars Setting Up the Status Bar Implementing the File Menu Using Dialogs Storing Settings Multiple Documents Splash Screens Chapter 4. Implementing Application Functionality The Central Widget Subclassing QTableWidget Loading and Saving Implementing the Edit Menu Implementing the Other Menus Subclassing QTableWidgetItem Chapter 5. Creating Custom Widgets Customizing Qt Widgets Subclassing QWidget Integrating Custom Widgets with Qt Designer Double Buffering <br>Part II: Intermediate Qt Chapter 6. Layout Management Laying Out Widgets on a Form Stacked Layouts Splitters Scrolling Areas Dock Windows and Toolbars Multiple Document Interface Chapter 7. Event Processing Reimplementing Event Handlers Installing Event Filters Staying Responsive during Intensive Processing Chapter 8. 2D Graphics Painting with QPainter Coordinate System Transformations High-Quality Rendering with QImage Item-Based Rendering with Graphics View Printing Chapter 9. Drag and Drop Enabling Drag and Drop Supporting Custom Drag Types Clipboard Handling Chapter 10. Item View Classes Using the Item View Convenience Classes Using Predefined Models Implementing Custom Models Implementing Custom Delegates Chapter 11. Container Classes Sequential Containers Associative Containers Generic Algorithms Strings, Byte Arrays, and Variants Chapter 12. Input/Output Reading and Writing Binary Data Reading and Writing Text Traversing Directories Embedding Resources Inter-Process Communication Chapter 13. Databases Connecting and Querying Viewing Tables Editing Records Using Forms Presenting Data in Tabular Forms Chapter 14. Multithreading Creating Threads Synchronizing Threads Communicating with the Main Thread Using Qt's Classes in Secondary Threads Chapter 15. Networking Writing FTP Clients Writing HTTP Clients Writing TCP Client–Server Applications Sending and Receiving UDP Datagrams Chapter 16. XML Reading XML with QXmlStreamReader Reading XML with DOM Reading XML with SAX Writing XML Chapter 17. Providing Online Help Tooltips, Status Tips, and "What's This?" Help Using a Web Browser to Provide Online Help Using QTextBrowser as a Simple Help Engine Using Qt Assistant for Powerful Online Help <br>Part III: Advanced Qt Chapter 18. Internationalization Working with Unicode Making Applications Translation-Aware Dynamic Language Switching Translating Applications Chapter 19. Look and Feel Customization Using Qt Style Sheets Subclassing QStyle Chapter 20. 3D Graphics Drawing Using OpenGL Combining OpenGL and QPainter Doing Overlays Using Framebuffer Objects Chapter 21. Creating Plugins Extending Qt with Plugins Making Applications Plugin-Aware Writing Application Plugins Chapter 22. Application Scripting Overview of the ECMAScript Language Extending Qt Applications with Scripts Implementing GUI Extensions Using Scripts Automating Tasks through Scripting Chapter 23. Platform-Specific Features Interfacing with Native APIs Using ActiveX on Windows Handling X11 Session Management Chapter 24. Embedded Programming Getting Started with Qt/Embedded Linux Customizing Qt/Embedded Linux Integrating Qt Applications with Qtopia Using Qtopia APIs <br>Part IV: Appendixes Appendix A. Obtaining and Installing Qt A Note on Licensing Installing Qt/Windows Installing Qt/Mac Installing Qt/X11 Appendix B. Building Qt Applications Using qmake Using Third-Party Build Tools Appendix C. Introduction to Qt Jambi Getting Started with Qt Jambi Using Qt Jambi in the Eclipse IDE Integrating C++ Components with Qt Jambi Appendix D. Introduction to C++ for Java and C# Programmers Getting Started with C++ Main Language Differences The Standard C++ Library About the Authors Jasmin Blanchette Mark Summerfield Production Index <br>

1 Writing an ANSI C++ Program 1 1.1 Getting Ready to Program....... 2 1.1 A First Program......... 3 1.2 Problem Solving: Recipes....... . 7 1.2.1 Algorithms—Being Precise...... . . 8 1.3 Implementing Our Algorithm in C++.... . . . 10 1.4 Software Engineering: Style...... . . 12 1.5 Common Programming Errors...... 13 1.6 Writing and Running a C++ Program.... . . . 14 1.6.1 Interrupting a Program...... 16 1.6.2 Typing an End-of-File Signal..... 16 1.7 Dr. P’s Prescriptions....... . . . 16 1.8 C++ Compared with Java....... 17 Summary.......... 20 Review Questions........ . 21 Exercises.......... 22 2 Native Types and Statements 25 2.1 Program Elements........ . 26 2.1.1 Comments........ . 26 2.1.2 Keywords........ . . 27 2.1.3 Identifiers........ . . 27 2.1.4 Literals......... 29 2.1.5 Operators and Punctuators..... . 31 2.2 Input/Output......... . 31 2.3 Program Structure........ . 34 2.3.1 Redirection........ . 36 2.4 Simple Types......... . 37 2.4.1 Initialization........ 39 2.5 The Traditional Conversions...... . 40 2.6 Enumeration Types........ 43 2.6.1 typedef Declarations...... . 44 2.7 Expressions.......... . 44 2.7.1 Precedence and Associativity of Operators.. . 45 2.7.2 Relational, Equality, and Logical Operators.. . 47 2.8 Statements......... . . 50 2.8.1 Assignment and Expressions..... . . . 51 2.8.2 The Compound Statement...... . 52 2.8.3 The if and if-else Statements.... . 52 2.8.4 The while Statement...... . 55 2.8.5 The for Statement...... . . . 56 2.8.6 The do Statement....... 57 2.8.7 The break and continue Statements... . 58 2.8.8 The switch Statement...... 59 2.8.9 The goto Statement...... . . 62 2.9 Software Engineering: Debugging..... . 62 2.10 Dr. P’s Prescriptions....... . . . 65 2.11 C++ Compared with Java....... 67 Summary.......... 69 Review Questions........ . 70 Exercises.......... 71 3 Functions, Pointers, and Arrays 75 3.1 Functions......... . . . 75 3.2 Function Invocation........ 76 3.3 Function Definition........ 78 3.4 The return Statement........ . 79 3.5 Function Prototypes........ . . . 80 3.6 Call-By-Value......... . 81 3.7 Recursion......... . . . 83 3.8 Default Arguments........ 84 3.9 Functions as Arguments....... 86 3.10 Overloading Functions........ . 88 3.11 Inlining.......... . 89 3.11.1Software Engineering: Avoiding Macros... 89 3.12 Scope and Storage Class....... 90 3.12.1The Storage Class auto...... . . . 92 3.12.2The Storage Class extern..... . . 92 3.12.3The Storage Class register..... 93 3.12.4The Storage Class static..... . . 94 3.12.5Header Files and Linkage Mysteries... . . . 95 3.13 Namespaces......... . 98 3.14 Pointer Types......... 99 3.14.1Addressing and Dereferencing.... . 100 3.14.2Pointer-Based Call-By-Reference..... 100 3.15 Reference Declarations....... 102 3.16 The Uses of void......... 104 3.17 Arrays.......... . 105 3.17.1Subscripting....... . . . 106 3.17.2 Initialization....... . . . 106 3.18 Arrays and Pointers....... . . . 106 3.19 Passing Arrays to Functions....... 107 3.20 Problem Solving: Random Numbers.... . . . 108 3.21 Software Engineering: Structured Programming.. . . 111 3.22 Core Language ADT: char* String..... 114 3.23 Multidimensional Arrays...... . . . 117 3.24 Operators new and delete...... . 120 3.24.1 Vector Instead of Array..... . . . 123 3.24.2 String Instead of char*..... . . . 124 3.25 Software Engineering: Program Correctness.... 124 3.26 Dr. P’s Prescriptions....... . . 127 3.27 C++ Compared with Java...... . . . 128 Summary......... . . . 130 Review Questions........ 132 Exercises......... . . . 133 4 Classes and Abstract Data Types 139 4.1 The Aggregate Type class and struct.... . . . 140 4.2 Member Selection Operator...... . 141 4.3 Member Functions........ . . . 143 4.4 Access: Private and Public...... . . 146 4.5 Classes.......... 147 4.6 Class Scope......... . 150 4.6.1 Scope Resolution Operator..... 150 4.6.2 Nested Classes....... . 152 4.7 An Example: Flushing....... . 153 4.8 The this Pointer........ . 158 4.9 static Members......... 159 4.10 const Members......... . 161 4.10.1Mutable Members...... . . . 163 4.11 A Container Class Example: ch_stack..... 164 4.12 Software Engineering: Class Design.... . . . 166 4.12.1Trade-Offs in Design...... . 168 4.12.2Unified Modeling Language (UML) and Design. . . 169 4.13 Dr. P’s Prescriptions....... . . 170 4.14 C++ Compared with Java...... . . . 171 4.15 Advanced Topics........ . 172 4.15.1Pointer to Class Member..... . . 172 4.15.2Unions........ . . . 174 4.15.3Bit Fields........ . . 175 Summary......... . . . 177 Review Questions........ 178 Exercises......... . . . 179 5 Ctors, Dtors, Conversions, and Operator Overloading 183 5.1 Classes with Constructors...... . . 184 5.1.1 The Default Constructor..... . . 186 5.1.2 Constructor Initializer...... 187 5.1.3 Constructors as Conversions..... . . 187 5.1.4 Improving the point Class..... 189 5.1.5 Constructing a Stack...... . 190 5.1.6 The Copy Constructor...... 193 5.2 Classes with Destructors...... . . . 195 5.3 Members That Are Class Types..... . . 195 5.4 Example: A Singly Linked List..... . . . 196 5.5 Strings Using Reference Semantics.... . . . 201 5.6 Constructor Issues and Mysteries..... 204 5.6.1 Destructor Details...... . . . 205 5.6.2 Constructor Pragmatics...... . . 206 5.7 Polymorphism Using Function Overloading... . 206 5.8 ADT Conversions......... 207 5.9 Overloading and Signature Matching.... . . 208 5.10 Friend Functions........ . 211 5.11 Overloading Operators....... 213 5.12 Unary Operator Overloading...... 214 5.13 Binary Operator Overloading...... 217 5.14 Overloading the Assignment Operator.... . 219 5.15 Overloading the Subscript Operator..... . . 220 5.16 Overloading Operator () for Indexing.... 221 5.17 Overloading << and >>....... 222 5.18 Overloading ->........ . . 223 5.19 Overloading new and delete...... . . . 224 5.20 More Signature Matching....... . . 227 5.21 Software Engineering: When to Use Overloading.. . 228 5.22 Dr. P’s Prescriptions....... . . 229 5.23 C++ Compared with Java...... . . . 231 Summary......... . . . 235 Review Questions........ 236 Exercises......... . . . 237 6 Templates and Generic Programming 243 6.1 Template Class stack....... . 246 6.2 Function Templates....... . . . 248 6.2.1 Signature Matching and Overloading.... 250 6.2.2 How to Write a Simple Function: square().. . . . 252 6.3 Generic Code Development: Quicksort..... 253 6.3.1 Converting to a Generic quicksort()... . . . 256 6.4 Class Templates........ . 260 6.4.1 Friends........ . . . 260 6.4.2 Static Members....... . 260 6.4.3 Class Template Arguments..... 261 6.4.4 Default Template Arguments..... . . 261 6.4.5 Member Templates...... . . 262 6.5 Parameterizing the Class vector...... 262 6.6 Using STL: string, vector, and complex... . . 265 6.6.1 string and basic_string<>.... . . . 265 6.6.2 vector<> in STL....... 267 6.6.3 Using complex<>...... . . . 267 6.6.4 limits and Other Useful Templates.... . . 268 6.7 Software Engineering: Reuse and Generics.... . 269 6.7.1 Debugging Template Code..... 269 6.7.2 Special Considerations..... . . . 270 6.7.3 Using typename....... 271 6.8 Dr. P’s Prescriptions....... . . 272 6.9 C++ Compared with Java...... . . . 272 Summary......... . . . 276 Review Questions........ 277 Exercises......... . . . 278 7 Standard Template Library 280 7.1 A Simple STL Example....... . 280 7.2 Containers.......... . 283 7.2.1 Sequence Containers....... 285 7.2.2 Associative Containers..... . . . 288 7.2.3 Container Adaptors...... . . 293 7.3 Iterators......... . . . 296 7.3.1 Iterators for istream and ostream... . . . 297 7.3.2 Iterator Adaptors....... . . . 300 7.4 Algorithms......... . 302 7.4.1 Sorting Algorithms...... . . 302 7.4.2 Nonmutating Sequence Algorithms... . . 305 7.4.3 Mutating Sequence Algorithms.... . 307 7.4.4 Numerical Algorithms...... 310 7.5 Numerical Integration Made Easy..... . 311 7.6 STL: Function Objects....... . 315 7.6.1 Building a Function Object..... 317 7.6.2 Function Adaptors....... . . 318 7.7 Allocators......... . . 320 7.8 Software Engineering: STL Use...... . . 320 7.8.1 Syntax Bugs....... . . . 321 7.9 Dr. P’s Prescriptions....... . . 322 7.10 C++ Compared with Java...... . . . 323 Summary......... . . . 324 Review Questions........ 325 Exercises......... . . . 326 8 Inheritance and OOP 328 8.1 A Derived Class........ . . 329 8.1.1 More Unified Modeling Language (UML)... . . 333 8.2 A Student ISA Person....... . . 334 8.3 Virtual Functions: Dynamic Determination... . . 337 8.3.1 Overloading and Overriding Confusion.. . . . 340 8.3.2 A Canonical Example: Class shape... . . 342 8.4 Abstract Base Classes....... . 343 8.5 Templates and Inheritance....... . 350 8.6 Multiple Inheritance........ . . 351 8.7 RTTI and Other Fine Points...... . 353 8.7.1 Finer Points........ 354 8.8 Software Engineering: Inheritance and Design.. . . . 355 8.8.1 Subtyping Form........ 356 8.8.2 Code Reuse........ . . . 357 8.9 Dr. P’s Prescriptions....... . . 358 8.10 C++ Compared with Java...... . . . 358 Summary......... . . . 361 Review Questions........ 362 Exercises......... . . . 363 9 Input/Output 366 9.1 The Output Class ostream....... . 366 9.2 Formatted Output and iomanip..... . . 367 9.3 User-Defined Types: Output....... 372 9.4 The Input Class istream....... . . . 374 9.5 Files.......... . . 375 9.6 Using Strings as Streams...... . . . 379 9.7 The Functions and Macros in ctype.... . . . 380 9.8 Using Stream States........ . . 380 9.9 Mixing I/O Libraries........ . . 383 9.10 Software Engineering: I/O...... . . 384 9.11 Dr. P’s Prescriptions....... . . 386 9.12 C++ Compared with Java...... . . . 386 Summary......... . . . 389 Review Questions........ 390 Exercises......... . . . 391 10Exceptions and Program Correctness 394 10.1 Using the assert Library....... . . . 394 10.2 C++ Exceptions........ . . 397 10.3 Throwing Exceptions....... . . 398 10.3.1Rethrown Exceptions....... 400 10.3.2Exception Expressions..... . . . 401 10.4 try Blocks.......... . 404 10.5 Handlers......... . . . 405 10.6 Converting Assertions to Exceptions.... . . 405 10.7 Exception Specification....... 408 10.8 terminate() and unexpected()..... 409 10.9 Standard Exceptions and Their Uses.... . . 409 10.10 Software Engineering: Exception Objects... . . . 411 10.11 Dr. P’s Prescriptions....... . . 413 10.12 C++ Compared with Java...... . . . 414 Summary......... . . . 417 Review Questions........ 418 Exercises......... . . . 419 11OOP Using C++ 421 11.1 OOP Language Requirements...... . . . 422 11.1.1ADTs: Encapsulation and Data Hiding... 423 11.1.2Reuse and Inheritance...... 423 11.1.3Polymorphism........ . 424 11.2 OOP: The Dominant Programming Methodology.. . 425 11.3 Designing with OOP in Mind...... 432 11.4 Class-Responsibility-Collaborator...... 434 11.4.1CRC Cards......... 435 11.5 Design Patterns........ . . 436 11.6 A Further Assessment of C++..... . . . 437 11.6.1Why C++ Is Better Than Java.... . . . 438 11.6.2A Short Rebuttal....... 439 11.7 Software Engineering: Last Thoughts.... . . 439 11.8 Dr. P’s Prescriptions....... . . 440 11.9 C++ Compared with Java...... . . . 441 Summary......... . . . 447 Review Questions........ 448 Exercises......... . . . 449 AASCII Character Codes 451 B Operator Precedence and Associativity 453 C String Library 455 C.1 Constructors......... 456 C.2 Member Functions........ . . . 457 C.3 Global Operators........ . 460 DThe tio Library 462 D.1 Console.......... . . . 462 D.2 FormattedWriter........ . 463 D.3 PrintFileWriter........ . . . 472 D.4 ReadException......... . . 472 D.5 ReadInput......... . . 473 Index 482

Section I Concepts 1 Chapter 1 Complexity 3 1.1 The Structure of Complex Systems 4 1.2 The Inherent Complexity of Software 7 1.3 The Five Attributes of a Complex System 12 1.4 Organized and Disorganized Complexity 14 1.5 Bringing Order to Chaos 18 1.6 On Designing Complex Systems 24 Chapter 2 The Object Model 29 2.1 The Evolution of the Object Model 29 2.2 Foundations of the Object Model 37 2.3 Elements of the Object Model 43 2.4 Applying the Object Model 71 Chapter 3 Classes and Objects 75 3.1 The Nature of an Object 75 3.2 Relationships among Objects 88 3.3 The Nature of a Class 92 3.4 Relationships among Classes 96 3.5 The Interplay of Classes and Objects 111 3.6 On Building Quality Classes and Objects 112 Chapter 4 Classification 121 4.1 The Importance of Proper Classification 121 4.2 Identifying Classes and Objects 126 4.3 Key Abstractions and Mechanisms 138 Section II Method 145 Chapter 5 Notation 147 5.1 The Unified Modeling Language 147 5.2 Package Diagrams 155 5.3 Component Diagrams 163 5.4 Deployment Diagrams 171 5.5 Use Case Diagrams 175 5.6 Activity Diagrams 185 5.7 Class Diagrams 192 5.8 Sequence Diagrams 206 5.9 Interaction Overview Diagrams 213 5.10 Composite Structure Diagrams 215 5.11 State Machine Diagrams 218 5.12 Timing Diagrams 231 5.13 Object Diagrams 235 5.14 Communication Diagrams 238 Chapter 6 Process 247 6.1 First Principles 248 6.2 The Macro Process: The Software Development Lifecycle 256 6.3 The Micro Process: The Analysis and Design Process 272 Chapter 7 Pragmatics 303 7.1 Management and Planning 304 7.2 Staffing 308 7.3 Release Management 312 7.4 Reuse 314 7.5 Quality Assurance and Metrics 316 7.6 Documentation 320 7.7 Tools 322 7.8 Special Topics 324 7.9 The Benefits and Risks of Object-Oriented Development 326 Section III Applications 331 Chapter 8 System Architecture: Satellite-Based Navigation 333 8.1 Inception 334 8.2 Elaboration 347 8.3 Construction 370 8.4 Post-Transition 371 Chapter 9 Control System: Traffic Management 375 9.1 Inception 376 9.2 Elaboration 385 9.3 Construction 396 9.4 Post-Transition 411 Chapter 10 Artificial Intelligence: Cryptanalysis 413 10.1 Inception 414 10.2 Elaboration 421 10.3 Construction 427 10.4 Post-Transition 446 Chapter 11 Data Acquisition: Weather Monitoring Station 449 11.1 Inception 450 11.2 Elaboration 463 11.3 Construction 474 11.4 Post-Transition 487 Chapter 12 Web Application: Vacation Tracking System 489 12.1 Inception 490 12.2 Elaboration 494 12.3 Construction 506 12.4 Transition and Post-Transition 534 Appendix A Object-Oriented Programming Languages 537 A.1 Language Evolution 537 A.2 Smalltalk 541 A.3 C++ 546 A.4 Java 551 Appendix B Further Reading 557 Notes 567

Table of Contents Copyright Praise for C++ Common Knowledge Preface Acknowledgments A Note on Typographical Conventions Item 1. Data Abstraction Item 2. Polymorphism Item 3. Design Patterns Item 4. The Standard Template Library Item 5. References Are Aliases, Not Pointers Item 6. Array Formal Arguments Item 7. Const Pointers and Pointers to Const Item 8. Pointers to Pointers Item 9. New Cast Operators Item 10. Meaning of a Const Member Function Item 11. The Compiler Puts Stuff in Classes Item 12. Assignment and Initialization Are Different Item 13. Copy Operations Item 14. Function Pointers Item 15. Pointers to Class Members Are Not Pointers Item 16. Pointers to Member Functions Are Not Pointers Item 17. Dealing with Function and Array Declarators Item 18. Function Objects Item 19. Commands and Hollywood Item 20. STL Function Objects Item 21. Overloading and Overriding Are Different Item 22. Template Method Item 23. Namespaces Item 24. Member Function Lookup Item 25. Argument Dependent Lookup Item 26. Operator Function Lookup Item 27. Capability Queries Item 28. Meaning of Pointer Comparison Item 29. Virtual Constructors and Prototype Item 30. Factory Method Item 31. Covariant Return Types Item 32. Preventing Copying Item 33. Manufacturing Abstract Bases Item 34. Restricting Heap Allocation Item 35. Placement New Item 36. Class-Specific Memory Management Item 37. Array Allocation Item 38. Exception Safety Axioms Axiom 1: Exceptions Are Synchronous Axiom 2: It's Safe to Destroy Axiom 3: Swap Doesn't Throw Item 39. Exception Safe Functions Item 40. RAII Item 41. New, Constructors, and Exceptions Item 42. Smart Pointers Item 43. auto_ptr Is Unusual Item 44. Pointer Arithmetic Item 45. Template Terminology Item 46. Class Template Explicit Specialization Item 47. Template Partial Specialization Item 48. Class Template Member Specialization Item 49. Disambiguating with Typename Item 50. Member Templates Item 51. Disambiguating with Template Item 52. Specializing for Type Information Item 53. Embedded Type Information Item 54. Traits Item 55. Template Template Parameters Item 56. Policies Item 57. Template Argument Deduction Item 58. Overloading Function Templates Item 59. SFINAE Item 60. Generic Algorithms Item 61. You Instantiate What You Use Item 62. Include Guards Item 63. Optional Keywords Bibliography Index Index of Code Examples

Introduction ...............................xxxiii<br>Part I: Linux First Steps<br>Chapter 1: Starting with Linux..........................3<br>Chapter 2: Running Commands from the Shell ...................35<br>Chapter 3: Getting into the Desktop .......................81<br>Part II: Running the Show<br>Chapter 4: Learning Basic Administration ......................131<br>Chapter 5: Getting on the Internet .........................179<br>Chapter 6: Securing Linux ............................203<br>Part III: Choosing and Installing a Linux Distribution<br>Chapter 7: Installing Linux ..........................253<br>Chapter 8: Running Fedora and Red Hat Enterprise Linux................283<br>Chapter 9: Running Debian GNU/Linux .....................303<br>Chapter 10: Running SUSE and openSUSE Linux ...................327<br>Chapter 11: Running KNOPPIX..........................343<br>Chapter 12: Running Yellow Dog Linux .......................365<br>Chapter 13: Running Gentoo Linux .......................383<br>Chapter 14: Running Slackware Linux ......................403<br>Chapter 15: Running Linspire and Freespire .....................419<br>Chapter 16: Running Mandriva ..........................435<br>Chapter 17: Running Ubuntu Linux ........................449<br>Chapter 18: Running a Linux Firewall/Router ...................467<br>Chapter 19: Running Bootable Linux Distributions .................493<br>Part IV: Running Applications<br>Chapter 20: Playing Music and Video ......................513<br>Chapter 21: Working with Words and Images ...................549<br>Chapter 22: E-Mailing and Web Browsing ......................589<br>Chapter 23: Gaming with Linux..........................623<br>Part V: Running Servers<br>Chapter 24: Running a Linux, Apache, MySQL, and PHP (LAMP) Server ..........649<br>Chapter 25: Running a Mail Server .......................671<br>Chapter 26: Running a Print Server .......................689<br>Chapter 27: Running a File Server .........................713<br>Part VI: Programming in Linux<br>Chapter 28: Programming Environments and Interfaces ...............749<br>Chapter 29: Programming Tools and Utilities.....................779<br>Appendix A: Media .............................809<br>Appendix B: Entering the Linux Community .....................819<br>Index ...................................825

■CHAPTER 1 Introducing Subversion . . . . . . . . . . . 1 ■CHAPTER 2 A Crash Course in Subversion . . . . . . . . . . 13 ■CHAPTER 3 Repository Administration. . . . . . . . . . . 61 ■CHAPTER 4 Migrating from Other Version Control Systems. . . . . . 91 ■CHAPTER 5 Advanced Apache Integration . . . . . . . . . 109 ■CHAPTER 6 Best Practices . . . . . . . . . . . . 127 ■CHAPTER 7 Integrating Subversion with Other Tools . . . . . . . . 151 ■CHAPTER 8 Using the Subversion APIs . . . . . . . . . 167 ■APPENDIX A Subversion Command Glossary . . . . . . . . . . 229 ■APPENDIX B Subversion Compared to Other Version Control Systems. . . . . . . . . . . . . . . 263 ■INDEX . . . . . . . . . . . . . . . . . . . . 269

About the Author . . . . . . . . . . . . . . . . . xxiii About the Technical Reviewer . . . . . . . . . . . . .xxv Acknowledgments. . . . . . . . . . . . . . . . xxvii Introduction . . . . . . . . . . . . . . . . . . xxix ■CHAPTER 1 C# and the .NET Framework . . . . . . . . . . . 1 ■CHAPTER 2 Overview of C# Programming . . . . . . . . . 15 ■CHAPTER 3 Types, Storage, and Variables . . . . . . . . 31 ■CHAPTER 4 Classes: The Basics . . . . . . . . . . . . 45 ■CHAPTER 5 Methods. . . . . . . . . . . . . . 65 ■CHAPTER 6 More About Classes . . . . . . . . . . . 101 ■CHAPTER 7 Classes and Inheritance . . . . . . . . . . 155 ■CHAPTER 8 Expressions and Operators . . . . . . . . . . 193 ■CHAPTER 9 Statements . . . . . . . . . . . . . 229 ■CHAPTER 10 Namespaces and Assemblies . . . . . . . . 259 ■CHAPTER 11 Exceptions . . . . . . . . . . . . . 285 ■CHAPTER 12 Structs . . . . . . . . . . . . . . 303 ■CHAPTER 13 Enumerations. . . . . . . . . . . . . . 313 ■CHAPTER 14 Arrays. . . . . . . . . . . . . . . 327 ■CHAPTER 15 Delegates . . . . . . . . . . . . . . 355 ■CHAPTER 16 Events . . . . . . . . . . . . . . 379 ■CHAPTER 17 Interfaces . . . . . . . . . . . . . . 397 ■CHAPTER 18 Conversions . . . . . . . . . . . . 423 ■CHAPTER 19 Generics . . . . . . . . . . . . . . . 453 ■CHAPTER 20 Enumerators and Iterators . . . . . . . . . . . 483 ■CHAPTER 21 Introduction to LINQ . . . . . . . . . . . 515 ■CHAPTER 22 Introduction to Asynchronous Programming . . . . . . 573 ■CHAPTER 23 Preprocessor Directives . . . . . . . . . . 593 ■CHAPTER 24 Reflection and Attributes . . . . . . . . . 605 ■CHAPTER 25 Other Topics . . . . . . . . . . . . 631 ■INDEX . . . . . . . . . . . . . . . . . . . . 657

Preface xv Acknowledgments xvii CHAPTER 1 Introduction 1 PART ONE Service-Oriented Life Cycle 29 CHAPTER 2 Service-Oriented Life Cycle Model 31 CHAPTER 3 Service-Oriented Life Cycle Perspectives 49 PART TWO Service-Oriented Conceptualization 69 CHAPTER 4 Attribution Analysis 75 CHAPTER 5 Conceptual Service Identification 87 PART THREE Service-Oriented Discovery and Analysis 111 CHAPTER 6 Service-Oriented Typing and Profiling Model 115 CHAPTER 7 Service-Oriented Discovery and Analysis: CHAPTER 8 Service-Oriented Analysis Modeling 155 PART FOUR Service-Oriented Business Integration 169 CHAPTER 9 Business Architecture Contextual Perspectives 177 CHAPTER 10 Business Architecture Structural Perspectives 191 CHAPTER 11 Service-Oriented Business Integration Modeling 211 PART FIVE Service-Oriented Design Model 229 CHAPTER 12 Service-Oriented Logical Design Relationship 233 CHAPTER 13 Service-Oriented Logical Design Composition 257 CHAPTER 14 Service-Oriented Transaction Model 283 PART SIX Service-Oriented Software Architecture CHAPTER 15 Service-Oriented Conceptual Architecture Modeling CHAPTER 16 Service-Oriented Logical Architecture Principles 341 Index 359

Section 1: Service-Oriented Architecture (SOA) Strategy 1 Introduction to Strategy..............3 Section 2: Service-Oriented Architecture (SOA) Methodology 2 Introduction to Program Management Methodology.......27 3 Deployment and Expansion of Web Services Based on SOA......61 4 Deployment of Services, Integration of Process and Services Architecture, and Restructuring of Organizations and Staff......97 5 Deployment and Exploitation of Services Based on SOE.....157 6 Conclusion................171 Section 3: Service-Oriented Architecture (SOA) Technology 7 Introduction to Service Technology............183 8 Service Technology Firms, Technologies, and Tools.......193 9 Conclusion................229 10 Service Terminology................233

The objective of this book is to introduce assembly language programming. Assembly language is very closely linked to the underlying processor architecture and design. Popular processor designs can be broadly divided into two categories: Complex Instruction Set Computers (CISC) and Reduced Instruction Set Computers (RISC). The dominant processor in the PC market, Pentium, belongs to the CISC category. However, the recent design trend is to use the RISC designs. Some example RISC processors include the MIPS, SPARC, PowerPC, and ARM. Even Intel’s 64-bit processor Itanium is a RISC processor. Thus, both types of processors are important candidates for our study. This book covers assembly language programming of both CISC and RISC processors. We use the Intel Pentium processor as the representative of the CISC category. We have selected the Pentium processor because of its market dominance. To explore RISC assembly language, we selected the MIPS processor. The MIPS processor is appealing as it closely adheres to the RISC principles. Furthermore, the availability of the SPIM simulator allows us to use a Pentium-based PC to learn MIPS assembly language. New in the Second Edition The second edition has been substantially revised to reflect the changes that have taken place since the publication of the first edition. The major changes are listed below: . We introduced RISC assembly language programming so that the reader can benefit from learning both CISC and RISC assembly languages. As mentioned before, Pentium and MIPS processors are used to cover CISC and RISC processors. . The first edition used MASM/TASM assemblers. In this edition, we use the NASM assembler. The syntax of NASM is slightly different from that of MASM/TASM assemblers. The advantage is that NASM is free! Another advantage is that it works with both MicrosoftWindows and Linux operating systems. . Consistent with our shift to NASM, we moved away from DOS to Linux. Since NASM is available for Windows a

Chapter 1: Starting with Fedora Linux . . . . . . . 1 Chapter 2: Installing Fedora and Adding Software . . . . .13 Chapter 3: Using the Shell . . . . . . . . . 33 Chapter 4: Working with Files . . . . . . . . .51 Chapter 5: Manipulating Text . . . . . . . . . .71 Chapter 6: Playing with Multimedia . . . . . . . 89 Chapter 7: Administering File Systems . . . . . . 103 Chapter 8: Backups and Removable Media . . . . . 131 Chapter 9: Checking and Managing Running Processes . . 147 Chapter 10: Managing the System . . . . . . . 165 Chapter 11: Managing Network Connections . . . . .187 Chapter 12: Accessing Network Resources . . . . . 209 Chapter 13: Doing Remote System Administration . . . 229 Chapter 14: Locking Down Security . . . . . . . .247 Appendix A: Using vi or Vim Editors . . . . . . . .263 Appendix B: Shell Special Characters and Variables . . . .271 Appendix C: Getting Information from /proc . . . . . .275 Index . . . . . . . . . . . . . . 281

Part I: Python Programming Chapter 1. Data Types and Data Structures Chapter 2. Control Structures Chapter 3. Classes and Modules Part II: Basic GUI Programming Chapter 4. Introduction to GUI Programming Chapter 5. Dialogs Chapter 6. Main Windows Chapter 7. Using Qt Designer Chapter 8. Data Handling and Custom File Formats Part III: Intermediate GUI Programming Chapter 9. Layouts and Multiple Documents Chapter 10. Events, the Clipboard, and Drag and Drop Chapter 11. Custom Widgets Chapter 12. Item-Based Graphics Chapter 13. Rich Text and Printing Chapter 14. Model/View Programming . Chapter 15. Databases Part IV: Advanced GUI Programming Chapter 16. Advanced Model/View Programming Chapter 17. Online Help and Internationalization Chapter 18. Networking Chapter 19. Multithreading Appendix A. Installing Appendix B. Selected PyQt Widgets Appendix C. Selected PyQt Class Hierarchies

Beyond the C++ Standard Library: An Introduction to Boost <br>By Björn Karlsson <br>............................................... <br>Publisher: Addison Wesley Professional <br>Pub Date: August 31, 2005 <br>ISBN: 0321133544 <br>Pages: 432 <br><br><br><br> Introduction to Boost <br> String and Text Processing <br> Data Structures, Containers, Iterators, and Algorithms <br> Function Objects and Higher-Order Programming <br> Generic Programming and Template Metaprogramming <br> Math and Numerics <br> Input/Output <br> Miscellaneous <br> Part I. General Libraries <br> Library 1. Smart_ptr <br> How Does the Smart_ptr Library Improve Your Programs? <br> When Do We Need Smart Pointers? <br> How Does Smart_ptr Fit with the Standard Library? <br> scoped_ptr <br> scoped_array <br> shared_ptr <br> shared_array <br> intrusive_ptr <br> weak_ptr <br> Smart_ptr Summary <br> Endnotes <br> Library 2. Conversion <br> How Does the Conversion Library Improve Your Programs? <br> polymorphic_cast <br> polymorphic_downcast <br> numeric_cast <br> lexical_cast <br> Conversion Summary <br> Library 3. Utility <br> How Does the Utility Library Improve Your Programs? <br> BOOST_STATIC_ASSERT <br> checked_delete <br> noncopyable <br> addressof <br> enable_if <br> Utility Summary <br> Library 4. Operators <br> How Does the Operators Library Improve Your Programs? <br> Operators <br> Usage <br> Operators Summary <br> Library 5. Regex <br> How Does the Regex Library Improve Your Programs? <br> How Does Regex Fit with the Standard Library? <br> Regex <br> Usage <br> Regex Summary <br> Part II. Containers and Data Structures <br> Library 6. Any <br> How Does the Any Library Improve Your Programs? <br> How Does Any Fit with the Standard Library? <br> Any <br> Usage <br> Any Summary <br> Library 7. Variant <br> How Does the Variant Library Improve Your Programs? <br> How Does Variant Fit with the Standard Library? <br> Variant <br> Usage <br> Variant Summary <br> Library 8. Tuple <br> How Does the Tuple Library Improve Your Programs? <br> How Does the Tuple Library Fit with the Standard Library? <br> Tuple <br> Usage <br> Tuple Summary <br> Part III. Function Objects and Higher-Order Programming <br> Library 9. Bind <br> How Does the Bind Library Improve Your Programs? <br> How Does Bind Fit with the Standard Library? <br> Bind <br> Usage <br> Bind Summary <br> Library 10. Lambda <br> How Does the Lambda Library Improve Your Programs? <br> How Does Lambda Fit with the Standard Library? <br> Lambda <br> Usage <br> Lambda Summary <br> Library 11. Function <br> How Does the Function Library Improve Your Programs? <br> How Does Function Fit with the Standard Library? <br> Function <br> Usage <br> Function Summary <br> Library 12. Signals <br> How Does the Signals Library Improve Your Programs? <br> How Does Signals Fit with the Standard Library? <br> Signals <br> Usage <br> Signals Summary <br> Endnotes <br>

Part I Introduction 1 Introduction to Linux 3 2 Getting Started 17 Part II The Linux Shell and File Structure 3 The Shell 35 4 The Shell Scripts and Programming 65 5 Shell Confi guration 89 6 Linux Files, Directories, and Archives 115 Part III Desktop 7 The X Window System, Xorg, and Display Managers 145 8 GNOME 169 9 KDE 197 Part IV Linux Software 10 Software Management 219 11 Offi ce and Database Applications 237 12 Graphics Tools and Multimedia 255 13 Mail and News Clients 265 14 Web, FTP, and Java Clients 281 15 Network Tools 301 Part V Security 16 Encryption, Integrity Checks, and Signatures 313 17 Security-Enhanced Linux 327 18 IPsec and Virtual Private Networks 349 19 Secure Shell and Kerberos 359 20 Firewalls 373 Part VI Internet and Network Services 21 Managing Services 401 22 FTP Servers 423 23 Web Servers 443 24 Proxy Servers 467 25 Mail Servers 477 26 Print, News, Search, and Database Servers 503 Part VII System Administration 27 Basic System Administration 523 28 Managing Users 551 29 File Systems 583 30 RAID and LVM 615 31 Devices and Modules 639 32 Kernel Administration 671 33 Backup Management 693 Part VIII Network Administration Services 34 Administering TCP/IP Networks 707 35 Network Autoconfi guration with IPv6, DHCPv6, and DHCP 745 36 NFS and NIS 761 37 Distributed Network File Systems 777 A Where to Obtain Linux Distributions 785 Index 787

Linux Application Development, Second Edition By Michael K. Johnson, Erik W. Troan ............................................... Publisher: Addison Wesley Professional Pub Date: November 17, 2004 Print ISBN-10: 0-321-21914-7 Print ISBN-13: 978-0-321-21914-5 Pages: 736 Part 1: Getting Started Chapter 1. History of Linux Development Section 1.1. A Short History of Free Unix Software Section 1.2. Development of Linux Section 1.3. Notional Lineage of Unix Systems Section 1.4. Linux Lineage Chapter 2. Licenses and Copyright Section 2.1. Copyright Section 2.2. Licensing Section 2.3. Free Software Licenses Chapter 3. Online System Documentation Section 3.1. The man Pages Section 3.2. The Info Pages Section 3.3. Other Documentation Part 2: Development Tools and Environment Chapter 4. Development Tools Section 4.1. Editors Section 4.2. Make Section 4.3. The GNU Debugger Section 4.4. Tracing Program Actions Chapter 5. gcc Options and Extensions Section 5.1. gcc Options Section 5.2. Header Files Chapter 6. The GNU C Library Section 6.1. Feature Selection Section 6.2. POSIX Interfaces Section 6.3. Compatibility Chapter 7. Memory Debugging Tools Section 7.1. Buggy Code Section 7.2. Memory-Checking Tools Included in glibc Section 7.3. Finding Memory Leaks with mpr Section 7.4. Investigating Memory Errors with Valgrind Section 7.5. Electric Fence Chapter 8. Creating and Using Libraries Section 8.1. Static Libraries Section 8.2. Shared Libraries Section 8.3. Designing Shared Libraries Section 8.4. Building Shared Libraries Section 8.5. Installing Shared Libraries Section 8.6. Using Shared Libraries Chapter 9. Linux System Environment Section 9.1. The Process Environment Section 9.2. Understanding System Calls Section 9.3. Finding Header and Library Files Part 3: System Programming Chapter 10. The Process Model Section 10.1. Defining a Process Section 10.2. Process Attributes Section 10.3. Process Information Section 10.4. Process Primitives Section 10.5. Simple Children Section 10.6. Sessions and Process Groups Section 10.7. Introduction to ladsh Section 10.8. Creating Clones Chapter 11. Simple File Handling Section 11.1. The File Mode Section 11.2. Basic File Operations Section 11.3. Querying and Changing Inode Information Section 11.4. Manipulating Directory Entries Section 11.5. Manipulating File Descriptors Section 11.6. Creating Unnamed Pipes Section 11.7. Adding Redirection to ladsh Chapter 12. Signal Processing Section 12.1. Signal Concepts Section 12.2. The Linux (and POSIX) Signal API Section 12.3. Available Signals Section 12.4. Writing Signal Handlers Section 12.5. Reopening Log Files Section 12.6. Real-Time Signals Section 12.7. Learning About a Signal Chapter 13. Advanced File Handling Section 13.1. Input and Output Multiplexing Section 13.2. Memory Mapping Section 13.3. File Locking Section 13.4. Alternatives to read() and write() Chapter 14. Directory Operations Section 14.1. The Current Working Directory Section 14.2. Changing the Root Directory Section 14.3. Creating and Removing Directories Section 14.4. Reading a Directory's Contents Section 14.5. File Name Globbing Section 14.6. Adding Directories and Globbing to ladsh Section 14.7. Walking File System Trees Section 14.8. Directory Change Notification Chapter 15. Job Control Section 15.1. Job Control Basics Section 15.2. Job Control in ladsh Chapter 16. Terminals and Pseudo Terminals Section 16.1. tty Operations Section 16.2. termios Overview Section 16.3. termios Examples Section 16.4. termios Debugging Section 16.5. termios Reference Section 16.6. Pseudo ttys Chapter 17. Networking with Sockets Section 17.1. Protocol Support Section 17.2. Utility Functions Section 17.3. Basic Socket Operations Section 17.4. Unix Domain Sockets Section 17.5. Networking Machines with TCP/IP Section 17.6. Using UDP Datagrams Section 17.7. Socket Errors Section 17.8. Legacy Networking Functions Chapter 18. Time Section 18.1. Telling Time and Dates Section 18.2. Using Timers Chapter 19. Random Numbers Section 19.1. Pseudo-Random Numbers Section 19.2. Cryptography and Random Numbers Chapter 20. Programming Virtual Consoles Section 20.1. Getting Started Section 20.2. Beeping Section 20.3. Determining Whether the Terminal Is a VC Section 20.4. Finding the Current VC Section 20.5. Managing VC Switching Section 20.6. Example: The open Command Chapter 21. The Linux Console Section 21.1. Capability Databases Section 21.2. Glyphs, Characters, and Maps Section 21.3. Linux Console Capabilities Section 21.4. Direct Screen Writing Chapter 22. Writing Secure Programs Section 22.1. When Security Matters Section 22.2. Minimizing the Opportunity for Attack Section 22.3. Common Security Holes Section 22.4. Running as a Daemon Part 4: Development Libraries Chapter 23. String Matching Section 23.1. Globbing Arbitrary Strings Section 23.2. Regular Expressions Chapter 24. Terminal Handling with S-Lang Section 24.1. Input Handling Section 24.2. Output Handling Chapter 25. A Hashed Database Library Section 25.1. Overview Section 25.2. Basic Operations Section 25.3. Reading Records Section 25.4. Modifying the Database Section 25.5. Example Chapter 26. Parsing Command-Line Options Section 26.1. The Option Table Section 26.2. Using the Option Table Section 26.3. Using Callbacks Section 26.4. Error Handling Section 26.5. Option Aliasing Section 26.6. Parsing Argument Strings Section 26.7. Handling Extra Arguments Section 26.8. Sample Application Chapter 27. Dynamic Loading at Run Time Section 27.1. The dl Interface Chapter 28. User Identification and Authentication Section 28.1. ID-to-Name Translation Section 28.2. Pluggable Authentication Modules Appendices Appendix A. Header Files Appendix B. ladsh Source Code

The Definitive Guide to GCC, Second Edition Copyright ? 2006 by William von Hagen ISBN-13 (pbk): 978-1-59059-585-5 ISBN-10 (pbk): 1-59059-585-8 ■CHAPTER 1 Using GCC’s C Compiler ■CHAPTER 2 Using GCC’s C++ Compiler ■CHAPTER 3 Using GCC’s Fortran Compiler- ■CHAPTER 4 Using GCC’s Java Compiler ■CHAPTER 5 Optimizing Code with GCC ■CHAPTER 6 Analyzing Code Produced with GCC Compilers ■CHAPTER 7 Using Autoconf and Automake ■CHAPTER 8 Using Libtool ■CHAPTER 9 Troubleshooting GCC ■CHAPTER 10 Additional GCC and Related Topic Resources ■CHAPTER 11 Compiling GCC ■CHAPTER 12 Building and Installing Glibc ■CHAPTER 13 Using Alternate C Libraries ■CHAPTER 14 Building and Using C Cross-Compilers ■APPENDIX A Using GCC Compilers ■APPENDIX B Machine- and Processor-Specific Options for GCC ■APPENDIX C Using GCC’s Online Help

Copyright ? 2007 by Andrew Troelsen ISBN-13: 978-1-59059-884-9 ISBN-10: 1-59059-884-9 Part 1 Introducing C# and the .NET Platform CHAPTER 1 The Philosophy of .NET CHAPTER 2 Building C# Applications Part 2 Core C# Programming Constructs CHAPTER 3 Core C# Programming Constructs, Part I CHAPTER 4 Core C# Programming Constructs, Part II . CHAPTER 5 Defining Encapsulated Class Types CHAPTER 6 Understanding Inheritance and Polymorphism CHAPTER 7 Understanding Structured Exception Handling. CHAPTER 8 Understanding Object Lifetime Part 3 Advanced C# Programming Constructs CHAPTER 9 Working with Interfaces . CHAPTER 10 Collections and Generics CHAPTER 11 Delegates, Events, and Lambdas CHAPTER 12 Indexers, Operators, and Pointers CHAPTER 13 C# 2008 Language Features CHAPTER 14 An Introduction to LINQ. PART 4 Programming with .NET Assemblies CHAPTER 15 Introducing .NET Assemblies CHAPTER 16 Type Reflection, Late Binding, and Attribute-Based Programming. CHAPTER 17 Processes, AppDomains, and Object Contexts CHAPTER 18 Building Multithreaded Applications CHAPTER 19 Understanding CIL and the Role of Dynamic Assemblies Part 5 Introducing the .NET Base Class Libraries CHAPTER 20 File I/O and Isolated Storage CHAPTER 21 Introducing Object Serialization CHAPTER 22 ADO.NET Part I: The Connected Layer. CHAPTER 23 ADO.NET Part II: The Disconnected Layer CHAPTER 24 Programming with the LINQ APIs CHAPTER 25 Introducing Windows Communication Foundation CHAPTER 26 Introducing Windows Workflow Foundation Part 6 Desktop User Interfaces CHAPTER 27 Programming with Windows Forms CHAPTER 28 Introducing Windows Presentation Foundation and XAML CHAPTER 29 Programming with WPF Controls CHAPTER 30 WPF 2D Graphical Rendering, Resources, and Themes Part 7 Building Web Applications with ASP.NET CHAPTER 31 Building ASP.NET Web Pages CHAPTER 32 ASP.NET Web Controls, Themes, and Master Pages CHAPTER 33 ASP.NET State Management Techniques Part 8 Appendixes APPENDIX A COM and .NET Interoperability APPENDIX B Platform-Independent .NET Development with Mono