Practical applications of information technology Books

a huge range and FREE tracked UK delivery on ALL orders.

Read more less

a huge range and FREE tracked UK delivery on ALL orders.

Read more less

Book SynopsisThe no-nonsense way to get started coding in the Python programming language Python Essentials For Dummies is a quick reference to all the core concepts in Python, the multifaceted general-purpose language used for everything from building websites to creating apps. This book gets right to the point, with no excess review, wordy explanations, or fluff, making it perfect as a desk reference on the job or as a brush-up as you expand your skills in related areas. Focusing on just the essential topics you need to know to brush up or level up your Python skill, this is the reliable little book you can always turn to for answers. Get a quick and thorough intro to the basic concepts of coding in PythonReview what you've already learned or pick up essential new skillsCreate websites, software, machine learning, and automation for school or workKeep this concise reference book handy for jogging your memory as you code This portable Dummies Essentials book focuses on the key topics you need to k

Read more less

Book Synopsis

Read more less

Book Synopsis

Read more less

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

Read more less

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

Read more less

Book SynopsisTable of ContentsIntroduction 1 Book 1: Introducing R 5 Chapter 1: R: What It Does and How It Does It 7 Chapter 2: Working with Packages, Importing, and Exporting 37 Book 2: Describing Data 51 Chapter 1: Getting Graphic 53 Chapter 2: Finding Your Center 93 Chapter 3: Deviating from the Average 103 Chapter 4: Meeting Standards and Standings 113 Chapter 5: Summarizing It All 125 Chapter 6: What’s Normal? 145 Book 3: Analyzing Data 163 Chapter 1: The Confidence Game: Estimation 165 Chapter 2: One-Sample Hypothesis Testing 181 Chapter 3: Two-Sample Hypothesis Testing 207 Chapter 4: Testing More than Two Samples 233 Chapter 5: More Complicated Testing 257 Chapter 6: Regression: Linear, Multiple, and the General Linear Model 279 Chapter 7: Correlation: The Rise and Fall of Relationships 315 Chapter 8: Curvilinear Regression: When Relationships Get Complicated 335 Chapter 9: In Due Time 359 Chapter 10: Non-Parametric Statistics 371 Chapter 11: Introducing Probability 393 Chapter 12: Probability Meets Regression: Logistic Regression 415 Book 4: Learning from Data 423 Chapter 1: Tools and Data for Machine Learning Projects 425 Chapter 2: Decisions, Decisions, Decisions 449 Chapter 3: Into the Forest, Randomly 467 Chapter 4: Support Your Local Vector 483 Chapter 5: K-Means Clustering 503 Chapter 6: Neural Networks 519 Chapter 7: Exploring Marketing 537 Chapter 8: From the City That Never Sleeps 557 Book 5: Harnessing R: Some Projects to Keep You Busy 573 Chapter 1: Working with a Browser 575 Chapter 2: Dashboards — How Dashing! 603 Index 639

Read more less

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

Read more less

Book SynopsisThe long-awaited x64 edition of the bestselling introduction to Intel assembly language In the newly revised fourth edition of x64 Assembly Language Step-by-Step: Programming with Linux, author Jeff Duntemann delivers an extensively rewritten introduction to assembly language with a strong focus on 64-bit long-mode Linux assembler. The book offers a lighthearted, robust, and accessible approach to a challenging technical discipline, giving you a step-by-step path to learning assembly code that's engaging and easy to read. x64 Assembly Language Step-by-Step makes quick work of programmable computing basics, the concepts of binary and hexadecimal number systems, the Intel x86/x64 computer architecture, and the process of Linux software development to dive deep into the x64 instruction set, memory addressing, procedures, macros, and interface to the C-language code libraries on which Linux is built. You'll also find: A set of free and open-source Table of ContentsIntroduction xxix Chapter 1 It’s All in the Plan 1 Another Pleasant Valley Saturday 1 Had This Been the Real Thing 5 Assembly Language Programming As a Square Dance 5 Assembly Language Programming As a Board Game 6 Chapter 2 Alien Bases 11 The Return of the New Math Monster 11 Octal: How the Grinch Stole Eight and Nine 16 Hexadecimal: Solving the Digit Shortage 20 From Hex to Decimal and from Decimal to Hex 24 Practice. Practice! PRACTICE! 27 Arithmetic in Hex 28 Binary 34 Hexadecimal as Shorthand for Binary 38 Prepare to Compute 40 Chapter 3 Lifting the Hood 41 RAXie, We Hardly Knew Ye 41 Switches, Transistors, and Memory 43 The Shop Supervisor and the Assembly Line 54 The Box That Follows a Plan 58 What vs. How: Architecture and Microarchitecture 63 Enter the Plant Manager 67 Chapter 4 Location, Location, Location 73 The Joy of Memory Models 73 The Nature of Segments 80 Segment Registers 87 The Four Major Assembly Programming Models 95 64-Bit Long Mode 101 Chapter 5 The Right to Assemble 103 The Nine and Sixty Ways to Code 103 Files and What’s Inside Them 104 Text In, Code Out 115 The Assembly Language Development Process 123 Linking the Object Code File 130 Taking a Trip Down Assembly Lane 134 Chapter 6 A Place to Stand, with Access to Tools 143 Integrated Development Environments 143 Introducing SASM 146 Linux and Terminals 153 Using Linux Make 164 Debugging with SASM 172 Chapter 7 Following Your Instructions 175 Build Yourself a Sandbox 176 Instructions and Their Operands 178 Source and Destination Operands 178 Rally Round the Flags, Boys! 186 Signed and Unsigned Values 195 Implicit Operands and MUL 200 Reading and Using an Assembly Language Reference 205 NEG Negate (Two’s Complement; i.e., Multiply by −1) 208 Chapter 8 Our Object All Sublime 213 The Bones of an Assembly Language Program 213 Last In, First Out via the Stack 223 Using Linux Kernel Services Through Syscall 231 Designing a Nontrivial Program 235 Going Further 248 Chapter 9 Bits, Flags, Branches, and Tables 251 Bits Is Bits (and Bytes Is Bits) 251 Shifting Bits 258 Bit-Bashing in Action 262 Flags, Tests, and Branches 270 X64 Long Mode Memory Addressing in Detail 279 Character Table Translation 290 Tables Instead of Calculations 298 Chapter 10 Dividing and Conquering 299 Boxes within Boxes 300 Calling and Returning 309 Local Labels and the Lengths of Jumps 325 Building External Procedure Libraries 330 The Art of Crafting Procedures 352 Simple Cursor Control in the Linux Console 356 Creating and Using Macros 364 Chapter 11 Strings and Things 377 The Notion of an Assembly Language String 378 REP STOSB, the Software Machine Gun 387 The Semiautomatic Weapon: STOSB Without REP 392 MOVSB: Fast Block Copies 397 Storing Data to Discontinuous Strings 402 Command-Line Arguments, String Searches, and the Linux Stack 408 The Stack, Its Structure, and How to Use It 414 Chapter 12 Heading Out to C 423 What’s GNU? 424 Linking to the Standard C Library 429 Formatted Text Output with printf() 438 Data In with fgets() and scanf() 442 Be a Linux Time Lord 448 Understanding AT&T Instruction Mnemonics 456 Generating Random Numbers 460 How C Sees Command-Line Arguments 472 Simple File I/O 474 Conclusion: Not the End, But Only the Beginning 489 Appendix A The Return of the Insight Debugger 493 Insight’s Shortcomings 494 Opening a Program Under Insight 495 Setting Command-Line Arguments with Insight 496 Running and Stepping a Program 496 The Memory Window 497 Showing the Stack in Insight’s Memory View 498 Examining the Stack with Insight’s Memory View 498 Learn gdb! 500 Appendix B Partial x64 Instruction Reference 501 What’s Been Removed from x64 502 Flag Results 502 Size Specifiers 503 Instruction Index 505 ADC: Arithmetic Addition with Carry 507 ADD: Arithmetic Addition 509 AND: Logical AND 511 BT: Bit Test 513 CALL: Call Procedure 515 CLC: Clear Carry Flag (CF) 517 CLD: Clear Direction Flag (DF) 518 CMP: Arithmetic Comparison 519 DEC: Decrement Operand 521 DIV: Unsigned Integer Division 522 INC: Increment Operand 524 J??: Jump If Condition Is Met 525 JECXZ: Jump if ECX=0 527 JRCXZ: Jump If RCX=0 528 JMP: Unconditional Jump 529 LEA: Load Effective Address 531 LOOP: Loop Until CX/ECX/RCX=0 532 LOOPNZ/LOOPNE: Loop Until CX/ECX/RCX=0 and ZF=0 534 LOOPZ/LOOPE: Loop Until CX/ECX/RCX=0 and ZF=1 535 MOV: Copy Right Operand into Left Operand 536 MOVS: Move String 538 MOVSX: Copy with Sign Extension 540 MUL: Unsigned Integer Multiplication 542 NEG: Negate (Two’s Complement; i.e., Multiply by −1) 544 NOP: No Operation 546 NOT: Logical NOT (One’s Complement) 547 OR: Logical OR 548 POP: Copy Top of Stack into Operand 550 POPF/D/Q: Copy Top of Stack into Flags Register 552 PUSH: Push Operand onto Top of Stack 553 PUSHF/D/Q: Push Flags Onto the Stack 555 RET: Return from Procedure 556 ROL/ROR: Rotate Left/Rotate Right 558 SBB: Arithmetic Subtraction with Borrow 560 SHL/SHR: Shift Left/Shift Right 562 STC: Set Carry Flag (CF) 564 STD: Set Direction Flag (DF) 565 STOS/B/W/D/Q: Store String 566 SUB: Arithmetic Subtraction 568 SYSCALL: Fast System Call into Linux 570 XCHG: Exchange Operands 571 XLAT: Translate Byte Via Table 572 XOR: Exclusive OR 573 Appendix C Character Set Charts 575 Index 579

Read more less

Book Synopsis

Read more less

Book Synopsis Personalized and adaptive systems employ user models to adapt content, services, interaction or navigation to individual users’ needs. User models can be inferred from implicitly observed information, such as the user’s interaction history or current location, or from explicitly entered information, such as user profile data or ratings. Applications of personalization include item recommendation, location-based services, learning assistance and the tailored selection of interaction modalities. With the transition from desktop computers to mobile devices and ubiquitous environments, the need for adapting to changing contexts is even more important. However, this also poses new challenges concerning privacy issues, user control, transparency, and explainability. In addition, user experience and other human factors are becoming increasingly important. This book describes foundations of user modeling, discusses user interaction as a basis for adaptivity, and showcases several personalization approaches in a variety of domains, including music recommendation, tourism, and accessible user interfaces.

Read more less

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

Read more less

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

Read more less

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

Read more less

Book Synopsis

Read more less

Book SynopsisLearn the most important SQL skills and apply them in your jobquickly and efficiently! SQL (Structured Query Language) is the modern language that almost every relational database system supports for adding data, retrieving data, and modifying data in a database. Although basic visual tools are available to help end-users input common commands, data scientists, business intelligence analysts, Cloud engineers, Machine Learning programmers, and other professionals routinely need to query a database using SQL. Job Ready SQL provides you with the foundational skills necessary to work with data of any kind. Offering a straightforward learn-by-doing' approach, this concise and highly practical guide teaches you all the basics of SQL so you can apply your knowledge in real-world environments immediately. Throughout the book, each lesson includes clear explanations of key concepts and hands-on exercises that mirror real-world SQL tasks. Teaches the basics of SQL database creation and managemenTable of ContentsAcknowledgments v About the Authors vi About the Technical Writer vii About the Technical Editor viii Introduction xix Part I: Introduction to Database Concepts 1 Lesson 1: Exploring Relational Databases and SQL 3 Saving Data 4 What Is a Database? 5 Database Uses 5 Data vs. Information 6 Structured vs. Unstructured 6 Database vs. DBMS 7 Relational Database Concepts 7 ACID Compliance 9 ACID Properties 10 Atomicity 10 Consistency 10 Isolation 12 Durability 12 Databases and Log Files 12 Entity Integrity 13 Ensuring Uniqueness 13 Finding Records 14 Backup Strategies 15 Summary 16 Exercises 17 Exercise 1.1: Customers and Orders 17 Exercise 1.2: Libraries and the Books Within 17 Exercise 1.3: Your Scenario 18 Lesson 2: Applying Normalization 19 What Is Normalization? 19 Data Redundancy Is a Problem 20 Storage Reduction 21 Functional Dependencies 22 Normalizing Data 22 First Normal Form 23 Top- to- Bottom or Left- to- Right Ordering 23 Every Row Can Be Uniquely Identified 24 Every Field Contains Only One Value 24 Summary of First Normal Form 25 Second Normal Form 26 Normalize to 1NF 27 Composite Keys 28 Summary of Second Normal Form 31 Third Normal Form 33 Denormalization 35 Summary 37 Exercises 37 Exercise 2.1: Employees 38 Exercise 2.2: Libraries and the Books Within 38 Exercise 2.3: Hotels 39 Exercise 2.4: Students and Courses 39 Exercise 2.5: On the Menu 40 Lesson 3: Creating Entity- Relationship Diagrams 41 Using ERDs 42 Available Tools 43 ERD Components 45 Creating Tables 45 Adding Fields 46 Identifying Keys 47 Including Additional Tables 47 Showing Relationships 48 ERD of Database 50 What About Many- to- Many Relationships? 51 Summary 52 Exercises 53 Exercise 3.1: Customers and Orders 53 Exercise 3.2: The Relationship Between Libraries and Books 53 Exercise 3.3: Many to Many No More 53 Exercise 3.4: Diagramming the Menu 54 Exercise 3.5: Database Design Assessment 54 Lesson 4: Pulling It All Together: Normalizing a Vinyl Record Shop Database 57 The Vinyl Record Shop Data Overview 58 Step 1: Identify the Entities and Attributes 59 Step 1 Results 60 Step 2: First Normal Form 61 Determining Primary Keys 62 Resolving Multivalued Fields 63 Normalizing the Song Entity 65 Step 2 Results 67 Step 3: Second Normal Form 69 Step 3 Results 69 Step 4: Third Normal Form 69 Step 4 Results 70 ERD in 3NF 71 Step 5: Finalize the Structure 73 Final Steps 73 Summary 75 Part II: Applying SQL 77 Lesson 5: Working with MySQL Server 79 MySQL Installation 80 Step 1: Get the Download 80 Step 2: Skipping the Login 80 Step 3: Starting the Install 81 Step 4: Tool Selection 82 Step 5: Product Configuration 83 Step 6: MySQL Router Configuration 87 MySQL Notifier 90 Command- Line Interface 91 Getting Started with MySQL Workbench 93 Use MySQL Workbench 96 Run a Test Command 101 Summary 102 Exercises 103 Exercise 5.1: Running the Tools 104 Exercise 5.2: Listing the Cities 104 Exercise 5.3: Small Cities 104 Lesson 6: Diving into SQL 105 Introduction to SQL 106 SQL Syntax 106 Semicolon 107 Line Breaks and Indents 107 Letter Case 108 Commas 109 Spaces 110 Quotation Marks 110 Spelling 111 Working with Null Values 111 Null vs. Zero 111 Nullable Fields 112 Consequences of Null Values 113 Working with Indexes 116 Primary vs. Secondary Storage 117 Indexing Fields 117 Default Indexes 118 Unique and Nonunique Indexes 119 Summary 119 Exercises 120 Exercise 6.1: Remember Your Lines 120 Exercise 6.2: Contact Questions 120 Exercise 6.3: Missing Contact 121 Lesson 7: Database Management Using DDL 123 Database Management 124 Create a New Database 124 List Existing Databases 125 Use a Database 126 Delete an Existing Database 127 MySQL Data Types 127 Data Types 128 Numeric Data Types 128 Integer Types 128 Decimal Types 129 String Types 130 Date/Time 130 Managing Tables in MySQL 131 Create a Table 131 List Tables 133 View a Table 134 Change a Table 135 Dropping a Field 135 Setting a Key Value 135 Modifying a Field 136 Adding a Field 137 Altering Tables with Existing Data 137 Delete a Table 137 Summarizing the book Table Changes 138 Managing Relationships in MySQL 139 Define a Foreign Key 139 Entity Integrity 141 Referential Integrity 141 Adding Data to a Foreign Key Field 141 Updating Data in a Primary Record 142 Deleting Data from a Primary Record 142 Work- Arounds for Referential Integrity 142 Remove the Foreign Key Constraints 142 Using ON UPDATE 142 Using ON DELETE 143 Summary 143 Exercises 144 Exercise 7.1: Books Database 144 Part 1: Define the Tables 146 Part 2: Books Database SQL Scripts 146 Part 3: Test the Script 147 Exercise 7.2: DDL Activity: Movies Database 147 Part 1: Define the Tables 148 Part 2: Create the Script 149 Part 3: Test the Script 149 Lesson 8: Pulling It All Together: Building the Vinyl Record Shop Database 151 Step 1: Examine the Structure 152 Organize the Tables 154 Create the Script File 155 Step 2: Create the Database 155 Step 3: Create the Primary Tables 157 Column Order 158 On Your Own 159 Step 4: Create the Related Tables 160 Create the song Table 160 Create the songAlbum Table 162 Create the bandArtist Table on Your Own 164 Step 5: Finalize the Script 164 Summary 167 Part III: Data Management and Manipulation 169 Lesson 9: Applying CRUD: Basic Data Management and Manipulation 171 Data Manipulation Language 172 Create a Database 172 Create the Database 175 Check That the Database Exists 176 Insert Data 176 Adding Without Columns Identified 177 Adding Columns with Column Names 177 The Better Option 178 Inserting Multiple Rows 179 Incrementing Auto- Increment Out of Order 180 Inserting a Foreign Key 181 Update Data 182 Updating One Row 183 Preview Before You Update 184 Updating Multiple Rows 184 Disabling SQL_SAFE_UPDATES 185 Delete Data 187 Summary 191 Exercises 191 Exercise 9.1: Setting Up a Book List 192 Exercise 9.2: Updating Books 193 Exercise 9.3: Removing a Book 193 Lesson 10: Working with SELECT Queries 195 Setting Up a Database 196 Using the SELECT Keyword 199 Using Single- Table SELECT 199 Using SELECT * 201 Using the WHERE Clause 202 Filtering Numbers 205 Filtering Dates 207 Pattern Matching Text 207 NULL: The “Billion- Dollar Mistake” 209 Performing Calculations 211 Summary 213 Exercises 214 Exercise 10.1: Complaints 214 Exercise 10.2: Personal Trainer 215 Instructions 216 Activity 1 216 Activity 2 216 Activity 3 217 Activity 4 217 Activity 5 217 Activity 6 217 Activity 7 218 Activity 8 218 Activity 9 218 Activity 10 218 Activity 11 219 Activity 12 219 Activity 13 220 Activity 14 220 Activity 15 220 Activity 16 220 Activity 17 221 Activity 18 221 Activity 19 221 Lesson 11: Adding JOIN Queries 223 Starting with a Schema 224 Get Data from Multiple Tables 226 Use the JOIN Clause 228 Inner Join 228 Optional Syntax Elements 230 Omitting Table Names 230 Omitting the INNER Keyword 232 Multiple JOINs 232 INNER JOIN Limitations 235 OUTER JOIN: LEFT, RIGHT, and FULL 236 Replacing a NULL Value with Ifnull() 238 Projects Without Workers 239 Workers Without a Project 241 Self- JOIN and Aliases 243 Cross Join 246 Summary 247 Exercises 247 Exercise 11.1: User Stories 248 Exercise 11.2: Personal Trainer Activities 248 Activity 1 (64 Rows) 248 Activity 2 (9 Rows) 248 Activity 3 (9 Rows) 250 Activity 4 (35 Rows) 250 Activity 5 (25 Rows) 250 Activity 6 (78 Rows) 250 Activity 7 (200 Rows) 250 Activity 8 (0 or 1 Row) 250 Activity 9 (12 Rows) 250 Activity 10 (16 Rows) 251 Activity 11 (50 Rows) 251 Activity 12 (6 Rows, 4 Unique Rows) 251 Activity 13 (26 Workouts, 3 Goals) 251 Activity 14 (744 Rows) 251 Lesson 12: Sorting and Limiting Query Results 253 Using ORDER BY 254 Sort by a Single Column 254 Sort by Multiple Columns 256 Changing the Order of the Columns 258 Handling NULL 260 Using LIMIT 261 Using DISTINCT 263 Summary 264 Exercises 265 Getting Started: World Database 265 Generating an ERD for World 266 Guidelines 267 Exercise 12.1: What’s in the World Database? 267 Exercise 12.2: Small Cities (42 rows) 267 Exercise 12.3: Cities by Region (4,079 rows) 267 Exercise 12.4: Speaking French (22 rows) 267 Exercise 12.5: No Independence (47 rows) 268 Exercise 12.6: Country Languages (990 rows) 268 Exercise 12.7: No Language (6 rows) 268 Exercise 12.8: City Population (232 rows) 268 Exercise 12.9: Average City Population (7 rows) 268 Exercise 12.10: GNP 269 Exercise 12.11: Capital Cities (4,079 rows) 269 Exercise 12.12: Country Capital Cities (239 rows) 269 Lesson 13: Grouping and Aggregates 271 Aggregate Functions 272 Using GROUP BY 273 Grouping and Multiple Columns 275 Adding DISTINCT 277 Using HAVING 279 SELECT Evaluation Order 281 Other Examples 281 Summary 283 Exercises 284 The Personal Trainer Database 284 Exercise 13.1: Number of Clients (1 row) 286 Exercise 13.2: Counting Client Birth Dates (1 row) 286 Exercise 13.3: Clients by City (20 rows) 286 Exercise 13.4: Invoice Totals (1,000 rows) 286 Exercise 13.5: Invoices More Than $500 (234 rows) 287 Exercise 13.6: Average Line Item Totals (3 rows) 287 Exercise 13.7: More Than $1, 000 Paid (146 rows) 287 Exercise 13.8: Counts by Category (13 rows) 288 Exercise 13.9: Exercises (64 rows) 288 Exercise 13.10: Client Birth Dates (26 rows) 288 Exercise 13.11: Client Goal Count (500 rows, 50 rows with no goal) 289 Exercise 13.12: Exercise Unit Value (82 rows) 289 Exercise 13.13: Categorized Exercise Unit Value (82 rows) 289 Exercise 13.14: Level Ages (4 rows) 290 Lesson 14: Pulling It All Together: Adding Data to the Vinyl Record Shop Database 291 Organize the Tables 292 Create a Script File 293 Inserting Data 294 What Is a Flat File? 294 Sql Insert 295 Inserting by Table Order 296 Adding by Field Name 297 On Your Own 298 Update Records 299 Import CSV Data 300 Set Up MySQL 301 Prepare the CSV File 303 Import the File 308 Command- Line Import 308 MySQL Workbench 310 Add Data to the Script 317 Test the Script 319 Wrap Up the Vinyl Music Shop Script 319 Summary 319 Lesson 15: Diving into Advanced SQL Topics 321 Adding Subqueries 322 Subqueries in the IN Operator 322 Subqueries for Tables 323 Subqueries for Values 325 Working with Views 326 Understanding Transactions 327 Transaction Example 328 Acid 329 Schema Optimization 331 Choosing Optimal Data Types 331 Indexing 333 B- Tree Indexes 334 Hash Indexes 335 Summary 336 Exercises 337 Exercise 15.1: Recent Tasks 337 Exercise 15.2: Before Grumps 338 Exercise 15.3: Project Due Dates 338 Exercise 15.4: The Work of Ealasaid Blinco 338 Exercise 15.5: Other Databases 339 Appendix A: Bonus Lesson on Applying SQL with Python 341 Appendix B: SQL Quick Reference 367 Index 375

Read more less

Book Synopsis

Read more less

Book SynopsisArtificial intelligence is emerging as a game-changer in the business world, with impacts across all sectors. AI allows business to process massive amounts of data instantaneously, and to scale solutions at almost zero marginal cost, forcing companies to adapt and reimagine their business and operations. The Rise of AI-Powered Companies examines some of the most successful examples of companies using artificial intelligence to their advantage. From AI-enabled countries across the globe that stayed resilient and strong in the face of COVID-19, to Business-to-Consumer businesses that transformed their product development processes thanks to unprecedented amounts of consumer data, increasing their revenues manifold along the way. The book then delves into the critical enablers to becoming AI-powered and the critical steps to activate and integrate them within business organizations. Starting with data strategy, it examines new forms of data sharing and how companies should think about governance and privacy risks. It then focuses on human–AI collaboration and its role in building a stronger team culture. Finally, "Responsible AI" is discussed as well as the impact of AI-powered businesses on society at large. AI-powered companies will become the norm in the years to come. By unpacking and showcasing the major steps of a successful AI transformation, this book will help guide organizations in making the critical leap to become AI-powered—essential to survive and remain competitive in the near future.

Read more less

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

Read more less

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

Read more less

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

Read more less

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

Read more less

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

Read more less

Book SynopsisWant to be the next Andy Serkis as Gollum in Lord of the Rings? Or Zoe Saldana in Avatar? How about Seth MacFarlane in Ted? Or do you want to star in video games such as Fortnite, Call of Duty or Halo? If so, this book will tell you everything you need to know about acting for motion capture. This is the first book to provide an invaluable resource for the education of the next generation of performers in this exciting medium. Over the last 10 years, a revolution has occurred in digital production - video games have overtaken the film and TV industries in terms of production and revenues. Many video games derive their digital animation from human performance by means of motion and performance capture. Actors such as Andy Serkis and Troy Baker have won critical acclaim for their digital performance in games and film. The book includes contributions from practitioners working across the globe, including: actor Kezia Burrows; software developer StéphaneTable of ContentsIntroduction: What is Motion Capture? A Brief History and Current Snapshot of an Evolving Technology. Data: Mocap as an Animated Medium The Body: Developing a Responsive, Free and Versatile Instrument Creating Characters: In Motion Capture, You Can Play Anybody… But Only if You Can Play Anybody! Imaginary Environments: Exploring the Limits of our Imagination and Professionalising Play Video Game Locomotion: Learning How to Perform Under the Extreme Limitations Required by Video Games, Within the Long Pipeline of Game Development Cinematics: Performing for Conventional Mediums and Acting in the Digital Realm Direction and the Lack of It The Industry: Finding your Place in a New Medium Appendix: What Will the Landscape be in 10 Years’ Time? Index

Read more less

Book SynopsisSwiftly brush up on the foundations of Java programming Java Essentials For Dummies is a reliable and succinct reference on the core components of Javathe multifaceted general-purpose language used for desktop, mobile, and web applications. This straightforward book gets right to the pointeliminating review material and wordy explanationsso you get what you need, fast. Strengthen your understanding of the basics of coding with JavaReview what you've already learned or pick up key skillsUse Java to build a variety of applications and moreJog your memory on the essentials as you work and get clear answers to your questions Perfect for supplementing classroom learning, reviewing for a certification, or staying knowledgeable on the job, Java Essentials For Dummies is a direct reference that's great to keep on hand as an everyday desk reference.

Read more less

Book SynopsisThis book examines the cutting-edge concept of gamification in tourism. It provides a theoretical foundation for tourism gamification and discusses the concepts of gaming and gamification and their application in the tourism and hospitality industry. The chapters offer valuable insights by showcasing examples of best practice from different countries and addressing key issues of game mechanism and game design principles. They focus on areas such as game design elements, game player types and their motivation, location-based games, augmented reality and virtual reality games. The volume will be useful for students and researchers in tourism marketing, digital tourism, smart tourism and tourism futures. It also serves as a helpful tool for tourism industry practitioners looking to increase customer engagement, enhance loyalty and raise brand awareness.Trade ReviewGiven the global Covid-19 crisis, the importance of digital for travel has grown massively. Gamification adds value to digital interactions by creating more interesting and compelling digital experiences. By presenting the state of the art in both the theory and practice of gamification, this text makes a valuable contribution for anyone wanting to compete in our new and increasingly virtual travel marketplace. * Peter O'Connor, University of South Australia, Australia *Rich in theory and filled with practical cases from around the globe, this book convincingly shows how central gamification and gaming are to experience creation and persuasion in the hedonic context of tourism and hospitality. The many illustrations make it an especially engaging read! * Ulrike Gretzel, University of Southern California, USA *In hard times we must not forget the importance of having fun and enjoying life. Thus, gamification as a playful approach to interacting with systems is not only an emerging field in IT and tourism, but also a reminder not to forget the sunny side of life. I enjoyed reading this excellent collection of papers, by both well established and new researchers. * Hannes Werthner, Vienna University of Technology, Austria *Given the growing demand for co-created novel and memorable experience, and the capabilities of digitalization to support it, the book “Gamification for Tourism” is a valuable source of theoretical and empirical knowledge for tourist academicians and practitioners, who search for innovative ways to design advanced tourist experience. -- Katerina Volchek, Deggendorf Institute of Technology, Germany * Information Technology & Tourism, January 2022 *The volume delivers a wealth of case studies from all over the world, including original applications and games, participation through third-party apps (e.g., Pokémon Go), and adaptations of existing technologies (e.g., geocaching) [...] Highly recommended. -- L. deLaubell, SUNY Cortland, USA * CHOICE connect, Vol. 60 No. 1 *Table of ContentsFigures and Tables Acknowledgements Contributors Chapter 1. Feifei Xu & Dimitrios Buhalis: Gamification in Tourism: The Cutting-Edge Trend in Tourism Part 1: Gamification Theories Chapter 2. Demos Parapanos & Eleni Michopoulou: Gamification, Game Mechanics, Game Thinking and Players' Profile and Life Cycle Chapter 3. Russell B. Williams: Understanding Games and Gamified Experiences: The MAPS-AIM Model Chapter 4. Ye (Sandy) Shen & Marion Joppe: Gamification: Practices, Benefits and Challenges Part 2: Gamification Application and Case Studies Chapter 5. Zuhal Cilingir Uk & Yaşar Gultekin: Gamification Applications in Hospitality and Airline Industries: A Unified Gamification Model Chapter 6. Marianna Sigala & Elin Nilsson: Innovating the Restaurant Industry: The Gamification of Business Models and Customer Experiences Chapter 7. Feifei Xu and Shaojin Li: Destination Marketing via Gamification: A Case Study of the Austria Adventure Game Chapter 8. Luiz Pinto Machado: Gamification and Geocaching for Tourism Destinations: Marketing Madeira, Portugal Chapter 9. Pablo Garrido-Pintado: Advergaming in Tourism: Spanish Cases Chapter 10. Russell B. Williams: Pokémon GO: Serious Leisure and Game-Playing Tourists Chapter 11. Sara MacBride-Stewart, Clare Parsons and Ilona Carati: Playfulness and Game Play: Using Geocaching to Engage Young People’s Well-being in a National Park Chapter 12. Evrim Çeltek: Gamification: Augmented Reality, Virtual Reality Games and Tourism Marketing Applications Chapter 13. Feifei Xu & Dimitrios Buhalis: Conclusion Index

Read more less

Book SynopsisTable of ContentsIntroduction xix Part I Welcome to Visual Studio Code 1 Chapter 1 Getting Started 3 Installing Visual Studio Code 4 The Visual Studio Code User Interface 4 Activity Bar 5 Side Bar 6 Editor 7 Panels 11 Status Bar 12 Command Palette 12 Extensions 14 Customizations 15 Settings 16 Color Themes and Icons 18 Keybindings 18 Display Langage 18 Summary 19 Chapter 2 Hello World for Python 21 Installing a Python Interpreter 21 macOS 22 Linux 22 Windows 22 Installing the Python Extension for Visual Studio Code 22 Creating a Python File 23 Selecting an Interpreter 24 Setting a Default Interpreter 26 Settings Editor 26 settings.json File 26 Selecting a Linter 26 Editing a Python File 27 Running a Python File 29 Workflow Recap 30 Summary 31 Chapter 3 Editing Code 33 Quick Fixes 34 Code Completion, Definitions, and Declarations 35 Formatting 38 Edit Formatting Settings in the Settings Editor 39 Edit Formatting Settings in settings.json 40 Linting 41 Enable and Disable Linting 41 Run Linting 42 Linting Settings 43 Refactoring 44 Extract Variable 44 Extract Method 45 Sort Imports 46 Snippets 47 Summary 48 Part II Additional Visual Studio Code Features 51 Chapter 4 Managing Projects and Collaboration 53 Files and Folders 53 Open a Project 54 Navigate Files 56 Search across Files 57 Close a File or Folder 60 Environments 60 Virtual Environments 61 Conda Environments 61 Source Control 63 Initialize a Repository 65 Commit Changes 66 Branches 69 Remotes 70 Gutter Indicators 71 View Diffs 71 Push and Merge Commits 73 Pull Requests 74 Live Share 74 Install Live Share 75 Sign In to Live Share 76 Share a Project 76 Join a Session 78 Editing and Collaboration 80 Follow a Participant 80 Share a Terminal 81 Summary 82 Chapter 5 Debugging 83 Starting a Debug Session 84 Debug Commands 89 Continue 89 Step Over 90 Step Into 90 Step Out 91 Stop 91 Restart 92 Call Stack 92 Triggering a Breakpoint 93 Logpoints 95 Watch 96 The Debug Console 98 Launch Configurations 101 Summary 104 Chapter 6 Unit Testing 105 Enable and Discover Tests 105 Run Tests 109 Debug Tests 113 Summary 115 Chapter 7 Jupyter Notebook 117 Creating and Opening a Jupyter Notebook 118 Code Cell Modes 120 Adding Cells 121 Editing Cells 122 Running a Cell 124 Running a Single Cell 124 Running All Code Cells 124 Running Cells Above and Below a Code Cell 125 Additional Commands 126 Viewing Variables and Data 126 Viewing Plots 128 Debugging a Jupyter Notebook 129 Connecting to a Remote Server 130 Exporting a Notebook 131 Summary 132 Chapter 8 Using Git and GitHub with Visual Studio Code 135 Getting Started 135 GitHub Pull Requests and Issues Extension 136 Publish a Project to GitHub 139 Push Changes to GitHub 141 Manage Pull Requests and Issues 143 Pull Requests 144 Issues 147 Clone Repository 152 Timeline View 154 Summary 156 Chapter 9 Deploy a Django App to Azure App Service with the Azure App Service Extension 157 Getting Started 157 Creating a Django Project 159 Creating an App 161 Creating a Home Page 163 Creating Website Pages 166 Deploying to Azure 168 Summary 175 Chapter 10 Create and Debug a Flask App 177 Getting Started 177 Create a Flask App 178 Create and Render a Template 180 Debug the Flask App 184 Summary 187 Chapter 11 Create and Deploy a Container with Azure Container Registry and Azure App Service 189 Getting Started 189 Create a Container 191 Add Docker Files to the Project 191 Build an Image 193 Build and Run a Container 195 Debug a Container 197 Push an Image to the Registry 197 Create an Azure Container Registry 198 Determine the Image’s Registry Location 199 Deploy the Container Image to Azure 201 Make Changes to the App and Deploy 205 Multicontainer Apps 206 Summary 207 Chapter 12 Deploy an Azure Function Trigger by a Timer 209 Getting Started 210 Create an Azure Function 211 Invoke the Function Locally 213 Add the Code to the Function 214 Deploy the Function to Azure 215 Summary 220 Appendix Getting Started with Azure 221 Index 225

Read more less

Book SynopsisA right-to-the-point guide on all the key topics of SQL programming SQL Essentials For Dummies is your quick reference to all the core concepts of SQLa valuable common standard language used in relational databases. This useful guide is straightforwardwith no excess review, wordy explanations, or fluffso you get what you need, fast. Great for a brush-up on the basics or as an everyday desk reference, this book is one you can rely on. Strengthen your understanding of the basics of SQLReview what you've already learned or pick up key skillsUse SQL to create, manipulate, and control relational databasesJog your memory on the essentials as you work and get clear answers to your questions Perfect for supplementing classroom learning, reviewing for a certification, and staying knowledgeable on the job, SQL Essentials For Dummies is the convenient, direct, and digestible reference you've been looking for.

Read more less

Book SynopsisArtifi cial Intelligence (AI) has been an exciting fi eld of study and research in educational institutions and research labs across the globe. Technology giants and IT organizations invest heavily on AI technologies and tools with the aim of preciselyautomating a variety of simple as well as complicated business operations acrossindustry verticals. This book covers the latest trends and transitions happening in thefuturistic AI domain. The book also focuses on machine and deep learning (ML/DL)algorithms, which are, undoubtedly, the mainstream implementation technologies ofstate-of-the-art AI systems and services. Also, there are chapters on computer vision(CV) and natural language processing (NLP), the primary use cases and applicationsof AI. The book has well-written chapters for demystifying AI model engineeringmethods. Further on, our esteemed readers can fi nd details on AI model evaluation,optimization, deployment and observability. Finally, the book deals and describesgenerative AI, the latest buzzword in the IT industry. The book presents the recent ground-breaking changes taking place in the aspects of AI model building, hosting, running and maintaining in cloud environments, articulates and accentuates the most recent developments taking place in the domain of Artifi cial Intelligence, covers the noteworthy innovations and disruptions towards Generative Artifi cial Intelligence (Generative AI), explains the breakthrough innovations and disruptions towards Artifi cial General Intelligence (AGI) and delineates an engaging discussion of Natural Language Processing, Neuromorphic Systems and Biometrics.

Read more less

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

Read more less

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

Read more less

Book SynopsisMachine Learning under Resource Constraints addresses novel machine learning algorithms that are challenged by high-throughput data, by high dimensions, or by complex structures of the data in three volumes. Resource constraints are given by the relation between the demands for processing the data and the capacity of the computing machinery. The resources are runtime, memory, communication, and energy. Hence, modern computer architectures play a significant role. Novel machine learning algorithms are optimized with regard to minimal resource consumption. Moreover, learned predictions are executed on diverse architectures to save resources. It provides a comprehensive overview of the novel approaches to machine learning research that consider resource constraints, as well as the application of the described methods in various domains of science and engineering. Volume 2 covers machine learning for knowledge discovery in particle and astroparticle physics. Their instruments, e.g., particle detectors or telescopes, gather petabytes of data. Here, machine learning is necessary not only to process the vast amounts of data and to detect the relevant examples efficiently, but also as part of the knowledge discovery process itself. The physical knowledge is encoded in simulations that are used to train the machine learning models. At the same time, the interpretation of the learned models serves to expand the physical knowledge. This results in a cycle of theory enhancement supported by machine learning.

Read more less

Book Synopsis The explosive growth in volume and varieties of data generated by the seemingly endless arrays of digital systems and applications is rapidly elevating the importance of being able to utilize data; in fact, data analytic literacy is becoming as important now, at the onset of the Digital Era, as rudimentary literacy and numeracy were throughout the Industrial Era. And yet, what constitutes data analytic literacy is poorly understood. To some, data analytic literacy is the ability to use basic statistics, to others it is data science ‘light’, and to still others it is just general familiarity with common data analytic outcomes. Exploring the scope and the structure of rudimentary data analytic competencies is at the core of this book which takes the perspective that data analytics is a new and distinct domain of knowledge and practice. It offers application-minded framing of rudimentary data analytic competencies built around conceptually sound and practically meaningful processes and mechanics of systematically transforming messy and heterogeneous data into informative insights.　 Data Analytic Literacy is meant to offer an easy-to-follow overview of the critical elements of the reasoning behind basic data manipulation and analysis approaches and steps, coupled with the commonly used data analytic and data communication techniques and tools. It offers an all-inclusive guide to developing basic data analytic competencies.

Read more less

Book SynopsisArtificial intelligence advancements, machine intelligence innovations, and semantic web developments together make up semantic intelligence technologies. The edited book integrates artifi cial intelligence, machine learning, IoT, blockchain, and natural language processing with semantic web technologies. This book also aims to offer real-life solutions to the pressing issues currently being faced by semantic web technologies.

Read more less

Book SynopsisSoftware Project Management (SPM) differs from the Traditional Project Management (PM) approaches in that Software Engineering requires multiple rounds of Software Testing, and Updating in accordance with their Testing results and their customer’s feedback. Thus, SPM introduces unique life cycle processes.This book presents an introduction and a critical analysis of the main Software Project Management Frameworks, and offers the author’s original approach toSPM as developed by him over years of professional and teaching experience in the Academia and the IT/Software Industry. It also provides Executive Summaries of the Project Management and Software Project Management Perspectives offered by the Project Management Institute (PMI), the IEEE-Computer Society (IEEE-CS), and the SCRUM Project Management Bodies such as the SCRUMstudy.

Read more less

Book SynopsisWerden Sie der nächste Bill Gates Dieses Buch führt in die Denkweise von Programmierern und die Funktionsweise von Programmen ein und zeigt Ihnen, worauf Sie beim Programmieren achten müssen: Geben Sie eindeutige Anweisungen, sichern Sie sich immer gegen alle Eventualitäten ab und kommen Sie mit den gegebenen, beschränkten Mitteln aus. Am Ende des Buches angelangt, haben Sie einen wichtigen Ausschnitt unserer digitalen Welt besser kennen gelernt und Einblicke in allgemeine Programmierkonzepte und die Programmiersprachen Java und PHP erhalten. Dann können Sie fundiert entscheiden, ob und wie Sie Ihr Wissen weiter vertiefen wollen. Sie erfahren Wie Sie mit Java objektorientiert programmierenWie Sie mit PHP dynamische Webseiten erstellenWelche Hilfsmittel Sie als Programmierer brauchenWie Sie sich helfen können, wenn Sie einmal nicht weiterwissen12:54 15-11-2024

Read more less

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.

Read more less

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

Read more less

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.

Read more less

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

Read more less

Book Synopsis

Read more less

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.

Read more less