Practical applications of information technology Books
John Wiley & Sons Inc Reversing Secrets of Reverse Engineering
Book SynopsisBeginning with a basic primer on reverse engineering including computer internals, operating systems, and assembly language and then discussing the various applications of reverse engineering, this book provides readers with practical, in-depth techniques for software reverse engineering.Table of ContentsForeword vii Acknowledgments xi Introduction xxiii Part I Reversing 101 1 Chapter 1 Foundations 3 What Is Reverse Engineering? 3 Software Reverse Engineering: Reversing 4 Reversing Applications 4 Security-Related Reversing 5 Malicious Software 5 Reversing Cryptographic Algorithms 6 Digital Rights Management 7 Auditing Program Binaries 7 Reversing in Software Development 8 Achieving Interoperability with Proprietary Software 8 Developing Competing Software 8 Evaluating Software Quality and Robustness 9 Low-Level Software 9 Assembly Language 10 Compilers 11 Virtual Machines and Bytecodes 12 Operating Systems 13 The Reversing Process 13 System-Level Reversing 14 Code-Level Reversing 14 The Tools 14 System-Monitoring Tools 15 Disassemblers 15 Debuggers 15 Decompilers 16 Is Reversing Legal? 17 Interoperability 17 Competition 18 Copyright Law 19 Trade Secrets and Patents 20 The Digital Millenium Copyright Act 20 DMCA Cases 22 License Agreement Considerations 23 Code Samples & Tools 23 Conclusion 23 Chapter 2 Low-Level Software 25 High-Level Perspectives 26 Program Structure 26 Modules 28 Common Code Constructs 28 Data Management 29 Variables 30 User-Defined Data Structures 30 Lists 31 Control Flow 32 High-Level Languages 33 C 34 C++ 35 Java 36 C# 36 Low-Level Perspectives 37 Low-Level Data Management 37 Registers 39 The Stack 40 Heaps 42 Executable Data Sections 43 Control Flow 43 Assembly Language 101 44 Registers 44 Flags 46 Instruction Format 47 Basic Instructions 48 Moving Data 49 Arithmetic 49 Comparing Operands 50 Conditional Branches 51 Function Calls 51 Examples 52 A Primer on Compilers and Compilation 53 Defining a Compiler 54 Compiler Architecture 55 Front End 55 Intermediate Representations 55 Optimizer 56 Back End 57 Listing Files 58 Specific Compilers 59 Execution Environments 60 Software Execution Environments (Virtual Machines) 60 Bytecodes 61 Interpreters 61 Just-in-Time Compilers 62 Reversing Strategies 62 Hardware Execution Environments in Modern Processors 63 Intel NetBurst 65 µops (Micro-Ops) 65 Pipelines 65 Branch Prediction 67 Conclusion 68 Chapter 3 Windows Fundamentals 69 Components and Basic Architecture 70 Brief History 70 Features 70 Supported Hardware 71 Memory Management 71 Virtual Memory and Paging 72 Paging 73 Page Faults 73 Working Sets 74 Kernel Memory and User Memory 74 The Kernel Memory Space 75 Section Objects 77 VAD Trees 78 User-Mode Allocations 78 Memory Management APIs 79 Objects and Handles 80 Named objects 81 Processes and Threads 83 Processes 84 Threads 84 Context Switching 85 Synchronization Objects 86 Process Initialization Sequence 87 Application Programming Interfaces 88 The Win32 API 88 The Native API 90 System Calling Mechanism 91 Executable Formats 93 Basic Concepts 93 Image Sections 95 Section Alignment 95 Dynamically Linked Libraries 96 Headers 97 Imports and Exports 99 Directories 99 Input and Output 103 The I/O System 103 The Win32 Subsystem 104 Object Management 105 Structured Exception Handling 105 Conclusion 107 Chapter 4 Reversing Tools 109 Different Reversing Approaches 110 Offline Code Analysis (Dead-Listing) 110 Live Code Analysis 110 Disassemblers 110 IDA Pro 112 ILDasm 115 Debuggers 116 User-Mode Debuggers 118 OllyDbg 118 User Debugging in WinDbg 119 IDA Pro 121 PEBrowse Professional Interactive 122 Kernel-Mode Debuggers 122 Kernel Debugging in WinDbg 123 Numega SoftICE 124 Kernel Debugging on Virtual Machines 127 Decompilers 129 System-Monitoring Tools 129 Patching Tools 131 Hex Workshop 131 Miscellaneous Reversing Tools 133 Executable-Dumping Tools 133 DUMPBIN 133 PEView 137 PEBrowse Professional 137 Conclusion 138 Part II Applied Reversing 139 Chapter 5 Beyond the Documentation 141 Reversing and Interoperability 142 Laying the Ground Rules 142 Locating Undocumented APIs 143 What Are We Looking For? 144 Case Study: The Generic Table API in NTDLL.DLL 145 RtlInitializeGenericTable 146 RtlNumberGenericTableElements 151 RtlIsGenericTableEmpty 152 RtlGetElementGenericTable 153 Setup and Initialization 155 Logic and Structure 159 Search Loop 1 161 Search Loop 2 163 Search Loop 3 164 Search Loop 4 165 Reconstructing the Source Code 165 RtlInsertElementGenericTable 168 RtlLocateNodeGenericTable 170 RtlRealInsertElementWorker 178 Splay Trees 187 RtlLookupElementGenericTable 188 RtlDeleteElementGenericTable 193 Putting the Pieces Together 194 Conclusion 196 Chapter 6 Deciphering File Formats 199 Cryptex 200 Using Cryptex 201 Reversing Cryptex 202 The Password Verification Process 207 Catching the “Bad Password” Message 207 The Password Transformation Algorithm 210 Hashing the Password 213 The Directory Layout 218 Analyzing the Directory Processing Code 218 Analyzing a File Entry 223 Dumping the Directory Layout 227 The File Extraction Process 228 Scanning the File List 234 Decrypting the File 235 The Floating-Point Sequence 236 The Decryption Loop 238 Verifying the Hash Value 239 The Big Picture 239 Digging Deeper 241 Conclusion 242 Chapter 7 Auditing Program Binaries 243 Defining the Problem 243 Vulnerabilities 245 Stack Overflows 245 A Simple Stack Vulnerability 247 Intrinsic Implementations 249 Stack Checking 250 Nonexecutable Memory 254 Heap Overflows 255 String Filters 256 Integer Overflows 256 Arithmetic Operations on User-Supplied Integers 258 Type Conversion Errors 260 Case-Study: The IIS Indexing Service Vulnerability 262 CVariableSet::AddExtensionControlBlock 263 DecodeURLEscapes 267 Conclusion 271 Chapter 8 Reversing Malware 273 Types of Malware 274 Viruses 274 Worms 274 Trojan Horses 275 Backdoors 276 Mobile Code 276 Adware/Spyware 276 Sticky Software 277 Future Malware 278 Information-Stealing Worms 278 BIOS/Firmware Malware 279 Uses of Malware 280 Malware Vulnerability 281 Polymorphism 282 Metamorphism 283 Establishing a Secure Environment 285 The Backdoor.Hacarmy.D 285 Unpacking the Executable 286 Initial Impressions 290 The Initial Installation 291 Initializing Communications 294 Connecting to the Server 296 Joining the Channel 298 Communicating with the Backdoor 299 Running SOCKS4 Servers 303 Clearing the Crime Scene 303 The Backdoor.Hacarmy.D: A Command Reference 304 Conclusion 306 Part III Cracking 307 Chapter 9 Piracy and Copy Protection 309 Copyrights in the New World 309 The Social Aspect 310 Software Piracy 310 Defining the Problem 311 Class Breaks 312 Requirements 313 The Theoretically Uncrackable Model 314 Types of Protection 314 Media-Based Protections 314 Serial Numbers 315 Challenge Response and Online Activations 315 Hardware-Based Protections 316 Software as a Service 317 Advanced Protection Concepts 318 Crypto-Processors 318 Digital Rights Management 319 DRM Models 320 The Windows Media Rights Manager 321 Secure Audio Path 321 Watermarking 321 Trusted Computing 322 Attacking Copy Protection Technologies 324 Conclusion 324 Chapter 10 Antireversing Techniques 327 Why Antireversing? 327 Basic Approaches to Antireversing 328 Eliminating Symbolic Information 329 Code Encryption 330 Active Antidebugger Techniques 331 Debugger Basics 331 The IsDebuggerPresent API 332 SystemKernelDebuggerInformation 333 Detecting SoftICE Using the Single-Step Interrupt 334 The Trap Flag 335 Code Checksums 335 Confusing Disassemblers 336 Linear Sweep Disassemblers 337 Recursive Traversal Disassemblers 338 Applications 343 Code Obfuscation 344 Control Flow Transformations 346 Opaque Predicates 346 Confusing Decompilers 348 Table Interpretation 348 Inlining and Outlining 353 Interleaving Code 354 Ordering Transformations 355 Data Transformations 355 Modifying Variable Encoding 355 Restructuring Arrays 356 Conclusion 356 Chapter 11 Breaking Protections 357 Patching 358 Keygenning 364 Ripping Key-Generation Algorithms 365 Advanced Cracking: Defender 370 Reversing Defender’s Initialization Routine 377 Analyzing the Decrypted Code 387 SoftICE’s Disappearance 396 Reversing the Secondary Thread 396 Defeating the “Killer” Thread 399 Loading KERNEL32.DLL 400 Reencrypting the Function 401 Back at the Entry Point 402 Parsing the Program Parameters 404 Processing the Username 406 Validating User Information 407 Unlocking the Code 409 Brute-Forcing Your Way through Defender 409 Protection Technologies in Defender 415 Localized Function-Level Encryption 415 Relatively Strong Cipher Block Chaining 415 Reencrypting 416 Obfuscated Application/Operating System Interface 416 Processor Time-Stamp Verification Thread 417 Runtime Generation of Decryption Keys 418 Interdependent Keys 418 User-Input-Based Decryption Keys 419 Heavy Inlining 419 Conclusion 419 Part IV Beyond Disassembly 421 Chapter 12 Reversing .NET 423 Ground Rules 424 .NET Basics 426 Managed Code 426 .NET Programming Languages 428 Common Type System (CTS) 428 Intermediate Language (IL) 429 The Evaluation Stack 430 Activation Records 430 IL Instructions 430 IL Code Samples 433 Counting Items 433 A Linked List Sample 436 Decompilers 443 Obfuscators 444 Renaming Symbols 444 Control Flow Obfuscation 444 Breaking Decompilation and Disassembly 444 Reversing Obfuscated Code 445 XenoCode Obfuscator 446 DotFuscator by Preemptive Solutions 448 Remotesoft Obfuscator and Linker 451 Remotesoft Protector 452 Precompiled Assemblies 453 Encrypted Assemblies 453 Conclusion 455 Chapter 13 Decompilation 457 Native Code Decompilation: An Unsolvable Problem? 457 Typical Decompiler Architecture 459 Intermediate Representations 459 Expressions and Expression Trees 461 Control Flow Graphs 462 The Front End 463 Semantic Analysis 463 Generating Control Flow Graphs 464 Code Analysis 466 Data-Flow Analysis 466 Single Static Assignment (SSA) 467 Data Propagation 468 Register Variable Identification 470 Data Type Propagation 471 Type Analysis 472 Primitive Data Types 472 Complex Data Types 473 Control Flow Analysis 475 Finding Library Functions 475 The Back End 476 Real-World IA-32 Decompilation 477 Conclusion 477 Appendix A Deciphering Code Structures 479 Appendix B Understanding Compiled Arithmetic 519 Appendix C Deciphering Program Data 537 Appendix D Citations 561 Index 567
£21.60
John Wiley & Sons Inc Web Programming
Book SynopsisWeb programming is about more than creating and formatting webpages and websites, though that is often a starting point for many. Using scripting languages such as JavaScript, Perl and PH, it becomes possible to add a lot more functionality to a site. This book teaches the essentials of working with the most important web technologies.Table of ContentsPreface xvii Acknowledgments xxiii 1 Introduction 1 1.1 HTML, XML, and the World Wide Web 3 Exercises 13 Part I HTML 15 2 Hypertext Markup Language 17 2.1 Basic HTML 17 2.2 The Document Body 22 2.3 Text 26 2.4 Hyperlinks 31 2.5 Adding More Formatting 37 2.6 Lists 37 2.7 Using Color and Images 42 2.8 Images 43 Exercises 47 3 More HTML 50 3.1 Tables 51 3.2 Multimedia Objects 57 3.3 Frames 64 3.4 Forms – Toward Interactivity 69 3.5 The HTML Document Head in Detail 73 3.6 XHTML – An Evolutionary Markup 77 Exercises 82 Part II Stylesheets 85 4 Cascading Stylesheets 87 4.1 Introduction 87 4.2 Using Styles: Simple Examples 88 4.3 Defining Your Own Styles 93 4.4 Properties and Values in Styles 97 4.5 Stylesheets – AWorked Example 102 4.6 Formatting Blocks of Information 106 4.7 Layers 109 Exercises 119 5 Cascading Style Sheets Two 121 5.1 The Design Of CSS2 122 5.2 Styling For Paged Media 124 5.3 Using Aural Presentation 127 5.4 Counters And Numbering 131 Exercises 135 Part III JavaScript 137 6 An Introduction to JavaScript 139 6.1 What is Dynamic HTML? 140 6.2 JavaScript 141 6.3 JavaScript – The Basics 144 6.4 Variables 151 6.5 String Manipulation 158 6.6 Mathematical Functions 163 6.7 Statements 167 6.8 Operators 174 6.9 Arrays 175 6.10 Functions 188 Exercises 196 7 Objects in JavaScript 198 7.1 Data and Objects in JavaScript 198 7.2 Regular Expressions 203 7.3 Exception Handling 211 7.4 Built-in Objects 215 7.5 Cookies 225 7.6 Events 230 Exercises 235 8 Dynamic HTML with JavaScript 237 8.1 Data Validation 238 8.2 Opening a New Window 242 8.3 Messages and Confirmations 244 8.4 The Status Bar 245 8.5 Writing to a Different Frame 246 8.6 Rollover Buttons 252 8.7 Moving Images 257 8.8 Multiple Pages in a Single Download 261 8.9 A Text-only Menu System 264 8.10 Floating Logos 267 Exercises 270 Part IV Perl 273 9 Programming in Perl 5 275 9.1 Why Perl? 277 9.2 On-line Documentation 278 9.3 The Basic Perl Program 280 9.4 Scalars 283 9.5 Arrays 287 9.6 Hashes 293 9.7 Control Structures 299 9.8 Processing Text 308 9.9 Regular Expressions 319 9.10 Using Files 328 9.11 Subroutines 331 9.12 Bits and Pieces 335 Exercises 340 10 CGI Scripting 346 10.1 What is CGI? 346 10.2 Developing CGI Applications 347 10.3 Processing CGI 348 10.4 Introduction to CGI.pm 349 10.5 CGI.pm Methods 351 10.6 Creating HTML Pages Dynamically 352 10.7 Using CGI.pm – An Example 356 10.8 Adding Robustness 357 10.9 Carp 360 10.10 Cookies 361 Exercises 367 11 Building Web Applications With Perl 369 11.1 Uploading Files 371 11.2 Tracking Users With Hidden Data 376 11.3 Using Relational Databases 379 11.4 Using libwww 386 11.5 Template-based Sites With HTML::Mason 393 11.6 Creating And Manipulating Images 402 Exercises 417 Part V PHP 419 12 An Introduction to PHP 421 12.1 PHP 422 12.2 Introducing PHP 423 12.3 Including PHP in a Page 425 12.4 Data Types 429 12.5 Program Control 434 12.6 Arrays 441 12.7 User-Defined Functions 450 12.8 Built-in Functions 452 12.9 Regular Expression 464 12.10 Using Files 468 Exercises 473 13 Building Web Applications With PHP 475 13.1 Tracking Users 476 13.2 Using Databases 485 13.3 Handling XML 498 Exercises 506 Part VI Miscellany 509 14 XML: Defining Data for Web Applications 511 14.1 Basic XML 514 14.2 Document Type Definition 523 14.3 XML Schema 530 14.4 Document Object Model 533 14.5 Presenting XML 535 14.6 Handling XML with Perl 546 14.7 Using XML::Parser 550 14.8 Handling the DOM with Perl 558 Exercises 568 15 Good Design 569 15.1 Structure 571 15.2 Tables versus Frames versus . . . 572 15.3 Accessibility 577 15.4 Internationalization 581 Exercises 581 16 Protocols 583 16.1 Protocols 584 16.2 IP and TCP 585 16.3 Hypertext Transfer Protocol 588 16.4 Common Gateway Interface 592 16.5 The Document Object Model 596 16.6 Introducing The Document Object Model 598 Exercises 599 17 Case Study 601 17.1 The Plan 601 17.2 The Data 603 Part VII Appendices 607 Glossary 609 Appendix A Accessing a Database From PHP Using mysqli 613 Appendix B Accessing a Database From PHP Using Pear DB 619 Appendix C HTML Color Codes 625 Appendix D HTML Entities 630 Index 639
£48.56
John Wiley & Sons Inc Level Up The Guide to Great Video Game Design 2e
Book SynopsisProvides examples that forgo theoretical gobbledygook with charmingly illustrated concepts and solutions based on years of professional experience. This book helps you teach how to develop marketable ideas, and learn what perils and pitfalls await during a game's pre-production, production and post-production stages.Table of ContentsIntroduction Press Start! 1 If You Are Anything Like Me 1 No, You Can’t Have My Job 3 Who Is This Book For? 4 Why a Second Edition? 6 Level 1 Welcome, N00bs! 7 A Brief History of Video Games 10 The Brave New World of Gaming: Mobiles, Online Distribution, and Touchscreens 14 Game Genres 16 Who Makes This Stuff? 17 Programmer 18 Artist 19 Designer 20 Producer 20 Tester 21 Composer 22 Sound Designer 23 Writer 23 Have You Thought about Publishing? 25 Product Manager 25 Creative Manager 25 Art Director 26 Technical Director 26 Marketing Team 26 And the Rest 26 Level 2 Ideas 29 Ideas: Where to Get Them and Where to Stick Them 30 Getting Ahead of the Game 32 What Do Gamers Want? 35 Brainstorming 36 Breaking Writer’s Block 38 Why I Hate “Fun” 40 Level 3 Writing the Story 43 Once Upon a Time 43 The Triangle of Weirdness 50 A Likely Story 52 Time to Wrap It Up 55 A Game by Any Other Name 56 Creating Characters Your Players Care About 58 A Few Pointers on Writing for Kids of All Ages 62 Writing for Licenses 62 Level 4 You Can Design a Game, but Can You Do the Paperwork? 65 Writing the GDD, Step 1: The One-Sheet 68 ESRB Ratings 69 Unique Selling Points 70 Competitive Products 70 Writing the GDD, Step 2: The Ten-Pager 71 The Rule of Threes 72 The Ten-Pager Outline 73 Page 1: Title Page 73 Page 2: Game Outline 73 Page 3: Character 74 Page 4: Gameplay 75 Page 5: Game World 76 Page 6: Game Experience 76 Page 7: Gameplay Mechanics 77 Page 8: Enemies 79 Page 9: Multiplayer and Bonus Materials 80 Page 10: Monetization 80 Writing the GDD, Step 3: Gameplay Progression 81 Writing the GDD, Step 4: The Beat Chart 82 Writing the GDD, Step 5: The Game Design Document (and the Awful Truth about Writing It) 85 Writing the GDD, Step 6: Above All, Don’t Be a Jerk 89 Level 5 The Three Cs, Part 1: Character 93 Who Do You Want To Be Today? 94 Personality: Do We Really Need Another Kratos? 96 Let’s Get Personal 98 Using All the Parts 102 Games Without Characters 103 We Are Not Alone 104 When More Is More 107 Who Are the People in Your Neighborhood? 109 Finally, We Talk About Gameplay 111 Metrics for Non-Characters 114 Be Kind to Our Four-Legged Friends 114 Why Walk When You Can Run? 114 The Art of Doing Nothing 119 Might as Well Jump 120 Hoists and Teeters 124 What Goes Up Must Fall Down 125 Me and My Shadow 126 The Water’s Fine . . . or Is It? 127 Level 6 The Three Cs, Part 2: Camera 131 Get It Right: Camera Views 132 First Person Camera 136 Third Person Camera 138 Giving Up Control 142 So You’ve Decided to Let the Player Control the Camera 142 So You’ve Decided Not to Let the Player Have Control over the Camera 144 So You’ve Decided to Let Players Sometimes Have Control over the Camera 145 Two and a Half D 145 Isometric Camera 146 Top-Down Camera 148 AR Cameras 149 Special Case Cameras 149 Tunnel Vision 150 Camera Shot Guide 150 Camera Angle Guide 153 Camera Movement Guide 154 Other Camera Notes 157 Always Point the Camera to the Objective 158 Never Let the Character Get out of the Camera’s Sight 159 Multiple-Player Cameras 159 Level 7 The Three Cs, Part 3: Controls 163 Control Is in Your Hand 164 You’ve Got the Touch 167 Dance, Monkey, Dance 169 Character or Camera Relative? 175 Shake, Rattle, and Roll 177 Level 8 Sign Language: HUD and Icon Design 181 Heads Up! 181 Health Bar 182 Targeting Reticule 183 Ammo Gauge 184 Inventory 185 Score/Experience 185 Positive Messaging 186 Radar/Map 187 Context-Sensitive Prompts 188 The Clean Screen 190 Icon Has Cheezburger? 191 Creating Icons for Mobile Games 194 Don’t Get QTE 196 HUDs and Where to Stick ‘Em 198 There Are Other Screens Than the HUD 199 A Final Word on Fonts 207 Level 9 Everything I Learned About Level Design, I Learned from Level 9 209 The Top 10 Cliché Video Game Themes 212 The Name Game 218 Everything I Learned About Level Design, I Learned from Disneyland 220 Mapping the World 221 Foreshadowing 222 Goal Setting 223 Following Procedure 225 You’ve Got the Beat 227 Re-using Re-use 229 The Gary Gygax Memorial Mapping Section 230 Sandbox Play 233 Illusional Narrative 236 The Dave Arneson Memorial Mapping Section 237 Wrapping Up Mapping 248 Gray Matters 251 Leave the Training Level for Last 253 Levels without Characters 254 Level 10 The Elements of Combat 257 400 Quatloos on the Newcomer! 259 Put ‘Em Up! 262 And a One and a Two 266 The Big Finish 268 Live by the Sword 270 Now You Have to Kiss Me 273 Let’s Get Defensive 273 Dodging the Bullet 276 On Guarding 277 State of the Art Bang Bang 281 The Best Gun for You 286 Run and Gun 290 Not Just Shooting 293 Dang it, Jones! Where Doesn’t It Hurt? 297 Death: What Is It Good For? 299 Conflict Without Combat 301 Level 11 They All Want You Dead 305 Sizing Up the Enemy 307 Bad Behavior 308 How Rapid is Rapid? 313 Movement Style 316 Bring on the Bad Guys 318 I Love Designing Enemies 327 The Alphabetical Bestiary of Choices 328 I Hate You to Pieces 337 Non-Enemy Enemies 341 How to Create the World’s Greatest Boss Battle 342 Who’s the Boss? 342 Size Matters 344 Location, Location, Location 349 Why Not to Create the World’s Greatest Boss Battle 351 Level 12 The Nuts and Bolts of Mechanics 353 The Mechanics of Mechanics 353 Holy Death Trap! 357 What I Learned from Making Kids Cry 360 Time to Die 361 The Music of Mechanics 364 Chip Off the Old Block 368 A Nice Little Calm Spot 371 Riddle Me This 372 Puzzle Me That 375 Minigames and Microgames 377 Level 13 Now You’re Playing with Power 381 Powering Up 381 “Love Thy Player” 388 Seriously. “Love Thy Player.” 390 More Wealth Than You Can Imagine! 391 High Score 394 Achievements 395 Money! Money! Money! 395 Souvenirs 399 Bonus Section about Bonus Features 400 How to Win at Losing 402 Level 14 Multiplayer—The More the Merrier 405 How Many Is the Right Number? 410 MMORPGS, or Hell Is Other People 410 Designing Multiplayer Levels 415 Planning Your Level 415 Mapping Your Level 416 Building Your Level 417 The Dirty Half Dozen 418 Level 15 Everybody Wins: Monetization 419 Cashing In 422 Money Is the Root of Something Something 423 Level 16 Some Notes on Music 427 I Know It When I Hear It 429 Music with Style 430 And the Beat Goes On 431 Sounds Like a Game to Me 434 Level 17 Cutscenes, or No One’s Gonna Watch ‘Em Anyway 441 A Cut Above 442 How to Write a Screenplay in Eight Easy Steps 444 Finding Your Voice 448 Level 18 And Now the Hard Part 451 No One Cares About Your Stupid Little World 452 Who’s Paying? 455 Video Games Is a Haaaard Business 456 When Reality Gets in the Way 457 Emergent, Vertical, or Horizontal? 459 What to Do for an Encore? 462 Continue? 467 Time to Level Up! 467 Bonus Level 1 The One-Sheet Sample 469 Bonus Level 2 The Ten-Page Design Document Sample 473 Bonus Level 3 Game Design Document Template 485 Bonus Level 4 The Medium-Sized List of Story Genres 493 Bonus Level 5 Game Genres 495 Bonus Level 6 The Big List of Environments 503 Bonus Level 7 Mechanics and Hazards 507 Bonus Level 8 Enemy Design Template 509 Bonus Level 9 Boss Design Template 511 Bonus Level 10 High-Concept Pitch Presentation 513 Bonus Level 11 Achievement Unlocked: Exactly Like Making Chili 521 Index 523
£21.00
John Wiley & Sons Inc NoSQL For Dummies
Book SynopsisGet up to speed on the nuances of NoSQL databases and what they mean for your organization This easy to read guide to NoSQL databases provides the type of no-nonsense overview and analysis that you need to learn, including what NoSQL is and which database is right for you.Table of ContentsIntroduction 1 Part I: Getting Started with NoSQL 5 Chapter 1: Introducing NoSQL: The Big Picture 7 Chapter 2: NoSQL Database Design and Terminology 27 Chapter 3: Evaluating NoSQL 59 Part II: Key-Value Stores 95 Chapter 4: Common Features of Key-Value Stores 97 Chapter 5: Key-Value Stores in the Enterprise 105 Chapter 6: Key-Value Use Cases 111 Chapter 7: Key-Value Store Products 117 Chapter 8: Riak and Basho 133 Part III: Bigtable Clones 139 Chapter 9: Common Features of Bigtables 141 Chapter 10: Bigtable in the Enterprise 153 Chapter 11: Bigtable Use Cases 165 Chapter 12: Bigtable Products 171 Chapter 13: Cassandra and DataStax 193 Part IV: Document Databases 199 Chapter 14: Common Features of Document Databases 201 Chapter 15: Document Databases in the Enterprise 213 Chapter 16: Document Database Use Cases 221 Chapter 17: Document Database Products 233 Chapter 18: MongoDB 251 Part V: Graph and Triple Stores 257 Chapter 19: Common Features of Triple and Graph Stores 259 Chapter 20: Triple Stores in the Enterprise 275 Chapter 21: Triple Store Use Cases 283 Chapter 22: Triple Store Products 293 Chapter 23: Neo4j and Neo Technologies 309 Part VI: Search Engines 315 Chapter 24: Common Features of Search Engines 317 Chapter 25: Search Engines in the Enterprise 327 Chapter 26: Search Engine Use Cases 335 Chapter 27: Types of Search Engines 341 Chapter 28: Elasticsearch 353 Part VII: Hybrid NoSQL Databases 359 Chapter 29: Common Hybrid NoSQL Features 361 Chapter 30: Hybrid Databases in the Enterprise 369 Chapter 31: Hybrid NoSQL Database Use Cases 375 Chapter 32: Hybrid NoSQL Database Products 381 Chapter 33: MarkLogic 389 Part VIII: The Part of Tens 399 Chapter 34: Ten Advantages of NoSQL over RDBMS 401 Chapter 35: Ten NoSQL Misconceptions 407 Chapter 36: Ten Reasons Developers Love NoSQL 413 Index 419
£19.99
John Wiley & Sons Inc Android App Development For Dummies
Book SynopsisThe updated edition of the bestselling guide to Android app development If you have ambitions to build an Android app, this hands-on guide gives you everything you need to dig into the development process and turn your great idea into a reality! In this new edition of Android App Development For Dummies, you''ll find easy-to-follow access to the latest programming techniques that take advantage of the new features of the Android operating system. Plus, two programs are provided: a simple program to get you started and an intermediate program that uses more advanced aspects of the Android platform. Android mobile devices currently account for nearly 80% of mobile phone market share worldwide, making it the best platform to reach the widest possible audience. With the help of this friendly guide, developers of all stripes will quickly find out how to install the tools they need, design a good user interface, grasp the design differences between phone and tablet aTable of ContentsIntroduction 1 Part I: Getting Started with Your First Android Application 7 Chapter 1: Developing Spectacular Android Applications 9 Chapter 2: Prepping Your Development Headquarters 25 Part II: Building and Publishing Your First Application 39 Chapter 3: Your First Android Project 41 Chapter 4: Creating the User Interface 65 Chapter 5: Coding Your Application 79 Chapter 6: Understanding Android Resources 107 Chapter 7: Turning Your Application into an App Widget 119 Chapter 8: Publishing Your App to the Google Play Store 139 Part III: Creating a Feature-Rich Application 155 Chapter 9: Designing the Tasks Application 157 Chapter 10: Creating the Task Detail Page 181 Chapter 11: Going a la Carte with Your Menu 199 Chapter 12: Handling User Input 211 Chapter 13: Getting Persistent with Data Storage 233 Chapter 14: Reminding the User 265 Chapter 15: Working with Android Preferences 279 Part IV: Android Is More than Phones 293 Chapter 16: Developing for Tablets 295 Chapter 17: Supporting Older Versions of Android 315 Chapter 18: Wearing the Tasks App 333 Chapter 19: Look Ma, I’m on TV! 357 Chapter 20: Moving beyond Google 381 Part V: The Part of Tens 393 Chapter 21: Ten Free Sample Applications and SDKs 395 Chapter 22: Ten Tools to Simplify Your Development Life 399 Index 403
£20.79
John Wiley & Sons Inc C AllinOne For Dummies
Book SynopsisTable of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 4 Icons Used in This Book 4 Beyond the Book 5 Where to Go from Here 6 Book 1: Getting Started with C++ 7 Chapter 1: Configuring Your Desktop System 9 Obtaining a Copy of C++ 20 10 Obtaining Code::Blocks 11 Installing Code::Blocks 12 Working with Windows 12 Working with Mac OS X 13 Using the standard Linux installation 14 Using the graphical Linux installation 15 Touring the Essential Code::Blocks Features 17 Starting Code::Blocks for the first time 18 Opening the sample projects 19 Viewing the essential windows 20 Using Other IDEs 25 Chapter 2: Configuring Your Mobile System 27 Obtaining CppDroid 28 Understanding why CppDroid is such a great choice 29 Getting your copy of CppDroid 31 Ensuring you get a good install 32 Considering Other Alternatives 32 Working with C4Droid 33 Getting multiple language support with AIDE 33 Using web-based IDEs 34 Touring the Essential CppDroid Features 35 Getting started with CppDroid 35 Accessing an example 37 Working with a simple online project 37 Accessing your source code 38 Considering differences with the desktop environment 39 Obtaining CppDroid Help 40 Working with the Help documentation 40 Getting community support 41 Using the free examples 42 Accessing the tutorials 43 Chapter 3: Creating Your First C++ Application 45 Code::Blocks Creating a Project 46 Understanding projects 46 Defining your first project 47 Building and executing your first application 52 Typing the Code 53 Starting with Main 55 Showing Information 55 Doing some math 60 Tabbing your output 66 Let Your Application Run Away 67 Chapter 4: Storing Data in C++ 69 Putting Your Data Places: Variables 70 Creating an integer variable 70 Declaring multiple variables 73 Changing values 74 Setting one variable equal to another 74 Initializing a variable 75 Creating a great name for yourself 76 Manipulating Integer Variables 78 Adding integer variables 78 Subtracting integer variables 82 Multiplying integer variables 84 Dividing integer variables 86 Characters 88 Null character 89 Nonprintable and other cool characters 89 Strings 93 Getting a part of a string 94 Changing part of a string 95 Adding onto a string 96 Adding two strings 97 Making Decisions Using Conditional Operators 98 Telling the Truth with Boolean Variables 100 Reading from the Console 102 Chapter 5: Directing the Application Flow 105 Doing This or Doing That 106 Evaluating Conditions in C++ 107 Finding the right C++ operators 108 Combining multiple evaluations 110 Including Evaluations in C++ Conditional Statements 111 Deciding what if and also what else 112 Going further with the else and if 113 Repeating Actions with Statements That Loop 115 Understanding how computers use loops 116 Looping situations 116 Looping for 117 Performing a simple for loop 118 Using multiple initialization variables 123 Working with ranges 126 Placing a condition within the declaration 128 Letting C++ determine the type 129 Looping while 130 Doing while 132 Breaking and continuing 133 Breaking 134 Continuing 135 Nesting loops 136 Chapter 6: Dividing Your Work with Functions 139 Dividing Your Work 139 Calling a Function 144 Passing a variable 146 Passing multiple variables 147 Writing Your Own Functions 148 Defining the AddOne() function 149 Seeing how AddOne() is called 150 Taking the AddOne() Function apart 150 Considering the AddOne() parameter 151 Understanding the AddOne() name and type 152 Improving On the Basic Function 153 Using multiple parameters or no parameters 153 Returning nothing 156 Keeping your variables local 157 Forward references and function prototypes 159 Writing two versions of the same function 161 Calling All String Functions 163 Inserting a string into a string 163 Removing parts of a string 164 Replacing parts of a string 164 Using the string functions together 164 Understanding main() 165 Chapter 7: Splitting Up Source Code Files 169 Creating Multiple Source Files 170 Adding a new source code file 170 Removing an existing source code file 173 Creating a project with multiple existing files 173 Getting multiple files to interact 177 Sharing with Header Files 179 Adding the header only once 182 Using angle brackets or quotes 182 Sharing Variables among Source Files 183 Using the Mysterious Header Wrappers 185 Chapter 8: Referring to Your Data Through Pointers 187 Understanding the Changes in Pointers for C++ 20 188 Avoiding broken code 188 Considering the issues 189 Writing cleaner and less bug-prone code 191 Heaping and Stacking the Variables 192 Getting a variable’s address 196 Changing a variable by using a pointer 198 Pointing at a string 200 Pointing to something else 203 Tips on pointer variables 204 Creating New Raw Pointers 205 Using new 206 Using an initializer 208 Freeing Raw Pointers 209 Working with Smart Pointers 211 Creating smart pointers using std::unique_ptr and std::shared_ptr 212 Defining nullable values using std::optional and std::nullopt 216 Passing Pointer Variables to Functions 218 Returning Pointer Variables from Functions 221 Part 2: Understanding Objects and Classes 225 Chapter 1: Working with Classes 227 Understanding Objects and Classes 227 Classifying classes and objects 230 Describing methods and data 231 Implementing a class 232 Separating method code 237 The parts of a class 240 Working with a Class 241 Accessing members 241 Using classes and raw pointers 244 Using classes and smart pointers 248 Passing objects to functions 249 Using const parameters in functions 251 Using the this pointer 252 Overloading methods 256 Starting and Ending with Constructors and Destructors 259 Starting with constructors 259 Ending with destructors 260 Sampling constructors and destructors 260 Adding parameters to constructors 263 Building Hierarchies of Classes 264 Creating a hierarchy in C++ 265 Understanding types of inheritance 266 Creating and Using Object Aliases 267 Chapter 2: Using Advanced C++ Features 269 Filling Your Code with Comments 270 Converting Types 272 Understanding how int and string conversions work 272 Seeing int and string conversions in action 273 Considering other conversion issues 276 Reading from the Console 277 Understanding Preprocessor Directives 282 Understanding the basics of preprocessing 282 Creating constants and macros with #define 283 Performing conditional compilation 286 Exercising the basic preprocessor directives 288 Using Constants 292 Using Switch Statements 295 Supercharging enums with Classes 298 Working with Random Numbers 300 Storing Data in Arrays 302 Declaring and accessing an array 303 Arrays of pointers 304 Passing arrays to functions 306 Adding and subtracting pointers 307 Chapter 3: Planning and Building Objects 309 Recognizing Objects 310 Observing the Mailboxes class 312 Observing the Mailbox class 314 Finding other objects 315 Encapsulating Objects 316 Considering the Application Programming Interface 316 Understanding properties 316 Choosing between private and protected 318 Defining a process 318 Implementing properties 319 Building Hierarchies 322 Establishing a hierarchy 322 Protecting members when inheriting 324 Overriding methods 330 Specializing with polymorphism 332 Getting abstract about things 333 Chapter 4: Building with Design Patterns 335 Delving Into Pattern History 336 Introducing a Simple Pattern: the Singleton 337 Using an existing pattern 337 Creating a singleton pattern class 338 Watching an Instance with an Observer 341 Understanding the observer pattern 341 Defining an observer pattern class 343 Observers and the Standard C++ Library 346 Automatically adding an observer 347 Mediating with a Pattern 349 Defining the mediator pattern scenario 350 Outlining the car example 351 Creating the car example 354 Book 3: Understanding Functional Programming 367 Chapter 1: Considering Functional Programming 369 Understanding How Functional Programming Differs 370 Defining an Impure Language 373 Considering the requirements 373 Understanding the C++ functional limitations 374 Seeing Data as Immutable 375 Working with immutable variables 376 Working with immutability in classes and structures 377 Creating constant expressions 378 Considering the Effects of State 381 Eliminating Side Effects 382 Contrasting declarations and functions 383 Associating functions with side effects 384 Removing side effects 385 Creating a declarative C++ example 387 Understanding the Role of auto 388 Passing Functions to Functions 390 Seeing a simple example of function input 391 Using transforms 393 Using Lambda Expressions for Implementation 394 Chapter 2: Working with Lambda Expressions 397 Creating More Readable and Concise C++ Code 398 Defining the Essential Lambda Expression 399 Defining the parts of a lambda expression 399 Relying on computer detection of return type 401 Using the auto keyword with lambda expressions 404 Using lambda expressions as macros 405 Developing with Lambda Expressions 406 Using lambda expressions with classes and structures 407 Working with the capture clause 408 Sorting data using a lambda expression 411 Specifying that the lambda expression throws exceptions 413 Chapter 3: Advanced Lambda Expressions 415 Considering the C++ 20 Lambda Extensions 416 Defining an immediate function 416 Using = and this in captures 417 Finding other changes 418 Working in Unevaluated Contexts 418 Using Assignable Stateless Lambda Expressions 420 Dealing with Pack Expansions 422 Considering the template 422 Processing the variables using recursion 423 Processing the variables using a lambda expression 424 Book 4: Fixing Problems 427 Chapter 1: Dealing with Bugs 429 It’s Not a Bug It’s a Feature! 430 Make Your Application Features Look Like Features 431 Anticipating (Almost) Everything 432 Considering menus 432 Dealing with textual input 435 Performing string processing 437 Avoiding Mistakes, Plain and Simple 441 Chapter 2: Debugging an Application 443 Programming with Debuggers 444 Running the debugger 446 Recognizing the parts of the Code::Blocks debugger 453 Debugging with Different Tools 455 Debugging a Code::Blocks Application with Command-Line Arguments 456 Chapter 3: Stopping and Inspecting Your Code 457 Setting and Disabling Breakpoints 458 Setting a breakpoint in Code::Blocks 459 Enabling and disabling breakpoints 460 Watching, Inspecting, and Changing Variables 463 Watching the variables 465 Changing values 466 Chapter 4: Traveling About the Stack 469 Stacking Your Data 470 Moving about the stack 471 Storing local variables 473 Debugging with Advanced Features 475 Viewing threads 475 Tracing through assembly code 475 Book 5: Advanced Programming 479 Chapter 1: Working with Arrays, Pointers, and References 481 Building Up Arrays 482 Declaring arrays 482 Arrays and pointers 484 Using multidimensional arrays 488 Arrays and command-line parameters 492 Allocating an array on the heap 494 Deleting an array from the heap 494 Storing arrays of pointers and arrays of arrays 495 Building constant arrays 498 Pointing with Pointers 498 Becoming horribly complex 499 Pointers to functions 505 Pointing a variable to a method 506 Pointing to static methods 509 Referring to References 510 Reference variables 510 Returning a reference from a function 511 Chapter 2: Creating Data Structures 515 Working with Data 515 The great variable roundup 516 Expressing variables from either side 518 Casting a spell on your data 520 Comparing casting and converting 521 Casting safely with C++ 523 Structuring Your Data 529 Structures as component data types 531 Equating structures 531 Returning compound data types 532 Naming Your Space 534 Creating a namespace 534 Employing using namespace 535 Using variables 537 Using part of a namespace 538 Chapter 3: Constructors, Destructors, and Exceptions 541 Constructing and Destructing Objects 542 Overloading constructors 542 Initializing members 543 Adding a default constructor 548 Functional constructors 550 Calling one constructor from another 553 Copying instances with copy constructors 555 When constructors go bad 557 Destroying your instances 558 Virtually inheriting destructors 560 Programming the Exceptions to the Rule 563 Creating a basic try catch block 563 Using multiple catch blocks 565 Throwing direct instances 566 Catching any exception 567 Rethrowing an exception 568 Using a standard category 570 Chapter 4: Advanced Class Usage 571 Inherently Inheriting Correctly 572 Morphing your inheritance 572 Avoiding polymorphism 573 Adjusting access 574 Avoiding variable naming conflicts 575 Using class-based access adjustment 576 Returning something different, virtually speaking 577 Multiple inheritance 581 Virtual inheritance 584 Friend classes and functions 588 Using Classes and Types within Classes 591 Nesting a class 591 Types within classes 597 Chapter 5: Creating Classes with Templates 601 Templatizing a Class 602 Considering types 602 Defining the need for templates 602 Creating and using a template 605 Understanding the template keyword 607 Going Beyond the Basics 609 Separating a template from the function code 609 Including static members in a template 611 Parameterizing a Template 612 Putting different types in the parameter 613 Including multiple parameters 616 Working with non-type parameters 619 Typedefing a Template 622 Deriving Templates 623 Deriving classes from a class template 623 Deriving a class template from a class 626 Deriving a class template from a class template 627 Templatizing a Function 630 Overloading and function templates 632 Templatizing a method 635 Chapter 6: Programming with the Standard Library 637 Architecting the Standard Library 638 Containing Your Classes 638 Storing in a vector 639 Working with std::array 642 Mapping your data 643 Containing instances, pointers, or references 644 Working with copies 648 Comparing instances 649 Iterating through a container 655 A map of pairs in your hand 658 The Great Container Showdown 658 Associating and storing with a set 658 Unionizing and intersecting sets 662 Listing with list 664 Stacking the deque 669 Waiting in line with stacks and queues 670 Copying Containers 673 Creating and Using Dynamic Arrays 675 Working with Unordered Data 677 Using std::unordered_set to create an unordered set 677 Manipulating unordered sets 677 Working with Ranges 679 Book 6: Reading and Writing Files 681 Chapter 1: Filing Information with the Streams Library 683 Seeing a Need for Streams 684 Programming with the Streams Library 686 Getting the right header file 686 Opening a file 687 Reading from a file 690 Reading and writing a file 691 Working with containers 692 Handling Errors When Opening a File 693 Flagging the ios Flags 695 Chapter 2: Writing with Output Streams 697 Inserting with the << Operator 698 Formatting Your Output 699 Formatting with flags 700 Specifying a precision 704 Setting the width and creating fields 707 Chapter 3: Reading with Input Streams 711 Extracting with Operators 712 Encountering the End of File 715 Using the record count approach 715 Using the EOF check approach 718 Reading Various Types 720 Understanding data reading issues 720 Writing and reading string-type data 721 Writing and reading structured data 724 Chapter 4: Building Directories and Contents 727 Manipulating Directories 728 Creating a directory 728 Deleting a directory 730 Getting the Contents of a Directory 731 Copying Files 733 Copying with windows 734 Using the quick-and-dirty method 734 Moving and Renaming Files and Directories 735 Chapter 5: Streaming Your Own Classes 737 Streaming a Class for Text Formatting 738 Understanding the process 739 Considering the insertion implementation 739 Considering the extraction implementation 741 Manipulating a Stream 742 What’s a manipulator? 742 Writing your own manipulator 744 Book 7: Advanced Standard Library Usage 751 Chapter 1: Exploring the Standard Library Further 753 Considering the Standard Library Categories 755 Algorithms 755 Atomic operations 757 C Compatibility 759 Concepts 759 Containers 760 Coroutines 760 Filesystem 761 Input/Output 761 Iterators 761 Localization 763 Numerics 763 Ranges 764 Regular Expressions 766 Strings 766 Thread Support 767 Utilities 767 Parsing Strings Using a Hash 768 Obtaining Information Using a Random Access Iterator 771 Locating Values Using the Find Algorithm 774 Using the Random Number Generator 776 Working with Temporary Buffers 777 Chapter 2: Working with User-Defined Literals (UDLs) 779 Understanding the Need for UDLs 780 Prefixes and suffixes 781 Differentiating between raw and cooked 784 Working with the UDLs in the Standard Library 785 std::basic_string 785 std::complex 788 std::chrono::duration 789 Creating Your Own UDLs 791 Developing a conversion UDL 792 Developing a custom type UDL 793 Using a custom UDL for side effects 794 Chapter 3: Building Original Templates 795 Deciding When to Create a Template 796 Defining the Elements of a Good Template 797 Creating a Basic Math Template 799 Building a Structure Template 801 Developing a Class Template 804 Considering Template Specialization 807 Creating a Template Library 809 Defining the library project 810 Configuring the library project 812 Coding the library 813 Using Your Template Library 815 Chapter 4: Investigating Boost 817 Considering the Standard Library Alternative 818 Understanding why the Standard Library contains Boost features 818 Defining the trade-offs of using the Standard Library 819 Understanding Boost 820 Boost features 821 Licensing 822 Paid support 823 Obtaining and Installing Boost for Code::Blocks 823 Unpacking Boost 823 Using the header-only libraries 825 Building the libraries 825 Testing the installation 827 Creating the Boost Tools 833 Using Boost.Build 836 Getting a successful build 836 Creating your own example 836 Using Inspect 837 Understanding BoostBook 840 Using QuickBook 841 Using bcp 843 Using Wave 845 Building Your First Boost Application Using Date Time 846 Chapter 5: Boosting up a Step 849 Parsing Strings Using RegEx 850 Adding the RegEx library 851 Creating the RegEx code 855 Breaking Strings into Tokens Using Tokenizer 857 Performing Numeric Conversion 858 Creating Improved Loops Using Foreach 862 Accessing the Operating System Using Filesystem 864 Index 869
£26.39
MIT Press LowDensity ParityCheck Codes
Book Synopsis
£23.63
John Wiley & Sons Professional XNA Programming
Book SynopsisThis improved and updated edition of the bestseller will get you up and running quickly with building games for Xbox 360 and the Windows platform. Professional game developer and Microsoft MVP Benjamin Nitschke begins by explaining how to install the free XNA Game Studio 2.
£34.54
John Wiley & Sons Inc LINQ For Dummies
Book SynopsisIf you've asked yourself Why can't I develop database and XML queries in a language I already know?, then Language INtegrated Query, or LINQ, is for you. LINQ For Dummies introduces you to LINQ and the .NET Framework technologies, so you can use LINQ to query any object, any data set, any kind of XML, and SQL Serverno questions asked. This plain-English guide gives you a thorough overview of LINQ, from understanding the tasks it performs to making LINQ work with both Visual Basic and Visual Studio 2005. It explains the four LINQ providers in the .NET Framework, the easiest ways to go about accessing data, and how to write more efficient applications with less code using LINQ. There's also clear guidance on combining third-party providers with LINQ to create even more powerful apps. With this single, comprehensive guide, you'll discover how to: Use one query language with all Microsoft languages Examine .NET language extensions and work with exTable of ContentsIntroduction. Part I: An Overview of LINQ. Chapter 1: Getting to Know LINQ. Chapter 2: Creating Simple LINQ Queries. Chapter 3: Considering the .NET Language Extensions. Chapter 4: Working with LINQ in Visual Basic .NET. Chapter 5: Working with LINQ in Visual Studio 2005. Part II: Using Standard LINQ to Technologies. Chapter 6: LINQ to Object. Chapter 7: LINQ to DataSet. Chapter 8: LINQ to SQL Server. Chapter 9: LINQ to XML. Part III: Extending LINQ to New Horizons. Chapter 10: Using LINQ with Office 2007. Chapter 11: Advanced LINQ to SQL Server. Chapter 12: LINQ to Active Directory. Chapter 13: Other LINQ to Strategies. Part IV: The Part of Tens. Chapter 14: Ten Ways to Improve LINQ Development. Chapter 15: Ten Ways to Reduce Application Support Costs. Chapter 16: Ten LINQ Resources. Index.
£17.59
John Wiley & Sons Inc Discovering Requirements
Book SynopsisThis book is not only of practical value. It''s also a lot of fun to read. Michael Jackson, The Open University. Do you need to know how to create good requirements? Discovering Requirements offers a set of simple, robust, and effective cognitive tools for building requirements. Using worked examples throughout the text, it shows you how to develop an understanding of any problem, leading to questions such as: What are you trying to achieve? Who is involved, and how? What do those people want? Do they agree? How do you envisage this working? What could go wrong? Why are you making these decisions? What are you assuming? The established author team of Ian Alexander and Ljerka Beus-Dukic answer these and related questions, using a set of complementary techniques, including stakeholder analysis, goal modelling, context modelling, storytelling and scenario modelling, identifying rTable of ContentsAcknowledgements xv Foreword xvii Part I: Discovering Requirement Elements 1 1 Introduction 3 1.1 Summary 4 1.2 Why You Should Read This Book 4 1.3 Simple but Not Easy 6 1.4 Discovered, Not Found 7 1.4.1 Many Different Situations 9 1.5 A Softer Process, at First 12 1.6 More than a List of ‘The System Shalls’ 16 1.6.1 A Network of Requirement Elements 16 1.6.2 Discovery as Search 18 1.7 A Minimum of Process: The Discovery Cycle 18 1.8 The Structure of this Book 20 1.8.1 Part I: Discovering Requirement Elements 21 1.8.2 Part II: Contexts for Discovery 22 1.9 Further Reading 22 1.9.1 Books on ‘Softer’ Approaches 22 1.9.2 Books on the Philosophical Background 23 1.9.3 Books on ‘Harder’ Approaches 24 2 Stakeholders 27 2.1 Summary 28 2.2 Discovering Stakeholders 28 2.2.1 Operational Stakeholders within ‘The System’ 30 2.2.2 Stakeholders in the Containing System and Wider Environment 30 2.3 Identifying Stakeholders 37 2.3.1 From your Sponsor or Client 37 2.3.2 With a Template such as the Onion Model 37 2.3.3 By Comparison with Similar Projects 40 2.3.4 By Analysing Context 40 2.4 Managing Your Stakeholders 41 2.4.1 Engaging with Stakeholders 41 2.4.2 Keeping Track of Stakeholders 42 2.4.3 Analysing Influences 42 2.4.4 Prioritising Stakeholders 43 2.4.5 Involving Stakeholders 45 2.4.6 The Integrated Project Team 45 2.5 Validating Your List of Stakeholders 45 2.5.1 Things To Check the Stakeholder Analysis Against 46 2.6 The Bare Minimum of Stakeholder Analysis 46 2.7 Next Steps: Requirements from Stakeholders 46 2.8 Exercise 49 2.9 Further Reading 49 3 Goals 51 3.1 Summary 52 3.2 Discovering Goals 52 3.2.1 Worked Example: Goals for a Spacecraft 54 3.2.2 Worked Example: Goals for a Restaurant 57 3.2.3 Worked Example: Tram Goals and Trade-offs 59 3.2.4 Finding Solutions to Goal Conflicts 62 3.2.5 Contexts for Discovering Goals 63 3.2.6 The Negative Side 65 3.3 Documenting Goals 68 3.3.1 Drawing Goal Diagrams 69 3.3.2 Other Ways of Documenting Goals 69 3.4 Validating Goals 71 3.4.1 Things To Check Goals Against 73 3.5 The Bare Minimum of Goals 73 3.6 Next Steps 73 3.7 Exercises 73 3.8 Further Reading 74 3.8.1 Goals 74 3.8.2 The Negative Side 74 3.8.3 The i∗ Goal Modelling Notation 74 4 Context, Interfaces, Scope 75 4.1 Summary 76 4.2 Introduction 76 4.3 A ‘Soft Systems’ Approach for Ill-Defined Boundaries 77 4.3.1 You are Part of the Soft System you are Observing 78 4.3.2 From Stakeholders to Boundaries 79 4.3.3 Identifying Interfaces 83 4.3.4 Documenting Interfaces 84 4.3.5 Validating your Choice of Boundary 86 4.4 Switching to a ‘Hard Systems’ Approach for Known Events 87 4.4.1 The Traditional Context Diagram 87 4.4.2 Scope as a List of Events 87 4.4.3 Expressing Event-handling Functions 89 4.4.4 Strengths and Weaknesses of Context Diagrams 92 4.4.5 Validating Interfaces and Events 93 4.4.6 Things To Check Context and Interfaces Against 95 4.5 The Bare Minimum of Context 95 4.6 Next Steps 95 4.7 Exercise 95 4.8 Further Reading 96 4.8.1 Soft Approaches 96 4.8.2 Event-Driven Approaches 96 4.8.3 Writing Requirements 96 5 Scenarios 97 5.1 Summary 98 5.2 Discovering Scenarios 98 5.2.1 Interviews, storytelling 99 5.2.2 Scenario Workshops 101 5.2.3 Discovering Negative Scenarios 107 5.3 Documenting Scenarios 114 5.3.1 Index Cards, User Stories 115 5.3.2 Storyboards 116 5.3.3 Operational Scenarios 118 5.3.4 Use Cases 119 5.4 Summary 124 5.5 Validating Scenarios 124 5.5.1 Scenario Walkthroughs 124 5.5.2 Animation, Simulation, Prototyping 126 5.5.3 Things To Check Scenarios Against 127 5.6 The Bare Minimum of Scenarios 127 5.7 Next Steps 127 5.8 Exercises 128 5.9 Further Reading 128 5.9.1 Storytelling 128 5.9.2 Alternative Scenario Approaches 128 5.9.3 Running Scenario Workshops 129 5.9.4 The Principle of Commensurate Care 129 6 Qualities and Constraints 131 6.1 Summary 132 6.2 What are Qualities and Constraints? 132 6.2.1 A Rich Mixture 132 6.2.2 Qualities that Govern Choices 132 6.2.3 Constraints that Matter to People 133 6.3 Discovering Qualities and Constraints 133 6.3.1 Using Goals to Discover Qualities and Constraints 134 6.3.2 Stakeholder Analysis to Discover Qualities and Constraints 136 6.3.3 Using a Checklist to Discover Qualities and Constraints 136 6.4 Documenting Qualities and Constraints 141 6.4.1 Constraints 142 6.4.2 Development (Process) Qualities 146 6.4.3 Usage (Product) Qualities 147 6.5 Validating Qualities and Constraints 157 6.5.1 Things To Check Qualities and Constraints Against 158 6.6 The Bare Minimum of Qualities and Constraints 159 6.7 Next Steps 159 6.8 Exercises 159 6.9 Further Reading 160 7 Rationale and Assumptions 161 7.1 Summary 162 7.2 The Value of Rationale 162 7.3 Discovering Rationale and Assumptions 163 7.3.1 Asking Why 164 7.3.2 Looking for the word ‘will’ in vision statements, plans, etc 165 7.3.3 Rationalising a Set of Requirements 166 7.3.4 Inverting Risks 168 7.4 Documenting Rationale 169 7.4.1 Justification Text Field 171 7.4.2 Lists of Assumptions, Risks, Issues and Decisions 172 7.4.3 Traceability to Goals, Assumptions, etc 173 7.4.4 Rationale Models 178 7.4.5 The Goal Structuring Notation (GSN) 182 7.5 Validating Rationale and Assumptions 183 7.5.1 Rationale Walkthrough 184 7.5.2 Analysis of Traceability 184 7.5.3 Things To Check Rationale and Assumptions Against 186 7.6 The Bare Minimum of Rationale and Assumptions 187 7.7 Next Steps 187 7.8 Exercise 187 7.9 Further Reading 187 7.9.1 Discovering Assumptions 187 7.9.2 Reasoning 188 7.9.3 Modelling Rationale 188 7.9.4 Tracing to Goals 188 7.9.5 Goal Structuring Notation (GSN) 188 7.9.6 Satisfaction Arguments 188 8 Definitions 189 8.1 Summary 190 8.2 Discovering Definitions 190 8.2.1 Synonyms 191 8.2.2 Homonyms 193 8.3 Constructing the Project Dictionary 194 8.3.1 Acronyms 195 8.3.2 Definitions and Designations 195 8.3.3 Roles (Operational Stakeholders) 199 8.3.4 Data Definitions 201 8.3.5 Constraints as Data 202 8.4 Validating the Project Dictionary 204 8.4.1 Validating Data Models 205 8.4.2 Things To Check Definitions Against 206 8.5 The Bare Minimum of Definitions 206 8.6 Next Steps 206 8.7 Exercise 206 8.8 Further Reading 206 8.8.1 Definitions and Designations 206 8.8.2 Data Modelling 207 9 Measurements 209 9.1 Summary 210 9.2 Discovering and Documenting Acceptance Criteria 211 9.2.1 Acceptance Criteria for Behavioural Requirements 212 9.2.2 Acceptance Criteria for Qualities 216 9.2.3 Acceptance Criteria for Constraints 218 9.2.4 Verification Method 219 9.3 Validating Acceptance Criteria 222 9.3.1 Testing from Day One 222 9.4 Measuring Quality of Service (QoS) 223 9.4.1 Example Service: Office Carpeting 224 9.4.2 Two Opposite Approaches 225 9.4.3 A Spectrum of Service Approaches 226 9.4.4 Worked Example: QoS Measures for Food Preparation Services 228 9.5 Validating QoS Measures 230 9.5.1 Qualities of a Good QoS Measure 230 9.5.2 Will your QoS Measures Work? 231 9.5.3 Common QoS Measures 232 9.5.4 Validating QoS with Negative Scenarios 232 9.5.5 Things To Check Measurements Against 233 9.6 The Bare Minimum of Measurement 233 9.7 Next Steps 233 9.8 Exercise 233 9.9 Further Reading 233 10 Priorities 235 10.1 Summary 236 10.2 Two Kinds of Priority 236 10.3 Input Priority 237 10.3.1 Discovering Input Priority 237 10.3.2 Documenting Input Priority 241 10.3.3 Validating Input Priority 242 10.4 Output Priority 243 10.4.1 Discovering Output Priority 243 10.4.2 Documenting Output Priority 251 10.4.3 Validating Output Priority 253 10.5 Things To Check Priority Against 254 10.6 The Bare Minimum of Priorities 255 10.7 Next Steps 255 10.8 Exercise 255 10.9 Further Reading 255 10.9.1 Triage 255 10.9.2 Input Priority 256 10.9.3 Boston Matrix 256 10.9.4 Review Process 256 10.9.5 Life Cycles 256 Part II: Discovery Contexts 257 11 Requirements from Individuals 259 11.1 Summary 260 11.2 Introduction 260 11.3 Interviews 261 11.3.1 Planning an Interview Campaign 261 11.3.2 Planning Each Interview 267 11.3.3 Documenting Interviews 268 11.3.4 Validating Interview Findings 273 11.4 Observation and ‘Apprenticeship’ 274 11.4.1 Making Observations 274 11.4.2 Being ‘Talked Through’ Operations 276 11.4.3 Documenting Observations 277 11.4.4 Validating Observations 280 11.5 The Bare Minimum from Individuals 280 11.6 Exercises 280 11.7 Further Reading 281 11.7.1 Interviewing 281 11.7.2 Using Video 281 11.7.3 Observation 282 11.7.4 Tacit Knowledge 282 11.7.5 Standard Types of Systems Analysis 282 11.7.6 Informal Modelling Techniques 282 11.7.7 Philosophy 282 12 Requirements from Groups 283 12.1 Summary 284 12.2 The Goal of Group Work 284 12.2.1 Unique Capabilities 284 12.2.2 Obstacles 285 12.2.3 Mediating Group Work (on one site or many) 285 12.3 Workshops 286 12.3.1 Define Workshop Mission 286 12.3.2 Workshop Planning 287 12.3.3 Workshop Rehearsal 289 12.3.4 Workshop Setup 290 12.3.5 Workshop Recording 299 12.3.6 Validating Workshop Findings 302 12.4 Group Media 305 12.4.1 Project Wall 305 12.4.2 Project Website 306 12.4.3 Project Wiki 307 12.4.4 Modelling Tool 308 12.4.5 Requirements Management Tool 309 12.4.6 Groupware and Working at a Distance 310 12.4.7 The Role of Group Media 312 12.5 The Bare Minimum from Groups 314 12.6 Next Steps 314 12.7 Exercise 314 12.8 Further Reading 315 12.8.1 Workshops 315 12.8.2 Working in Groups 315 13 Requirements from Things 317 13.1 Summary 318 13.2 Requirements Prototyping 318 13.2.1 Purpose 319 13.2.2 Techniques 319 13.3 Reverse Engineering 330 13.3.1 From an Existing Product 330 13.4 Requirements Reuse 337 13.4.1 Type 1: Naïve Reuse 337 13.4.2 Type 2: Standardisation 338 13.4.3 Type 3: Product Lines 338 13.4.4 Tool Support for Reuse 338 13.5 Validating Requirements from Things 340 13.6 The Bare Minimum from Things 340 13.7 Exercises 340 13.8 Further Reading 340 13.8.1 Prototyping 340 14 Trade-offs 343 14.1 Summary 344 14.2 Optioneering: The Engineering of Trade-offs 344 14.2.1 The Requirements-First Life-Cycle Myth 344 14.2.2 An Optioneering Life Cycle 345 14.2.3 The Optioneering Process 350 14.2.4 Selecting the Winning Option 352 14.2.5 Optioneering with PCA: A Worked Example 360 14.3 Validating your Trade-offs 367 14.4 The Bare Minimum of Trade-offs 367 14.5 Next Steps 367 14.6 Exercises 368 14.7 Further Reading 369 14.7.1 Trade-offs 369 14.7.2 Statistics 370 14.7.3 PCA 370 14.7.4 Weighting Approaches 370 14.7.5 Analytic Hierarchy Process (AHP) 370 14.7.6 Quality Function Deployment (QFD) 370 14.7.7 Questions, Options, Criteria (QOC) 371 15 Putting it all Together 373 15.1 Summary 374 15.2 After Discovery 374 15.2.1 Everything Depends on the Requirements 374 15.2.2 Principles for the Requirements Chef 375 15.3 The Right Process for your Project 376 15.3.1 Case Study: A Retail IT Project 377 15.3.2 Case Study: Transport Planning 379 15.3.3 Requirements-Driven Project Management 381 15.4 Organising the Requirements Specification 385 15.4.1 Template 385 15.4.2 Levels 385 15.4.3 Can Use Cases Do Everything? 386 15.4.4 Organising Product Functions 386 15.4.5 Traditional ‘Shalls’ 387 15.4.6 Relating Requirements of Different Types 388 15.4.7 Conflicting Needs for Requirement Organisation 390 15.4.8 The Benefit of Requirements (Traceability) Tools 390 15.4.9 An Alternative View: Competing Approaches 391 15.5 The Bare Minimum of Putting it all Together 394 15.6 Further Reading 394 15.6.1 Choosing and Tailoring Development Life Cycles 394 15.6.2 Managing Projects From Requirements 395 15.6.3 Classics for Inspiration and Reflection 395 15.6.4 A Look Ahead 396 Appendix A: Exercise Answers and Hints 397 Appendix B: Getting the Level Right 405 Appendix C: Tools for Requirements Discovery 411 Appendix D: Template 423 Bibliography 429 Glossary 433 Index 445
£27.75
John Wiley & Sons Inc Architecting Enterprise Solutions Patterns for
Book SynopsisBased on real--world problems and systems and illustrated with "war stories," this practical nuts--and--bolts guide to architectural solutions describes step--by--step how to design robustness and flexibility into a system. A running case study illustrates the evolution and iteration of the system as it grows in functionality and capability.Table of ContentsAcknowledgements. An All-Too-Common Story. Introduction. Part 1 Architecture, Patterns and Internet Technology. System Architecture. Internet Technology Systems. Architectural Patterns for Internet Technology Systems. The GlobalTech System. Part 2 The Patterns. Fundamental Patterns. System Performance Patterns. System Control Patterns. System Evolution Patterns. Part 3 Application of the Patterns. GlobalTech Revisited. Appplying the Patterns. Moving on from Here. Appendix Reference Patterns. Bibliography. Glossary.
£23.99
John Wiley & Sons Inc Security Patterns
Book SynopsisMost security books are targeted at security engineers and specialists. Few show how build security into software. None breakdown the different concerns facing security at different levels of the system: the enterprise, architectural and operational layers.Table of ContentsChapter 1 The Pattern Approach 1 Patterns at a Glance 2 No Pattern is an Island 4 Patterns Everywhere 4 Humans are the Target 5 Patterns Resolve Problems and Shape Environments 6 Towards Pattern Languages 7 Documenting Patterns 9 A Brief Note on The History of Patterns 11 The Pattern Community and its Culture 12 Chapter 2 Security Foundations 15 Overview 16 Security Taxonomy 17 General Security Resources 26 Chapter 3 Security Patterns 29 The History of Security Patterns 30 Characteristics of Security Patterns 31 Why Security Patterns? 34 Sources for Security Pattern Mining 37 Chapter 4 Patterns Scope and Enterprise Security 47 The Scope of Patterns in the Book 48 Organization Factors 49 Resulting Organization 51 Mapping to the Taxonomy 53 Organization in the Context of an Enterprise Framework 53 Chapter 5 The Security Pattern Landscape 59 Enterprise Security and Risk Management Patterns 59 Identification & Authentication (I&A) Patterns 62 Access Control Model Patterns 67 System Access Control Architecture Patterns 69 Operating System Access Control Patterns 71 Accounting Patterns 73 Firewall Architecture Patterns 77 Secure Internet Applications Patterns 78 Cryptographic Key Management Patterns 80 Related Security Pattern Repositories Patterns 83 Chapter 6 Enterprise Security and Risk Management 85 Security Needs Identification for Enterprise Assets 89 Asset Valuation 103 Threat Assessment 113 Vulnerability Assessment 125 Risk Determination 137 Enterprise Security Approaches 148 Enterprise Security Services 161 Enterprise Partner Communication 173 Chapter 7 Identification and Authentication (I&A) 187 I&A Requirements 192 Automated I&A Design Alternatives 207 Password Design and Use 217 Biometrics Design Alternatives 229 Chapter 8 Access Control Models 243 Authorization 245 Role-Based Access Control 249 Multilevel Security 253 Reference Monitor 256 Role Rights Definition 259 Chapter 9 System Access Control Architecture 265 Access Control Requirements 267 Single Access Point 279 Check Point 287 Security Session 297 Full Access with Errors 305 Limited Access 312 Chapter 10 Operating System Access Control 321 Authenticator 323 Controlled Process Creator 328 Controlled Object Factory 331 Controlled Object Monitor 335 Controlled Virtual Address Space 339 Execution Domain 343 Controlled Execution Environment 346 File Authorization 350 Chapter 11 Accounting 355 Security Accounting Requirements 360 Audit Requirements 369 Audit Trails and Logging Requirements 378 Intrusion Detection Requirements 388 Non-Repudiation Requirements 396 Chapter 12 Firewall Architectures 403 Packet Filter Firewall 405 Proxy-Based Firewall 411 Stateful Firewall 417 Chapter 13 Secure Internet Applications 423 Information Obscurity 426 Secure Channels 434 Known Partners 442 Demilitarized Zone 449 Protection Reverse Proxy 457 Integration Reverse Proxy 465 Front Door 473 Chapter 14 Case Study: IP Telephony 481 IP Telephony at a Glance 482 The Fundamentals of IP Telephony 483 Vulnerabilities of IP Telephony Components 488 IP Telephony Use Cases 488 Securing IP telephony with patterns 493 Applying Individual Security Patterns 497 Conclusion 500 Chapter 15 Supplementary Concepts 503 Security Principles and Security Patterns 504 Enhancing Security Patterns with Misuse Cases 525 Chapter 16 Closing Remarks 531 References 535 Index 555
£32.00
John Wiley & Sons Inc Practical Database Programming with Java
Book SynopsisThis important resource offers a detailed description about the practical considerations and applications in database programming using Java NetBeans 6. 8 with authentic examples and detailed explanations. This book provides readers with a clear picture as to how to handle the database programming issues in the Java NetBeans environment.Table of ContentsPreface xxiii Acknowledgments xxv Chapter 1 Introduction 1 What This Book Covers 2 How This Book Is Organized and How to Use This Book 3 How to Use the Source Code and Sample Databases 5 Instructor and Customer Support 6 Homework Solutions 7 Chapter 2 Introduction to Databases 9 2.1 What Are Databases and Database Programs? 10 2.2 Develop a Database 12 2.3 Sample Database 13 2.4 Identifying Keys 17 2.5 Define Relationships 18 2.6 ER Notation 21 2.7 Data Normalization 21 2.8 Database Components in Some Popular Databases 26 2.9 Create Microsoft Access Sample Database 34 2.10 Create Microsoft SQL Server 2008 2.11 Create Oracle 10g XE Sample Database 61 2.12 Chapter Summary 85 Chapter 3 JDBC API and JDBC Drivers 89 3.1 What Are JDBC and JDBC API? 89 3.2 JDBC Components and Architecture 90 3.3 How Does JDBC Work? 92 3.4 JDBC Driver and Driver Types 95 3.5 JDBC Standard Extension API 99 3.6 Chapter Summary 108 Chapter 4 JDBC Application Design Considerations 113 4.1 JDBC Application Models 113 4.2 JDBC Applications Fundamentals 115 4.3 Chapter Summary 151 Chapter 5 Introduction to NetBeans IDE 155 5.1 Overview of the NetBeans IDE 6.8 156 5.2 Installing and Confi guring the NetBeans IDE 6.8 161 5.3 Exploring NetBeans IDE 6.8 164 5.4 Chapter Summary 312 PART I Building Two-Tier Client–Server Applications 317 Chapter 6 Query Data from Databases 319 Section I Query Data Using Java Persistence API Wizards 319 6.1 Java Persistence APIs 319 6.2 Query Data Using Java Persistence API Wizards (JPA) 321 Section II Query Data Using Java Runtime Objects Method 383 6.3 Introduction to Runtime Object Method 383 6.4 Create a Java Application Project to Access the SQL Server Database 384 6.5 Create a Java Application Project to Access the Oracle Database 441 6.6 Chapter Summary 455 Chapter 7 Insert, Update, and Delete Data from Databases 463 Section I Insert, Update and Delete Data Using Java Persistence API Wizards 463 7.1 Perform Data Manipulations to SQL Server Database Using JPA Wizards 464 7.2 Perform Data Manipulations to Oracle Database Using JPA Wizards 482 Section II Insert, Update and Delete Data Using Java Runtime Objects Method 488 7.3 Perform Data Manipulations to SQL Server Database Using Java Runtime Object 488 7.4 Perform Data Manipulations to Oracle Database Using Java Runtime Object 502 7.5 Perform Data Manipulations Using Updatable ResultSet 510 7.6 Perform Data Manipulations Using Callable Statements 522 7.7 Chapter Summary 550 PART II Building Three-Tier Client–Server Applications 555 Chapter 8 Developing Java Web Applications to Access Databases 557 8.1 A Historical Review about Java Web Application Development 557 8.2 Java EE Web Application Model 597 8.3 The Architecture and Components of Java Web Applications 599 8.4 Getting Started with Java Web Applications Using NetBeans IDE 611 8.5 Build Java Web Project to Access SQL Server Database 625 8.6 Build Java Web Project to Access and Manipulate Oracle Database 690 8.7 Chapter Summary 764 Chapter 9 Developing Java Web Services to Access Databases 769 9.1 Introduction to Java Web Services 770 9.2 The Structure and Components of SOAP-Based Web Services 772 9.3 The Procedure of Building a Typical SOAP-Based Web Service Project 774 9.4 Getting Started with Java Web Services Using NetBeans IDE 786 9.5 Build Java Web Service Projects to Access SQL Server Database 787 9.6 Build a Windows-Based Web Client Project to Consume the Web Service 795 9.7 Build a Web-Based Client Project to Consume the Web Service 801 9.8 Build Java Web Service to Insert Data into the SQL Server Database 808 9.9 Build a Windows-Based Web Client Project to Consume the Web Service 811 9.10 Build a Web-Based Client Project to Consume the Web Service 815 9.11 Build Java Web Service to Update and Delete Data from the SQL Server Database 819 9.12 Build a Windows-Based Web Client Project to Consume the Web Service 827 9.13 Build a Web-Based Client Project to Consume the Web Service 834 9.14 Build Java Web Service Projects to Access Oracle Databases 840 9.15 Build a Windows-Based Web Client Project to Consume the Web Service 873 9.16 Build a Web-Based Web Client Project to Consume the Web Service 890 9.17 Chapter Summary 904 Homework 905 Index 909 About the Author 919
£86.36
John Wiley & Sons C for Everyone
Book Synopsis
£121.50
John Wiley & Sons Inc C Scientific Programming
Book Synopsis Teaches the design of programs for scientific computation in C++ Introduces unique C++ classes, defines the particular relationships among these classes, and demonstrates their use in a dozen of the most powerful current applications Presents a set of practices that allows programmers to embrace the attractive features of C++ without incurring undesired side effects and hidden costs Includes a collection of source code files downloadable from the Wiley ftp site Originally announced as Scientific Program Design: C++ for Native Fortran Writers Trade Review"...teaches the design of programs for scientific computation in C++." (SciTech Book News, Vol. 25, No. 4, December 2001) "With a view to teaching the design of programs...the author introduces unique C++ classes for vectors, dense matrices, and sparse matrices...demonstrates their use..." (Mechanical Engineering, www.wemagazine.org, April 2, 2002)Table of ContentsPreafce. Overview. Vector ad Matrix Basics. Sparse Matrix Basics. Conjugate-Gradient Methods. Triangular Matrices. Householder Matrix Methods. Singular Value Decomposition. Cholesky Decomposition. Automatic Derivatives. Constrained Optimization. Interior-Point Extensions. LU Factorization. Complex Arrays. Fourier Transforms. References. Index.
£84.56
John Wiley & Sons Inc Software Project Management For Dummies
Book SynopsisHelps you manage scope creep and keep your project on schedule and get the scoop on managing time, cost, people, risk, quality, and integration.Table of ContentsIntroduction 1 Part I: Starting Your Software Project 7 Chapter 1: Examining the Big Picture of Project Management 9 Chapter 2: Initiating a Software Project 25 Chapter 3: Creating the Software Scope 55 Part II: Planning Your Software Project 77 Chapter 4: Planning for Communications 79 Chapter 5: Planning for Software Project Risks 107 Chapter 6: Planning for Software Quality 131 Chapter 7: Building the Project Team 147 Chapter 8: Creating Project Time Estimates 165 Chapter 9: Building Your Project Budget 191 Part III: Executing Your Software Project Plan 209 Chapter 10: Working the Project Plan 211 Chapter 11: Working with Project People 229 Chapter 12: Procuring Goods and Services 245 Part IV: Controlling Your Software Project 263 Chapter 13: Managing Changes to the Software Project 265 Chapter 14: Using Earned Value Management in Software Projects 281 Chapter 15: Tracking Project Performance 295 Part V: Closing Your Software Project 313 Chapter 16: Finalizing the Project Management Processes 315 Chapter 17: Documenting Your Software Project 333 Part VI: The Part of Tens 347 Chapter 18: Ten Ways to Make Your Software Project Crash and Burn 349 Chapter 19: Ten Ways to Make Any Software Project Better 359 Appendix: Formal Project Management Training and Certification 369 Index 375
£22.39
O'Reilly Media Java Servlet Programming
Book SynopsisThis new edition of this book has been updated to add the new features of the Java Servlet API Version 2.2, and new chapters on servlet security and advanced communication. It also introduces several popular tools including JavaServer Pages (JSP), Tea, XMLC, and the Element Construction Set.Table of Contents1. Introduction History of Web Applications Support for Servlets The Power of Servlets. 2. HTTP Servlet Basics HTTP Basics The Servlet API Page Generation Web Applications Moving On. 3. The Servlet Lifecycle The Servlet Alternative Servlet Reloading Init and Destroy Single-Thread Model Background Processing Load on Startup Client-Side Caching Server-Side Caching. 4. Retrieving Information The Servlet The Server The Client. 5. Sending HTML Information The Structure of a Response Sending a Normal Response Using Persistent Connections Response Buffering Status Codes HTTP Headers When Things Go Wrong Six Ways to Skin a Servlet Cat. 6. Sending Multimedia Content WAP and WML Images Compressed Content Server Push. 7. Session Tracking User Authentication Hidden Form Fields URL Rewriting Persistent Cookies The Session Tracking API. 8. Security HTTP Authentication Form-Based Authentication Custom Authentication Digital Certificates Secure Sockets Layer (SSL). 9. Database Connectivity Relational Databases The JDBC API Reusing Database Objects Transactions A Guestbook Servlet Advanced JDBC Techniques Beyond the Core. 10. Applet-Servlet Communication Communication Options Daytime Server Chat Server. 11. Servlet Collaboration Sharing Information Sharing Control. 12. Enterprise Servlets and J2EE Distributing Load Integrating with J2EE. 13. Internationalization Western European Languages Conforming to Local Customs Non-Western European Languages Multiple Languages Dynamic Language Negotiation HTML Forms. 14. The Tea Framework The Tea Language Getting Started Request Information Tea Administration Tea Applications A Tool Application Final Words. 15. WebMacro The WebMacro Framework Installing WebMacro WebMacro Directives WebMacro Templates A Tool Application Filters. 16. Element Construction Set Page Components as Objects Displaying a Result Set. 17. XMLC A Simple XML Compile The Manipulation Class A Tool Application. 18. JavaServer Pages Using JavaServer Pages Behind the Scenes Expressions and Declarations Directives JSP and JavaBeans Includes and Forwards A Tool Application Custom Tag Libraries. 19. Odds and Ends Parsing Parameters Sending Email Using Regular Expressions Executing Programs Using Native Methods Acting as an RMI Client Debugging Performance Tuning. 20. What's New in the Servlet 2.3 API Changes in the Servlet API 2.3 Conclusion. A. Servlet API Quick Reference. B. HTTP Servlet API Quick Reference. C. Deployment Descriptor DTD Reference. D. HTTP Status Codes. E. Character Entities. F. Charsets. Index
£29.99
O'Reilly Media Programming Web Services with SOAP
Book SynopsisThis is an introduction to building distributed Web-based applications using the SOAP, WSDL, and UDDI protocols. You'll learn the XML underlying these standards, as well as how to use the popular toolkits for Java and Perl. The book also addresses security and other enterprise issues.Table of ContentsPreface 1. Introducing Web Services What Is a Web Service? Web Service Fundamentals The Web Service Technology Stack Application The Peer Services Model 2. Introducing SOAP SOAP and XML SOAP Messages SOAP Faults The SOAP Message Exchange Model Using SOAP for RPC-Style Web Services SOAP's Data Encoding SOAP Data Types SOAP Transports 3. Writing SOAP Web Services Web Services Anatomy 101 Creating Web Services in Perl with SOAP::Lite Creating Web Services in Java with Apache SOAP Creating Web Services In .NET Interoperability Issues 4. The Publisher Web Service Overview The Publisher Operations The Publisher Server The Java Shell Client 5. Describing a SOAP Service Describing Web Services Anatomy of a Service Description Defining Data Types and Structures with XML Schemas Describing the Web Service Interface Describing the Web Service Implementation Understanding Messaging Patterns 6. Discovering SOAP Services The UDDI Registry The UDDI Interfaces Using UDDI to Publish Services Using UDDI to Locate Services Generating UDDI from WSDL Using UDDI and WSDL Together The Web Service Inspection Language (WS-Inspection) 7. Web Services in Action The CodeShare Service Network The Code Share Index Web Services Security Definitions and Descriptions Implementing the CodeShare Server Implementing the CodeShare Owner Implementing the CodeShare Client Seeing It in Action What's Missing from This Picture? Developing CodeShare 8. Web Services Security What Is a "Secure" Web Service? Microsoft Passport, Version 1.x and 2.x Microsoft Passport, Version 3.x Give Me Liberty or Give Me - A Magic Carpet The Need for Standards XML Digital Signatures and Encryption 9. The Future of Web Services The Future of Web Development The Future of SOAP The Future of WSDL The Future of UDDI Web Services Battlegrounds Technologies Web Services Rollout A. Web Service Standardization B. XML Schema Basics C. Code Listings Index
£20.99
O'Reilly Media Programming Web Services with XMLRPC
Book SynopsisIntroduces the capabilities of XML-RPC, a system for remote procedure calls built on XML and the HTTP protocol. XML-RPC lets developers connect programs running on different computers by wrapping procedure calls in XML and establishing simple pathways for calling functions.Trade Review'This is a good book and, if this is an area of programming that interests you, simply buy a copy and save yourself hours of trial and error.' - Mike James, Computer Shopper, October 2001Table of ContentsForeword. Preface. 1. Introduction What XML-RPC Does Where XML-RPC Excels A Quick Tour of the Minefields. 2. The XML-RPC Protocol Choreography Data Types Request Format Response Format The Nil Value A DTD for XML-RPC. 3. Client-Server Communication: XML-RPC in Java Why XML-RPC for Java? The XML-RPC Java Library Building XML-RPC Clients Building XML-RPC Servers Creating XML-RPC Handlers Three Practical Examples Moving Toward Cross-Platform Peer-to-Peer. 4. XML-RPC and Perl Perl's Implementation of XML-RPC Data Types XML-RPC Clients XML-RPC Servers Integrating XML-RPC into a Web Server. 5. Integrating Web Applications: XML-RPC in PHP Getting the XML-RPC Library for PHP Understanding the Client Classes Mapping Data Between PHP and XML-RPC Invoking Methods Building XML-RPC Servers in PHP Connecting Web Applications What PHP and XML-RPC Can Do. 6. XML-RPC and Python Python Implementations of XML-RPC Installing PythonWare XML-RPC Data Types XML-RPC Clients XML-RPC Servers Integrating XML-RPC into a Web Server Using Zope as an XML-RPC Server. 7. Bridging XML-RPC and COM: XML-RPC in ASP Using XML-RPC with ASP Making Active Server Pages More Active Data Types and the API Building an Address Book Web Service with ASP Talking to MS Access from Linux An XML-RPC Client in ASP Creating a Window to Linux Connections and Caveats. 8. XML-RPC and the Web Services Landscape The Web Services Vision Public XML-RPC Services Design Considerations for Any XML-RPC Application Beyond XML-RPC Protocol Design Choices XML-RPC and Web Services. A. The XML You Need for XML-RPC B. The HTTP You Need for XML-RPC Index
£20.99
Pluto Press Reinventing the Welfare State Digital Platforms
Book SynopsisThe welfare state is unfit for purpose – how can we transform it into a force for equality and social justice?Trade Review'Huws documents brilliantly how the welfare state has morphed into a machine for increasing inequality and distributing wealth upwards. Her solutions are radical, but in the post-Covid slump radicalism will be essential.' -- Paul Mason, author of 'Postcapitalism: A Guide to Our Future'‘A must-read for those who seek to find a logical order behind the dramatic events of current times. Ursula Huws’ work maps out with great attention the new borders of the socio-economic issues of today’ -- Justin Nogarede, Digital Policy Advisor at the Foundation for European Progressive Studies'A searing critique of how welfare cuts have hit the most vulnerable hardest - and a compelling account of how we can rebuild social security with new tech. A must read for policymakers, campaigners and trade unionists.' -- Frances O'Grady, General Secretary of the Trades Union Congress'With remarkable precision, Ursula Huws provides a chilling account of how the British welfare state has been turned upside down, no longer a mechanism for reversing inequality but for enhancing the wealth of the super-rich. She then outlines a new welfare agenda, detailing the infrastructures necessary to enhance the lives of carers and cared for alike, as well as now essential for global sustainability overall. Not to be missed!' -- Lynne Segal (from the Care Collective)'Ursula Huws hits the nail on its head exposing the brutal exploitation of vulnerable workers as the gig economies flourish.' -- Yaseen Aslam, President of the App Drivers and Couriers Union, and lead claimant in the Aslam v. Uber worker rights claim'A must-read for those who seek to find a logical order behind the rapid and dramatic events of current times' -- Brando Benifei, MEP and Vice President of the International European MovementTable of ContentsSeries Preface Preface Acknowledgements 1. Introduction 2. What Has Happened to the Twentieth-century Welfare State? 3. What Has Happened in the Labour Market? 4. What Has Happened to Gender Equality? 5. Recalibrating the Mechanisms of Redistribution 6. A Universal Basic Income that is Genuinely Redistributive 7. A New Deal for Labour 8. Digital Platforms for Public Good 9. The Way Forward Notes Index
£68.00
Pluto Press Reinventing the Welfare State
Book SynopsisThe welfare state is unfit for purpose how can we transform it into a force for equality and social justice?Trade Review'Huws documents brilliantly how the welfare state has morphed into a machine for increasing inequality and distributing wealth upwards. Her solutions are radical, but in the post-Covid slump radicalism will be essential.' -- Paul Mason, author of 'Postcapitalism: A Guide to Our Future'‘A must-read for those who seek to find a logical order behind the dramatic events of current times. Ursula Huws’ work maps out with great attention the new borders of the socio-economic issues of today’ -- Justin Nogarede, Digital Policy Advisor at the Foundation for European Progressive Studies'A searing critique of how welfare cuts have hit the most vulnerable hardest - and a compelling account of how we can rebuild social security with new tech. A must read for policymakers, campaigners and trade unionists.' -- Frances O'Grady, General Secretary of the Trades Union Congress'With remarkable precision, Ursula Huws provides a chilling account of how the British welfare state has been turned upside down, no longer a mechanism for reversing inequality but for enhancing the wealth of the super-rich. She then outlines a new welfare agenda, detailing the infrastructures necessary to enhance the lives of carers and cared for alike, as well as now essential for global sustainability overall. Not to be missed!' -- Lynne Segal (from the Care Collective)'Ursula Huws hits the nail on its head exposing the brutal exploitation of vulnerable workers as the gig economies flourish.' -- Yaseen Aslam, President of the App Drivers and Couriers Union, and lead claimant in the Aslam v. Uber worker rights claim'A must-read for those who seek to find a logical order behind the rapid and dramatic events of current times' -- Brando Benifei, MEP and Vice President of the International European MovementTable of ContentsSeries Preface Preface Acknowledgements 1. Introduction 2. What Has Happened to the Twentieth-century Welfare State? 3. What Has Happened in the Labour Market? 4. What Has Happened to Gender Equality? 5. Recalibrating the Mechanisms of Redistribution 6. A Universal Basic Income that is Genuinely Redistributive 7. A New Deal for Labour 8. Digital Platforms for Public Good 9. The Way Forward Notes Index
£17.09
John Wiley & Sons Inc Beginning Algorithms
Book SynopsisBeginning Algorithms A good understanding of algorithms, and the knowledge of when to apply them, is crucial to producing software that not only works correctly, but also performs efficiently.Table of ContentsAcknowledgments. Introduction. Chapter 1: Getting Started. Chapter 2: Iteration and Recursion. Chapter 3: Lists. Chapter 4: Queues. Chapter 5: Stacks. Chapter 6: Basic Sorting. Chapter 7: Advanced Sorting. Chapter 8: Priority Queues. Chapter 9: Binary Searching and Insertion. Chapter 10: Binary Search Trees. Chapter 11: Hashing. Chapter 12: Sets. Chapter 13: Maps. Chapter 14: Ternary Search Trees. Chapter 15: B-Trees. Chapter 16: String Searching. Chapter 17: String Matching. Chapter 18: Computational Geometry. Chapter 19: Pragmatic Optimization. Appendix A: Further Reading. Appendix B: Resources. Appendix C: Bibliography. Appendix D: Answers to Exercises. Index.
£24.69
John Wiley & Sons Java For Everyone
Book Synopsis
£117.90
Wrox PHP and MySQL 24Hour Trainer
Book SynopsisStep-by-step lessons for using PHP and MySQL in a unique book-and-video combination Assuming no previous experience with PHP or MySQL, this book-and-video package is ideal reading for anyone who wants to go beyond HTML/CSS in order to provide clients with the most dynamic web sites possible. The approachable tone breaks down the basics of programming and PHP and MySQL in individual lessons starting with the installation of the programs necessary to run PHP. You begin with a static web site and then watch and learn as PHP functionality is added as you work through the lessons. When working with databases, the MySQL database is introduced with demonstrations that show how to interact with it. The accompanying videos enhance your learning experience, as each lesson in the book is portrayed in the video exercises. Lessons include:*Getting started with PHP*Setting up your workspace*Adding PHP to a web page*Learning PHP syntax
£29.44
John Wiley & Sons Inc Beginning R The Statistical Programming Language
Book SynopsisConquer the complexities of this open source statistical language R is fast becoming the de facto standard for statistical computing and analysis in science, business, engineering, and related fields. This book examines this complex language using simple statistical examples, showing how R operates in a user-friendly context.Table of ContentsIntroduction xxi Chapter 1: Introducing R: What It Is and How to Get It 1 Getting the Hang of R 2 The R Website 3 Downloading and Installing R from CRAN 3 Installing R on Your Windows Computer 4 Installing R on Your Macintosh Computer 7 Installing R on Your Linux Computer 7 Running the R Program 8 Finding Your Way with R 10 Getting Help via the CRAN Website and the Internet 10 The Help Command in R 10 Help for Windows Users 11 Help for Macintosh Users 11 Help for Linux Users 13 Help For All Users 13 Anatomy of a Help Item in R 14 Command Packages 16 Standard Command Packages 16 What Extra Packages Can Do for You 16 How to Get Extra Packages of R Commands 18 How to Install Extra Packages for Windows Users 18 How to Install Extra Packages for Macintosh Users 18 How to Install Extra Packages for Linux Users 19 Running and Manipulating Packages 20 Loading Packages 21 Windows-Specific Package Commands 21 Macintosh-Specific Package Commands 21 Removing or Unloading Packages 22 Summary 22 Chapter 2: Starting Out: Becoming Familiar with R 25 Some Simple Math 26 Use R Like a Calculator 26 Storing the Results of Calculations 29 Reading and Getting Data into R 30 Using the combine Command for Making Data 30 Entering Numerical Items as Data 30 Entering Text Items as Data 31 Using the scan Command for Making Data 32 Entering Text as Data 33 Using the Clipboard to Make Data 33 Reading a File of Data from a Disk 35 Reading Bigger Data Files 37 The read.csv() Command 37 Alternative Commands for Reading Data in R 39 Missing Values in Data Files 40 Viewing Named Objects 41 Viewing Previously Loaded Named-Objects 42 Viewing All Objects 42 Viewing Only Matching Names 42 Removing Objects from R 44 Types of Data Items 45 Number Data 45 Text Items 45 Converting Between Number and Text Data 46 The Structure of Data Items 47 Vector Items 48 Data Frames 48 Matrix Objects 49 List Objects 49 Examining Data Structure 49 Working with History Commands 51 Using History Files 52 Viewing the Previous Command History 52 Saving and Recalling Lists of Commands 52 Alternative History Commands in Macintosh OS 52 Editing History Files 53 Saving Your Work in R 54 Saving the Workspace on Exit 54 Saving Data Files to Disk 54 Save Named Objects 54 Save Everything 55 Reading Data Files from Disk 56 Saving Data to Disk as Text Files 57 Writing Vector Objects to Disk 58 Writing Matrix and Data Frame Objects to Disk 58 Writing List Objects to Disk 59 Converting List Objects to Data Frames 60 Summary 61 Chapter 3: Starting Out: Working With Objects 65 Manipulating Objects 65 Manipulating Vectors 66 Selecting and Displaying Parts of a Vector 66 Sorting and Rearranging a Vector 68 Returning Logical Values from a Vector 70 Manipulating Matrix and Data Frames 70 Selecting and Displaying Parts of a Matrix or Data Frame 71 Sorting and Rearranging a Matrix or Data Frame 74 Manipulating Lists 76 Viewing Objects within Objects 77 Looking Inside Complicated Data Objects 77 Opening Complicated Data Objects 78 Quick Looks at Complicated Data Objects 80 Viewing and Setting Names 82 Rotating Data Tables 86 Constructing Data Objects 86 Making Lists 87 Making Data Frames 88 Making Matrix Objects 89 Re-ordering Data Frames and Matrix Objects 92 Forms of Data Objects: Testing and Converting 96 Testing to See What Type of Object You Have 96 Converting from One Object Form to Another 97 Convert a Matrix to a Data Frame 97 Convert a Data Frame into a Matrix 98 Convert a Data Frame into a List 99 Convert a Matrix into a List 100 Convert a List to Something Else 100 Summary 104 Chapter 4: Data: Descriptive Statistics and Tabulation 107 Summary Commands 108 Summarizing Samples 110 Summary Statistics for Vectors 110 Summary Commands With Single Value Results 110 Summary Commands With Multiple Results 113 Cumulative Statistics 115 Simple Cumulative Commands 115 Complex Cumulative Commands 117 Summary Statistics for Data Frames 118 Generic Summary Commands for Data Frames 119 Special Row and Column Summary Commands 119 The apply() Command for Summaries on Rows or Columns 120 Summary Statistics for Matrix Objects 120 Summary Statistics for Lists 121 Summary Tables 122 Making Contingency Tables 123 Creating Contingency Tables from Vectors 123 Creating Contingency Tables from Complicated Data 123 Creating Custom Contingency Tables 126 Creating Contingency Tables from Matrix Objects 128 Selecting Parts of a Table Object 130 Converting an Object into a Table 132 Testing for Table Objects 133 Complex (Flat) Tables 134 Making “Flat” Contingency Tables 134 Making Selective “Flat” Contingency Tables 138 Testing “Flat” Table Objects 139 Summary Commands for Tables 139 Cross Tabulation 142 Testing Cross-Table (xtabs) Objects 144 A Better Class Test 144 Recreating Original Data from a Contingency Table 145 Switching Class 146 Summary 147 Chapter 5: Data: Distrib ution 151 Looking at the Distribution of Data 151 Stem and Leaf Plot 152 Histograms 154 Density Function 158 Using the Density Function to Draw a Graph 159 Adding Density Lines to Existing Graphs 160 Types of Data Distribution 161 The Normal Distribution 161 Other Distributions 164 Random Number Generation and Control 166 Random Numbers and Sampling 168 The Shapiro-Wilk Test for Normality 171 The Kolmogorov-Smirnov Test 172 Quantile-Quantile Plots 174 A Basic Normal Quantile-Quantile Plot 174 Adding a Straight Line to a QQ Plot 174 Plotting the Distribution of One Sample Against Another 175 Summary 177 Chapter 6: Si mple Hypothesis Testing 181 Using the Student’s t-test 181 Two-Sample t-Test with Unequal Variance 182 Two-Sample t-Test with Equal Variance 183 One-Sample t-Testing 183 Using Directional Hypotheses 183 Formula Syntax and Subsetting Samples in the t-Test 184 The Wilcoxon U-Test (Mann-Whitney) 188 Two-Sample U-Test 189 One-Sample U-Test 189 Using Directional Hypotheses 189 Formula Syntax and Subsetting Samples in the U-test 190 Paired t- and U-Tests 193 Correlation and Covariance 196 Simple Correlation 197 Covariance 199 Significance Testing in Correlation Tests 199 Formula Syntax 200 Tests for Association 203 Multiple Categories: Chi-Squared Tests 204 Monte Carlo Simulation 205 Yates’ Correction for 2 n 2 Tables 206 Single Category: Goodness of Fit Tests 206 Summary 210 Chapter 7: Introduction to Graphical Analysis 215 Box-whisker Plots 215 Basic Boxplots 216 Customizing Boxplots 217 Horizontal Boxplots 218 Scatter Plots 222 Basic Scatter Plots 222 Adding Axis Labels 223 Plotting Symbols 223 Setting Axis Limits 224 Using Formula Syntax 225 Adding Lines of Best-Fit to Scatter Plots 225 Pairs Plots (Multiple Correlation Plots) 229 Line Charts 232 Line Charts Using Numeric Data 232 Line Charts Using Categorical Data 233 Pie Charts 236 Cleveland Dot Charts 239 Bar Charts 245 Single-Category Bar Charts 245 Multiple Category Bar Charts 250 Stacked Bar Charts 250 Grouped Bar Charts 250 Horizontal Bars 253 Bar Charts from Summary Data 253 Copy Graphics to Other Applications 256 Use Copy/Paste to Copy Graphs 257 Save a Graphic to Disk 257 Windows 257 Macintosh 258 Linux 258 Summary 259 Chapter 8: Formula Notation and Complex Statistic s 263 Examples of Using Formula Syntax for Basic Tests 264 Formula Notation in Graphics 266 Analysis of Variance (ANOVA) 268 One-Way ANOVA 268 Stacking the Data before Running Analysis of Variance 269 Running aov() Commands 270 Simple Post-hoc Testing 271 Extracting Means from aov() Models 271 Two-Way ANOVA 273 More about Post-hoc Testing 275 Graphical Summary of ANOVA 277 Graphical Summary of Post-hoc Testing 278 Extracting Means and Summary Statistics 281 Model Tables 281 Table Commands 283 Interaction Plots 283 More Complex ANOVA Models 289 Other Options for aov() 290 Replications and Balance 290 Summary 292 Chapter 9: Manipulating Data and Extracting Components 295 Creating Data for Complex Analysis 295 Data Frames 296 Matrix Objects 299 Creating and Setting Factor Data 300 Making Replicate Treatment Factors 304 Adding Rows or Columns 306 Summarizing Data 312 Simple Column and Row Summaries 312 Complex Summary Functions 313 The rowsum() Command 314 The apply() Command 315 Using tapply() to Summarize Using a Grouping Variable 316 The aggregate() Command 319 Summary 323 Chapter 10: Regression (Li near Modeling) 327 Simple Linear Regression 328 Linear Model Results Objects 329 Coefficients 330 Fitted Values 330 Residuals 330 Formula 331 Best-Fit Line 331 Similarity between lm() and aov() 334 Multiple Regression 335 Formulae and Linear Models 335 Model Building 337 Adding Terms with Forward Stepwise Regression 337 Removing Terms with Backwards Deletion 339 Comparing Models 341 Curvilinear Regression 343 Logarithmic Regression 344 Polynomial Regression 345 Plotting Linear Models and Curve Fitting 347 Best-Fit Lines 348 Adding Line of Best-Fit with abline() 348 Calculating Lines with fitted() 348 Producing Smooth Curves using spline() 350 Confidence Intervals on Fitted Lines 351 Summarizing Regression Models 356 Diagnostic Plots 356 Summary of Fit 357 Summary 359 Chapter 11: More About Graphs 363 Adding Elements to Existing Plots 364 Error Bars 364 Using the segments() Command for Error Bars 364 Using the arrows() Command to Add Error Bars 368 Adding Legends to Graphs 368 Color Palettes 370 Placing a Legend on an Existing Plot 371 Adding Text to Graphs 372 Making Superscript and Subscript Axis Titles 373 Orienting the Axis Labels 375 Making Extra Space in the Margin for Labels 375 Setting Text and Label Sizes 375 Adding Text to the Plot Area 376 Adding Text in the Plot Margins 378 Creating Mathematical Expressions 379 Adding Points to an Existing Graph 382 Adding Various Sorts of Lines to Graphs 386 Adding Straight Lines as Gridlines or Best-Fit Lines 386 Making Curved Lines to Add to Graphs 388 Plotting Mathematical Expressions 390 Adding Short Segments of Lines to an Existing Plot 393 Adding Arrows to an Existing Graph 394 Matrix Plots (Multiple Series on One Graph) 396 Multiple Plots in One Window 399 Splitting the Plot Window into Equal Sections 399 Splitting the Plot Window into Unequal Sections 402 Exporting Graphs 405 Using Copy and Paste to Move a Graph 406 Saving a Graph to a File 406 Windows 406 Macintosh 406 Linux 406 Using the Device Driver to Save a Graph to Disk 407 PNG Device Driver 407 PDF Device Driver 407 Copying a Graph from Screen to Disk File 408 Making a New Graph Directly to a Disk File 408 Summary 410 Chapter 12: Writing Your Own Scripts: Beginning to Program 415 Copy and Paste Scripts 416 Make Your Own Help File as Plaintext 416 Using Annotations with the # Character 417 Creating Simple Functions 417 One-Line Functions 417 Using Default Values in Functions 418 Simple Customized Functions with Multiple Lines 419 Storing Customized Functions 420 Making Source Code 421 Displaying the Results of Customized Functions and Scripts 421 Displaying Messages as Part of Script Output 422 Simple Screen Text 422 Display a Message and Wait for User Intervention 424 Summary 428 Appendix: Answers to Exerci ses 433 Index 461
£21.59
John Wiley & Sons Inc Professional Android Sensor Programming
Book SynopsisLearn to build human-interactive Android apps, starting with device sensors This book shows Android developers how to exploit the rich set of device sensors locational, physical (temperature, pressure, light, acceleration, etc.Table of ContentsINTRODUCTION xxvii PART I: LOCATION SERVICES CHAPTER 1: INTRODUCING THE ANDROID LOCATION SERVICE 3 CHAPTER 2: DETERMINING A DEVICE'S CURRENT LOCATION 11 CHAPTER 3: TRACKING DEVICE MOVEMENT 27 CHAPTER 4: PROXIMITY ALERTS 45 PART II: INFERRING INFORMATION FROM PHYSICAL SENSORS CHAPTER 5: OVERVIEW OF PHYSICAL SENSORS 65 CHAPTER 6: ERRORS AND SENSOR SIGNAL PROCESSING 103 CHAPTER 7: DETERMINING DEVICE ORIENTATION 121 CHAPTER 8: DETECTING MOVEMENT 147 CHAPTER 10: ANDROID OPEN ACCESSORY 189 PART III: SENSING THE AUGMENTED, PATTERN-RICH EXTERNAL WORLD CHAPTER 11: NEAR FIELD COMMUNICATION (NFC) 219 CHAPTER 12: USING THE CAMERA 255 CHAPTER 13: IMAGE-PROCESSING TECHNIQUES 281 CHAPTER 14: USING THE MICROPHONE 303 PART IV: SPEAKING TO ANDROID CHAPTER 15: DESIGNING A SPEECH-ENABLED APP 333 CHAPTER 16: USING SPEECH RECOGNITION AND TEXT-TO-SPEECH APIS 349 CHAPTER 17: MATCHING WHAT WAS SAID 407 CHAPTER 18: EXECUTING VOICE ACTIONS 441 CHAPTER 19: IMPLEMENTING SPEECH ACTIVATION 471 INDEX 495
£28.49
John Wiley & Sons Inc Beginning Visual Basic 2012
Book SynopsisThe ultimate beginner's guide to programming in Visual Basic 2012 Visual Basic, used to write Windows applications and web apps with ASP. NET, is an essential language for beginning programmers. Using the time-tested Wrox approach, this guide provides a step-by-step format that gets beginners up and running quickly and confidently.Table of ContentsINTRODUCTION xxvii CHAPTER 1: WELCOME TO VISUAL BASIC 2012 1 Event-Driven Programming 2 Installing Visual Basic 2012 3 The Visual Studio 2012 IDE 6 The Profile Setup Page 6 The Menu 7 The Toolbars 8 Creating a Simple Application 9 Windows in the Visual Studio 2012 IDE 10 The Toolbox 14 Modified Hungarian Notation 17 The Code Editor 18 Using the Help System 23 Summary 23 CHAPTER 2: THE MICROSOFT .NET FRAMEWORK 27 Microsoft’s Reliance on Windows 28 MSN 1.0 28 The .NET Vision 29 This Sounds Like Java 30 Where Now? 30 Writing Software for Windows 31 The .NET Framework Classes 32 Executing Code 33 Common Language Runtime 34 Code Loading and Execution 35 Application Isolation 35 Security 35 Interoperability 36 Exception Handling 36 The Common Type System and Common Language Specification 37 Summary 37 CHAPTER 3: WRITING SOFTWARE 41 Information and Data 41 Algorithms 42 What Is a Programming Language? 43 Working with Variables 44 Comments and Whitespace 46 Comments 47 Whitespace 48 Data Types 49 Working with Numbers 49 Common Integer Math Operations 50 Integer Math Shorthand 52 The Problem with Integer Math 54 Floating-Point Math 54 Other States 56 Single-Precision Floating-Point Numbers 56 Working with Strings 57 Concatenation 58 Using the Concatenation Operator Inline 59 More String Operations 59 Substrings 61 Formatting Strings 62 Localized Formatting 63 Replacing Substrings 64 Using Dates 65 Formatting Date Strings 66 Extracting Date Properties 67 Date Constants 68 Defining Date Literals 69 Manipulating Dates 70 Boolean 71 Storing Variables 71 Binary 71 Bits and Bytes 72 Representing Values 73 Converting Values 74 Methods 76 Why Use Methods? 76 Methods You’ve Already Seen 77 Building a Method 80 Choosing Method Names 83 Scope 84 Summary 86 CHAPTER 4: CONTROLLING THE FLOW 89 Making Decisions 89 The If Statement 90 The Else Statement 92 Allowing Multiple Alternatives with ElseIf 92 Nested If Statements 94 Single-Line If Statement 94 Comparison Operators 94 Using Not Equal To 94 Using the Numeric Operators 96 The And and Or Operators 99 Using the And Operator 101 More on And and Or 102 String Comparison 103 Select Case 104 Case-Insensitive Select Case 108 Multiple Selections 110 The Case Else Statement 112 Different Data Types with Select Case 112 Loops 113 The For…Next Loop 113 Using the Step Keyword 116 Looping Backward 117 The For Each…Next Loop 118 The Do…Loop Loops 119 Do While…Loop 121 Acceptable Expressions for a Do…Loop 123 Other Versions of the Do…Loop 123 Nested Loops 124 Quitting Early 126 Quitting Do…Loops 128 Infinite Loops 129 Summary 130 CHAPTER 5: WORKING WITH DATA STRUCTURES 133 Understanding Arrays 134 Defining and Using Arrays 134 Using For Each…Next 137 Passing Arrays As Parameters 139 Sorting Arrays 141 Going Backward 142 Initializing Arrays with Values 144 Understanding Enumerations 145 Using Enumerations 145 Determining the State 149 Setting Invalid Values 151 Understanding Constants 152 Using Constants 152 Different Constant Types 154 Structures 155 Building Structures 155 Adding Properties to Structures 158 Working with ArrayLists 159 Using an ArrayList 159 Deleting from an ArrayList 163 Showing Items in the ArrayList 166 Working with Collections 167 Creating CustomerCollection 168 Adding an Item Property 170 Building Lookup Tables with Hashtable 171 Using Hashtables 172 Cleaning Up: Remove, RemoveAt, and Clear 175 Case Sensitivity 177 Advanced Array Manipulation 179 Dynamic Arrays 179 Using Preserve 181 Summary 182 CHAPTER 6: EXTENSIBLE APPLICATION MARKUP LANGUAGE (XAML) 185 What Is XAML? 186 XAML Syntax 187 Windows Presentation Foundation 190 Creating a Rich WPF User Interface 191 Using WPF Common Controls 197 Wiring Up Events 201 Summary 205 CHAPTER 7: BUILDING WINDOWS APPLICATIONS 209 Responding to Events 210 Building a Simple Application 217 Counting Characters 221 Counting Words 223 Creating More Complex Applications 229 Creating the Toolbar 231 Creating the Status Bar 235 Creating an Edit Box 237 Clearing the Edit Box 239 Responding to Toolbar Buttons 242 Using Multiple Forms 247 About Dialog 247 Summary 251 CHAPTER 8: DISPLAYING DIALOGS 255 The MessageBox 256 Available Icons for MessageBox 256 Available Buttons for MessageBox 257 Setting the Default Button 257 Miscellaneous Options 258 The Show Method Syntax 258 Example Message Boxes 260 The OpenFileDialog Control 263 The OpenFileDialog Control 264 The Properties of OpenFileDialog 265 OpenFileDialog Methods 266 Using the OpenFileDialog Control 266 The SaveDialog Control 271 The Properties of SaveFileDialog 271 SaveFileDialog Methods 273 Using the SaveFileDialog Control 273 The FontDialog Control 276 The Properties of FontDialog 277 The Methods of FontDialog 277 Using the FontDialog Control 277 The ColorDialog Control 280 The Properties of ColorDialog 281 Using the ColorDialog Control 282 The PrintDialog Control 283 The Properties of PrintDialog 284 Using the PrintDialog Control 285 The PrintDocument Class 285 The Properties of the PrintDocument Class 285 Printing a Document 285 The FolderBrowserDialog Control 292 The Properties of FolderBrowserDialog 292 Using the FolderBrowserDialog Control 293 Summary 296 CHAPTER 9: CREATING MENUS 299 Understanding Menu Features 299 Images 300 Access Keys 300 Shortcut Keys 300 Check Marks 300 The Properties Window 301 Creating Menus 302 Designing the Menus 302 Adding Toolbars and Controls 304 Coding Menus 306 Coding the View Menu and Toolbars 310 Testing Your Code 311 Context Menus 314 Creating Context Menus 315 Enabling and Disabling Menu Items and Toolbar Buttons 318 Summary 321 CHAPTER 10: DEBUGGING AND ERROR HANDLING 325 Major Error Types 326 Syntax Errors 326 Execution Errors 330 Logic Errors 330 Debugging 331 Creating a Sample Project 332 Setting Breakpoints 348 Debugging Using the Watch Window and QuickWatch Dialog Box 356 Debugging with the Autos Window 358 Debugging with the Locals Window 358 Error Handling 360 Using Structured Error Handling 361 Summary 363 CHAPTER 11: BUILDING OBJECTS 367 Understanding Objects 368 Encapsulation 369 Methods and Properties 369 Events 370 Visibility 370 What Is a Class? 371 Building Classes 371 Reusability 372 Designing an Object 373 State 374 Behavior 374 Storing State 375 Real Properties 378 Read/Write Properties 381 Auto-Implemented Properties 384 The IsMoving Method 384 Constructors 386 Inheritance 388 Adding New Methods and Properties 389 Adding a GetPowerToWeightRatio Method 392 Changing Defaults 394 Polymorphism: Scary Word, Simple Concept 395 Overriding More Methods 396 Inheriting from the Object Class 398 Objects and Structures 399 The Framework Classes 399 Namespaces 399 The Imports Statement 402 Creating Your Own Namespace 402 Inheritance in the .NET Framework 406 Summary 407 CHAPTER 12: ADVANCED OBJECT-ORIENTED TECHNIQUES 409 Building a Favorites Viewer 410 Internet Shortcuts and Favorites 410 Using Classes 412 Scanning Favorites 418 Viewing Favorites 426 An Alternative Favorite Viewer 428 Building a Favorites Tray 428 Displaying Favorites 429 Using Shared Properties and Methods 433 Using Shared Properties 434 Using Shared Methods 438 Understanding Object-Oriented Programming and Memory Management 439 Garbage Collection 440 Releasing Resources 441 Defragmentation and Compaction 442 Summary 443 CHAPTER 13: BUILDING CLASS LIBRARIES 445 Understanding Class Libraries 446 Creating a Class Library 446 Building a Class Library for Favorites Viewer 448 A Multitiered Application 452 Using Strong Names 453 Signing Assemblies 453 Assembly Versions 456 Registering Assemblies 456 Gacutil Utility 457 Why Is My Assembly Not Visible in the References Dialog? 457 Designing Class Libraries 457 Using Third-Party Class Libraries 459 Viewing Classes with the Object Browser 460 Summary 461 CHAPTER 14: CREATING WINDOWS FORMS USER CONTROLS 463 Windows Forms Controls 464 Creating and Testing a User Control 464 Exposing Properties from User Controls 468 Adding Properties 468 Exposing Methods from User Controls 470 Exposing Events from User Controls 471 Design Time or Runtime 476 Creating a Command Link Control 478 Building the Command Link Control 479 Using the Command Link Control 487 Summary 490 CHAPTER 15: ACCESSING DATA USING STRUCTURED QUERY LANGUAGE 493 What You Need to Complete This Chapter’s Exercises 494 What Is a Database? 495 Database Tables 495 Primary and Foreign Keys 500 Understanding Primary Keys 500 Understanding Foreign Keys 501 Queries 502 Understanding Basic SQL Syntax 503 Using SELECT Statement 503 Using the JOIN Statement 504 Using the UPDATE Statement 505 Using the DELETE Statement 506 Using the INSERT Statement 507 Using the SQL Comment 508 Executing Queries in SQL Server 508 Summary 511 CHAPTER 16: DATABASE PROGRAMMING WITH SQL SERVER AND ADO.NET 515 ADO.NET 516 ADO.NET Data Namespaces 516 The SqlConnection Class 517 Working with the Connection String Parameters 518 Opening and Closing the Connection 519 The SqlCommand Class 519 The Connection Property 520 The CommandText Property 520 The Parameters Collection 520 The ExecuteNonQuery Method 521 The SqlDataAdapter Class 522 The SelectCommand Property 522 Setting SelectCommand to SQL Text 523 Setting SelectCommand to a Stored Procedure 523 Using Command Builders to Create the Other Commands 524 The Fill Method 524 The DataSet Class 526 DataView 526 The Sort Property 527 The RowFilter Property 527 The Find Method 528 The ADO.NET Classes in Action 528 Data Binding 537 BindingContext and CurrencyManager 538 Binding Controls 539 Binding Examples 539 Summary 567 CHAPTER 17: DYNAMIC DATA WEBSITE 571 Creating a Dynamic Data Entities Website 571 Customizing the Design of a Dynamic Data Website 577 Page Templates 578 Entity Templates 578 Field Templates 578 Filter Templates 579 Summary 583 CHAPTER 18: ASP.NET 587 Thin-Client Architecture 588 Web Forms versus Windows Forms 589 Windows Forms Advantages 589 Web Forms Advantages 589 Web Applications: The Basic Pieces 590 Web Servers 590 Browsers 590 HyperText Markup Language 591 JavaScript 591 Cascading Style Sheets 591 Active Server Pages 592 Benefits of ASP.NET Web Pages 592 Special Website Files 592 Global.asax 592 Web.config 592 Development 593 Controls: The Toolbox 593 Building Websites 593 Creating a Web Form for Client- and Server-Side Processing 594 Website Locations with VS 2012 599 Performing Data Entry and Validation 602 Site Layout, Themes, and Navigation 606 Using the GridView to Build a Data-Driven Web Form 611 Summary 616 CHAPTER 19: DEPLOYING YOUR APPLICATION 619 What Is Deployment? 620 ClickOnce Deployment 620 XCOPY Deployment 626 Creating a Visual Studio 2012 Setup Application 626 Customize the User Interface 632 Deploying Diff erent Solutions 633 Private Assemblies 633 Shared Assemblies 634 Deploying Desktop Applications 635 Deploying Web Applications 635 Deploying XML Web Services 635 Useful Tools 635 Summary 636 CHAPTER 20: WINDOWS 8 APPS 639 Windows 8 Application Design Principles 640 Using Touch 640 Application Commands 640 Windows 8 Controls 642 Creating your First Windows 8 App 643 Application Layout 655 Application Views 656 Screen Sizes and Orientation 656 Summary 661 APPENDIX A: EXERCISE SOLUTIONS 665 APPENDIX B: WHERE TO NOW? 679 INDEX 683
£33.24
John Wiley & Sons Inc Beginning ArcGIS for Desktop Development Using
Book SynopsisGet the very most out of the ArcGIS for Desktop products through ArcObjects and. NET ArcGIS for Desktop is a powerful suite of software tools for creating and using maps, compiling, analyzing and sharing geographic information, using maps and geographic information in applications, and managing geographic databases.Table of ContentsINTRODUCTION xxi PART I: THE BASICS CHAPTER 1: WHY GEOSPATIAL IS SPECIAL 3 A Tour of Geospatial Data 4 Why Geospatial Is Special 8 Various Kinds of GIS Software 10 Server GIS 11 Desktop GIS 13 Developer GIS 17 Mobile GIS 18 Geospatial Data Models and Storage 19 Raster 19 Vector 20 Geospatial Data as Text or Binary File 20 Geospatial Data in Georelational Models 21 Geospatial Data Inside Spatial DBMS 21 Geospatial Data in XML Structures 23 Esri Geodatabase 30 Personal Geodatabase 30 File Geodatabase 30 ArcSDE Geodatabase 31 Summary 32 CHAPTER 2: INTRODUCTION TO ARCGIS FOR DESKTOP APPLICATIONS CUSTOMIZATION 35 Four Ways to Customize ArcGIS for Desktop 36 Customizing the User Interface 37 Scripting 41 Desktop Add-Ins 48 ArcObjects SDK 55 Summary 59 PART II: .NET PROGRAMMING FUNDAMENTALS CHAPTER 3: .NET PROGRAMMING FUNDAMENTALS, PART I 63 The .NET Framework 63 The C# Language 64 A Brief History of C# 64 Basic Concepts 65 Variables and Data Types 66 Nullable Data Types 71 Operations on Variables 71 Arrays 75 Decision-Making 76 Iteration 78 Object Manipulation 81 Data Type Conversion 83 Enumerations 85 Methods 89 Introduction to Object-Oriented Programming in C# 93 Object-Oriented Programming in Action 94 Defi ning Properties 96 Defi ning Methods 98 Defi ning Constructors 98 Summary 100 CHAPTER 4: .NET PROGRAMMING FUNDAMENTALS, PART II 103 Overview of Object-Oriented Programming Concepts 104 Abstraction 104 Encapsulation 104 Inheritance 105 Polymorphism 106 Reference Types and Value Types 108 Assignment Operations 108 Comparison Operations 109 Passing Parameters between Method Calls 109 Brief Explanation of All .NET Types 111 Namespaces and Assemblies 112 Debugging Using Visual Studio 113 Structured Exception Handling 117 Casting Objects 120 Aggregation Using Collections 121 The ArrayList 122 Generics 123 Reading and Writing Files 123 Summary 135 PART III: ARCOBJECTS PROGRAMMING CHAPTER 5: UNDERSTANDING ARCOBJECTS OBJECT MODEL DIAGRAMS 139 What Is ArcObjects? 140 Interface-Based Programming in Brief 140 Understanding Object Model Diagrams 144 Types of Classes in ArcObjects 145 Relationships between Classes 147 Members of Interfaces 149 Interface Inheritance 151 Wormhole 153 Additional Tips for Using Object Model Diagrams 153 Where to Start with ArcObjects 155 How to Find an Associated Member 156 Summary 163 CHAPTER 6: ACCESSING MAPS AND LAYERS 165 Introduction to Maps and Layers In ArcObjects 165 General Properties of All Layers 175 Working with FeatureLayers 179 Working with RasterLayers 183 Adding an Existing *.lyr File to a Map 184 Adding *.lyr Files Using GxDialog 186 Saving *.lyr and *.mxd Files 191 Summary 194 CHAPTER 7: WORKING WITH TABLES AND FEATURECLASSES 197 Accessing Tables and FeatureClasses 197 Adding and Deleting Fields 204 Adding Existing FeatureClasses, Tables, and Rasters to a Map 207 Deleting an Existing FeatureDataset, FeatureClass, Table, or Raster 215 Creating Tables and Rows 215 Summary 225 CHAPTER 8: SUBSETS OF RECORDS 227 Using Object Model Diagrams for Selecting Features and Rows 228 Working with Existing Selections 229 Selecting Rows and Features 233 Accessing a Subset of Records 237 Simple Statistics of Features 245 Some Important Points about Using Cursors 251 Displaying Subsets of Geospatial Data 254 Summary 255 CHAPTER 9: CONSTRUCTING AND USING THE GEOMETRY OF FEATURES 257 Object Model Diagram for the Geometry of Features and Graphics 258 Displaying Geometries on the Screen 260 Creating and Drawing Points 261 Creating and Drawing Multipoints 264 Creating and Drawing Polylines 268 Creating and Drawing Polygons 272 Creating a New Feature and Editing an Existing Feature’s Geometry 276 Working with Spatial Operators 281 Examining Spatial Relationships 281 Common Geoprocessing Operations 284 Determining the Nearest Points and Distance 287 Length, Area, Centroid, and Envelope of Geometries 292 Summary 293 CHAPTER 10: RENDERING GEOSPATIAL DATA AND USING HYPERLINKS AND MAPTIPS 295 Geospatial Data Display 296 Color and ColorRamp Classes 296 Symbols 298 Renderers for Vector and Raster Geospatial Data 300 Going beyond Simple Display 318 Simple and Advanced MapTips 319 Hyperlinks 321 Summary 324 CHAPTER 11: LABELING, EXPORTING ACTIVEVIEW, AND WORKING WITH ELEMENTS 327 Labeling 328 Labeling with the Default Labeling Engine 329 Labeling with the Maplex Labeling Engine 334 Exporting the ActiveView 336 Working with Elements 346 Adding GraphicElements 348 Adding FrameElements 352 Summary 361 CHAPTER 12: GEOPROCESSING WITH TOOLS AND MODELS 365 ArcObjects and the Geoprocessing Framework 365 Running Geoprocessing Tools 366 Running Custom Tools 375 Opening a Tool’s Dialog Box in Code 384 Geoprocessing in the Background 389 Bach Processing 397 Can I Manage the Execution of Geoprocessing Tools? 399 Summary 400 CHAPTER 13: FEATURE DATA MANAGEMENT 403 Use of GUID in ArcObjects 404 Working with the Geodatabase Model 406 Creating Geodatabases 407 Creating FeatureDatasets and FeatureClasses 408 Working with Features 418 Creating New Features 418 Modifying Existing Features 422 Summary 426 CHAPTER 14: ADVANCED TOPICS IN ARCOBJECTS PROGRAMMING AND DEPLOYMENT 429 Sharing State and Functionality between Components 430 Event Handling in ArcObjects 432 Application Extension 435 Add-In Deployment 450 Preparing for Release 450 Add-In File Structure 452 Distributing and Installing an Add-In 453 Custom Component Deployment 456 Creating an Installer for Custom Component 459 Summary 465 APPENDIX: ANSWERS TO CHAPTER EXERCISES 467 INDEX 479
£19.99
John Wiley & Sons Inc WordPress
Book SynopsisTake WordPress beyond its comfort zone As the most popular open source blogging tool, WordPress is being used to power increasingly advanced sites, pushing it beyond its original purpose.Table of ContentsIntroduction 1 Part I: Professional WordPress Development 5 Chapter 1 WordPress As a Professional Web Development Tool 7 Chapter 2 Kicking Off a WordPress Project 27 Part II Content and Administration 47 Chapter 3 Content Organization and Relationships 49 Chapter 4 Customizing the WordPress Admin 91 Part III Practicalities of Developing and Hosting WordPress Sites 139 Chapter 5 Development and Hosting Environments 141 Chapter 6 Avoiding and Dealing with Disaster 165 Part IV Pushing the Limits: The Best Tools for Site Development 191 Chapter 7 Theme Building: Frameworks, Standalone Themes, or Child Themes? 193 Chapter 8 Conditional Display: Functions, Template Files, and Styling 241 Chapter 9 Custom Functionality in Theme Functions and Plugins 273 Chapter 10 Making Your Site Soar: HTML, JavaScript, and CSS 313 Chapter 11 Device Compatibility: Responsive and Mobile Development 351 Chapter 12 Releasing Your Code to the Public 399 Index 429
£23.99
John Wiley & Sons Inc CSS3 Pushing the Limits
Book SynopsisPush CSS3 and your design skills to the limit and beyond! Representing an evolutionary leap forward for CSS, CSS3 is chock-full of new capabilities that dramatically expand the boundaries of what a styling language can do.Table of ContentsIntroduction 1 Part I New Toys 7 Chapter 1 Advanced Selectors 9 Child and Sibling Selectors 9 Child Combinator 9 Adjacent Sibling Combinator 10 General Sibling Combinator 10 Attribute Selectors 11 Selecting Based on the Existence of an HTML Attribute 11 Selecting Based on the Exact Value of an HTML Attribute 11 Selecting Based on the Partial Contents of an HTML Attribute Value 12 Selecting Based on the Beginning of an HTML Attribute Value 12 Selecting Based on the End of an HTML Attribute Value 13 Selecting Based on Space-Separated HTML Attribute Values 13 Pseudo-Classes 13 Firsts and Lasts 14 Nth Child Selectors 15 Taking Nth Child to the Next Level with Expressions 16 Using Keywords with Nth Child 17 Using Negative Numbers with Nth Child 17 The Best of the Rest 19 Bringing It All Together 20 Summary 23 Further Reading 24 Chapter 2 New Tools for Text 25 Perfecting Your Type 25 Ligatures 25 Kerning 27 Borrowing from SVG 28 Maintaining Legibility with Aspect Values 30 More Control with More New Toys 33 Font Stretch 33 Synthetic Font Styling 33 By the Numbers 34 Hyphenation 35 Writing Modes 37 The Direction Property 38 The Writing Mode Property 38 The Text Orientation Property 38 SVG to the Rescue! 38 Looking Good Is Half the Battle 39 Text Decoration 39 Masking Background Images Over Text 40 Text Shadow 42 Creating 3D Text 42 Creating Outer Glow 44 Summary 45 Further Reading 46 Chapter 3 New Tools for Backgrounds and Borders 47 More Control with CSS3 Backgrounds 47 Background Clip and Background Origin 47 Background Size 50 Understanding the Background Shorthand 52 Handling Box Breaks 52 Into the Future with the Image Function 53 Multiple Backgrounds 55 The Syntax for Multiple Backgrounds 55 Layered Backgrounds 56 Animating Multiple Backgrounds 57 New Tools for Borders 58 Border Image 58 Into the Future with Border Corner Shape 62 Gradients 63 Linear Gradients 63 The Linear Gradient Syntax 63 Browser Support 65 Linear Gradients in Action 65 Radial Gradients 66 The Radial Gradients Syntax 66 Radial Gradients in Action 68 Browser Support 69 Pushing the Limits with Gradient Patterns 70 Summary 73 Further Reading 74 Chapter 4 Into the Browser with CSS3 Filters and Blending Modes 75 CSS3 Filters 75 How Do CSS Filters Work? 76 Grayscale 76 Brightness 77 Contrast 77 Saturate 78 Sepia 78 Hue-Rotate 79 Invert 79 Opacity 80 Drop Shadow 80 Blur 81 Combining Filters 82 Blending Modes 83 What Are Blending Modes? 84 The Blending Modes Syntax 85 Summary 85 Further Reading 86 Part II Transforms, Transitions, and Animation 87 Chapter 5 Introducing CSS3 2D Transforms 89 The Transform Property 89 Translate 90 Skew 93 Rotate 94 Scale 96 Transform Origin 99 Combining Transforms 100 Browser Support 102 Summary 102 Further Reading 102 Chapter 6 Bringing 2D Transforms to Life with Transitions 103 Introducing CSS Transitions 103 Controlling Your Transitions 104 Understanding the Shorthand Syntax 105 Understanding the Transition Property 106 Applying Separate On and Off Transitions 107 Understanding the Timing Function 108 The Bézier Curve 109 Ease 111 Linear 112 Ease-In 113 Ease-Out 113 Ease-In-Out 114 Stepping Functions 115 Browser Support for Transitions 117 Transitions in Action 117 Combining Transitions and 2D Transforms 120 Transitioning Rotate 120 Transitioning Translate 123 Transitioning Scale 127 Transitioning Skew 128 Creating a Scattered Image Gallery 129 Summary 133 Further Reading 134 Chapter 7 A New Dimension with 3D Transforms 135 What Are 3D Transforms? 135 It’s All About Perspective 136 The Perspective Property 137 Perspective Origin 141 Maintaining Perspective 142 Backface Visibility 145 Moving on to More Transform Properties 148 Rotating in a 3D Environment 149 Translating in a 3D Environment 151 Scaling in a 3D Environment 153 Creating a Cube Using 3D Transforms 154 Animating the Cube with Transitions 157 Examining Browser Support for 3D Transforms 159 Summary 160 Further Reading 160 Chapter 8 Getting Animated 161 Introducing CSS3 Animation 161 Defining Keyframes 161 Applying the Animation 163 Further Control 163 Looking at CSS3 Animations in Action 166 Adding Progressive Enhancement with Subtle Animation 170 Fade In Effects 171 Attention Seekers 173 Shake 173 Wobble 174 Combining Animations 175 Forming the Structure 176 Creating an Animated Slide Show 177 Creating a Swinging Animation 178 Introducing Content with Subtle Animation 180 Seeking Attention with Loud Animation 182 Examining Browser Support for CSS Animation 182 Summary 183 Further Reading 183 Part III Getting to Grips with New Layout Tools 185 Chapter 9 Creating a Multicolumn Layout 187 The Evolution of Layout Tools 187 What’s New in Layout Solutions? 188 Introducing Multi-column Layout 189 New Multicolumn Properties 189 Defining Your Columns 189 Handling Column Breaks 198 Limitations 201 Creating a Multicolumn Layout 202 Examining Browser Support for Multi-column Layout 206 Summary 207 Further Reading 208 Chapter 10 Flexible Box Layout 209 What Is Flexbox? 209 New Flexbox Properties 210 Establishing the Flex Formatting Context 210 Examining Direction, Flow, and Visual Ordering 212 Controlling Alignment 217 Defining Flex Factors 223 Creating a Flexible Box Layout 225 Examining Browser Support for Flexbox 230 Summary 231 Further Reading 231 Chapter 11 Grid Layout, Regions, and Exclusions 233 Introducing CSS Grid Layout 233 What Is Grid Layout? 234 Creating a Grid Element 234 Defining the Grid 235 Positioning Elements into the Grid 237 Making Your Grid Flexible and Adaptable 238 Introducing CSS Regions 241 What Are CSS Regions? 241 How Do Regions Work? 242 Introducing CSS Exclusions 243 What Are CSS Exclusions? 244 How Do Exclusions Work? 244 Playing with Shapes 247 A Caveat on Exclusions and Shapes 249 Summary 249 Further Reading 250 Chapter 12 Going Responsive with CSS3 Media Queries 251 What Is Responsive Web Design? 251 Using Media Queries to Design for Device Differences 252 Understanding Media Types and Media Features 253 Applying the Mobile-First Approach 253 Using the Viewport Meta Tag 256 Making a Multicolumn Layout Responsive 256 Making a Flexbox Layout Responsive 261 A Word on CSS Grid Layout 268 The Here and Now of RWD 269 Summary 269 Further Reading 270 Part IV Pushing the Limits 271 Chapter 13 Getting Creative with Pseudo-elements 273 Distinguishing Pseudo-elements and Pseudo-classes 273 What Is a Pseudo-class? 273 What Is a Pseudo-element? 274 Syntactical Differences 274 Exploring the Current Range of Pseudo-elements 275 Enhancing Your Typography with Pseudo-elements 275 Drawing Users into Your Copy 276 Getting Creative with Type-based Pseudo-elements 278 Using Pseudo-elements to Generate Content 282 Pushing Pseudo-elements to the Limit 285 A Contemporary Clearfix 287 Creating Scalable Icons and Shapes 288 Creating a Speech Bubble 288 Creating an OK Icon 289 Creating a Print Icon 290 Creating a Save Icon 291 Pushing the Limits Even Further and Knowing When to Stop 293 Summary 293 Further Reading 294 Chapter 14 Using Preprocessors to Push CSS3 to the Limit 295 What Is a CSS Preprocessor? 295 What Can CSS Preprocessors Do for You? 295 Choosing the Right Preprocessor for You 296 Declaring Variables 297 Doing Functions and Simple Math 298 Using Mixins 299 Selector Inheritance 300 Nested Selectors 301 Getting to Grips with the Dark Side of Preprocessors 302 Step 1: Installing Ruby 303 Step 2: Installing Sass 304 Step 3: Creating Your First Sass File 304 Step 4: Compiling Your Sass Code 305 Helpful Tools 306 Making CSS3 More Efficient with Mixins 307 Creating Proportional Layouts with Simple Math 309 Using Functions to Form a Dynamic Color Palette 310 A Word of Caution on Preprocessors 311 Summary 311 Further Reading 311 Chapter 15 Creating Practical Solutions Using Only CSS3 313 Creating Tabbed Content Using Only CSS3 313 The Markup 314 Applying Basic Styling to the Panels 316 Styling the Tabs 317 Making the Tabs Functional 318 Applying the Finishing Touches 320 Creating a Lightbox Feature Using Only CSS3 321 Laying the Foundations for the Markup 322 Styling the Thumbnail Gallery 324 Adding the Lightbox Markup 326 Making the Lightbox Functional 327 Applying the Polish to the Final Design 330 Creating a 3D Image Carousel Using Only CSS3 334 Marking Up the Carousel 334 Establishing a 3D Formatting Context 335 Positioning the Images in a 3D Environment 335 Making the Carousel Functional 339 Applying the Finishing Touches 340 Summary 342 Further Reading 343 Chapter 16 The Future of CSS 345 CSS Variables 346 CSS Selectors: Level 4 348 Browser Support Using CSS Conditional Rules 352 Pseudo-elements: Level 4 353 Have Your Say 354 Summary 354 Further Reading 355 Index 357
£23.99
John Wiley & Sons Inc Professional Java for Web Applications
Book SynopsisThe comprehensive Wrox guide for creating Java web applications for the enterprise This guide shows Java software developers and software engineers how to build complex web applications in an enterprise environment.Table of ContentsIntroduction xxiii Part I: Creating Enterprise Applications Chapter 1: Introducing Java Platform, Enterprise Edition 3 A Timeline of Java Platforms 3 Understanding the Basic Web Application Structure 13 Summary 18 Chapter 2: Using Web Containers 19 Choosing a Web Container 19 Installing Tomcat on Your Machine 23 Deploying and Undeploying Applications in Tomcat 27 Debugging Tomcat from Your IDE 30 Summary 39 Chapter 3: Writing Your First Servlet 41 Creating a Servlet Class 42 Configuring a Servlet for Deployment 46 Understanding doGet(), doPost(), and Other Methods 51 Using Parameters and Accepting Form Submissions 56 Configuring your Application Using Init Parameters 61 Uploading Files from a Form 64 Making Your Application Safe for Multithreading 69 Summary 71 Chapter 4: Using JSPs to Di splay Content 73 is Easier Than output.println(“”) 74 Creating Your First JSP 78 Using Java within a JSP (and Why You Shouldn’t!) 88 Combining Servlets and JSPs 94 A Note about JSP Documents (JSPX) 102 Summary 104 Chapter 5: Maintaining State Using Sessions 105 Understanding Why Sessions are Necessary 106 Using Session Cookies and URL Rewriting 107 Storing Data in a Session 116 Applying Sessions Usefully 129 Clustering an Application That Uses Sessions 139 Summary 142 Chapter 6: U sing the Expression Language in JSPs 143 Understanding Expression Language 144 Writing with the EL Syntax 147 Using Scoped Variables in EL Expressions 160 Accessing Collections with the Stream API 167 Replacing Java Code with Expression Language 172 Summary 175 Chapter 7: U sing the Java Standard Tag Library 177 Introducing JSP Tags and the JSTL 178 Using the Core Tag Library (C Namespace) 182 Using the Internationalization and Formatting Tag Library (FMT Namespace) 193 Using the Database Access Tag Library (SQL Namespace) 203 Using the XML Processing Tag Library (X Namespace) 205 Replacing Java Code with JSP Tags 205 Summary 208 Chapter 8: Writing Custom Tag and Function Libraries 209 Understanding TLDs, Tag Files, and Tag Handlers 210 Creating Your First Tag File to Serve as an HTML Template 219 Creating a More Useful Date Formatting Tag Handler 221 Creating an EL Function to Abbreviate Strings 226 Replacing Java Code with Custom JSP Tags 227 Summary 232 Chapter 9: Improving Your Application Using Filters 233 Understanding the Purpose of Filters 234 Creating, Declaring, and Mapping Filters 235 Ordering Your Filters Properly 239 Investigating Practical Uses for Filters 247 Simplifying Authentication with a Filter 254 Summary 255 Chapter 10: Making Your Application Interactive with WebSockets 257 Evolution: From Ajax to WebSockets 258 Understanding the WebSocket APIs 268 Creating Multiplayer Games with WebSockets 273 Using WebSockets to Communicate in a Cluster 284 Adding “Chat with Support” to the Customer Support Application 288 Summary 296 Chapter 11: Using Logging to Monitor Your Application 297 Understanding the Concepts of Logging 298 Using Logging Levels and Categories 303 Choosing a Logging Framework 305 Integrating Logging into Your Application 312 Summary 320 Part II: Adding Spring Framework Into the Mix Chapter 12: Introducing Spring Framework 323 What is Spring Framework? 324 Why Spring Framework? 326 Understanding Application Contexts 327 Bootstrapping Spring Framework 329 Configuring Spring Framework 336 Utilizing Bean Definition Profiles 349 Summary 353 Chapter 13: Replacing Your Servlets with Controllers 355 Understanding @RequestMapping 356 Using Spring Framework’s Model and View Pattern 370 Making Your Life Easier with Form Objects 380 Updating the Customer Support Application 384 Summary 387 Chapter 14: Using Services and Repositories to Support Your Controllers 389 Understanding Model-View-Controller Plus Controller-Service-Repository 390 Using the Root Application Context Instead of a Web Application Context 394 Improving Services with Asynchronous and Scheduled Execution 404 Applying Logic Layer Separation to WebSockets 409 Summary 416 Chapter 15: Internationalizing Your Application with Spring Framework i18n 417 Why Do You Need Spring Framework i18n? 418 Using the Basic Internationalization and Localization APIs 419 Configuring Internationalization in Spring Framework 424 Internationalizing Your Code 430 Summary 440 Chapter 16: Using JSR 349, Spring Framework, and Hibernate Validator for Bean Validation 441 What is Bean Validation? 442 Configuring Validation in the Spring Framework Container 445 Adding Constraint Validation Annotations to Your Beans 450 Configuring Spring Beans for Method Validation 458 Writing Your Own Validation Constraints 466 Integrating Validation in the Customer Support Application 470 Summary 472 Chapter 17: Creating RESTful and SOAP Web Services 473 Understanding Web Services 474 Configuring RESTful Web Services with Spring MVC 484 Testing Your Web Service Endpoints 496 Using Spring Web Services for SOAP 500 Summary 508 Chapter 18: Using Messaging and Clustering for Flexibility and Reliability 509 Recognizing When You Need Messaging and Clustering 510 Adding Messaging Support to your Application 520 Making your Messaging Distributable Across a Cluster 525 Distributing Events with AMQP 534 Summary 540 Part III: Persisting Data with JPA and Hibernate ORM Chapter 19: Introducing Java Persistence API and Hibernate ORM 543 What is Data Persistence? 543 What is an Object-Relational Mapper? 547 A Brief Look at Hibernate ORM 552 Preparing a Relational Database 559 A Note About Maven Dependencies 564 Summary 564 Chapter 20: Mapping Entities to Tables with JPA Annotations 565 Getting Started with Simple Entities 566 Creating and Using a Persistence Unit 581 Mapping Complex Data Types 590 Summary 596 Chapter 21: Using JPA in Spring Framework Repositories 597 Using Spring Repositories and Transactions 598 Configuring Persistence in Spring Framework 602 Creating and Using JPA Repositories 610 Converting Data with DTOs and Entities 624 Summary 632 Chapter 22: Eliminating Boilerplate Repositories with Spring Data JPA 633 Understanding Spring Data’s Unified Data Access 634 Configuring and Creating Spring Data JPA Repositories 646 Refactoring the Customer Support Application 656 Summary 661 Chapter 23: Searching for Data with JPA and Hibernate Search 663 An Introduction to Searching 664 Using Advanced Criteria to Locate Objects 666 Taking Advantage of Full-Text Indexes with JPA 676 Indexing Any Data with Apache Lucene and Hibernate Search 684 Summary 692 Chapter 24: Creating Advanced Mappings and Custom Data Types 693 What’s Left? 694 Converting Nonstandard Data Types 695 Embedding POJOs Within Entities 699 Defining Relationships Between Entities 703 Addressing Other Common Situations 709 Creating Programmatic Triggers 717 Refining the Customer Support Application 720 Summary 725 Part IV: Securing Your Application with Spring Security Chapter 25: Introducing Spring Security 729 What is Authentication? 729 Why Spring Security? 743 Summary 746 Chapter 26: Authenticating Users with Spring Security 747 Choosing and Configuring an Authentication Provider 748 Writing Your Own Authentication Provider 766 Summary 778 Chapter 27: Using Authorization Tags and Annotations 779 Authorizing by Declaration 780 Understanding Authorization Decisions 794 Creating Access Control Lists for Object Security 798 Adding Authorization to Customer Support 804 Summary 814 Chapter 28: Securing RESTful Web Services with OAuth 815 Understanding Web Service Security 816 Introducing OAuth 818 Using Spring Security OAuth 833 Finishing the Customer Support Application 840 Creating an OAuth Client Application 856 Summary 862 Index 865
£45.12
John Wiley & Sons Data Structures and Algorithms in Java 6th Editio
Book Synopsis
£154.85
John Wiley & Sons Inc Professional Embedded ARM Development
Book SynopsisA practical Wrox guide to ARM programming for mobile devices With more than 90 percent of mobile phones sold in recent years using ARM-based processors, developers are eager to master this embedded technology. If you know the basics of C programming, this guide will ease you into the world of embedded ARM technology.Trade Review"A comprehensive introduction to Assembley language development on ARM-based boards like Raspberry Pi, with plenty of background and information on essential tooling." (MagPi, October 2016)Table of ContentsINTRODUCTION xxiPART I: ARM SYSTEMS AND DEVELOPMENTCHAPTER 1: THE HISTORY OF ARM 3 CHAPTER 2: ARM EMBEDDED SYSTEMS 13 CHAPTER 3: ARM ARCHITECTURE 29 CHAPTER 4: ARM ASSEMBLY LANGUAGE 53 CHAPTER 5: FIRST STEPS 73 CHAPTER 6: THUMB INSTRUCTION SET 107 CHAPTER 7: ASSEMBLY INSTRUCTIONS 121 CHAPTER 8: NEON 145 CHAPTER 9: DEBUGGING 159 CHAPTER 10: WRITING OPTIMIZED C 175 APPENDIX A: TERMINOLOGY 193 APPENDIX B: ARM ARCHITECTURE VERSIONS 199 APPENDIX C: ARM CORE VERSIONS 205 APPENDIX D: NEON INTRINSICS AND INSTRUCTIONS 215 APPENDIX E: ASSEMBLY INSTRUCTIONS 221 INDEX 247
£34.19
John Wiley & Sons Inc Professional AngularJS
Book SynopsisA comprehensive guide to AngularJS, Google's open-source client-side framework for app development. Most of the existing guides to AngularJS struggle to provide simple and understandable explanations for more advanced concepts.Table of ContentsINTRODUCTION xxv CHAPTER 1: BUILDING A SIMPLE ANGULARJS APPLICATION 1 What You Are Building 1 What You Will Learn 3 Step 1: Scaffolding Your Project with Yeoman 4 Step 2: Creating Watchlists 9 Step 3: Configuring Client-Side Routing 19 Step 4: Creating a Navigation Bar 23 Step 5: Adding Stocks 26 Step 6: Integrating with Yahoo Finance 32 Step 7: Creating the Stock Table 36 Step 8: Inline Form Editing 40 Step 9: Formatting Currency 44 Step 10: Animating Price Changes 46 Step 11: Creating the Dashboard 49 Production Deployment 53 CHAPTER 2: INTELLIGENT WORKFLOW AND BUILD TOOLS 57 What Can Tooling Do for Me? 57 What Is Bower? 58 What Is Grunt? 60 What Is Gulp? 73 What Is Yeoman? 84 CHAPTER 3: ARCHITECTURE 95 Why Is Architecture Important? 95 Controllers, Services, and Directives 96 The ModelService Paradigm 102 Exposing API Using Controllers 108 Organizing Your Code with Modules 109 Directory Structure 113 Best Practices for Structuring User Authentication 127 CHAPTER 4: DATA BINDING 131 What Is Data Binding? 131 What Data Binding Can Do for You 134 CHAPTER 5: DIRECTIVES 157 What Is a Directive? 157 A Deeper Understanding of Directives 167 Changing Directive Templates at Runtime 179 CHAPTER 6: TEMPLATES, LOCATION, AND ROUTING 185 Part I: Templates 187 Part II: The $location Service 196 Part III: Routing 200 CHAPTER 7: SERVICES, FACTORIES, AND PROVIDERS 217 A Brief Overview of Dependency Injection 218 Building Your Own Services 221 Common Use Cases for Services 232 Utilizing Built-In Providers 236 CHAPTER 8: SERVER COMMUNICATION 243 Why Will I Learn? 243 Introduction to Promises 244 Services for HTTP Requests 246 Consuming the Twitter REST API 262 Scaffolding a REST API with StrongLoop LoopBack 264 Using Web Sockets with AngularJS 270 Using Firebase with AngularJS 273 CHAPTER 9: TESTING AND DEBUGGING ANGULARJS APPLICATIONS 277 AngularJS Testing Philosophy 277 DOM Integration Tests 292 Debugging AngularJS Apps 309 CHAPTER 10: MOVING ON 315 Using Angular-UI Bootstrap 316 Hybrid Mobile Apps with the Ionic Framework 325 Integrating Open Source JavaScript with AngularJS 331 AngularJS and ECMAScript 6 341 Conclusion 343 APPENDIX: RESOURCES 345 INDEX 347
£33.24
John Wiley & Sons Inc Beginning Spring
Book SynopsisGet up to speed quickly with this comprehensive guide to Spring Beginning Spring is the complete beginner's guide to Java's most popular framework. Written with an eye toward real-world enterprises, the book covers all aspects of application development within the Spring Framework.Table of ContentsFOREWORDS xxvii INTRODUCTION xxxi CHAPTER 1: POJO PROGRAMMING MODEL, LIGHTWEIGHT CONTAINERS, AND INVERSION OF CONTROL 1 CHAPTER 2: DEPENDENCY INJECTION WITH SPRING 17 CHAPTER 3: BUILDING WEB APPLICATIONS USING SPRING MVC 63 CHAPTER 4: JDBC DATA ACCESS WITH SPRING 103 CHAPTER 5: DATA ACCESS WITH JPA USING SPRING 137 CHAPTER 6: MANAGING TRANSACTIONS WITH SPRING 175 CHAPTER 7: TEST]DRIVEN DEVELOPMENT WITH SPRING 209 CHAPTER 8: ASPECT]ORIENTED PROGRAMMING WITH SPRING 237 CHAPTER 9: SPRING EXPRESSION LANGUAGE 263 Configuring Applications with SpEL 268 CHAPTER 10: CACHING 285 CHAPTER 11: RESTFUL WEB SERVICES WITH SPRING 305 CHAPTER 12: SECURING WEB APPLICATIONS WITH SPRING SECURITY 331 CHAPTER 13: NEXT STOP: SPRING 4.0 369 APPENDIX: SOLUTIONS TO EXERCISES 385 INDEX 425
£26.24
John Wiley & Sons Inc Web Design with HTML CSS JavaScript and jQuery
Book SynopsisA two-book set for web designers and front-end developers This two-book set combines the titles HTML & CSS: Designing and Building Web Sites and JavaScript & jQuery: Interactive Front-End Development.Table of ContentsHTML and CSS: Design and Build Websites Introduction 2 Chapter 1: Structure 12 Chapter 2: Text 40 Chapter 3: Lists 62 Chapter 4: Links 74 Chapter 5: Images 94 Chapter 6: Tables 126 Chapter 7: Forms 144 Chapter 8: Extra Markup 176 Chapter 9: Flash, Video & Audio 200 Chapter 10: Introducing CSS 226 Chapter 11: Color 246 Chapter 12: Text 264 Chapter 13: Boxes 300 Chapter 14: Lists, Tables & Forms 330 Chapter 15: Layout 358 Chapter 16: Images 406 Chapter 17: HTML5 Layout 428 Chapter 18: Process & Design 452 Chapter 19: Practical Information 476 Index 493 JavaScript and JQuery: Interactive Front-End Web Development Introduction 1 Chapter 1: The ABC of Programming 11 Chapter 2: Basic JavaScript Instructions 53 Chapter 3: Functions, Methods & Objects 85 Chapter 4: Decisions & Loops 145 Chapter 5: Document Object Model 183 Chapter 6: Events 243 Chapter 7: jQuery 293 Chapter 8: Ajax & JSON 367 Chapter 9: APIs 409 Chapter 10: Error Handling & Debugging 449 Chapter 11: Content Panels 487 Chapter 12: Filtering, Searching & Sorting 527 Chapter 13: Form Enhancement & Validation 567 Index 623
£36.00
John Wiley & Sons Inc HTML5 JavaScript and jQuery 24Hour Trainer
Book SynopsisMaster web app development with hands-on practice and video demonstration HTML5, JavaScript, and jQuery 24-Hour Trainer shows you how to build real-world HTML5 apps both web-based and mobile in combination with JavaScript, jQuery, and CSS/CSS3.Table of ContentsINTRODUCTION xviiPART I: HTML AND CSSCHAPTER 1: INTRODUCTION TO HTML5 3 What Is a Markup Language? 3 The Simplest HTML Page Possible 4 An HTML Template 6 Understanding Elements and Attributes 8 Try It 9 CHAPTER 2: BASIC HTML 11 Structuring Text 11 Links and Images 14 Try It 16 CHAPTER 3: LISTS AND TABLES 19 Lists 19 Tables 21 Try It 24 CHAPTER 4: INTRODUCTION TO CSS 27 CSS Selectors 28 CSS Files and Inline Styles 32 Specificity 32 Inheritance 33 Browser Defaults 34 Chrome Scratch Pad 34 Try It 36 CHAPTER 5: STRUCTURING PAGES WITH CSS 39 The Box Model 39 Display Type 41 Positioning Elements 42 Controlling Positions 46 Try It 48 CHAPTER 6: HTML FORMS 51 What Is a Form? 51 Adding Fields to a Form 53 HTML5 Input Fields 56 Try It 59 CHAPTER 7: SEMANTIC TAGS 61 Grouping and Segmenting Content 62 Styling Semantic Tags with CSS 64 Microformats 65 Summing Up 66 Try It 66 CHAPTER 8: HTML5 VALIDATION 69 Adding Validation Rules 69 Customizing Validation 72 Disabling Validation 74 Try It 74 CHAPTER 9: DRAG AND DROP 77 Understanding Events 78 Drag and Drop Example 78 Try It 82 CHAPTER 10: DYNAMIC ELEMENTS 85 Summary and Details Tags 85 Progress Bar and Meter 86 Range Element 88 Polyfills 88 Try It 90 CHAPTER 11: JAVASCRIPT 95 JavaScript Console 95 Data Types 96 Control Structures 101 Truthy and Falsy Values 103 Dynamic Typing 104 Try It 105 CHAPTER 12: DEBUGGING 107 Try It 108 CHAPTER 13: FUNCTIONS 115 Closures 118 Hoisting and Block Scope 120 Arguments 121 Bind 122 Try It 122 CHAPTER 14: OBJECTS 125 Object Literals 125 Prototypes 127 Constructor Functions 130 Modules 131 Try It 133 CHAPTER 15: JSON 135 Replacing and Reviving 138 Try It 140 CHAPTER 16: DOCUMENT OBJECT MODEL 141 Nodes and Objects 141 Try It 147 CHAPTER 17: JQUERY SELECTION 151 Loading jQuery 151 Selecting Elements 153 Pseudo-selectors 154 Selection Within a Context 155 Wrapped Objects 156 Try It 157 CHAPTER 18: JQUERY TRAVERSAL AND MANIPULATION 159 Traversal 159 Chaining 160 Manipulation 161 Changing Elements 163 Iteration 164 Try It 165 CHAPTER 19: JQUERY EVENTS 167 Registering Event Listeners 167 Delegated Event Listeners 170 Form Events 172 Screen Events 173 Animation 174 Try It 174 CHAPTER 20: DATA ATTRIBUTES AND TEMPLATES 177 Template Tag 177 Data Attributes 178 Using the Template 180 Try It 182 CHAPTER 21: JQUERY PLUGINS 185 jQuery UI 185 Writing a Plugin 188 Try It 191 CHAPTER 22: HTML5 AUDIO 195 File Formats 195 Audio Tag 198 Controlling Playback 199 Try It 201 CHAPTER 23: HTML5 VIDEO 203 File Formats 203 Controlling Volume 205 Controlling Playback Speed 207 Controlling Video Size 207 Media Source Extensions 209 Encrypted Media Extensions 209 Web Cryptography 210 Try It 210 CHAPTER 24: CANVAS: PART I 213 Simple Drawing 214 Drawing Lines 216 Circles and Curves 216 Drawing Text 218 Try It 219 CHAPTER 25: CANVAS: PART II 221 Linear Gradients 221 Shadows 222 Images 223 Transforming Shapes 224 Basic Animation 227 Try It 228 CHAPTER 26: CSS3: PART I 231 Selectors 231 CSS Borders 233 Custom Fonts 237 Try It 239 CHAPTER 27: CSS3: PART II 241 Linear Gradients 241 Calc Function 243 Text Effects 243 2D Transformations 245 Transitions 248 Try It 250 CHAPTER 28: CSS3 MEDIA QUERIES 253 Adding Media Queries 254 External Stylesheets 256 Try It 257 CHAPTER 29: WEB SERVERS 261 URLs 262 Choosing a Web Server 262 Try It 263 CHAPTER 30: WEB STORAGE 267 Client-Side Storage 268 Web Storage API 269 Storing Structured Data 271 Try It 273 CHAPTER 31: INDEXEDDB 275 Creating a Database 276 Storing Data 278 Reading Data 279 Deleting Data 281 Try It 281 CHAPTER 32: APPLICATION CACHE 285 Manifest Files 285 Updating Resources 288 Cache Events 289 Try It 290 CHAPTER 33: WEB WORKERS 293 JavaScript Event Model 294 Web Workers 296 Try It 300 CHAPTER 34: FILES 303 FileReader API 304 Other File-Related APIs 307 Try It 308 CHAPTER 35: AJAX 311 AJAX Requests 312 Try It 316 CHAPTER 36: PROMISES 319 Working with Promises 320 Creating Promises 322 Try It 325 CHAPTER 37: RESPONSIVE WEB DESIGN 329 Testing Screen Resolution 330 Flexible Grids 331 Media Queries 336 Try It 340 CHAPTER 38: LOCATION API 343 Monitor Movement 345 Loading the Application 349 Try It 353 CHAPTER 39: JQUERY MOBILE: PART I 355 Understanding jQuery Mobile 356 JQUERY Mobile Pages 358 Form-Based Pages 362 JavaScript 365 Try It 366 CHAPTER 40: JQUERY MOBILE: PART II 369 UI Components 369 Events 373 Try It 376 INDEX 379
£31.49
John Wiley & Sons Inc Writing Computer Code
Book SynopsisA technology book for kids! Learning how to code can be like learning a foreign language. This book serves as an excellent guide to help you start writing in the odd-looking languages that make the web work. Follow simple steps as you work with real code to build your own web robots.Table of ContentsIntroduction 1 About This Book 1 About You 2 About The Icons 3 The First Step 4 Project 1: Becoming a Programmer 5 What Is Programming? 5 How can you talk to computers? 10 What languages will you learn? 14 Gathering Your Tools 18 Getting your browser ready 18 Working with JSFiddle 19 Sharing Your Fiddle 27 Summary 28 Project 2: Gathering the Parts to Build Your Robot 2 9 Saying What You Mean 30 Making a statement 31 Following the rules 33 Giving and Receiving Data 34 Knowing Your Operands and @Operators 39 Introducing the Super-Calculator 40 Forking the Super-Calculator 41 Using the Super-Calculator 42 Super-calculating with text 44 Summary 47 Project 3: Building Your Robot s Body 48 Writing HTML 48 Seeing what text looks like without HTML 49 Using HTML: It's all about the tags 50 Nesting HTML tags 52 Writing your first HTML document 54 Knowing your HTML elements 56 Introducing Douglas the Robot 58 Changing HTML Using JavaScript 4 Summary 66 Project 4: Giving Your Robot Style 67 Giving Douglas Style 68 Getting the Basics of CSS 69 CSS selectors 70 CSS declarations 74 CSS properties 76 Colorizing Douglas 78 Using CSS colors 78 Changing colors 81 Customizing Your Own Robot 84 Summary 85 Project 5: Animating Your Robot 87 Changing CSS with JavaScript 87 Modifying Douglas with JavaScript 89 Experimenting with Douglas 92 Making Douglas Dance 94 Creating Animations with JavaScript 97 Animating another element 100 Using a second animation function 100 Summary 104 Project 6: Creating a JavaScript Word Game 105 Creating a Variable Story 105 Creating the Word Replacement Game 106 Writing the HTML 108 Styling the Word Game 111 Writing the JavaScript Code 114 Finishing the Program 117
£8.54
John Wiley & Sons Inc Creating Digital Animations
Book SynopsisThe easy way to start animating today! Creating Digital Animations is your ticket to learning animation! Learn how to animate your very own characters using Scratchthe free multimedia tool that lets you create interactive stories, games, and animations. Designed specifically for kids aged seven and up, this easy-to-follow, full-color guide introduces you to important game design concepts through three simple projects. Step-by-step instructions walk you through the four major phases of animation design, showing you how to turn your idea into a real animation with sound effects and more! You''ll work just like the pros as you sketch out your main idea, add your own details, and develop a complete, workable character from scratch. If you''re curious about coding, animation is the perfect place to start exploring. The Scratch platform doesn''t require an actual programming language, but it gets you used to thinking like a programmer while you develop your very own animaTable of ContentsIntroduction 1 About Scratch 1 About This Book 2 Icons Used in This Book 3 Access Scratch 3 Create online account 3 Use Scratch offline 4 Project 1: Animation Essentials 8 Draw Your First Character 8 Create project 9 Draw body parts 9 Sculpt the body with the Reshape tool 10 Adjust the thickness of multiple lines 11 Animate the Stick Figure 12 Draw a simple backdrop 13 Adjust movement against the backdrop 14 Putting the jump in jacks 15 Animate with Code Blocks 17 Bring Humor to Your Animation 20 Add Stick Man's Best Friend 20 Modify parts to create a new character 21 Develop your humorous story 22 Walk Like a Man 23 Rotate parts with the Select tool 24 Animate the Dog 26 Add code to animate the stick dog 26 Animate tail wagging 27 Talk Like a Man 28 Project 2: Animate Great Characters 31 Keep It Simple, Stupid 31 Getting a Head Start 33 Create a new project 34 Paint a new sprite 34 Quick hairstyling 35 Open wide 36 Give 'em a nose job 37 A Little Body Work 37 Add simple legs 38 Arming your characters 39 Apply Finishing Touches 40 It's Okay to Clone Scratch People 41 From Dead Skin to Furry Beast 41 Fangs Make the Beast 43 Undress the Beast 44 Strike a Pose 45 Add Finishing Touches 45 Create a Third Character 47 From zombie girl to bland boy 48 Design character clothing 50 Tweak facial features 50 Add a set of teeth 51 Posing clothed figures 52 Assembling Your Cast 52 Project 3: Location, Location, Location 54 Planning Animation Scenes 54 Design an Interior Scene 55 Make Scenes More Immersive 59 Change a backdrop into a sprite 60 Design see-through windows 60 Build your own furniture 63 Design an Exterior Scene 66 Draw scenes with perspective 69 Scale characters inside a scene 71 Project 4: Sounds Good to Me 74 That's What He Said 74 Write dialogue for your characters 75 Record Dialogue in Scratch 76 Find the Record button 77 Edit Audio Clips 80 Trim Beginning of Sound 81 Use sound editing effects 82 Play Sound with Code Blocks 83 Animate Character Speech 84 Mouthing the words 85 Easy lip-synching 86 Achieve more realistic lip-synching 87 Create custom phoneme costumes 90 Switch costumes to match phonemes 91 Project 5: Lights, Camera, Action! 95 (Not) Starting from Scratch 95 Create a night scene 95 Turn out the lights 98 Camera (or What Do I Focus On?) 101 Increase the costume size 101 Create a back view of characters 103 Create a side view of characters 104 Action! (or Let's Get the Story@Moving) 104 Animate sprite entering the scene 105 Add a (slightly) more realistic walk 105 Broadcast Animation Messages 106 Send a broadcast message 106 Receive a broadcast message 107 Switch between Animation Scenes 108 And Cut! 111 Author Notes 112 Share Your Scratch Projects in the Scratch Online Community 112 Share project from the online Scratch editor 113 Share project from the offline Scratch editor 114 Broadcast Scratch Animation on Any Website 114 Record/Export Scratch Videos 115 Export Scratch Graphics to Other Applications 117
£8.54
John Wiley & Sons Inc Programming Interviews For Dummies
Book SynopsisTable of ContentsIntroduction 1 Part 1: Finding and Hooking Your Next Employer 7 Chapter 1: What Should You Expect? 9 Chapter 2: Knowing How the Company Is Preparing 21 Chapter 3: Understanding the Investment a Company Makes 31 Part 2: Preparing for Your Interview 41 Chapter 4: Searching High and Low for Companies 43 Chapter 5: Shining Up Your Résumé and Social Media Accounts 55 Chapter 6: How Your Experience Affects Your Interview 73 Chapter 7: Getting Ready for the First Ring 87 Part 3: Everyone’s Testing Time 99 Chapter 8: Testing Strategies for the Interviewee 101 Chapter 9: Working with Data Structures: Garbage In Means Garbage Out 117 Chapter 10: Identifying Design Patterns and Using Recursion 127 Chapter 11: Sorting with Sorting Algorithms 135 Chapter 12: Solving Puzzles Is Fun 147 Part 4: Sealing the Deal 161 Chapter 13: Closing the Deal 163 Chapter 14: Honing Your Negotiating Skills 177 Part 5: The Part of Tens 189 Chapter 15: Ten Ways to Stand Out 191 Chapter 16: Ten Non-Technical Questions You May Be Asked 203 Chapter 17: Ten Reasons Your Résumé Will End up in the Round File 211 Chapter 18: Ten Useful Websites to Check Out 219 Chapter 19: Ten Great Books to Read 231 Index 239
£16.19
John Wiley & Sons Inc Flutter For Dummies
Book SynopsisCreate awesome iOS and Android apps with a single tool! Flutter is an app developer's dream come true. With Google'sopen sourcetoolkit, you can easily build beautiful apps that workacross platforms using a single codebase. This flexibility allows you to get your work out to the widest possible audience. With Flutter already being used by thousands of developers worldwide in a market where billions of apps are downloaded every year, now is the right time to get ahead of the curve with this incredible tool. Flutter for Dummiesis your friendly, ground-up route to creating multi-platform apps. From how to construct your initial frameworks to writing code in Dart, you'll findthe essentialsyou need to ride the Flutter revolutionary wave to success. This book includes how to create an intuitive and stunning UI, add rich interactivity, and easily pull in data. You'll also see how Flutter features like Hot Reloadproviding sub-second refreshes as you refine your workhelp you make sure your appTable of ContentsIntroduction 1 How to Use This Book 1 Conventions Used in This Book 2 What You Don’t Have to Read 2 Foolish Assumptions 3 How This Book is Organized 4 Part 1, “Getting Ready” 4 Part 2, “Flutter: A Burd’s-Eye View” 4 Part 3, “Details, Details” 4 Part 4, “The Part of Tens” 4 More on the web! 5 Icons Used in This Book 5 Beyond the Book 6 Where to Go from Here 6 Part 1: Getting Ready 7 Chapter 1: What is Flutter? 9 Hardware and Software (Things You May Already Know) 10 Where Does Flutter Fit In? 15 Cross-platform development 15 A quick-and-easy development cycle 17 A great way to think about app development 25 Enough New Terminology! What’s Next? 28 Chapter 2: Setting Up Your Computer for Mobile App Development 29 The Stuff You Need 30 What to Do 32 Getting and installing the stuff 32 For Mac users only 34 Configuring Android Studio 35 Running your first app 36 Dealing with the Devil’s Details 43 On installing Android Studio 43 On launching Android Studio for the first time 44 On installing Android Studio’s Flutter plugin 44 On adding virtual devices 46 On installing Flutter 50 Divisiveness Among Devices 52 Running apps on an Android device 52 Testing apps on a physical device 53 Using Android Studio 59 Starting up 59 The main window 60 Running This Book’s Sample Programs 63 Enjoying reruns 65 If you’re finicky 65 Were These Setup Steps Fun or What? 66 Part 2: Flutter: A Burd’s-Eye View 67 Chapter 3: “Hello” From Flutter 69 First Things First 69 What’s it all about? 72 A constructor’s parameters 75 A note about punctuation 76 Don’t relent — simply indent 77 Classes, Objects, and Widgets 79 A brief treatise on “within-ness” 81 The documentation is your friend 82 Making Things Look Nicer 83 Creating a scaffold 86 Adding visual tweaks 88 Dart’s enum feature 89 Hello from sunny California! 89 Adding another widget 91 Centering the text (Part 1) 94 Centering the text (Part 2) 97 Displaying an image 100 Hey, Wait a Minute 104 Chapter 4: Hello Again 105 Creating and Using a Function 106 The function declaration 107 A function call 108 Parameters and the return value 108 Programming in Dart: The Small Stuff 112 Statements and declarations 112 Dart’s typing feature 113 Literals, variables, and expressions 114 Two for the price of one 117 Dart’s var keyword 119 Built-in types 121 Types that aren’t built-in 123 Using import declarations 123 Variations on a Theme from Die Flutter Mouse 124 Type names in function declarations 127 Naming your parameters 128 What about the build function? 129 More Fun to Come! 130 Chapter 5: Making Things Happen 131 Let’s All Press a Floating Action Button 132 Stateless widgets and stateful widgets 134 Widgets have methods 135 Pay no attention to the framework behind the curtain 139 Enhancing Your App 146 More parameters, please 148 The override annotation 151 What does mean? 152 Anonymous functions 153 What belongs where 156 Names that start with an underscore 160 Whew! 162 Chapter 6: Laying Things Out 163 The Big Picture 164 Creating bite-size pieces of code 167 Creating a parameter list 169 Living color 170 Adding padding 171 Your humble servant, the Column widget 173 The SizedBox widget 175 Your friend, the Container widget 176 Nesting Rows and Columns 181 More Levels of Nesting 183 Using the Expanded Widget 186 Expanded versus unexpanded 189 Expanded widget saves the day 192 Flexing some muscles 196 How Big is My Device? 199 Part 3: Details, Details 205 Chapter 7: Interacting with the User 207 A Simple Switch 208 Dart’s const keyword 211 Compatible or NOT? 213 Wait For It! 214 How Much Do You Love Flutter? 217 Dealing with Text Fields 220 Callouts 1 and 2 223 Callout 3 225 Callout 4 226 Callout 5 230 Creating Radio Buttons 230 Creating an enum 233 Building the radio group 233 Displaying the user’s choice 235 Creating a Dropdown Button 239 Building the dropdown button 242 The little Reset button 244 Making a Map 245 Onward and Upward 246 Chapter 8: Navigation, Lists, and Other Goodies 247 Extending a Dart Class 248 From One Page to Another 251 An icon on a button 254 Pushing and popping 255 Passing Data from Source to Destination 256 Passing Data Back to the Source 261 Dart’s async and await keywords 264 Taking control of the app bar’s Back button 266 Passing Data in Both Directions 267 Creating Named Routes 272 Creating a List 276 The ListView widget 279 Creating list items one-by-one 285 Another new Dart language feature 288 Fetching Data from the Internet 290 Using a public API 293 Sending a URL to a server 295 Making sense of a JSON response 296 What’s Next? 296 Chapter 9: Moving Right Along 297 Setting the Stage for Flutter Animation 297 Moving Along a Straight Line 303 Bouncing Around 308 Animating Size and Color Changes 310 Moving Along a Curve 312 Dragging Things Around 314 Where To Go From Here 319 Part 4: The Part of Tens 321 Chapter 10: Ten Ways to Avoid Mistakes 323 Put Capital Letters Where They Belong 323 Use Parentheses When (and Only When) They’re Appropriate 323 Limit Access to Variables 324 Call setState 324 Make Adjustments for Indices Starting at Zero 324 Use the Expanded Widget 325 Add itemCount to Your ListView.builder 325 Add Imports When They’re Required 325 Declare Assets and Dependencies in pubspec.yaml 325 Indent Your Code According to Dart Language Guidelines 326 Chapter 11: Ten Ways to Enhance Your App Development Career 327 Practice! Practice! 327 Critique Your Own Code 328 Have Others Review Your Code 328 Find Out Which Technologies Your Nearby Companies Use 328 Attend User Group Meetings 328 Ask Questions 329 Ask Yourself Whether You Truly Understand 329 Learn Things That You May Never Need to Know 329 Do What You Love to Do 330 Get Plenty of Sleep 330 Chapter 12: Ten Chapters about Flutter App Development 331 Introduction 331 What is Flutter? 331 Setting Up Your Computer for Mobile App Development 332 ‘Hello’ from Flutter 332 Hello Again 332 Making Things Happen 332 Laying Things Out 332 Interacting with the User 332 Navigation, Lists, and Other Goodies 333 Moving Right Along 333 Part 5: Appendices 335 Appendix: Doris’s Dating App 337 Index 347
£17.59
John Wiley & Sons Inc Making YouTube Videos Star in Your Own Video Sec
Book SynopsisTable of ContentsIntroduction 1 About YouTube 1 About This Book 1 About You 3 About the Icons 3 Project 1: Get Started 4 Follow the Video-Making Process 5 Development 5 Preproduction 6 Production 6 Post-production 7 Distribution 7 Gather Your Tools 8 Choose Your Camera 10 Webcams 12 Camera phones 13 Camcorders 15 Action cameras 17 Aerial cameras 18 DSLR and mirrorless video 18 Digital cinema cameras 20 Project 2: Shoot 22 Choose a Style 23 Think of an Idea 25 Structure Your Video 26 Script Your Video 28 Write Dialogue 29 Make a Shot List 30 Choose a Shot Type 32 Wide shot 33 Mid shot 34 Close-up 36 Choose Movement or Fixed 38 Record Sound 41 Built-in microphone 43 External microphone 44 Use a Microphone for Dialogue 47 Deal with wind 49 Monitor sound 50 Dubbing and foley 53 Light Your Video 54 Use natural light 54 Use extra lights 56 Direct Your Film 66 Direct your actors 68 Direct your crew 68 Use Shooting Tips 69 Check for continuity mistakes 69 Always get one more take than you need 70 Shoot out of order 70 Check Your Shots 70 Project 3: Edit 73 Choose an Editing Tool 73 Create a New Project in iMovie 76 Import Your Footage in iMovie 77 Record from Webcam in iMovie 80 Add Footage to a Timeline in iMovie 81 Add Transitions in iMovie 87 Add Jump Cuts in iMovie 89 Add Titles in iMovie 90 Record a Voiceover in iMovie 93 Import Your Footage into a New Filmora Project 96 Record from a Webcam in Filmora 98 Add Footage to a Timeline in Filmora 100 Add Transitions in Filmora 105 Add Jump Cuts in Filmora 107 Add Titles in Filmora 109 Record a Voiceover in Filmora 112 Project 4: Creating a Gameplay Video 115 Capturing Game Footage from a PS4 117 Capturing Game Footage from an XBox One 120 Capturing Game Footage from a PC or Macintosh 121 Importing Gameplay into HitFilm Express 124 Basic Editing in HitFilm Express 127 More Basic Editing in HitFilm Express 132 Adding a Voiceover to Your Gameplay Video 136 Recording and Editing a Voiceover for Your Gameplay Video 138 Adding a Voiceover to Your HitFilm Project 141 Exporting your HitFilm Project for YouTube 142 Project 5: Share 144 Get a Google Account 144 Upload a Video to YouTube 148 Share Your Video to YouTube with iMovie 152 Share Your Video to YouTube with Filmora 155 Titles, Thumbnails, and Testing 159 Titles 159 Thumbnails 160 Testing 162 Your YouTube Studio 162 The Dashboard 163 Videos 164 Analytics 165 Comments 169 How to Make Great Videos 171 A is for Attract their attention 171 B is for Be yourself 172 C is for connection 173 D is for direct them on what to do next 173 Ways to Attract More Views! 174 Glossary 177
£8.54
John Wiley & Sons Inc Getting Started with Coding
Book SynopsisAn introduction to coding for kids Coding know-how is the coolest new tool kids can add to their creativity toolboxesand all they need to get started is a computer connected to the internet and the lessons in this book. Easy! The book offers fun step-by-step projects to create games, animations, and other digital toys while teaching a bit about coding along the way. Plus, each project has an end goal to instill confidence and a sense of accomplishment in young coders once the project comes to life. Create simple applications in Scratch to learn how to build things with codingExperiment with real coding with tools built in JavaScriptUse free online toolsShare what you build with friends, family, and teachers Get creative and get coding!Table of ContentsIntroduction 2 About This Book 2 What's New in the Second Edition 4 About You 5 About the Icons 6 Project 1: Get Started 7 Coding QuickStart 7 A Hello World! example 8 What's an algorithm? 9 Sequence, selection, and repetition .10 Flowcharting 11 Picking a Language 12 Using a Dashboard (IDE) 13 Setting Up Your Account in Scratch 14 Getting Around in Scratch 15 Using the Code Tab in Scratch 18 Getting Around in MakeCode 20 Using the Code Toolbox in MakeCode 23 Fixing Errors 24 Debugging in Scratch .25 Debugging in MakeCode .27 Getting Help 28 Project 2: Jungle Chat 29 Brainstorm 30 Flowchart 30 Start a New Project 31 Add a Backdrop 32 Add Animal Sprites 33 Add Text-to-Speech Commands 36 Code the Monkey to Run When Clicked 36 Code the Monkey to Ask the User’s Name 38 Make and Give the Greeting 39 Code the Monkey to Play a Sound 40 Code the Snake to Play a Sound You Record 41 Code the Toucan to Play a Sound from the Sound Library 43 Enhance Your Scene 45 Save, Test, and Debug Your Program 46 Share Your Program with the World 46 Big Ideas in the Project 46 Project 3: Freeze the Pops 48 Brainstorm 49 Flowchart 49 Start a New Project 51 Make a Variable 52 Code Button A to Measure and Show the Temperature 53 Continue Coding Button A to Show If the Pops Are Frozen 56 Save, Test, and Debug Your Program 59 Transfer Your Program to the micro:bit 60 Put Your micro:bit in the Freezer 60 Enhance Your Gadget 61 Big Ideas in the Project 62 Project 4: Jellyfi sh Jumble 64 Brainstorm 65 Flowcharts 65 Start a New Project 67 Add a Backdrop 67 Add a Jellyfi sh Sprite and Custom Costumes 68 Make a Mr Jelly Sprite and a Fake Sprite 70 Code the Green Flag Blocks 73 Background .73 Mr Jelly .74 Fake and the fakers .75 Code the Faker Clones to Swish 77 Code Mr Jelly to Know He’s Been Found 78 Enhance Your Scene 79 Save, Test, and Debug Your Program 81 Share Your Program with the World 81 Big Ideas in the Project 81 Project 5: Card War 83 Brainstorm 84 Flowcharts 84 Start a New Project 85 Make a Variable 87 Code on shake to Make and Send Your Number 88 Code an on radio received Block to Identify a Winner 90 Save, Test, and Debug Your Program 97 Transfer Your Program to the micro:bit 99 Enhance Your Gadget 99 Big Ideas in the Project 100 Project 6: Avoid the Asteroids 102 Brainstorm 103 Flowcharts 103 Green fl ag fl owchart 104 Robot fl owchart 105 Start a New Project 106 Add Three Backdrops 106 Add a Robot Sprite 108 Add an Asteroid Sprite 110 Make Dents and Timer Variables 112 Add Background Music from the Sound Library 113 Code the Green Flag Blocks 114 Background 114 Robot 117 Asteroids 122 Build Your Asteroid Field 125 Code Key Control of the Robot 126 Enhance Your Scene 127 Save, Test, and Debug Your Program 128 Share Your Program with the World 128 Big Ideas in the Project 128 Project 7: Get Fancy 131 Programming Your Own Ideas 132 Getting inspiration from Scratchers 132 Getting inspiration from MakeCode projects 134 Looking at daily human challenges 134 Entering some contests 135 Getting Your Scratch Programs into the World 135 Sharing a project in Scratch 135 Starting your own Scratch studio 136 Making Your Gadgets Real 137 Putting a program on the micro:bit board 137 Adding more hardware 139 Upping Your Game 140 At-home learning 140 Camps and clubs 140 Books 141 Souping Up User Interfaces in Scratch 142 Painting your own images 142 Finding images online 143 Recording your own sounds 144 Finding sounds online 144 Next Steps 145 Coding at school 145 Coding in college 145 Coding as a career 146
£8.54
John Wiley & Sons Inc SwiftUI For Dummies
Book SynopsisThe simplest way to create world-class apps Have a unique app idea but worried you don't quite have the coding skills to build it? Good news: You can stop fretting about someone beating you to market with the same idea and start work right now using SwiftUI. SwiftUI is a gateway app development framework that has become one of the best ways for fledgling developers to get iOS apps off the ground without having to become a coding expert overnight. SwiftUI For Dummies makes that process even faster, providing a friendly introduction to the SwiftUI and Swift programming language and helping you feel right at home creating and building with playgrounds. The book also covers the frameworks and APIs that make it so easy to create smooth, intuitive interfacesjust dive right in and have fun! Combine projects into workspacesEmploy Xcode editing toolsUse constants and variablesTest your code on iOS Simulator Time is of the essence, and with SwiftUI For Dummies, it's also on your side. Get goiTable of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 2 Icons Used in This Book 2 Beyond the Book 3 Where to Go from Here 3 Part 1: Getting Started with Swift and SwiftUI 5 Chapter 1: Introducing SwiftUI 7 Understanding What SwiftUI Is 7 Getting the Tools 11 Hello, SwiftUI 12 Automatically previewing your user interface using the canvas 14 Working with Live Preview 18 Generating different previews 19 The Gory Details 21 Info plist 22 AppDelegate swift 22 SceneDelegate swift 23 Chapter 2: Basics of the Swift Programming Language 25 Basic Swift Syntax 26 Constants 26 Variables 27 Strings 27 Comments 27 Basic Data Types 28 Integers 28 Floating-point numbers 29 Booleans 29 Tuples 30 Arrays 30 Retrieving elements from an array 31 Inserting elements into an array 31 Modifying elements in an array 31 Appending elements to an array 31 Removing elements from an array 32 Dictionaries 32 Retrieving elements from a dictionary 32 Modifying an item in a dictionary 33 Removing an item from a dictionary 33 Optional Types 33 Working with implicitly unwrapped optionals 35 Using optional binding 36 Unwrapping optionals using “?” 36 Using the nil coalescing operator 37 Functions 38 Understanding input parameters 38 Returning a value 39 Flow Control 39 If-Else statement 40 Ternary conditional operator 40 Switch statement 40 Looping 41 For-In loop 42 While loop 42 Repeat-While loop 42 Control transfer statements 42 Range operators 43 Structures 43 Memberwise initializers 44 Structures as value types 45 Classes 47 Defining a class 47 Understanding properties 47 Using methods in classes 49 Trying out the self property 50 Closures 51 Understanding closures 51 Using functions as closures 52 Assigning closures to variables 52 Writing closures inline 53 Understanding type inference 53 Using shorthand argument names 54 Working with the operator function 54 Using trailing closures 55 Protocols 55 Defining and using a protocol 56 Conforming to a protocol 56 Using the Codable protocol 57 Using the some keyword 59 Part 2: Understanding the Basics of SwiftUI 61 Chapter 3: Getting Started with the Basics of SwiftUI 63 Taking a Look at SwiftUI Views 63 Conforming to the View protocol 64 Using modifiers 66 Stacking modifiers 66 Using the Inspector 67 Displaying an Image 70 Using modifiers on the Image view 72 Resizing images 73 Displaying a Button 75 Customizing the button 76 Adding actions 77 Stacking the Views 78 VStack 79 HStack 80 Putting on the Finishing Touches 85 Chapter 4: Handling User Inputs and Custom Views 87 Looking at Input Views 87 TextField 88 SecureField 92 Toggle 93 Slider 94 Stepper 98 Picker 100 Composing Custom Views 103 Composing the custom view 104 Using the custom view 111 Chapter 5: Displaying Lists of Items 113 Using the List View to Display Items 113 Customizing the rows 114 Adding rows programmatically 116 Alternative way to generate rows in a List view 119 Displaying the List within a NavigationView 120 Making the items tappable 121 Adding rows 123 Using the Identifiable protocol 125 Deleting rows 126 Editing rows 128 Moving rows 130 Displaying Sections 133 Displaying sections from a dictionary 134 Changing the style of the List view 136 Previewing in Light and Dark Modes 138 During runtime 138 During design time 139 Chapter 6: Creating Navigation and Tabbed Applications 143 Creating Navigation Apps 144 Working with the two key views in navigation-style apps 145 Navigating to a page 148 Navigating programmatically 149 Creating a news reader application 151 Creating Tabbed Applications 167 Using the TabView 168 Selecting TabViews programmatically 169 Chapter 7: Formatting Your User Interface 173 Laying Out Views Using Stacks 173 VStack 174 HStack 186 ZStack 190 Using Container Views 195 Form and Section 198 Group 200 Divider 203 Part 3: Exploring with SwiftUI in More Detail 205 Chapter 8: Understanding State Management in SwiftUI 207 Using a Property Wrapper 207 Maintaining State Using State Variables 209 Binding State Variables 213 Managing State from External Objects 218 Using the ObservableObject protocol and @Published 219 Using the @ObservedObject 221 Sharing Objects 223 Accessing Built-in Environment Variables 228 Defining your own environment keys 230 Using your own environment keys 231 Chapter 9: Using Legacy UIKit Views and View Controllers in SwiftUI 235 Using UIKit in SwiftUI 236 Understanding the UIKit View Controller life cycle 237 Understanding the SwiftUI view life cycle 239 Using the UIViewRepresentable Protocol for UIKit Views 247 ActivityIndicator 248 WebView 251 Using the UIViewControllerRepresentable Protocol for UIKit View Controllers 253 Creating the ImagePickerViewController 254 Handling events using coordinators 256 Defining the methods in the Coordinator class 258 Using the updated ImagePickerViewController 260 Part 4: Performing Animations and Drawings 263 Chapter 10: Drawings and Special Effects 265 Drawing Using the Five Built-in Shapes 266 Rectangles 266 Rounded rectangles 270 Circles 273 Capsules 274 Ellipses 275 Clipping with the Basic Shapes 277 Drawing Custom Shapes 281 Drawing lines 283 Filling the shape 284 Drawing a border 286 Drawing an arc 287 Combining fill and stroke 289 Using Special Effects in SwiftUI 292 Blend modes 292 Blurs 297 Saturation 298 Chapter 11: Performing Animations in SwiftUI 299 Understanding How to Animate 299 Specifying the type of animation 303 Repeating the animation 303 Stopping the animation 304 Performing Your Own Animation 307 Rotating in 2D 307 Rotating in 3D 309 Creating a Custom Progress Indicator 314 Indeterminate progress indicator 314 Determinate progress indicator 318 Chapter 12: Creating a Complete Project 323 Understanding What the App Does 323 Building the Project 325 Creating the layouts 325 Defining the news sources and observable objects 328 Fetching the data 330 Displaying the news headlines 331 Displaying the images 334 Displaying the news 336 Creating the share sheet 338 Creating the preferences view 339 Persisting the user’s preferences 344 Deploying the App 346 Part 5: The Part of Tens 351 Chapter 13: Ten SwiftUI Tips and Tricks 353 Resuming Live Preview 353 Implementing Localization 354 Combining Text Views 358 Creating Custom Modifiers 360 Displaying Multiple Alerts 362 Enabling Debug Preview 363 Previewing Using Different Devices 364 Dark Mode Only Works On NavigationView 368 Extracting Subviews 370 Displaying a Context Menu 373 Chapter 14: Ten Great SwiftUI Resources 375 Apple 375 SwiftUI by Example 376 100 Days of SwiftUI 376 Gosh Darn SwiftUI 376 SwiftUI Hub 376 Awesome SwiftUI 377 raywenderlich com 377 Swift Talk 377 About SwiftUI 377 Stack Overflow 378 Appendix: Code Snippets for Common Swiftui Views 379 Index 387
£19.99
John Wiley & Sons Inc Android Application Development AllinOne For
Book SynopsisConquer the world of Android app development Android has taken over the mobile and TV markets and become unstoppable! Android offers a vast stage for developers to serve millionsand rake in the profitswith diverse and wide-ranging app ideas. Whether you're a raw recruit or a veteran programmer, you can get in on the action and become a master of the Android programming universe with the new edition of Android Application Development For Dummies All-in-One. In addition to receiving guidance on mobile and TV development, you'll find overviews of native code, watch, car, Android wear, and other device development. This friendly, easy-to-follow book kicks off by offering a fundamental understanding of Android's major technical ideas, including functional programming techniques. It moves on to show you how to work effectively in Studio, program cool new features, and test your app to make sure it's ready to release to a waiting world. You'll also have an opportunity to brush up on your KTable of ContentsIntroduction 1 How to Use This Book 1 Conventions Used in This Book 2 Foolish Assumptions 2 Icons Used in This Book 3 Beyond the Book 4 Where to Go from Here 4 Book 1: Getting Started with Android Application Development 5 Chapter 1: All about Android 7 The Consumer Perspective 8 The Versions of Android 9 The Developer Perspective 12 Java and Kotlin 12 XML 14 Linux 16 The Business Perspective 18 Chapter 2: Installing the Software Tools 19 Setting Up the Software 20 Considering the requirements 20 Downloading the software 21 Installing Android Studio 23 Installing offline tools 25 Launching the Android Studio IDE 28 In Windows 29 On a Mac 29 In Linux 30 In Chrome OS 30 Using the Android Studio Setup Wizard 30 Fattening Up the Android SDK 32 The more things stay the same, the more they change 32 Installing new versions (and older versions) of Android 33 Creating an Android virtual device 35 A third-party emulator 39 Chapter 3: Creating an Android App 43 Creating Your First App 43 Starting the IDE and creating your first app 45 Launching your first app 50 Running Your App 52 You Can Download All the Code 55 Troubleshooting Common IDE Errors 58 Error message: Failed to find target 58 Error running ‘app’: No target device found 58 Error message: Android Virtual Device may be incompatible with your configuration 58 You lose contact with the Android Debug Bridge (ADB) 59 You don’t like whatever AVD opens automatically 59 The emulator stalls during startup 60 Error message: The user data image is used by another emulator 61 Error message: Unknown virtual device name 63 The emulator displays a “process isn’t responding” dialog box 63 Changes to your app don’t appear in the emulator 64 Testing Apps on a Real Device 64 Chapter 4: Examining a Basic Android App 67 A Project’s Files 68 The MainActivity.kt file 71 The onCreate() method 72 Using other templates 73 The res Branch 76 The res/drawable branch 77 The res/layout branch 77 The res/menu branch 78 The res/mipmap branch 79 The res/values branch 80 Other Files in an Android Project 82 The build.gradle file 82 The AndroidManifest.xml file 85 The R.java file 87 The assets folder 89 The android.jar archive 90 The APK file 91 What Did I Agree To? 93 What’s in a name? 93 Choosing a language 95 Your app’s API levels 95 Chapter 5: Conjuring and Embellishing an Android App 101 Dragging, Dropping, and Otherwise Tweaking an App 102 Creating the “look” 102 Coding the behavior 112 A Bit of Debugging 118 Try it! 118 Discovering the secrets of Logcat 123 Using the debugger 126 Chapter 6: Improving Your App 131 Improving the Layout 131 Changing the layout 132 Creating a reusable layout 139 Reusing a layout 142 Starting Another Activity 145 Localizing Your App 151 Responding to Check Box Events 155 Displaying Images 157 Sending in Your Order 162 Book 2: Android Background Material 167 Chapter 1: Using Android Studio 169 Good to Know versus Need to Know 170 Getting a Feel for the Big Picture 171 The main window 173 Viewing modes 179 The Designer tool 181 Discovering What You Can Do 184 Finding things 185 Fixing code 190 Refactoring 199 Chapter 2: Kotlin for Java Programmers 203 Using Kotlin or Java for Development 204 Defining the Java Issues That Kotlin Fixes 207 Improving control over null references 207 Removing raw data types 210 Using invariant arrays 210 Working with proper function types 212 Getting rid of the checked exceptions 213 Nothing’s Perfect: Kotlin is Missing Features, Too 214 Considering primitive types that are not classes 214 Losing static members 214 Eliminating non-private fields 215 Reducing confusion by eliminating wildcard-types 216 Abandoning the ternary-operator a ? b : c 217 Looking at What Kotlin Adds to the Picture 218 Considering higher order functions and lambdas 218 Refining object orientation using extension functions 218 Relying on smart casts 219 Employing string templates 220 Understanding primary constructors 221 Implementing first-class delegation 221 Using ranges of values 223 Creating data classes 224 Overloading operators 224 Developing asynchronous code using coroutines 225 Chapter 3: Kotlin for Everyone 227 Moving from Development to Execution with Kotlin 228 What is a compiler? 228 Understanding native code compiler or interpreter issues 230 Considering the Android Runtime (ART) 231 Grasping Kotlin Code 235 Nearly everything begins with an expression 236 The Kotlin class 238 Classes and objects 239 Kotlin types 240 Performing casts 245 The Kotlin function 249 Objects and their constructors 252 Classes grow on trees 254 The Kotlin package 255 Considering Kotlin visibility rules 257 Defying your parent 258 Kotlin comments 259 Chapter 4: What Kotlin Does (and When) 261 Making Decisions (Kotlin if Statements) 261 Testing for equality 264 Choosing among many alternatives (Kotlin when statements) 266 Repeating Instructions Over and Over Again 269 Kotlin while statements 269 Kotlin do statements 271 Arrays in Kotlin 273 Kotlin’s for statements 277 Looping using Kotlin recursion 281 Working with break and continue 283 Jumping Away from Trouble 284 Working with Kotlin Collections 286 Considering the collection types 287 Differentiating between read-only and mutable collections 289 Chapter 5: Object-Oriented Programming in Kotlin 291 Static Fields and Methods 291 Interfaces and Callbacks 294 Event handling and callbacks 299 An object remembers who created it 302 A less wordy way to implement an interface 303 Classes That Must (and Must Not) Be Extended 305 The need to override 306 Java’s final classes 306 Kotlin’s open classes 307 Kotlin extensions 307 Abstract classes 308 Inner Classes 310 Named inner classes 310 Anonymous inner classes 312 Chapter 6: Functional Programming in Kotlin 315 Defining Functional Programming 316 Differences from other programming paradigms 316 Understanding its goals 317 Understanding Pure and Impure Languages 318 Using the pure approach 318 Using the impure approach 320 Comparing the Functional Paradigm 320 Using Kotlin for Functional Programming Needs 322 Defining the Role of State 323 Using Recursion to Perform Calculations 324 Relying on standard recursion 324 Relying on tail recursion 326 Using Function Types 327 Understanding Function Literals 329 Lambda expressions 329 Anonymous functions 330 Defining the Function Types 331 Comprehensions 331 Receivers 332 Inline 334 Utility 335 Using Functional Programming for Android Apps 336 Chapter 7: A Look at XML 339 XML Isn’t Ordinary Text 340 Of tags and elements 340 Other things you find in an XML document 348 What’s in a Namespace? 350 The package attribute 353 The style attribute 354 Book 3: The Building Blocks 357 Chapter 1: Getting an Overview of Jetpack 359 Understanding the Benefits of Jetpack 360 Eliminating boilerplate code 360 Managing background tasks 361 Navigating between activities and fragments 362 Managing memory 364 Performing configuration changes 365 Considering the Jetpack Components 366 Foundation 367 Architecture 368 Behavior 370 UI 372 Getting an Overview of the AndroidX Package 373 Working with Lifecycle-Aware Components 374 Focusing on activities 375 Understanding events and states 376 Chapter 2: Building a Foundation for Your App 377 Working with Android KTX 378 Getting a feel for KTX features 378 Using KTX in your project 381 Considering the modules 382 Addressing Security Issues 389 Benchmarking Your Application 392 Removing barriers to correct results 393 Creating a test app 394 Profiling your app 397 Tracing your app 398 Checking for benchmarking module support 400 Benchmarking the app 401 Testing Application Functionality 403 Chapter 3: Creating an Architecture 405 Managing Application Activities 405 Defining an activity 406 Getting an overview of intent filters 407 Considering the activity lifecycle 407 Understanding the backstack 409 Working with fragments 412 Considering the fragment lifecycle 416 Seeing activities and fragments in action 417 Providing for Navigational Needs 433 Creating the navigational graph 434 Adding a NavHostFragment to your activity 437 Adding destinations 438 Creating links between destinations 440 Creating the required linkages 442 Performing Background Tasks Using WorkManager 446 Chapter 4: Defining an App’s Behavior 451 Working with Notifications 452 Understanding what notifications do 452 Anatomy of a notification 454 Assigning a channel to your notification 456 Setting the notification importance 457 Considering the notification types 458 Relying on notification updates 459 Do Not Disturb mode 460 Creating a notification 460 Getting Permission 466 Considering permission use 467 Configuring permissions in AndroidManifest.xml 468 Complying with User Preferences 469 Deciding on a preference set 470 Setting preferences using the Preference Library 472 Working with MediaPlayer 481 Adding Camera Support Using CameraX 484 Sharing with Others 487 Performing simple share actions with other apps 487 Using Slices 488 Chapter 5: Interacting with the Users 491 Creating a Great Layout 492 Defining the View and ViewGroup elements 492 Creating a layout using XML 493 Modifying a layout at runtime 497 Considering the common layouts 498 Working with adapters 499 Debugging your layout 500 Employing Color and Texture 502 Working with styles and themes 503 Creating a palette 509 Using swatches to create color schemes 510 Using Animations and Transitions 510 Understanding the need for animations 511 Animating graphics 511 Communicating with Emoji 514 Keyboard emoji support 515 Using the cut-and-paste method on standard controls 516 Using the AndroidX approach 517 Book 4: Programming Cool Phone Features 521 Chapter 1: Hungry Burds: A Simple Android Game 523 Introducing the Hungry Burds Game 523 The Hungry Burds Project’s Files 526 The Main Activity 528 The Code, All the Code, and Nothing But the Code 530 Setting Up the Game 535 Declaring properties 535 The onCreate Method 537 Displaying a Burd 538 Creating random values 538 Creating a Burd 539 Placing a Burd on the constraint layout 540 Animating a Burd 542 Handling a Touch Event 544 Finishing Up 546 Chapter 2: An Android Social Media App 547 Setting Things Up on Facebook’s Developer Site 548 A Minimal Facebook App 549 The build.gradle file 550 The manifest file 550 A Bare-Bones Main Activity 551 Enriching the Minimal App 555 Working with a radio group 559 Controlling the web view 562 Who tests your Facebook app? 563 Chapter 3: Going Native 567 The Native Development Kit 567 Understanding why you need the NDK 568 Knowing what you get 569 Getting the NDK 570 Creating an Application 573 Starting with the template 573 Seeing the essential project differences 575 Considering the build.gradle (Module: app) differences 577 Understanding the default template differences 580 Getting an overview of the C++ file 582 Seeing the result 583 Book 5: Apps for Tablets, Watches, TV Sets, and Cars 585 Chapter 1: Apps for Tablets 587 Gaining Perspective 588 Creating the right devices 589 Running code on multiple devices 593 Copying the project 594 Seeing presentation differences 596 Developing a Nested Navigational Graph 603 Understanding the uses for nested navigational graphs 603 Developing an app design 604 Considering the content needs 608 Creating a Responsive App 612 Chapter 2: Developing for Android Wear 615 Seeing Where Wearables Are Used 615 Setting Up Your Testing Environment 617 Creating the project 617 Configuring a wearable device emulator 620 Other testing configurations 624 Wearable Apps: What’s the Big Deal? 625 Case Study: A Watch Face 626 Defining the watch face project 627 Testing the watch face app 628 Dissecting the skeletal watch face project 631 Enhancing the skeletal watch face project 634 Chapter 3: Developing for Android TV 637 Getting Started 638 Running the Skeletal App 641 Dissecting the TV App 644 Adding to the standard AndroidManifest.xml 644 Looking into build.gradle (Module: app) 645 Defining a layout 646 The adapter and the presenter 647 Using the Adapter class 648 Using the Presenter class 650 Chapter 4: Developing for Android Auto 653 Checking Auto Compatibility 654 Choosing the Google Play Services 656 Considering Notification Limits 658 Creating an Emulator 660 Configuring your car for development 661 Defining an emulator 662 Developing an Android Auto App 670 Creating the project 670 Viewing the project configuration 672 Performing required configuration tasks 674 Touring the Media Service app 675 Book 6: The Job Isn’t Done Until 679 Chapter 1: Publishing Your App to the Google Play Store 681 Creating a Google Play Developer Account 681 Preparing Your Code 682 Un-testing the app 683 Choosing Android versions 683 Setting your app’s own version code and version name 684 Choosing a package name 685 Preparing Graphic Assets for the Play Store 685 Creating an icon 686 Creating screenshots 688 Providing other visual assets 690 Creating a Publishable File 691 Differences among builds 692 Creating the release build 697 Running a new APK file 702 Running the app in a new AAB file 703 Another way to build and run an AAB file 705 Publishing Your App 708 The App Releases page 708 The Store Listing page 710 The App Signing page 711 Other pages 711 Leave No Stone Unturned 714 Publishing Elsewhere 714 The Amazon Appstore 714 Other venues 715 Chapter 2: Monetizing and Marketing Your App 717 Choosing a Revenue Model 718 Charging for your app 719 Offering an extended free trial 723 Freemium apps 724 Selling things with your app 726 Subscription pricing 729 Earning revenue from advertising 729 Variations on in-app advertising 731 Donationware 732 Offering your app for free 732 Getting paid to develop apps for others 732 Marketing Your Application 733 Brick Breaker Master: An App Marketing Case Study 734 Chapter 3: Creating Public Support for Your App 739 Obtaining Support through Patreon 740 Discovering that patronage isn’t new 740 Considering crowdfunding 741 Defining why you should use crowdfunding 741 Understanding the development angle 742 Determining the trade-offs 744 Developing Your Own Distribution Stream 744 Creating podcasts 744 Developing YouTube videos 746 Employing social media 748 Answering questions 750 Taking the Personal Approach 750 Creating a blog 751 Answering your email 752 Considering App Store Alternatives 754 Getting Awards 756 Looking for awards in all the right places 757 Strutting your stuff 757 Index 759
£23.99
John Wiley & Sons Inc Beginning Rust Programming
Book SynopsisQuickly learn the ropes with the Rust programming languageusing this practical, step-by-step guideInBeginning Rust Programming, accomplished programmer and author Ric Messier delivers a highly practical, real-world guide to coding with Rust.Avoiding dry, theoretical content and Hello, world-type tutorials of questionable utility, the book dives immediately intofunctional Rust programming that takes advantage of the language's blazing speed and memory efficiency. Designed from the ground up togive you a running start to using the multiparadigm system programming language, this book will teach you to: Solve real-world computer science problemsof practical importanceUse Rust's rich type system and ownership model to guarantee memory-safetyand thread-safetyIntegrate Rust with other programming languages and use it for embedded devices Perfect for programmers with some experience in other languages, like C or C++,Beginning Rust Programmingis also a great pick for students new to programming and seeking a user-friendly and robust language with which to start their codingcareer.Table of ContentsIntroduction xix Chapter 1: Game of Life: The Basics 1 Game of Life: The Program 2 Starting with Cargo 4 Putting the Pieces Together 5 Bringing In External Functionality 5 Namespaces 6 Generating the Game Grid 7 Dissecting Main 8 Defining Functions 8 Defining Variables 9 Datatypes 11 Arrays 12 Control Structures 14 Looking at More Function Functions 16 Returning Values 16 Passing Parameters 18 Scope 21 Compiling Programs 22 Summary 24 Exercises 25 Additional Resources 25 Chapter 2: Extended Life 27 Understanding Ownership 28 Extending Life 30 Adding Modules 32 Working with Command-Line Arguments 34 Option Types 36 Reading from Files 39 Extracting Values 41 Populating from the Vector 42 Outputting to the Terminal 43 Using Colors 44 Printing Generations 44 Summary 46 Exercises 48 Additional Resources 48 Chapter 3: Building A Library 49 References 50 First Pass 53 Traits and Implementations 56 Self-Identification 60 The Rest 60 Second Pass 62 The Driver 65 Summary 67 Exercises 69 Additional Resources 69 Chapter 4: Hangman 71 Our Data 74 The Traits 77 Implementations 79 Using the Option Enum 82 Finishing Up the Implementation 83 Reading Files and Selecting Words 84 Handling Errors Concisely 85 Generics and Bounds 87 A Vector of Lines 88 The Rest of the Story 90 Initialization 91 Playing the Game 92 Summary 94 Exercises 95 Additional Resources 95 Chapter 5: In Concurrence 97 The Dining Philosophers 98 Mutexes and Semaphores 101 Interprocess Communications 103 The Main Event 106 Unix Sockets 107 File and Directory Handling 109 Closures 112 Threading in the Main 114 Creating Streams 115 Cryptographic Hashing 116 Creating Threads 117 Summary 118 Exercises 119 Additional Resources 119 Chapter 6: Clients and Servers 121 Planning 123 Network Programming 125 Programming Sockets 128 Rust TCP Server 131 Handling Requests 134 Operating System Calls 137 Summary 139 Exercises 140 Additional Resources 140 Chapter 7: Client-Side Applications 141 Encryption 142 Encryption Algorithms 144 Going Hybrid 145 Encryption Algorithms 147 Transport Layer Security (TLS) 147 TLS Server 151 Remote Access Client 154 Creating the Connection 156 Validating Input 157 Regular Expressions 157 The Final Function 159 Summary 163 Exercises 164 Additional Resources 164 Chapter 8: Going Relational 165 Application Architectures 166 n-Tier Applications 167 Microservices 169 Model-View-Controller 171 Databases 172 Structured Query Language 172 Server or Embedded 175 Accessing Databases 176 Writing a Database Program 177 Main and Modules 178 Database Functions 183 Adding Records 184 Listing Records 186 Summary 189 Exercises 190 Additional Resources 190 Chapter 9: NO(SQL) Going 191 Assertions 192 Design by Contract 195 NoSQL 198 Working with MongoDB 202 Inserting Data 202 Reading in Data from a File 206 Populating the Database 207 Retrieving Values 209 Summary 213 Exercises 214 Additional Resources 214 Chapter 10: Web Communications 215 Style Guides 216 Hypertext Transfer Protocol 219 Programmatic Communication 222 Web Communication Over TLS 227 Client Communication 229 Jumping Ahead 232 Jumping Back 237 Summary 238 Exercises 239 Additional Resources 240 Chapter 11: Web Server 241 Offensive vs. Defensive Programming 242 Web Application Communications 245 Web Application Parameters 245 Asynchronous JavaScript and XML 248 Representational State Transfer 249 APIs in Node.js and Python 250 API Server in Rust 252 Rust Rocket 255 Summary 262 Exercises 262 Additional Resources 263 Chapter 12: Getting to the System 265 Extending Functionality 266 Windows Registry 272 Programmatic Access to the Registry 275 Using Rust to Access the Registry 277 System Information with Rust 282 Persistence (for Fun) 287 Summary 289 Exercises 290 Additional Resources 290 Chapter 13: Device Programming 291 Logging 292 Using syslog 292 Using Windows Event Logs 299 Working with Raspberry Pi 305 Lighting Lights 310 Reading GPIO 315 Summary 318 Exercises 319 Additional Resources 319 Chapter 14: Collecting Stuff 321 Arrays and Vectors 322 Linked Lists 329 Stacks 333 Queues 336 Sorting 337 Search Trees 340 Summary 345 Exercises 346 Additional Resources 346 Chapter 15: Odds and Sods 347 Unit Testing 348 Testing Types 350 Test Plans 351 Unit Tests 353 Recursion 360 Machine Learning 364 Chatbots 366 Neural Networks 369 Summary 371 Exercises 373 Additional Resources 373 Index 375
£28.49
John Wiley & Sons Inc Oracle Database Programming with Visual Basic.Net
Book SynopsisOracle Database Programming with Visual Basic.NET Discover a detailed treatment of the practical considerations and applications of Oracle database programming with Visual Basic 2019 Oracle Database Programming with Visual Basic.NET: Concepts, Designs, and Implementations delivers a comprehensive exploration of the foundations of Oracle database programming using Visual Basic.NET. Using Visual Basic.NET 2019, Visual Studio.NET 2019, and Oracle 18c XE, the book introduces the Oracle database development system, Oracle SQL Developer and Modeler, and teaches readers how to implement a sample database solution. The distinguished author also demonstrates the use of dotConnect for Oracle to show readers how to create an effective connection to an Oracle 18c XE database. The current versions of the .NET framework, ASP.NET, and ASP.NET 4.7 are also explored and used to offer readers the most up to date web database programming techniques available today. The book provides practical example p
£62.06
John Wiley & Sons Inc C Programming For Dummies
Book SynopsisTable of ContentsIntroduction 1 Why the C Language? 1 The C Programming For Dummies Approach 2 How This Book Works 3 Icons Used in This Book 4 Parting Thoughts 5 Part 1: The ABs of C 7 Chapter 1: A Quick Start for the Impatient 9 What You Need to Program 9 Command Prompt Programming 10 IDE Programming 11 Installing Code::Blocks 12 Touring the Code::Blocks workspace 13 Your First Program 14 Coding at the command prompt 15 Building a new Code::Blocks project 16 Building and running 18 Chapter 2: The Programming Thing 21 The History of Programming 21 Reviewing early programming history 21 Introducing the C language 22 The Programming Process 23 Understanding programming 23 Writing source code 24 Compiling and linking 26 Running and testing 27 Chapter 3: Anatomy of C 29 Parts of the C Language 29 Keywords 30 Functions 31 Operators 33 Variables and values 33 Statements and structure 33 Comments 35 Behold the Typical C Program 37 Understanding C program structure 37 Setting the main() function 38 Returning something to the operating system 39 Adding a function 40 Part 2: C Programming 101 43 Chapter 4: Trials and Errors 45 Display Stuff on the Screen 45 Displaying a humorous message 45 Introducing the puts() function 46 Adding more text 47 Commenting out a statement 49 Goofing up on purpose 49 More Text Output Nonsense 51 Displaying text with printf() 52 Introducing the printf() function 52 Understanding the newline 53 Employing escape sequences 54 Goofing up on purpose again 55 Chapter 5: Values and Simple Math 57 A Venue for Various Values 57 Understanding values 58 Displaying values with printf() 59 Minding the extra zeros 61 The Computer Does the Math 61 Doing simple arithmetic 61 Reviewing the float-integer thing 63 Pretending integers are floats 64 Chapter 6: A Place to Put Stuff 67 Values That Vary 67 Setting up a quick example 68 Introducing data types 69 Using variables 70 Variable Madness! 73 Using more-specific data types 73 Working with several variables 75 Assigning a value upon creation 77 Reusing variables 77 Constants Always the Same 79 Using the same value over and over 79 Constants in your code 80 Putting constants to use 81 Chapter 7: Input and Output 83 Character I/O 83 Understanding input and output devices 83 Fetching characters with getchar() 84 Using the putchar() function 86 Working with character variables 87 Text I/O, but Mostly I 88 Storing strings 89 Introducing the scanf() function 90 Reading a string with scanf() 91 Reading values with scanf() 93 Using fgets() for text input 94 Chapter 8: Decision Making 97 What If? 97 Making a simple comparison 97 Introducing the if keyword 99 Comparing values in various ways 100 Knowing the difference between = and == 102 Forgetting where to put the semicolon 103 Multiple Decisions 104 Making more-complex decisions 104 Adding a third option 105 Multiple Comparisons with Logic 106 Building a logical comparison 106 Adding some logical operators 107 The Old Switch Case Trick 108 Making a multiple-choice selection 108 Understanding the switch-case structure 110 Taking no breaks 111 The Weird ?: Decision Thing 112 Chapter 9: Loops, Loops, Loops 115 A Little Déjà Vu 115 The Thrill of for Loops 116 Doing something x number of times 116 Introducing the for loop 117 Counting with the for statement 119 Looping letters 120 Nesting for loops 121 The Joy of the while Loop 123 Structuring a while loop 123 Using the do while loop 125 Loopy Stuff 126 Looping endlessly 126 Looping endlessly but on purpose 127 Breaking out of a loop 128 Adding multiple for loop conditions 129 Screwing up a loop 130 Chapter 10: Fun with Functions 133 Anatomy of a Function 133 Constructing a function 133 Prototyping (or not) 136 Functions and Variables 139 Using variables in functions 139 Sending a value to a function 140 Sending multiple values to a function 142 Creating functions that return values 143 Returning early 145 Constants of the Global Kind 147 Introducing defined constants 147 Putting defined constants to use 148 Part 3: Build Upon What You Know 151 Chapter 11: The Unavoidable Math Chapter 153 Math Operators from Beyond Infinity 153 Incrementing and decrementing 154 Prefixing the ++ and -- operators 156 Discovering the remainder (modulus) 158 Saving time with assignment operators 158 Math Function Mania 160 Exploring some common math functions 161 Suffering through trigonometry 163 It’s Totally Random 166 Spewing random numbers 166 Making the numbers more random 167 The Holy Order of Precedence 170 Getting the order correct 170 Forcing order with parentheses 171 Chapter 12: Give Me Arrays 173 Behold the Array 173 Avoiding arrays 173 Understanding arrays 174 Initializing an array 177 Playing with character arrays (strings) 177 Working with empty char arrays 179 Sorting arrays 181 Multidimensional Arrays 183 Making a two-dimensional array 183 Going crazy with three-dimensional arrays 186 Declaring an initialized multidimensional array 188 Arrays and Functions 189 Passing an array to a function 189 Returning an array from a function 191 Chapter 13: Fun with Text 193 Character Manipulation Functions 193 Introducing the CTYPEs 193 Testing characters 195 Changing characters 197 String Functions Galore 198 Reviewing string functions 198 Comparing text 199 Building strings 200 Fun with printf() Formatting 202 Formatting floating point 202 Setting the output width 204 Aligning output 206 Gently Down the Stream 207 Demonstrating stream input 207 Dealing with stream input 208 Chapter 14: Structures, the Multivariable 211 Hello, Structure 211 Introducing the multivariable 211 Understanding struct 213 Filling a structure 215 Making an array of structures 216 Weird Structure Concepts 218 Putting structures within structures 218 Passing a structure to a function 219 Chapter 15: Life at the Command Prompt 221 Conjure a Terminal Window 221 Starting a terminal window 222 Running code in text mode 223 Arguments for the main() Function 225 Reading the command line 225 Understanding main()’s arguments 227 Time to Bail 229 Quitting the program 229 Running another program 230 Chapter 16: Variable Nonsense 233 Variable Control 233 Typecasting into disbelief 233 Creating new things with typedef 235 Making static variables 238 Variables, Variables Everywhere 241 Using external variables 241 Creating an external structure variable 243 Enumerating 245 Chapter 17: Binary Mania 249 Binary Basics 249 Understanding binary 249 Outputting binary values 251 Bit Manipulation 253 Using the bitwise | operator 253 Using bitwise & 256 Operating exclusively with XOR 257 Understanding the ~ and ! operators 259 Shifting binary values 259 Explaining the binbin() function 263 The Joy of Hex 264 Part 4: The Advanced Part 267 Chapter 18: Introduction to Pointers 269 The Biggest Problem with Pointers 269 Sizing Up Variable Storage 270 Understanding variable storage 270 Reading a variable’s size 271 Checking a variable’s location 275 Reviewing variable storage info 278 The Hideously Complex Topic of Pointers 279 Introducing the pointer 279 Working with pointers 282 Chapter 19: Deep into Pointer Land 285 Pointers and Arrays 285 Getting the address of an array 285 Working pointer math in an array 287 Substituting pointers for array notation 293 Strings Are Pointer-Things 294 Using pointers to display a string 294 Using a pointer to declare a string 295 Building an array of pointers 296 Sorting strings 300 Pointers in Functions 302 Passing a pointer to a function 302 Returning a pointer from a function 303 Chapter 20: Memory Chunks and Linked Lists 305 Give Me Memory! 306 Introducing the malloc() function 306 Creating string storage 308 Using the calloc() function 309 Getting more memory 311 Freeing memory 313 Lists That Link 314 Allocating space for a structure 314 Creating a linked list 316 Editing a linked list 323 Saving a linked list 328 Chapter 21: It’s About Time 329 What Time is It? 329 Understanding the calendar 330 Working with time in C 330 Time to Program 331 Checking the clock 331 Viewing a timestamp 333 Slicing through the time string 334 Snoozing 336 Part 5: And the Rest of It 337 Chapter 22: Permanent Storage Functions 339 Sequential File Access 339 Understanding C file access 340 Writing text to a file 341 Reading text from a file 342 Appending text to a file 345 Writing binary data 346 Reading binary data 348 Random File Access 350 Writing a structure to a file 351 Reading and rewinding 353 Finding a specific record 355 Saving a linked list to a file 357 Chapter 23: File Management 359 Directory Madness 359 Calling up a directory 359 Gathering more file info 361 Separating files from directories 363 Exploring the directory tree 364 Fun with Files 365 Renaming a file 365 Copying a file 367 Deleting a file 368 Chapter 24: Beyond Mere Mortal Projects 369 The Multi-Module Monster 369 Linking two source code files 370 Sharing variables between modules 372 Creating a custom header file 374 Other Libraries to Link 378 Chapter 25: Out, Bugs! 381 Simple Tricks to Resolve Problems 381 Documenting the flow 382 Talking through your code 382 Writing comments for future-you 382 The Debugger 383 Debugging setup 383 Working the debugger 385 Setting a breakpoint 387 Watching variables 388 Improved Error Messages 390 Part 6: The Part of Tens 393 Chapter 26: Ten Common Boo-Boos 395 Conditional Foul-Ups 395 == v = 396 Dangerous Loop Semicolons 397 Commas in for Loops 398 Missing break in a switch Structure 398 Missing Parentheses and Curly Brackets 399 Don’t Ignore a Warning 399 Endless Loops 400 scanf() Blunders 401 Streaming Input Restrictions 402 Chapter 27: Ten Reminders and Suggestions 403 Maintain Good Posture 404 Use Creative Names 404 Write a Function 405 Work on Your Code a Little Bit at a Time 405 Break Apart Larger Projects into Several Modules 406 Know What a Pointer is 406 Add Whitespace before Condensing 407 Know When if-else Becomes switch-case 407 Remember Assignment Operators 408 When You Get Stuck, Read Your Code Out Loud 409 Part 7: Appendices 411 Appendix A: ASCII Codes 413 Appendix B: Keywords 419 Appendix C: Operators 421 Appendix D: Data Types 423 Appendix E: Escape Sequences 425 Appendix F: Conversion Characters 427 Appendix G: Order of Precedence 429 Index 431
£20.79
