Learn to develop iPhone and iPad applications for networked enterprise environments
The iPhone and iPad have made a powerful impact on the business world. Developers creating iOS apps for the enterprise face unique challenges involving networking, system integration, security, and device management. This Wrox guide provides everything you need to know to write iOS apps that integrate with enterprise network resources, providing options for networking iOS devices to enterprise systems and to each other.
Offers a complete compendium of methods and techniques for networked communication between iOS applications and other platforms and devices
Includes instruction on incorporating synchronous and asynchronous HTTP requests, security, communication issues, and more
Covers payload handling, network security, GameKit and Bonjour communications, and low-level network communications
Professional iOS Network Programming focuses on the networking aspects of iOS and its relationship to remote data sources, offering a truly unique approach.
Copyright
Praise for Effective C++, Third Edition
Addison-Wesley Professional Computing Series
Preface
Acknowledgments
Introduction
Terminology
Chapter 1. Accustoming Yourself to C++
Item 1: View C++ as a federation of languages
Item 2: Prefer consts, enums, and inlines to #defines
Item 3: Use const whenever possible
Item 4: Make sure that objects are initialized before they're used
Chapter 2. Constructors, Destructors, and Assignment Operators
Item 5: Know what functions C++ silently writes and calls
Item 6: Explicitly disallow the use of compiler-generated functions you do not want
Item 7: Declare destructors virtual in polymorphic base classes
Item 8: Prevent exceptions from leaving destructors
Item 9: Never call virtual functions during construction or destruction
Item 10: Have assignment operators return a reference to *this
Item 11: Handle assignment to self in operator=
Item 12: Copy all parts of an object
Chapter 3. Resource Management
Item 13: Use objects to manage resources.
Item 14: Think carefully about copying behavior in resource-managing classes.
Item 15: Provide access to raw resources in resource-managing classes.
Item 16: Use the same form in corresponding uses of new and delete.
Item 17: Store newed objects in smart pointers in standalone statements.
Chapter 4. Designs and Declarations
Item 18: Make interfaces easy to use correctly and hard to use incorrectly
Item 19: Treat class design as type design
Item 20: Prefer pass-by-reference-to-const to pass-by-value
Item 21: Don't try to return a reference when you must return an object
Item 22: Declare data members private
Item 23: Prefer non-member non-friend functions to member functions
Item 24: Declare non-member functions when type conversions should apply to all parameters
Item 25: Consider support for a non-throwing swap
Chapter 5. Implementations
Item 26: Postpone variable definitions as long as possible.
Item 27: Minimize casting.
Item 28: Avoid returning "handles" to object internals.
Item29: Strive for exception-safe code.
Item 30: Understand the ins and outs of inlining.
Item31: Minimize compilation dependencies between files.
Chapter 6. Inheritance and Object-Oriented Design
Item 32: Make sure public inheritance models "is-a."
Item 33: Avoid hiding inherited names
Item 34: Differentiate between inheritance of interface and inheritance of implementation
Item 35: Consider alternatives to virtual functions
Item 36: Never redefine an inherited non-virtual function
Item 37: Never redefine a function's inherited default parameter value
Item 38: Model "has-a" or "is-implemented-in-terms-of" through composition
Item 39: Use private inheritance judiciously
Item 40: Use multiple inheritance judiciously
Chapter 7. Templates and Generic Programming
Item 41: Understand implicit interfaces and compile-time polymorphism
Item 42: Understand the two meanings of typename
Item 43: Know how to access names in templatized base classes
Item 44: Factor parameter-independent code out of templates
Item 45: Use member function templates to accept "all compatible types."
Item 46: Define non-member functions inside templates when type conversions are desired
Item 47: Use traits classes for information about types
Item 48: Be aware of template metaprogramming
Chapter 8. Customizing new and delete
Item 49: Understand the behavior of the new-handler
Item 50: Understand when it makes sense to replace new and delete
Item 51: Adhere to convention when writing new and delete
Item 52: Write placement delete if you write placement new
Chapter 9. Miscellany
Item 53: Pay attention to compiler warnings.
Item 54: Familiarize yourself with the standard library, including TR1
Item.55: Familiarize yourself with Boost.
Appendix A. Beyond Effective C++
Appendix B. Item Mappings Between Second and Third Editions
Copyright
Addison-Wesley Professional Computing Series
List of Figures
List of Tables
List of Examples
Preface
Who Should Read This Book
How to Use This Book
Related References
Conventions Used in This Book
Our Case Studies
Author's Acknowledgements
Part I: Context
Chapter 1. Philosophy: Philosophy Matters
Section 1.1. Culture? What Culture?
Section 1.2. The Durability of Unix
Section 1.3. The Case against Learning Unix Culture
Section 1.4. What Unix Gets Wrong
Section 1.5. What Unix Gets Right
Section 1.6. Basics of the Unix Philosophy
Section 1.7. The Unix Philosophy in One Lesson
Section 1.8. Applying the Unix Philosophy
Section 1.9. Attitude Matters Too
Chapter 2. History: A Tale of Two Cultures
Section 2.1. Origins and History of Unix, 1969–1995
Section 2.2. Origins and History of the Hackers, 1961–1995
Section 2.3. The Open-Source Movement: 1998 and Onward
Section 2.4. The Lessons of Unix History
Chapter 3. Contrasts: Comparing the Unix Philosophy with Others
Section 3.1. The Elements of Operating-System Style
Section 3.2. Operating-System Comparisons
Section 3.3. What Goes Around, Comes Around
Part II: Design
Chapter 4. Modularity: Keeping It Clean, Keeping It Simple
Section 4.1. Encapsulation and Optimal Module Size
Section 4.2. Compactness and Orthogonality
Section 4.3. Software Is a Many-Layered Thing
Section 4.4. Libraries
Section 4.5. Unix and Object-Oriented Languages
Section 4.6. Coding for Modularity
Chapter 5. Textuality: Good Protocols Make Good Practice
Section 5.1. The Importance of Being Textual
Section 5.2. Data File Metaformats
Section 5.3. Application Protocol Design
Section 5.4. Application Protocol Metaformats
Chapter 6. Transparency: Let There Be Light
Section 6.1. Studying Cases
Section 6.2. Designing for Transparency and Discoverability
Section 6.3. Designing for Maintainability
Chapter 7. Multiprogramming: Separating Processes to Separate Function
Section 7.1. Separating Complexity Control from Performance Tuning
Section 7.2. Taxonomy of Unix IPC Methods
Section 7.3. Problems and Methods to Avoid
Section 7.4. Process Partitioning at the Design Level
Chapter 8. Minilanguages: Finding a Notation That Sings
Section 8.1. Understanding the Taxonomy of Languages
Section 8.2. Applying Minilanguages
Section 8.3. Designing Minilanguages
Chapter 9. Generation: Pushing the Specification Level Upwards
Section 9.1. Data-Driven Programming
Section 9.2. Ad-hoc Code Generation
Chapter 10. Configuration: Starting on the Right Foot
Section 10.1. What Should Be Configurable?
Section 10.2. Where Configurations Live
Section 10.3. Run-Control Files
Section 10.4. Environment Variables
Section 10.5. Command-Line Options
Section 10.6. How to Choose among the Methods
Section 10.7. On Breaking These Rules
Chapter 11. Interfaces: User-Interface Design Patterns in the Unix Environment
Section 11.1. Applying the Rule of Least Surprise
Section 11.2. History of Interface Design on Unix
Section 11.3. Evaluating Interface Designs
Section 11.4. Tradeoffs between CLI and Visual Interfaces
Section 11.5. Transparency, Expressiveness, and Configurability
Section 11.6. Unix Interface Design Patterns
Section 11.7. Applying Unix Interface-Design Patterns
Section 11.8. The Web Browser as a Universal Front End
Section 11.9. Silence Is Golden
Chapter 12. Optimization
Section 12.1. Don't Just Do Something, Stand There!
Section 12.2. Measure before Optimizing
Section 12.3. Nonlocality Considered Harmful
Section 12.4. Throughput vs. Latency
Chapter 13. Complexity: As Simple As Possible, but No Simpler
Section 13.1. Speaking of Complexity
Section 13.2. A Tale of Five Editors
Section 13.3. The Right Size for an Editor
Section 13.4. The Right Size of Software
Part III: Implementation
Chapter 14. Languages: To C or Not To C?
Section 14.1. Unix's Cornucopia of Languages
Section 14.2. Why Not C?
Section 14.3. Interpreted Languages and Mixed Strategies
Section 14.4. Language Evaluations
Section 14.5. Trends for the Future
Section 14.6. Choosing an X Toolkit
Chapter 15. Tools: The Tactics of Development
Section 15.1. A Developer-Friendly Operating System
Section 15.2. Choosing an Editor
Section 15.3. Special-Purpose Code Generators
Section 15.4. make: Automating Your Recipes
Section 15.5. Version-Control Systems
Section 15.6. Runtime Debugging
Section 15.7. Profiling
Section 15.8. Combining Tools with Emacs
Chapter 16. Reuse: On Not Reinventing the Wheel
Section 16.1. The Tale of J. Random Newbie
Section 16.2. Transparency as the Key to Reuse
Section 16.3. From Reuse to Open Source
Section 16.4. The Best Things in Life Are Open
Section 16.5. Where to Look?
Section 16.6. Issues in Using Open-Source Software
Section 16.7. Licensing Issues
Part IV: Community
Chapter 17. Portability: Software Portability and Keeping Up Standards
Section 17.1. Evolution of C
Section 17.2. Unix Standards
Section 17.3. IETF and the RFC Standards Process
Section 17.4. Specifications as DNA, Code as RNA
Section 17.5. Programming for Portability
Section 17.6. Internationalization
Section 17.7. Portability, Open Standards, and Open Source
Chapter 18. Documentation: Explaining Your Code to a Web-Centric World
Section 18.1. Documentation Concepts
Section 18.2. The Unix Style
Section 18.3. The Zoo of Unix Documentation Formats
Section 18.4. The Present Chaos and a Possible Way Out
Section 18.5. DocBook
Section 18.6. Best Practices for Writing Unix Documentation
Chapter 19. Open Source: Programming in the New Unix Community
Section 19.1. Unix and Open Source
Section 19.2. Best Practices for Working with Open-Source Developers
Section 19.3. The Logic of Licenses: How to Pick One
Section 19.4. Why You Should Use a Standard License
Section 19.5. Varieties of Open-Source Licensing
Chapter 20. Futures: Dangers and Opportunities
Section 20.1. Essence and Accident in Unix Tradition
Section 20.2. Plan 9: The Way the Future Was
Section 20.3. Problems in the Design of Unix
Section 20.4. Problems in the Environment of Unix
Section 20.5. Problems in the Culture of Unix
Section 20.6. Reasons to Believe
Appendix A. Glossary of Abbreviations
Appendix B. References
Appendix C. Contributors
Appendix D. Rootless Root: The Unix Koans of Master Foo
Editor's Introduction
Master Foo and the Ten Thousand Lines
Master Foo and the Script Kiddie
Master Foo Discourses on the Two Paths
Master Foo and the Methodologist
Master Foo Discourses on the Graphical User Interface
Master Foo and the Unix Zealot
Master Foo Discourses on the Unix-Nature
Master Foo and the End User
Index
Praise for Windows System Programming, Third Edition
"If you're a systems-level 32-bit or 64-bit Windows [developer], whether using the Windows API directly or via .NET interop, you'll definitely want to take a look at this update to Johnson Hart's well-respected and well-loved book. Johnson starts with Windows history and cultural issues and moves through basic and advanced system services in a thoughtful, thorough manner. If Mr. Rogers wrote a book with David Cutler, this is what they'd come up with."
Chris Sells, Longhorn Content Strategist, Microsoft Corporation
"While focusing on UNIX developers that are looking to augment their skills or simply jump ship, Windows System Programming, Third Edition is a book that even some seasoned systems-level Windows developers will undoubtedly find useful. This is not your average bland GUI treatise; Hart takes you down to the metal, explains all the relevant concepts clearly and in-depth, and gives you an extensive library of high-quality code examples that can be easily adapted for your own larger applications. Even if you've created server applications before, Windows System Programming will teach you new tricks, shed new light on concepts you thought you'd mastered, and offer new strategies for creating robust and secure solutions."
Klaus H. Probst, Senior Architect, Spherion Technology Services; Microsoft MVP
"This book is quite easy to follow; there are clear explanations of everything. Even the explanation of the standards is readable! For a developer not familiar with developing with Windows, Hart's book also provides basic information on where Windows was and where it is today, plus a great explanation of how it is different from Posix and Unix."
Eric Landes, Microsoft MVP, www.aspalliance.com/corporatecoder
"Even advanced developers will always need to have a book like this one on hand when the abstractions of a platform like .NET are inadequate or when they need to know more about how .NET is implemented. And the focus on low-level programming (specifically memory management and IO) and other non-GUI topics makes it stand out as superior among other Windows programming books. In keeping the GUI focus to a minimum, Hart's book is able to be comprehensive on the topics contained within."
