Computer programming / software engineering Books

Book Synopsis

Read more less

Book SynopsisMark Seemann, a former economist, found a second career as a programmer and has worked as a web and enterprise developer since the late 1990s. He is a Certified Rockstar Developer and has written a Jolt Award-winning book about Dependency Injection, given more than a hundred international conference talks, and authored video courses for both Pluralsight and Clean Coders. Mark has regularly published his blog ( blog.ploeh.dk) since 2006.Trade Review"We progress in software by standing on the shoulders of those who came before us. Mark's vast experience ranges from philosophical and organisational considerations right down to the precise details of writing code. In this book, you're offered an opportunity to build on that experience. Use it." --Adam Ralph, speaker, tutor, and software simplifier, Particular Software "I've been reading Mark's blogs for years and he always manages to entertain while at the same time offering deep technical insights. Code That Fits in Your Head follows in that vein, offering a wealth of information to any software developer looking to take their skills to the next level." --Adam Tornhill, founder of CodeScene, author of Software Design X-Rays and Your Code as a Crime Scene "My favorite thing about this book is how it uses a single code base as a working example. Rather than having to download separate code samples, you get a single Git repository with the entire application. Its history is handcrafted to show the evolution of the code alongside the concepts being explained in the book. As you read about a particular principle or technique, you'll find a direct reference to the commit that demonstrates it in practice. Of course, you're also free to navigate the history at your own leisure, stopping at any stage to inspect, debug, or even experiment with the code. I've never seen this level of interactivity in a book before, and it brings me special joy because it takes advantage of Git's unique design in a new constructive way." --Enrico Campidoglio, independent consultant, speaker and Pluralsight author "Mark Seemann not only has decades of experience architecting and building large software systems, but is also one of the foremost thinkers on how to scale and manage the complex relationship between such systems and the teams that build them." --Mike Hadlow, freelance software consultant and blogger "Mark writes, 'Successful software endures'--this book will help you to write that kind of software." --Bryan Hogan, software architect, podcaster, blogger "Mark has an extraordinary ability to help others think deeply about the industry and profession of software development. With every interview on .NET Rocks! I have come away knowing I would have to go back and listen to my own show to really take in everything we discussed." --Richard Campbell, co-host, .NET Rocks!Table of ContentsSeries Editor Foreword xixPreface xxiiiAbout the Author xxix Part I: Acceleration 1Chapter 1: Art or Science? 3 1.1 Building a House 4 1.2 Growing a Garden 7 1.3 Towards Engineering 8 1.4 Conclusion 14 Chapter 2: Checklists 15 2.1 An Aid to Memory 15 2.2 Checklist for a New Code Base 17 2.3 Adding Checks to Existing Code Bases 29 2.4 Conclusion 32 Chapter 3: Tackling Complexity 33 3.1 Purpose 34 3.2 Why Programming Is Difficult 38 3.3 Towards Software Engineering 44 3.4 Conclusion 46 Chapter 4: Vertical Slice 49 4.1 Start with Working Software 50 4.2 Walking Skeleton 53 4.3 Outside-in 60 4.4 Complete the Slice 77 4.5 Conclusion 85 Chapter 5: Encapsulation 87 5.1 Save the Data 87 5.2 Validation 92 5.3 Protection of Invariants 105 5.4 Conclusion 108 Chapter 6: Triangulation 111 6.1 Short-Term versus Long-Term Memory 111 6.2 Capacity 114 6.3 Conclusion 127 Chapter 7: Decomposition 129 7.1 Code Rot 129 7.2 Code That Fits in Your Brain 136 7.3 Conclusion 153 Chapter 8: API Design 155 8.1 Principles of API Design 156 8.2 API Design Example 168 8.3 Conclusion 176 Chapter 9: Teamwork 177 9.1 Git 178 9.2 Collective Code Ownership 187 9.3 Conclusion 199 Part II: Sustainability 201Chapter 10: Augmenting Code 203 10.1 Feature Flags 204 10.2 The Strangler Pattern 209 10.3 Versioning 218 10.4 Conclusion 220 Chapter 11: Editing Unit Tests 223 11.1 Refactoring Unit Tests 223 11.2 See Tests Fail 233 11.3 Conclusion 234 Chapter 12: Troubleshooting 235 12.1 Understanding 235 12.2 Defects 240 12.3 Bisection 250 12.4 Conclusion 255 Chapter 13: Separation of Concerns 257 13.1 Composition 258 13.2 Cross-Cutting Concerns 267 13.3 Conclusion 274 Chapter 14: Rhythm 275 14.1 Personal Rhythm 276 14.2 Team Rhythm 282 14.3 Conclusion 285 Chapter 15: The Usual Suspects 287 15.1 Performance 288 15.2 Security 292 15.3 Other Techniques 300 15.4 Conclusion 308 Chapter 16: Tour 309 16.1 Navigation 309 16.2 Architecture 318 16.3 Usage 323 16.4 Conclusion 326 Appendix A: List of Practices 329 A.1 The 50/72 Rule 329 A.2 The 80/24 Rule 330 A.3 Arrange Act Assert 330 A.4 Bisection 330 A.5 Checklist for A New Code Base 331 A.6 Command Query Separation 331 A.7 Count the Variables 331 A.8 Cyclomatic Complexity 331 A.9 Decorators for Cross-Cutting Concerns 332 A.10 Devil's Advocate 332 A.11 Feature Flag 332 A.12 Functional Core, Imperative Shell 333 A.13 Hierarchy of Communication 333 A.14 Justify Exceptions from the Rule 333 A.15 Parse, Don't Validate 334 A.16 Postel's Law 334 A.17 Red Green Refactor 334 A.18 Regularly Update Dependencies 335 A.19 Reproduce Defects as Tests 335 A.20 Review Code 335 A.21 Semantic Versioning 335 A.22 Separate Refactoring of Test and Production Code 335 A.23 Slice 336 A.24 Strangler 336 A.25 Threat-Model 337 A.26 Transformation Priority Premise 337 A.27 X-driven Development 337 A.28 X Out Names 338 Bibliography 339Index 349

Read more less

Book SynopsisThe popular guide to the project management body of knowledge, now fully updated Now in its eighth edition, this comprehensive guide to project management has long been considered the standard for both professionals and academics, with nearly 40,000 copies sold in the last three editions! Well-known expert Robert Wysocki has added four chapters of new content based on instructor feedback, enhancing the coverage of best-of-breed methods and tools for ensuring project management success. With enriched case studies, accompanying exercises and solutions on the companion website, and PowerPoint slides for all figures and tables, the book is ideal for instructors and students as well as active project managers. Serves as a comprehensive guide to project management for both educators and project management professionalsUpdated to cover the new PMBOK Sixth Edition Examines traditional, agile, and extreme project management techniques; the Enterprise Project Management Model; and Kanban and Scrumban methodologiesIncludes a companion website with exercises and solutions and well as PowerPoint slides for all the figures and tables usedWritten by well-known project management expert Robert Wysocki Effective Project Management, Eighth Editionremains the comprehensive resource for project management practitioners, instructors, and students. (PMBOK is a registered mark of the Project Management Institute, Inc.)Table of ContentsPreface xxxiii Introduction xxxvii Part I Understanding the Project Management Landscape 1 Chapter 1 What Is a Project? 3 Chapter 2 What Is Project Management? 23 Chapter 3 What Is Strategic Project Management? 63 Chapter 4 What Is a Collaborative Project Team? 91 Chapter 5 What Are Project Management Process Groups? 115 Part II Traditional Project Management 151 Chapter 6 How to Scope a TPM Project 153 Chapter 7 How to Plan a TPM Project 191 Chapter 8 How to Launch a TPM Project 263 Chapter 9 How to Execute a TPM Project 313 Chapter 10 How to Close a TPM Project 343 Part III Complex Project Management 353 Chapter 11 Complexity and Uncertainty in the Project Landscape 355 Chapter 12 Agile Complex Project Management Models 381 Chapter 13 Extreme Complex Project Management Models 393 Chapter 14 Hybrid Project Management Framework 405 Chapter 15 Comparing TPM and CPM Models 453 Appendix A Terms and Acronyms 537 Appendix B Case Study: Workforce and Business Development Center 543 Appendix C Case Study: Pizza Delivered Quickly ( PDQ ) 557 Appendix D Cited References 561 Appendix E What’s on the eiipbs.com Website? 565

Read more less

Book SynopsisTable 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 Book 1: Getting Started with Programming 5 Chapter 1: Getting Started Programming a Computer 7 How Computer Programming Works 8 Identifying the problem 8 Defining the steps 9 The History of Computer Programming 10 Talking to a processor in machine language 11 Using assembly language as a shortcut to machine language 12 Hiding the details of a computer with a high-level language 15 Combining the best of both worlds with the C programming language 15 Weighing the pros and cons of programming languages 16 Figuring Out Programming 18 Desire beats technical training every time 19 Picking a computer and an operating system 19 Writing programs with an editor 21 Converting source code with an assembler or compiler 23 Translating source code with an interpreter 25 Combining a compiler with an interpreter to create p-code 25 Taking the time to understand 26 Chapter 2: Different Methods for Writing Programs 29 Spaghetti Programming 31 Structured Programming 34 The three parts of structured programming 34 Top-down programming 36 Event-Driven Programming 38 Designing a user interface 41 Writing event handlers 42 Writing your program 44 Object-Oriented Programming 44 Isolating data 46 Simplifying modifications 47 Using Protocol-Oriented Programming 49 Design Patterns 50 Chapter 3: Types of Programming Languages 53 Your First Language 54 BASICally disrespected 55 Visual programming with Scratch 56 Programming robots with LEGO Mindstorms 57 Learning object-oriented programming with Alice 57 Programming a killer robot 58 Curly-Bracket Languages 60 Learning programming with C 60 Adding object-oriented programming with C++ 62 Gaining true portability with Java 63 Programming more safely with C# 64 Choosing a curly-bracket language 66 Artificial Intelligence Languages 67 Scripting Languages 71 Automating a program 72 Customizing a program 73 Transferring data among multiple programs 74 Creating stand-alone programs 74 Database Programming Languages 75 Comparing Programming Languages 76 Chapter 4: Programming Tools 77 Choosing a Compiler 78 Defining your needs for a compiler 79 Evaluating the technical features of a compiler 80 Finding an Interpreter 84 Compiling to a Virtual Machine 86 Writing a Program with an Editor 88 Stand-alone editors 88 Integrated development environments 90 Fixing a Program with a Debugger 91 Stepping line-by-line 92 Watching variables 95 Saving Time with Third-Party Components 96 Optimizing a Program with a Profiler 97 Managing Source Code 97 Creating a Help File 99 Installing a Program 99 Dissecting Programs with a Disassembler 99 Book 2: Programming Basics 101 Chapter 1: How Programs Work 103 Using Keywords as Building Blocks 105 Organizing a Program 108 Dividing a Program into Subprograms 109 Dividing a Program into Objects 113 Creating a User Interface 115 Chapter 2: Variables, Data Types, and Constants 119 Declaring Variables 120 Variable naming conventions 121 Creating variables in a command 122 Declaring the data type of a variable 124 Using Different Data Types 126 Storing Data in a Variable 130 Retrieving Data from a Variable 132 Using Constant Values 133 Defining the Scope of a Variable 135 Handling global variables with care 136 Restricting scope to a module 137 Isolating variables in a subprogram 138 Passing data among subprograms 139 Chapter 3: Manipulating Data 141 Storing Data with the Assignment Operator 142 Using Math to Manipulate Numbers 143 Organizing equations with operator precedence 144 Using built-in math functions 146 Manipulating Strings 147 Finding Strings with Regular Expressions 148 Pattern-matching with the single character (.) wildcard 149 Pattern-matching for specific characters 149 Pattern-matching with the multiple-character (*) and plus (+) wildcards 150 Pattern-matching with ranges 151 Using Comparison Operators 153 Using Boolean Operators 156 Using the Not operator 156 Using the And operator 157 Using the Or operator 158 Using the Xor operator 159 Converting Data Types 160 Chapter 4: Making Decisions by Branching 163 Picking One Choice with the IF-THEN Statement 164 Picking Two Choices with the IF-THEN-ELSE Statement 166 Picking Three or More Choices with the IF-THEN-ELSEIF Statement 168 Checking a condition for each set of commands 168 Offering three or more choices 170 Playing with Multiple Boolean Operators 171 Making Multiple Choices with the SELECT CASE Statement 174 Matching multiple values in a SELECT CASE statement 177 Checking a range of values 178 Comparing values 179 Chapter 5: Repeating Commands by Looping 181 Looping a Fixed Number of Times with the FOR-NEXT Loop 182 Using a FOR-NEXT loop variable 183 Counting by a different range 185 Counting by different increments 186 Counting backward 187 Counting over arrays and other items 188 Looping Zero or More Times with the WHILE Loop 189 Looping at Least Once with the DO Loop 192 Playing with Nested Loops 193 Prematurely Exiting from a Loop 195 Checking Your Loops 195 Chapter 6: Breaking a Large Program into Subprograms 197 Creating and Using Subprograms 199 Creating a subprogram 200 “Calling” a subprogram 201 Passing Parameters 203 Passing parameters by reference 206 Storing values in a subprogram name 210 Repeating a Subprogram with Recursion 212 Chapter 7: Breaking a Large Program into Objects 215 How Object-Oriented Programming Works 216 Encapsulation Isolates Data and Subprograms 219 Shielding data inside an object 221 Grouping methods inside of an object 221 Protecting code from other programmers 222 Sharing Code with Inheritance 223 Polymorphism: Modifying Code without Changing Its Name 226 Design Patterns 228 Object-Oriented Languages 230 Hybrid languages 231 Pure languages 231 Disadvantages of object-oriented programming 232 Real-Life Programming Examples 233 Defining an object with a class 233 Creating an object from a class 236 Running methods stored in an object 236 Inheriting an object 238 Using method overloading to rewrite an inherited subprogram 239 Chapter 8: Reading and Saving Files 243 Storing Data in Text Files 243 Creating a text file 246 Reading a text file 247 Storing Fixed-Size Data in Random-Access Files 250 Writing data 251 Reading data 252 Storing Varying-Size Data in Untyped Files 253 Writing data 254 Reading data 255 Using Database Files 257 Looking at the structure of a database 257 Connecting to a database 259 Chapter 9: Documenting Your Program 263 Adding Comments to Source Code 264 Identifying the two types of comments 265 Describing code and algorithms 268 Documentation 270 Debugging 271 Writing Software Documentation 272 Documentation types 272 Documentation tools 274 Help files 275 Chapter 10: Principles of User Interface Design 277 The Evolution of User Interfaces 278 Command-line interface 278 Menus 278 Graphical user interface 280 Elements of a User Interface 281 Displaying commands to a user interface 281 Giving data to the user interface 284 Showing information back to the user 288 Organizing a user interface 290 Designing a User Interface 291 Know the user 291 Hide/disable unusable options 292 Tolerate mistakes 293 Be consistent 294 Give the user freedom to customize the user interface 295 Make navigation easy 295 Chapter 11: Debugging and Testing 297 Common Types of Programming Errors 297 Debugging with Comments and Print Statements 300 Breakpoints, Stepping, and Watching 302 Stepping through code 304 Watching variables 305 Testing Code 306 Unit tests 307 Integration tests 308 User interface testing 309 Book 3: Data Structures 311 Chapter 1: Structures and Arrays 313 Using Structures 314 Storing data 315 Retrieving data 315 Using an Array 316 Defining the size 317 Storing data 320 Retrieving data 321 Working with Resizable Arrays 321 BASIC 322 C# 323 Swift 323 Working with Multidimensional Arrays 323 Creating a multidimensional array 324 Storing and retrieving data 325 Using Structures with Arrays 325 Drawbacks of Arrays 327 Data types 328 Searching and sorting 328 Adding and deleting 329 Identifying the location of data in an array 330 Chapter 2: Sets and Linked Lists 333 Using Sets 334 Adding and deleting data in a set 335 Checking for membership 336 Avoiding duplicate data 337 Manipulating two sets 337 Using Linked Lists 342 Creating a linked list 343 Modifying a linked list 344 Creating a double linked list 345 Drawbacks of Sets and Linked Lists 346 Problems with pointers 347 Problems with accessing data 347 Chapter 3: Collections and Dictionaries 351 Using a Collection 352 Adding data to a collection 352 Deleting data from a collection 354 Identifying data with keys 355 Searching and retrieving data 356 Using Dictionaries 358 Adding data to a dictionary 358 Searching and retrieving data from a dictionary 359 Understanding Hash Tables 360 Converting keys with a hash function 360 Hash function collisions 362 Chapter 4: Stacks, Queues, and Deques 367 Using Stacks 368 Adding data to a stack 369 Removing data from a stack 370 Counting and searching a stack 371 Using Queues 372 Adding data to a queue 373 Removing data from a queue 374 Counting and searching a queue 375 Using Deques 376 Chapter 5: Graphs and Trees 381 Understanding Graphs 383 Types of graphs 384 Uses for graphs 385 Creating Trees 386 Ordered trees 387 Binary trees 388 B-trees 389 Taking Action on Trees 390 Traversing a tree to search for data 390 Adding new data 392 Deleting data 393 Pruning and grafting sub-trees 394 Book 4: Algorithms 397 Chapter 1: Sorting Algorithms 399 Using Bubble Sort 400 Using Selection Sort 402 Using Insertion Sort 403 Using Shell Sort 405 Using Heap Sort 406 Using Merge Sort 410 Using Quick Sort 411 Comparing Sorting Algorithms 412 Chapter 2: Searching Algorithms 415 Sequential Search 416 Backward or forward searching 417 Block searching 418 Binary searching 419 Interpolation searching 420 Using Indexes 422 Creating an index 422 Clustered and unclustered indexes 423 Problems with indexes 424 Adversarial Search 424 Depth versus time 426 Alpha-beta pruning 426 Looking up a library of good moves 427 Chapter 3: String Searching 429 Sequential Text Search 430 The Boyer-Moore algorithm 431 The Rabin–Karp algorithm 431 The Shift Or algorithm 433 The finite automaton algorithm 435 Searching with Regular Expressions 436 Searching for single character patterns 436 Searching for multiple character patterns 437 Searching for alternate patterns 438 Searching Phonetically 438 Chapter 4: Data Compression Algorithms 441 Lossless Data Compression Algorithms 442 Run-length encoding 442 The Burrows–Wheeler transform algorithm 442 Dictionary encoding 445 Lossy Data Compression 449 Chapter 5: Encryption Algorithms 451 How Encryption Works 451 The Basics of Encryption 453 Stream ciphers 456 Block ciphers 457 Symmetric/Asymmetric Encryption Algorithms 459 Cracking Encryption 463 Brute-force attacks 463 Dictionary attacks 464 Plaintext and ciphertext attacks 466 Book 5: Web Programming 469 Chapter 1: HyperText Markup Language 471 The Structure of an HTML Document 472 Creating a title 472 Creating the body text 472 Aligning text 474 Emphasizing text 475 Adding color 476 Changing the font size 477 Adding comments 478 Adding Graphics 478 Defining the Background 479 Creating Hyperlinks 480 Defining an anchor point 480 Linking to an anchor point 480 Making Tables 481 Defining a table 481 Defining a table heading 482 Creating table rows and data 483 Displaying a table caption, header, and footer 484 Chapter 2: CSS 487 The Structure of a Stylesheet 488 Creating Style Classes 489 Separating Styles in Files 491 Cascading Stylesheets 493 Chapter 3: JavaScript 495 The Structure of a JavaScript Program 496 Creating Comments 497 Declaring Variables 498 Using Operators 498 Increment and decrement operators 500 Assignment operators 501 Branching Statements 501 Looping Statements 503 Creating Functions 504 Using Arrays 505 Designing User Interfaces 505 Creating dialog boxes 505 Creating windows 507 Chapter 4: PHP 509 Examining the Structure of a PHP Program 510 Creating Comments 510 Declaring Variables 511 Using Operators 512 Increment and decrement operators 513 Assignment operators 515 Branching Statements 515 Looping Statements 517 Creating Functions 518 Using Arrays 519 Creating Objects 520 Chapter 5: Ruby 523 The Structure of a Ruby Program 524 Creating Comments 524 Declaring Variables 525 Using Operators 526 Branching Statements 528 Looping Statements 530 Creating Functions 531 Using Data Structures 532 Creating Objects 534 Book 6: Programming Language Syntax 537 Chapter 1: C and C++ 539 Looking at the Structure of a C/C++ Program 540 Creating Comments 541 Declaring Variables 542 Declaring string data types 542 Declaring integer data types 543 Declaring floating-point data types 544 Declaring Boolean values 545 Using Operators 545 Increment and decrement operators 546 Assignment operators 548 Branching Statements 548 Looping Statements 550 Creating Functions 551 Data Structures 553 Creating a structure 553 Creating enumerations 554 Creating an array 554 Using Objects 555 Chapter 2: Java and C# 557 Looking at the Structure of a Java/C# Program 558 Creating Comments 559 Declaring Variables 559 Declaring string data types 560 Declaring integer data types 560 Declaring floating-point data types 561 Declaring Boolean variables 562 Using Operators 562 Increment and decrement operators 564 Assignment operators 564 Branching Statements 565 Looping Statements 568 Creating Functions 569 Data Structures 571 Creating a C# structure 571 Creating an array 572 Creating a Java linked list 573 Creating C# data structures 574 Using Objects 574 Chapter 3: Perl and Python 577 Reviewing the Structure of a Perl or Python Program 578 Creating Comments 579 Defining Variables 580 Using Operators 580 Increment and decrement operators 582 Assignment operators 583 Branching Statements 584 Looping Statements 586 Creating Functions 588 Making Data Structures 588 Perl data structures 589 Python data structures 590 Using Objects 592 Chapter 4: Kotlin 595 Looking at the Structure of a Kotlin Program 596 Creating Comments 596 Declaring Variables 597 Declaring string data types 597 Declaring integer data types 598 Declaring floating-point data types 599 Declaring Boolean values 599 Declaring Constants 600 Using Operators 600 Branching Statements 601 Looping Statements 605 Creating Functions 606 Creating Data Structures 608 Creating a list 609 Creating an array 610 Creating a set 610 Creating Objects 611 Chapter 5: Swift and SwiftUI 613 Considering the Structure of a Swift Program 614 Understanding SwiftUI 614 Creating a SwiftUI user interface 616 Understanding SwiftUI state variables 616 Creating Comments 618 Declaring Variables 618 Declaring string data types 619 Declaring integer data types 620 Declaring decimal data types 620 Declaring Boolean values 621 Declaring Constants 621 Using Operators 622 Branching Statements 623 Looping Statements 627 Creating Functions 628 Data Structures 630 Creating an array 630 Creating a dictionary 632 Creating a set 633 Creating Objects 634 Chapter 6: Flutter and Dart 637 Working with Flutter 638 Understanding the structure of a Flutter program 638 Working with widgets in Flutter 639 Aligning widgets in rows and columns 642 Understanding the Dart Language 645 Creating comments 645 Declaring variables 646 Using operators 646 Using branching statements 649 Using looping statements 650 Creating functions 652 Creating data structures 653 Using objects 656 Book 7: Applications 657 Chapter 1: Database Management 659 Understanding the Basics of Databases 659 Free-form databases 660 Flat-file databases 661 Relational databases 663 Manipulating Data 667 Writing database commands 669 The SQL language 670 Data integrity 671 Data mining 672 Database Programming 672 Chapter 2: Bioinformatics 675 The Basics of Bioinformatics 676 Representing molecules 676 Manipulating molecules in a computer 677 Database Searches 679 Bioinformatics Programming 681 Chapter 3: Computer Security 685 Stopping Malware 686 Viruses 687 Worms 687 Trojan horses 688 Spyware 689 Distributed denial-of-service attacks 690 Stopping Hackers 691 Intrusion detection systems 692 Rootkit detectors 693 Forensics 694 Secure Computing 695 Patching as an afterthought 695 Security in coding 696 Security by design 697 Chapter 4: Artificial Intelligence 699 Problem Solving 700 Game-playing 701 Natural language processing 702 Speech recognition 704 Image recognition 705 Machine Learning 706 Bayesian probability 707 Neural networks 707 Applications of Artificial Intelligence 710 Chapter 5: Mobile and Wearable Computing 711 Understanding the Different Generations of Computing 712 Giving Data to the User 714 Getting Data from the User 716 Tracking Motion and Location 717 Tracking Real-Time Health Data 718 Looking to the Future of Augmented Reality and Wearable Computers 718 Chapter 6: Game Engines 721 Understanding Game Engines 722 Picking a Game Engine 723 Programming a Game Engine 724 Exploring the Future Uses of Game Engines 726 Filmmaking 726 Architecture and engineering simulations 727 Marketing and advertising 728 Chapter 7: The Future of Computer Programming 731 Picking a Programming Language 732 Picking an Operating System 733 Doing Cross-Platform Programming 735 The portability of C 735 Cross-platform languages 736 Virtual machines 737 Software as a service 738 Data science 739 Website programming 740 Macro programming 740 Robotics programming 741 Blockchain programming 742 Defining Your Future in Programming 743 Teaching yourself other languages 743 Combining other interests besides programming 744 Getting experience and knowledge 744 Index 747

Read more less

Book SynopsisTable of ContentsIntroduction 1 Part 1: Getting Started with Python 7 Chapter 1: Talking to Your Computer 9 Chapter 2: Working with Google Colab 23 Chapter 3: Interacting with Python 41 Chapter 4: Writing Your First Application 57 Chapter 5: Performing Magic 79 Part 2: Talking the Talk 93 Chapter 6: Storing and Modifying Information 95 Chapter 7: Managing Information 107 Chapter 8: Making Decisions 127 Chapter 9: Performing Repetitive Tasks 143 Chapter 10: Dealing with Errors 157 Part 3: Performing Common Tasks 187 Chapter 11: Interacting with Packages 189 Chapter 12: Working with Strings 215 Chapter 13: Managing Lists 239 Chapter 14: Collecting All Sorts of Data 257 Chapter 15: Creating and Using Classes 279 Part 4: Performing Advanced Tasks 301 Chapter 16: Storing Data in Files 303 Chapter 17: Sending an Email 321 Part 5: The Part of Tens 337 Chapter 18: Ten Amazing Programming Resources 339 Chapter 19: Ten Ways to Make a Living with Python 349 Chapter 20: Ten Tools That Enhance Your Python Experience 357 Chapter 21: Ten (Plus) Libraries You Need to Know About 369 Index 379

Read more less

Book SynopsisJames Robertson and Suzanne Robertson are two of the most respected names in business analysis and requirements discovery. During the Robertsons' careers, their books, templates, training, and consulting have helped hundreds of companies to upgrade their requirements discovery process. The Robertsons have written numerous books, among others the three previous editions of this book, Business Analysis Agility, and with their co-authors at the Atlantic Systems Guild, the acclaimed Adrenaline Junkies and Template Zombies. James and Suzanne live in London and France.

Read more less

Book SynopsisBayesian Statistics the Fun Way gets you understanding the theory behind data analysis without making you slog through a load of dry concepts first - with no programming experience necessary. You'll learn about probability with LEGO, statistics through Star Wars, distributions with bomb fuses, estimation through precipitation, and come away with some strong mathematical reasoning skills. This is a super approachable book for people who need to do data science and probability work in their lives, but never got a good grip on the underlying theory.Trade Review"An excellent introduction to subjects critical to all data scientists."—Inside Big Data"The author uses great examples to clarify key concepts . . . I would highly recommend as a supplement for any stats student or professional looking to refresh on Bayesian statistics." —Stan T., Design Collective

Read more less

Book SynopsisUnderstanding Java from the JVM up gives you a solid foundation to grow your expertise and take on advanced techniques for performance, concurrency, containerization, and more. In The Well-Grounded Java Developer, Second Edition you will learn: The new Java module system and why you should use it Bytecode for the JVM, including operations and classloading Performance tuning the JVM Working with Java's built-in concurrency and expanded options Programming in Kotlin and Clojure on the JVM Maximizing the benefits from your build/CI tooling with Maven and Gradle Running the JVM in containers Planning for future JVM releases The Well-Grounded Java Developer, Second Edition introduces both the modern innovations and timeless fundamentals you need to know to become a Java master. Authors Ben Evans, Martijn Verburg, and Jason Clark distil their decades of experience as Java Champions, veteran developers, and key contributors to the Java ecosystem into this clear and practical guide. about the technology Java's history of innovation, its huge collection of libraries and frameworks, and the flexibility of the JVM have cemented its place as one of the world's most popular programming languages. Although it's easy to get started with Java, understanding how the language intersects with the JVM is the key to unlocking the power of this awesome language and its deep ecosystem of frameworks, tools, and alternative JVM-based languages. about the book The Well-Grounded Java Developer, Second Edition is a complete revision of the classic original with the latest innovations of the Java platform. It upgrades your existing Java skills with both JVM fundamentals like bytecode, and powerful new features such as modules and concurrency models. You'll broaden your understanding of what's possible by exploring Kotlin and other JVM languages, and learn how functional programming can offer a powerful new perspective. Each concept is illustrated with hands-on examples, including a fully modularized application/library, build setups for Maven and Gradle, and creating your own multithreaded application.Trade Review'A required read to understand new technologies.' Michael Haller 'Provides a lot of great material and helps Java developers discover the "known unknowns" to build their breadth of knowledge that can be leveraged for exploring specific topics in more depth.' Andy Keffalas 'A really good foundation for leveling up your Java development skills. This is a great resource for anybody wanting to dig deeper into the Java ecosystem and learn more about how Java works.' Jared Duncan 'This is a fantastic book to reach beyond the typical Java developer environment.' Matt D.Table of Contentstable of contents PART 1: FROM 8 TO 11 TO 17 READ IN LIVEBOOK 1INTRODUCING MODERN JAVA READ IN LIVEBOOK 2JAVA MODULES READ IN LIVEBOOK 3JAVA 17 PART 2: UNDER THE HOOD READ IN LIVEBOOK 4CLASS FILES AND BYTECODE READ IN LIVEBOOK 5JAVA CONCURRENCY FUNDAMENTALS READ IN LIVEBOOK 6JDK CONCURRENCY LIBRARIES 7 UNDERSTANDING JAVA PERFORMANCE PART 3: NON-JAVA LANGUAGES ON THE JVM READ IN LIVEBOOK 8ALTERNATIVE JVM LANGUAGES READ IN LIVEBOOK 9KOTLIN READ IN LIVEBOOK 10CLOJURE: A DIFFERENT VIEW OF PROGRAMMING PART 4: BUILD AND DEPLOYMENT READ IN LIVEBOOK 11BUILDING WITH GRADLE & MAVEN 12 RUNNING JAVA IN CONTAINERS READ IN LIVEBOOK 13TESTING FUNDAMENTALS 14 TESTING BEYOND JUNIT PART 5: NEW FRONTIERS READ IN LIVEBOOK 15ADVANCED FUNCTIONAL PROGRAMMING 16 ADVANCED CONCURRENT PROGRAMMING 17 MODERN INTERNALS 18 JAVA BEYOND 11 APPENDIXES APPENDIX A: INSTALLING JAVA 11 & BUILDS AND LICENSES APPENDIX B: REVIEW OF STREAMS AND FUNCTIONAL PROGRAMMING IN JAVA

Read more less

Book SynopsisMary Poppendieck is a seasoned leader in operations and product development with more than thirty years of IT experience. She has led teams implementing solutions ranging from enterprise supply chain management to digital media, and built one of 3M's first Just-in-Time Lean production systems. Mary is the president of Poppendieck LLC, which specializes in bringing Lean techniques to software development. Tom Poppendieck is an enterprise analyst, architect, and agile process mentor with more than twenty-five years of experience developing and implementing complex systems. He currently assists organizations in applying Lean principles and tools to software development processes. Table of ContentsForeword by Jeff Sutherland xvii Foreword by Kent Beck xx Preface xxiii Chapter 1: History 1 Interchangeable Parts 1 Interchangeable People 2 The Toyodas 3 The Toyota Production System 4 Taiichi Ohno 5 Shigeo Shingo 6 Just-in-Time 7 Lean 11 Lean Manufacturing / Lean Operations 11 Lean Supply Chain 12 Lean Product Development 13 Lean Software Development 17 Try This 17 Chapter 2: Principles 19 Principles and Practices 19 Software Development 20 The Seven Principles of Lean Software Development 23 Principle 1: Eliminate Waste 23 Principle 2: Build Quality In 25 Principle 3: Create Knowledge 29 Principle 4: Defer Commitment 32 Principle 5: Deliver Fast 34 Principle 6: Respect People 36 Principle 7: Optimize the Whole 38 Try This 42 Chapter 3: Value 43 Lean Solutions 43 Google 43 From Concept to Cash 46 Delighted Customers 49 Deep Customer Understanding 50 Focus on the Job 51 The Customer-Focused Organization 52 Leadership 52 Complete Teams 57 Custom Development 60 From Projects to Products 60 IT--Business Collaboration 62 Try This 65 Chapter 4: Waste 67 Write Less Code 67 Zara 67 Complexity 69 The Seven Wastes 73 Partially Done Work 74 Extra Features 75 Relearning 76 Handoffs 77 Task Switching 78 Delays 80 Defects 81 Mapping the Value Stream 83 Preparation 83 Examples 85 Future Value Stream Maps 92 Try This 92 Chapter 5: Speed 95 Deliver Fast 95 PatientKeeper 95 Time: The Universal Currency 98 Queuing Theory 100 Little's Law 100 Variation and Utilization 101 Reducing Cycle Time 103 Try This 114 Chapter 6: People 117 A System of Management 117 The Boeing 777 117 W. Edwards Deming 120 Why Good Programs Fail 124 Teams 126 What Makes a Team? 126 Expertise 129 Leadership 132 Responsibility-Based Planning and Control 133 The Visual Workspace 136 Self-Directing Work 137 Incentives 141 Performance Evaluations 141 Compensation 143 Try This 147 Chapter 7: Knowledge 149 Creating Knowledge 149 Rally 149 What, Exactly, Is Your Problem? 152 A Scientific Way of Thinking 154 Keeping Track of What You Know 155 Just-in-Time Commitment 159 Set-Based Design 160 Refactoring 164 Problem Solving 168 A Disciplined Approach 169 Kaizen Events 173 Try This 175 Chapter 8: Quality 177 Feedback 177 The Polaris Program 177 Release Planning 179 Architecture 182 Iterations 183 Discipline 190 The Five S's 190 Standards 193 Mistake-Proofing 196 Test-Driven Development 198 Configuration Management 201 Continuous Integration 202 Nested Synchronization 203 Try This 204 Chapter 9: Partners 207 Synergy 207 Emergency! 207 Open Source 209 Global Networks 210 Outsourcing 214 Contracts 217 The T5 Agreement 217 The PS 2000 Contract 218 Relational Contracts 219 Try This 221 Chapter 10: Journey 223 Where Do You Want to Go? 223 A Computer on Wheels 224 A Long-Term Perspective 225 Centered on People 227 What Have We Learned? 229 Six Sigma 229 Theory of Constraints 230 Hypothesis 234 Training 234 Thinking 236 Measurement 237 Roadmap 242 Try This 243 Optimize the Whole 243 Respect People 243 Deliver Fast 244 Defer Commitment 244 Create Knowledge 245 Build Quality In 245 Eliminate Waste 246 Bibliography 247 Index 257

Read more less

Book SynopsisPublisher's Note: Products purchased from Third Party sellers are not guaranteed by the publisher for quality, authenticity, or access to any online entitlements included with the product.LabVIEW programming techniques, tips, and practicesLearn to build effective LabVIEW programs using the detailed information contained in this thoroughly revised resource. This edition updates all content to align with the latest version and adds new chapters that clearly explain object-oriented programming methods, and programming in teams using the cloud. LabVIEW Graphical Programming, Fifth Edition begins with basics for beginners and quickly progresses to intermediate and advanced programming techniques. Written by a pair of LabVIEW experts, this hands-on guide shows how to work with data types, start building your own applications, handle I/O, and use the DAQmix library. You will also find out how to build applications that commTable of ContentsPrefaceAbbreviationsChapter 1. RootsChapter 2. LabVIEW FundamentalsChapter 3. Data AcquisitionChapter 4. LabVIEW Object Oriented ProgrammingChapter 5. LabVIEW FrameworksChapter 6. Unit TestingChapter 7. Developing in LabVIEW for TeamsChapter 8. Enterprise and IoT MessagingIindex

Read more less

Book SynopsisThe Legacy Apocalypse is upon us and business, community, and political leaders at all levels need this timely and thoughtful book from a superstar in the field. Aging computer systems present complex technical challenges for organisations both large and small, and Kill It with Fire provides sound strategies for spearheading modernisation efforts. Kill It with Fire examines ageing computer systems, the evolution of technology over time, and how organisations can modernise, maintain, and future-proof their current systems.Trade Review"A valuable addition to the literature on the topic, particularly for managers and senior contributors . . . Kill it With Fire is a useful and highly readable guide to solving these problems by leveraging the organization—the system around the system."—Laura Nolan, USENIX"Modernizing legacy systems is an increasingly common task for software developers. Kill It with Fire guides you through the ins and outs of these endeavors in an engaging way, diving into both the technical and social aspects that are crucial to making you successful when undertaking modernization projects." –Damian Schenkelman, Principal Engineer, Auth0"Kill It With Fire is incredibly well timed. For those alarmed by the provocative title, rest assured the only thing Bellotti advocates torching is the notion of torching itself. And while the book is written for technical leadership, her wisdom is something many nontechnical government leaders need to hear right now, lest they fall prey to the gaggle of advisers saying things like 'we just need to get them off the mainframe.' . . . Bellotti’s book could not have come at a better time, and while there are other factors in this equation, she outlines some of the most important." —Jennifer Pahlka, OneZero"When it comes to the right processes and thought patterns for successfully dealing with legacy systems, Bellotti's remarks are worth their weight in gold."—Peter Schmitz, Heise Media"A most excellent book for both engineers and managers alike."—Michael Simons, @rotnroll666"I am RIDICULOUSLY EXCITED to read this book!"—Katie Sylor-Miller, @ksylorTable of ContentsIntroductionChapter 1: Time Is a Flat CircleChapter 2: Cannibal CodeChapter 3: Evaluating Your ArchitectureChapter 4: Why Is It Hard?Chapter 5: Building and Protecting MomentumChapter 6: Coming in MidstreamChapter 7: Design and DestinyChapter 8: Breaking ChangesChapter 9: How to FinishChapter 10: Future-ProofingConclusion

Read more less

Book Synopsis

Read more less

Book Synopsis

Read more less

Book SynopsisRobert C. Martin (Uncle Bob) has been a programmer since 1970. He is founder of Uncle Bob Consulting, LLC, and cofounder with his son Micah Martin of The Clean Coders LLC. Martin has published dozens of articles in various trade journals and is a regular speaker at international conferences and trade shows. He has authored and edited many books, including: Designing Object Oriented C++ Applications Using the Booch Method, Patterns Languages of Program Design 3, More C++ Gems, Extreme Programming in Practice, Agile Software Development: Principles, Patterns, and Practices, UML for Java Programmers, Clean Code, and The Clean Coder. A leader in the industry of software development, Martin served for three years as editor-in-chief of the C++ Report, and he served as the first chairman of the Agile Alliance.Table of Contents Foreword xv Preface xix Acknowledgments xxiii About the Author xxv Part I: Introduction 1 Chapter 1: What Is Design and Architecture? 3 The Goal? 4 Case Study 5 Conclusion 12 Chapter 2: A Tale of Two Values 13 Behavior 14 Architecture 14 The Greater Value 15 Eisenhower’s Matrix 16 Fight for the Architecture 18 Part II: Starting with the Bricks: Programming Paradigms 19 Chapter 3: Paradigm Overview 21 Structured Programming 22 Object-Oriented Programming 22 Functional Programming 22 Food for Thought 23 Conclusion 24 Chapter 4: Structured Programming 25 Proof 27 A Harmful Proclamation 28 Functional Decomposition 29 No Formal Proofs 30 Science to the Rescue 30 Tests 31 Conclusion 31 Chapter 5: Object-Oriented Programming 33 Encapsulation? 34 Inheritance? 37 Polymorphism? 40 Conclusion 47 Chapter 6: Functional Programming 49 Squares of Integers 50 Immutability and Architecture 52 Segregation of Mutability 52 Event Sourcing 54 Conclusion 56 Part III: Design Principles 57 Chapter 7: SRP: The Single Responsibility Principle 61 Symptom 1: Accidental Duplication 63 Symptom 2: Merges 65 Solutions 66 Conclusion 67 Chapter 8: OCP: The Open-Closed Principle 69 A Thought Experiment 70 Directional Control 74 Information Hiding 74 Conclusion 75 Chapter 9: LSP: The Liskov Substitution Principle 77 Guiding the Use of Inheritance 78 The Square/Rectangle Problem 79 LSP and Architecture 80 Example LSP Violation 80 Conclusion 82 Chapter 10: ISP: The Interface Segregation Principle 83 ISP and Language 85 ISP and Architecture 86 Conclusion 86 Chapter 11: DIP: The Dependency Inversion Principle 87 Stable Abstractions 88 Factories 89 Concrete Components 91 Conclusion 91 Part IV: Component Principles 93 Chapter 12: Components 95 A Brief History of Components 96 Relocatability 99 Linkers 100 Conclusion 102 Chapter 13: Component Cohesion 103 The Reuse/Release Equivalence Principle 104 The Common Closure Principle 105 The Common Reuse Principle 107 The Tension Diagram for Component Cohesion 108 Conclusion 110 Chapter 14: Component Coupling 111 The Acyclic Dependencies Principle 112 Top-Down Design 118 The Stable Dependencies Principle 120 The Stable Abstractions Principle 126 Conclusion 132 Part V: Architecture 133 Chapter 15: What Is Architecture? 135 Development 137 Deployment 138 Operation 138 Maintenance 139 Keeping Options Open 140 Device Independence 142 Junk Mail 144 Physical Addressing 145 Conclusion 146 Chapter 16: Independence 147 Use Cases 148 Operation 149 Development 149 Deployment 150 Leaving Options Open 150 Decoupling Layers 151 Decoupling Use Cases 152 Decoupling Mode 153 Independent Develop-ability 153 Independent Deployability 154 Duplication 154 Decoupling Modes (Again) 155 Conclusion 158 Chapter 17: Boundaries: Drawing Lines 159 A Couple of Sad Stories 160 FitNesse 163 Which Lines Do You Draw, and When Do You Draw Them? 165 What About Input and Output? 169 Plugin Architecture 170 The Plugin Argument 172 Conclusion 173 Chapter 18: Boundary Anatomy 175 Boundary Crossing 176 The Dreaded Monolith 176 Deployment Components 178 Threads 179 Local Processes 179 Services 180 Conclusion 181 Chapter 19: Policy and Level 183 Level 184 Conclusion 187 Chapter 20: Business Rules 189 Entities 190 Use Cases 191 Request and Response Models 193 Conclusion 194 Chapter 21: Screaming Architecture 195 The Theme of an Architecture 196 The Purpose of an Architecture 197 But What About the Web? 197 Frameworks Are Tools, Not Ways of Life 198 Testable Architectures 198 Conclusion 199 Chapter 22: The Clean Architecture 201 The Dependency Rule 203 A Typical Scenario 207 Conclusion 209 Chapter 23: Presenters and Humble Objects 211 The Humble Object Pattern 212 Presenters and Views 212 Testing and Architecture 213 Database Gateways 214 Data Mappers 214 Service Listeners 215 Conclusion 215 Chapter 24: Partial Boundaries 217 Skip the Last Step 218 One-Dimensional Boundaries 219 Facades 220 Conclusion 220 Chapter 25: Layers and Boundaries 221 Hunt the Wumpus 222 Clean Architecture? 223 Crossing the Streams 226 Splitting the Streams 227 Conclusion 228 Chapter 26: The Main Component 231 The Ultimate Detail 232 Conclusion 237 Chapter 27: Services: Great and Small 239 Service Architecture? 240 Service Benefits? 240 The Kitty Problem 242 Objects to the Rescue 244 Component-Based Services 245 Cross-Cutting Concerns 246 Conclusion 247 Chapter 28: The Test Boundary 249 Tests as System Components 250 Design for Testability 251 The Testing API 252 Conclusion 253 Chapter 29: Clean Embedded Architecture 255 App-titude Test 258 The Target-Hardware Bottleneck 261 Conclusion 273 Part VI: Details 275 Chapter 30: The Database Is a Detail 277 Relational Databases 278 Why Are Database Systems So Prevalent? 279 What If There Were No Disk? 280 Details 281 But What about Performance? 281 Anecdote 281 Conclusion 283 Chapter 31: The Web Is a Detail 285 The Endless Pendulum 286 The Upshot 288 Conclusion 289 Chapter 32: Frameworks Are Details 291 Framework Authors 292 Asymmetric Marriage 292 The Risks 293 The Solution 294 I Now Pronounce You … 295 Conclusion 295 Chapter 33: Case Study: Video Sales 297 The Product 298 Use Case Analysis 298 Component Architecture 300 Dependency Management 302 Conclusion 302 Chapter 34: The Missing Chapter 303 Package by Layer 304 Package by Feature 306 Ports and Adapters 308 Package by Component 310 The Devil Is in the Implementation Details 315 Organization versus Encapsulation 316 Other Decoupling Modes 319 Conclusion: The Missing Advice 321 Part VII: Appendix 323 Appendix A Architecture Archaeology 325 Index 375

Read more less

Book SynopsisIf you''ve ever spent hours renaming files or updating hundreds of spreadsheet cells, you know how tedious tasks like these can be. But what if you could have your computer do them for you? In this fully revised edition of the best-selling classicAutomate the Boring Stuff with Python, you''ll learn how to use Python to write programs that do in minutes what would take you hours to do by hand - no prior programming experience required. You''ll learn the basics of coding in Python and explore the language''s rich library of modules for performing specific tasks, like scraping data from websites, searching for text across multiple files, and merging, watermarking, or encrypting PDFs. The third edition includes: Expanded coverage of developer techniques, like creating command line programs; Updated examples and new projects; Additional chapters about working with SQLite databases, speech-recognition technology, video and audio editing, and text-to-speech capabilities; Simplified explanations

Read more less

Book SynopsisWorking scientists and data crunchers familiar with reading and writing Python code will find the second edition of this comprehensive desk reference ideal for tackling day-to-day issues: manipulating, transforming, and cleaning data; visualizing different types of data; and using data to build statistical or machine learning models.

Read more less

Book SynopsisFor almost four decades, Software Engineering: A Practitioner''s Approach (SEPA) has been the world''s leading textbook in software engineering. The ninth edition represents a major restructuring and update of previous editions, solidifying the book''s position as the most comprehensive guide to this important subject.Table of Contents1) Software and Software EngineeringPart One - The Software Process2) Process Models3) Agility and Process4) Recommended Process Model5) Human Aspects of Software EngineeringPart Two - Modeling6) Principles That Guide Practice7) Understanding Requirements8) Requirements Modeling - A Recommended Approach9) Design Concepts10) Architectural Design - A Recommended Approach11) Component-Level Design12) User Experience Design13) Design for Mobility14) Pattern-Based DesignPart Three - Quality and Security15) Quality Concepts16) Reviews - A Recommended Approach17) Software Quality Assurance18) Software Security Engineering19) Software Testing - Component Level20) Software Testing - Integration Level21) Software Testing - Specialized Testing for Mobility22) Software Configuration Management23) Software Metrics and AnalyticsPart Four - Managing Software Projects24) Project Management Concepts25) Creating a Viable Software Plan26) Risk Management27) A Strategy for Software SupportPart Five - Advanced Topics 28) Software Process Improvement29) Emerging Trends in Software Engineering30) Concluding CommentsAppendix I - An Introduction to UML Appendix II - Data Science for Software Engineers

Read more less

Book SynopsisKotlin is a new programming language targeting the Java platform. Itoffers on expressiveness and safety without compromising simplicity,seamless interoperability with existing Java code, and great toolingsupport. Because Kotlin generates regular Java bytecode and workstogether with existing Java libraries and frameworks, it can be usedalmost everywhere where Java is used today - for server-sidedevelopment, Android apps, and much more. Kotlin in Action takes experienced Java developers from the languagebasics all the way through building applications to run on the JVM andAndroid devices. Written by core developers of Kotlin, this examplerichbook begins by teaching the basic syntax of the Kotlin language.Then readers learn how to use features that let them build reusableabstractions, higher-level functions, libraries, and even entire domainspecific languages. Finally, the book focuses on details of applyingKotlin in real-world projects, such as build system integration, Androidsupport and concurrent programming. KEY FEATURES • Hands on examples• Tutorial for a new programming language• Teaches how to build Android applications• Written by core developers of Kotlin AUDIENCEThis book is for experienced Java developers. ABOUT THE TECHNOLOGYKotlin is a new programming language targeting the Java platform. It offersexpressiveness and safety without compromising simplicity, seamlessinteroperability with existing Java code, and great tooling support.

Read more less

Book SynopsisTable of Contents Introduction 1 1 Some Fundamentals 5 Programming 5 Higher-Level Languages 5 Operating Systems 6 Compiling Programs 7 Integrated Development Environments 10 Language Interpreters 10 2 Compiling and Running Your First Program 11 Compiling Your Program 12 Running Your Program 12 Understanding Your First Program 13 Displaying the Values of Variables 15 Comments 17 Exercises 19 3 Variables, Data Types, and Arithmetic Expressions 21 Understanding Data Types and Constants 21 The Integer Type int 22 The Floating Number Type float 23 The Extended Precision Type double 23 The Single Character Type char 24 The Boolean Data Type _Bool 24 Type Specifiers: long, long long, short, unsigned, and signed 26 Working with Variables 29 Working with Arithmetic Expressions 30 Integer Arithmetic and the Unary Minus Operator 33 Combining Operations with Assignment: The Assignment Operators 39 Types _Complex and _Imaginary 40 Exercises 40 4 Program Looping 43 Triangular Numbers 43 The for Statement 44 Relational Operators 46 Aligning Output 50 Program Input 51 Nested for Loops 53 for Loop Variants 55 The while Statement 56 The do Statement 60 The break Statement 62 The continue Statement 62 Exercises 63 5 Making Decisions 65 The if Statement 65 The if-else Construct 69 Compound Relational Tests 72 Nested if Statements 74 The else if Construct 76 The switch Statement 83 Boolean Variables 86 The Conditional Operator 90 Exercises 92 6 Working with Arrays 95 Defining an Array 96 Using Array Elements as Counters 100 Generating Fibonacci Numbers 103 Using an Array to Generate Prime Numbers 104 Initializing Arrays 106 Character Arrays 108 Base Conversion Using Arrays 109 The const Qualifier 111 Multidimensional Arrays 113 Variable Length Arrays 115 Exercises 117 7 Working with Functions 119 Defining a Function 119 Arguments and Local Variables 123 Function Prototype Declaration 124 Automatic Local Variables 124 Returning Function Results 126 Functions Calling Functions Calling... 130 Declaring Return Types and Argument Types 133 Checking Function Arguments 135 Top-Down Programming 137 Functions and Arrays 137 Assignment Operators 141 Sorting Arrays 143 Multidimensional Arrays 146 Global Variables 151 Automatic and Static Variables 155 Recursive Functions 158 Exercises 161 8 Working with Structures 163 The Basics of Structures 163 A Structure for Storing the Date 164 Using Structures in Expressions 166 Functions and Structures 169 A Structure for Storing the Time 175 Initializing Structures 178 Compound Literals 178 Arrays of Structures 180 Structures Containing Structures 183 Structures Containing Arrays 185 Structure Variants 189 Exercises 190 9 Character Strings 193 Revisiting the Basics of Strings 193 Arrays of Characters 194 Variable-Length Character Strings 197 Initializing and Displaying Character Strings 199 Testing Two Character Strings for Equality 202 Inputting Character Strings 204 Single-Character Input 206 The Null String 211 Escape Characters 215 More on Constant Strings 217 Character Strings, Structures, and Arrays 218 A Better Search Method 221 Character Operations 226 Exercises 229 10 Pointers 233 Pointers and Indirection 233 Defining a Pointer Variable 234 Using Pointers in Expressions 237 Working with Pointers and Structures 239 Structures Containing Pointers 241 Linked Lists 243 The Keyword const and Pointers 251 Pointers and Functions 252 Pointers and Arrays 258 A Slight Digression About Program Optimization 262 Is It an Array or Is It a Pointer? 262 Pointers to Character Strings 264 Constant Character Strings and Pointers 266 The Increment and Decrement Operators Revisited 267 Operations on Pointers 271 Pointers to Functions 272 Pointers and Memory Addresses 273 Exercises 275 11 Operations on Bits 277 The Basics of Bits 277 Bit Operators 278 The Bitwise AND Operator 279 The Bitwise Inclusive-OR Operator 281 The Bitwise Exclusive-OR Operator 282 The Ones Complement Operator 283 The Left Shift Operator 285 The Right Shift Operator 286 A Shift Function 286 Rotating Bits 288 Bit Fields 291 Exercises 295 12 The Preprocessor 297 The #define Statement 297 Program Extendability 301 Program Portability 302 More Advanced Types of Definitions 304 The # Operator 309 The ## Operator 310 The #include Statement 311 System Include Files 313 Conditional Compilation 314 The #ifdef, #endif, #else, and #ifndef Statements 314 The #if and #elif Preprocessor Statements 316 The #undef Statement 317 Exercises 318 13 Extending Data Types with the Enumerated Data Type, Type Definitions, and Data Type Conversions 319 Enumerated Data Types 319 The typedef Statement 323 Data Type Conversions 325 Sign Extension 327 Argument Conversion 328 Exercises 329 14 Working with Larger Programs 331 Dividing Your Program into Multiple Files 331 Compiling Multiple Source Files from the Command Line 332 Communication Between Modules 334 External Variables 334 Static Versus Extern Variables and Functions 337 Using Header Files Effectively 339 Other Utilities for Working with Larger Programs 341 The make Utility 341 The cvs Utility 343 Unix Utilities: ar, grep, sed, and so on 343 15 Input and Output Operations in C 345 Character I/O: getchar() and putchar() 346 Formatted I/O: printf() and scanf() 346 The printf() Function 346 The scanf() Function 353 Input and Output Operations with Files 358 Redirecting I/O to a File 358 End of File 361 Special Functions for Working with Files 362 The fopen Function 362 The getc() and putc() Functions 364 The fclose() Function 365 The feof Function 367 The fprintf() and fscanf() Functions 367 The fgets() and fputs() Functions 367 stdin, stdout, and stderr 368 The exit() Function 369 Renaming and Removing Files 370 Exercises 371 16 Miscellaneous and Advanced Features 373 Miscellaneous Language Statements 373 The goto Statement 373 The null Statement 374 Working with Unions 375 The Comma Operator 378 Type Qualifiers 379 The register Qualifier 379 The volatile Qualifier 379 The restrict Qualifier 379 Command-line Arguments 380 Dynamic Memory Allocation 384 The calloc() and malloc() Functions 385 The sizeof Operator 385 The free Function 387 Exercises 389 17 Debugging Programs 391 Debugging with the Preprocessor 391 Debugging Programs with gdb 397 Working with Variables 400 Source File Display 401 Controlling Program Execution 402 Getting a Stack Trace 406 Calling Functions and Setting Arrays and Structures 407 Getting Help with gdb Commands 408 Odds and Ends 410 18 Object-Oriented Programming 413 What Is an Object Anyway? 413 Instances and Methods 414 Writing a C Program to Work with Fractions 416 Defining an Objective-C Class to Work with Fractions 417 Defining a C++ Class to Work with Fractions 421 Defining a C# Class to Work with Fractions 424 A C Language Summary 427 B The Standard C Library 471 C Compiling Programs with gcc 495 D Common Programming Mistakes 499 E Resources 505 TOC, 9780321776419, 7/28/2014

Read more less

Book Synopsis''One of the best software design books of all time'' - BookAuthorityCory Althoff is a self-taught programmer. After a year of self-study, he learned to program well enough to land a job as a software engineer II at eBay. But once he got there, he realised he was severely under-prepared. He was overwhelmed by the amount of things he needed to know but hadn''t learned. His journey learning to program, and his experience in first software engineering job were the inspiration for this book. This book is not just about learning to program, although you will learn to code. If you want to program professionally, it is not enough to learn to code; that is why, in addition to helping you learn to program, Althoff also cover the rest of the things you need to know to program professionally that classes and books don''t teach you. The Self-taught Programmer is a roadmap, a guide to take you from writing your first Python program to passing your first technTrade ReviewI always keep a few copies of The Self-taught Programmer around to give to anyone that comes to me for career advice -- Robin Abrams, board member, HCL Technologies, FactSet Research, Lattice Semiconductor and Sierra WirelessWant to learn to program professionally? Follow Cory's advice -- David Phillips, co-founder, Hackbright AcademyI am incredibly impressed with this book -- JoAnn Buchanan, senior research associate, Allen Institute for Brain ScienceLearning to program is increasingly important in finance. Althoff's book taught me the skills I need to stay competitive -- Derek Schaefer, senior finance manager, Charles SchwabThe Self-taught Programmer was a pleasure to read - something I never thought I would say about a technical book -- Melinda Sacks, former writer, editor, San Jose Mercury NewsOne of the best software design books of all time * BookAuthority *

Read more less

Book SynopsisBjarne Stroustrup is the designer and original implementer of C++, as well as the author of The C++ Programming Language (4th Edition), A Tour of C++ (3rd edition), Programming: Principles and Practice Using C++ (3rd Edition), and many popular and academic publications. He is a professor of Computer Science at Columbia University in New York City. Dr. Stroustrup is a member of the US National Academy of Engineering, and an IEEE, ACM, and CHM fellow. He received the 2018 Charles Stark Draper Prize, the IEEE Computer Society's 2018 Computer Pioneer Award, and the 2017 IET Faraday Medal.

Read more less

Book SynopsisRobert C. Martin (Uncle Bob) has been a programmer and software development expert since 1970. He is founder of Uncle Bob Consulting, LLC, and cofounder with his son Micah Martin of The Clean Coders LLC. Martin has published dozens of articles in various trade journals and is a regular speaker at international conferences and trade shows. He is the author of many books, including Agile Software Development: Principles, Patterns, and Practices; UML for Java Programmers; Clean Code; The Clean Coder; Clean Architecture; Clean Agile; Clean Craftsmanship; and Functional Design. Martin served for three years as editor-in-chief of the C++ Report and as the first chairman of the Agile Alliance.

Read more less

Book SynopsisUnmesh Joshi is a Principal Consultant at Thoughtworks with 22 years of industry experience. He is a software architecture enthusiast, who believes that understanding principles of distributed systems is as essential today as understanding web architecture or object-oriented programming was in the last decade. For the last two years he has been publishing patterns of distributed systems on martinfowler.com. He has also conducted various training sessions around this topic. Twitter: @unmeshjoshiTable of ContentsForeword xviiPreface xixAcknowledgments xxiiiAbout the Author xxv Part I: Narratives 1 Chapter 1: The Promise and Perils of Distributed Systems 3The Limits of a Single Server 3Separate Business Logic and Data Layer 5Partitioning Data 6A Look at Failures 7Replication: Masking Failures 9Defining the Term "Distributed Systems" 10The Patterns Approach 10 Chapter 2: Overview of the Patterns 13Keeping Data Resilient on a Single Server 14Competing Updates 15Dealing with the Leader Failing 17Multiple Failures Need a Generation Clock 21Log Entries Cannot Be Committed until They Are Accepted by a Majority Quorum 26Followers Commit Based on a High-Water Mark 29Leaders Use a Series of Queues to Remain Responsive to Many Clients 34Followers Can Handle Read Requests to Reduce Load on the Leader 40A Large Amount of Data Can Be Partitioned over Multiple Nodes 42Partitions Can Be Replicated for Resilience 45A Minimum of Two Phases Are Needed to Maintain Consistency across Partitions 46In Distributed Systems, Ordering Cannot Depend on System Timestamps 49A Consistent Core Can Manage the Membership of a Data Cluster 58Gossip Dissemination for Decentralized Cluster Management 62 Part II: Patterns of Data Replication 69 Chapter 3: Write-Ahead Log 71Problem 71Solution 71Examples 76 Chapter 4: Segmented Log 77Problem 77Solution 77Examples 79 Chapter 5: Low-Water Mark 81Problem 81Solution 81Examples 83 Chapter 6: Leader and Followers 85Problem 85Solution 85Examples 92 Chapter 7: HeartBeat 93Problem 93Solution 93Examples 98 Chapter 8: Majority Quorum 99Problem 99Solution 100Examples 102 Chapter 9: Generation Clock 103Problem 103Solution 104Examples 107 Chapter 10: High-Water Mark 109Problem 109Solution 109Examples 115 Chapter 11: Paxos 117Problem 117Solution 117Examples 132 Chapter 12: Replicated Log 133Problem 133Solution 133Examples 158 Chapter 13: Singular Update Queue 159Problem 159Solution 159Examples 166 Chapter 14: Request Waiting List 167Problem 167Solution 167Examples 173 Chapter 15: Idempotent Receiver 175Problem 175Solution 175Examples 181 Chapter 16: Follower Reads 183Problem 183Solution 183Examples 191 Chapter 17: Versioned Value 193Problem 193Solution 193Examples 201 Chapter 18: Version Vector 203Problem 203Solution 203Examples 216 Part III: Patterns of Data Partitioning 217 Chapter 19: Fixed Partitions 219Problem 219Solution 220Examples 241 Chapter 20: Key-Range Partitions 243Problem 243Solution 244Examples 255 Chapter 21: Two-Phase Commit 257Problem 257Solution 257Examples 297 Part IV: Patterns of Distributed Time 299 Chapter 22: Lamport Clock 301Problem 301Solution 301Examples 307 Chapter 23: Hybrid Clock 309Problem 309Solution 309Examples 316 Chapter 24: Clock-Bound Wait 317Problem 317Solution 318Examples 332 Part V: Patterns of Cluster Management 335 Chapter 25: Consistent Core 337Problem 337Solution 337Examples 342 Chapter 26: Lease 345Problem 345Solution 345Examples 354 Chapter 27: State Watch 355Problem 355Solution 355Examples 362 Chapter 28: Gossip Dissemination 363Problem 363Solution 363Examples 373 Chapter 29: Emergent Leader 375Problem 375Solution 375Examples 392 Part VI: Patterns of Communication between Nodes 393 Chapter 30: Single-Socket Channel 395Problem 395Solution 395Examples 397 Chapter 31: Request Batch 399Problem 399Solution 399Examples 404 Chapter 32: Request Pipeline 405Problem 405Solution 405Examples 408 References 409Index 413

Read more less

Book SynopsisIf you're getting started along the exciting path of hacking, cybersecurity, and pentesting, this book is an excellent first step. Using Kali Linux - an advanced penetration testing distribution of Linux - you'll quickly pick up the basics of using the Linux operating system, and acquire the tools and techniques you'll need to take control of a Linux environment. Later chapters focus on foundational hacking concepts like security, anonymity and scripting, along with practical tutorials and exercises that test your skills. This fully revised second edition covers the latest version of Kali, includes new options for setting up a Linux virtual machine, and discusses some differences between the bash and Z shells used on the newest versions of the distribution. It also addresses contemporary examples of real-world hacking, such as the cyberwar between Russia and Ukraine. You'll learn how to: Install Kali on a virtual machine and build your own hacking tools; Perform common tasks like manipulating text and controlling file and directory permissions; Cover your tracks by leveraging the rsyslog logging utility; Hide your internet activity using Tor, proxy servers, VPNs, and encrypted email; Write bash and Python scripts to scan open ports for potential targets. If you're ready to dive into hacking, cybersecurity, or pentesting, Linux Basics for Hackers, 2nd Edition is exactly what you need to get going.

Read more less

Book Synopsis

Read more less

Book SynopsisTable of ContentsChapter 1 Introduction 1.1 Opinions, Products 1.2 Roadmap to the Book 1.3 Terminology 1.4 Notation 1.5 Cryptographically Protected Sessions 1.6 Active and Passive Attacks 1.7 Legal Issues 1.7.1 Patents 1.7.2 Government Regulations 1.8 Some Network Basics 1.8.1 Network Layers 1.8.2 TCP and UDP Ports 1.8.3 DNS (Domain Name System) 1.8.4 HTTP and URLs 1.8.5 Web Cookies 1.9 Names for Humans 1.10 Authentication and Authorization 1.10.1 ACL (Access Control List) 1.10.2 Central Administration/Capabilities 1.10.3 Groups 1.10.4 Cross-Organizational and Nested Groups 1.10.5 Roles 1.11 Malware: Viruses, Worms, Trojan Horses 1.11.1 Where Does Malware Come From? 1.11.2 Virus Checkers 1.12 Security Gateway 1.12.1 Firewall 1.12.2 Application-Level Gateway/Proxy 1.12.3 Secure Tunnels 1.12.4 Why Firewalls Don't Work 1.13 Denial-of-Service (DoS) Attacks 1.14 NAT (Network Address Translation) 1.14.1 Summary Chapter 2 Introduction to Cryptography 2.1 Introduction 2.1.1 The Fundamental Tenet of Cryptography 2.1.2 Keys 2.1.3 Computational Difficulty 2.1.4 To Publish or Not to Publish 2.1.5 Earliest Encryption 2.1.6 One-Time Pad (OTP) 2.2 Secret Key Cryptography 2.2.1 Transmitting Over an Insecure Channel 2.2.2 Secure Storage on Insecure Media 2.2.3 Authentication 2.2.4 Integrity Check 2.3 Public Key Cryptography 2.3.1 Transmitting Over an Insecure Channel 2.3.2 Secure Storage on Insecure Media 2.3.3 Authentication 2.3.4 Digital Signatures 2.4 Hash Algorithms 2.4.1 Password Hashing 2.4.2 Message Integrity 2.4.3 Message Fingerprint 2.4.4 Efficient Digital Signatures 2.5 Breaking an Encryption Scheme 2.5.1 Ciphertext Only 2.5.2 Known Plaintext 2.5.3 Chosen Plaintext 2.5.4 Chosen Ciphertext 2.5.5 Side-Channel Attacks 2.6 Random Numbers 2.6.1 Gathering Entropy 2.6.2 Generating Random Seeds 2.6.3 Calculating a Pseudorandom Stream from the Seed 2.6.4 Periodic Reseeding 2.6.5 Types of Random Numbers 2.6.6 Noteworthy Mistakes 2.7 Numbers 2.7.1 Finite Fields 2.7.2 Exponentiation 2.7.3 Avoiding a Side-Channel Attack 2.7.4 Types of Elements used in Cryptography 2.7.5 Euclidean Algorithm 2.7.6 Chinese Remainder Theorem 2.8 Homework Chapter 3 Secret Key Cryptography 3.1 Introduction 3.2 Generic Block Cipher Issues 3.2.1 Blocksize, Keysize 3.2.2 Completely General Mapping 3.2.3 Looking Random 3.3 Constructing a Practical Block Cipher 3.3.1 Per-Round Keys 3.3.2 S-boxes and Bit Shuffles 3.3.3 Feistel Ciphers 3.4 Choosing Constants 3.5 Data Encryption Standard (DES) 3.5.1 DES Overview 3.5.2 The Mangler Function 3.5.3 Undesirable Symmetries 3.5.4 What's So Special About DES? 3.6 3DES (Multiple Encryption DES) 3.6.1 How Many Encryptions? 3.6.1.1 Encrypting Twice with the Same Key 3.6.1.2 Encrypting Twice with Two Keys 3.6.1.3 Triple Encryption with Only Two Keys 3.6.2 Why EDE Rather Than EEE? 3.7 Advanced Encryption Standard (AES) 3.7.1 Origins of AES 3.7.2 Broad Overview 3.7.3 AES Overview 3.7.4 Key Expansion 3.7.5 Inverse Rounds 3.7.6 Software Implementations of AES 3.8 RC4 3.9 Homework Chapter 4 Modes of Operation 4.1 Introduction 4.2 Encrypting a Large Message 4.2.1 ECB (Electronic Code Book) 4.2.2 CBC (Cipher Block Chaining) 4.2.2.1 Randomized ECB 4.2.2.2 CBC 4.2.2.3 CBC Threat—Modifying Ciphertext Blocks 4.2.3 CTR (Counter Mode) 4.2.3.1 Choosing IVs for CTR Mode 4.2.4 XEX (XOR Encrypt XOR) 4.2.5 XTS (XEX with Ciphertext Stealing) 4.3 Generating MACs 4.3.1 CBC-MAC 4.3.1.1 CBC Forgery Attack 4.3.2 CMAC 4.3.3 GMAC 4.3.3.1 GHASH 4.3.3.2 Transforming GHASH into GMAC 4.4 Ensuring Privacy and Integrity Together 4.4.1 CCM (Counter with CBC-MAC) 4.4.2 GCM (Galois/Counter Mode) 4.5 Performance Issues 4.6 Homework Chapter 5 Cryptographic Hashes 5.1 Introduction 5.2 The Birthday Problem 5.3 A Brief History of Hash Functions 5.4 Nifty Things to Do with a Hash 5.4.1 Digital Signatures 5.4.2 Password Database 5.4.3 Secure Shorthand of Larger Piece of Data 5.4.4 Hash Chains 5.4.5 Blockchain 5.4.6 Puzzles 5.4.7 Bit Commitment 5.4.8 Hash Trees 5.4.9 Authentication 5.4.10 Computing a MAC with a Hash 5.4.11 HMAC 5.4.12 Encryption with a Secret and a Hash Algorithm 5.5 Creating a Hash Using a Block Cipher 5.6 Construction of Hash Functions 5.6.1 Construction of MD4, MD5, SHA-1 and SHA-2 5.6.2 Construction of SHA-3 5.7 Padding 5.7.1 MD4, MD5, SHA-1, and SHA2-256 Message Padding 5.7.2 SHA-3 Padding Rule 5.8 The Internal Encryption Algorithms 5.8.1 SHA-1 Internal Encryption Algorithm 5.8.2 SHA-2 Internal Encryption Algorithm 5.9 SHA-3 f Function (Also Known as KECCAK-f) 5.10 Homework Chapter 6 First-Generation Public Key Algorithms 6.1 Introduction 6.2 Modular Arithmetic 6.2.1 Modular Addition 6.2.2 Modular Multiplication 6.2.3 Modular Exponentiation 6.2.4 Fermat's Theorem and Euler's Theorem 6.3 RSA 6.3.1 RSA Algorithm 6.3.2 Why Does RSA Work? 6.3.3 Why Is RSA Secure? 6.3.4 How Efficient Are the RSA Operations? 6.3.4.1 Exponentiating with Big Numbers 6.3.4.2 Generating RSA Keys 6.3.4.3 Why a Non-Prime Has Multiple Square Roots of One 6.3.4.4 Having a Small Constant e 6.3.4.5 Optimizing RSA Private Key Operations 6.3.5 Arcane RSA Threats 6.3.5.1 Smooth Numbers 6.3.5.2 The Cube Root Problem 6.3.6 Public-Key Cryptography Standard (PKCS) 6.3.6.1 Encryption 6.3.6.2 The Million-Message Attack 6.3.6.3 Signing 6.4 Diffie-Hellman 6.4.1 MITM (Meddler-in-the-Middle) Attack 6.4.2 Defenses Against MITM Attack 6.4.3 Safe Primes and the Small-Subgroup Attack 6.4.4 ElGamal Signatures 6.5 Digital Signature Algorithm (DSA) 6.5.1 The DSA Algorithm 6.5.2 Why Is This Secure? 6.5.3 Per-Message Secret Number 6.6 How Secure Are RSA and Diffie-Hellman? 6.7 Elliptic Curve Cryptography (ECC) 6.7.1 Elliptic Curve Diffie-Hellman (ECDH) 6.7.2 Elliptic Curve Digital Signature Algorithm (ECDSA) 6.8 Homework Chapter 7 Quantum Computing 7.1 What Is a Quantum Computer? 7.1.1 A Preview of the Conclusions 7.1.2 First, What Is a Classical Computer? 7.1.3 Qubits and Superposition 7.1.3.1 Example of a Qubit 7.1.3.2 Multi-Qubit States and Entanglement 7.1.4 States and Gates as Vectors and Matrices 7.1.5 Becoming Superposed and Entangled 7.1.6 Linearity 7.1.6.1 No Cloning Theorem 7.1.7 Operating on Entangled Qubits 7.1.8 Unitarity 7.1.9 Doing Irreversible Operations by Measurement 7.1.10 Making Irreversible Classical Operations Reversible 7.1.11 Universal Gate Sets 7.2 Grover's Algorithm 7.2.1 Geometric Description 7.2.2 How to Negate the Amplitude of |k⟩ 7.2.3 How to Reflect All the Amplitudes Across the Mean 7.2.4 Parallelizing Grover's Algorithm 7.3 Shor's Algorithm 7.3.1 Why Exponentiation mod n Is a Periodic Function 7.3.2 How Finding the Period of ax mod n Lets You Factor n 7.3.3 Overview of Shor's Algorithm 7.3.4 Converting to the Frequency Graph—Introduction 7.3.5 The Mechanics of Converting to the Frequency Graph 7.3.6 Calculating the Period 7.3.7 Quantum Fourier Transform 7.4 Quantum Key Distribution (QKD) 7.4.1 Why It's Sometimes Called Quantum Encryption 7.4.2 Is Quantum Key Distribution Important? 7.5 How Hard Are Quantum Computers to Build? 7.6 Quantum Error Correction 7.7 Homework Chapter 8 Post-Quantum Cryptography 8.1 Signature and/or Encryption Schemes 8.1.1 NIST Criteria for Security Levels 8.1.2 Authentication 8.1.3 Defense Against Dishonest Ciphertext 8.2 Hash-based Signatures 8.2.1 Simplest Scheme – Signing a Single Bit 8.2.2 Signing an Arbitrary-sized Message 8.2.3 Signing Lots of Messages 8.2.4 Deterministic Tree Generation 8.2.5 Short Hashes 8.2.6 Hash Chains 8.2.7 Standardized Schemes 8.2.7.1 Stateless Schemes 8.3 Lattice-Based Cryptography 8.3.1 A Lattice Problem 8.3.2 Optimization: Matrices with Structure 8.3.3 NTRU-Encryption Family of Lattice Encryption Schemes 8.3.3.1 Bob Computes a (Public, Private) Key Pair 8.3.3.2 How Bob Decrypts to Find m 8.3.3.3 How Does this Relate to Lattices? 8.3.4 Lattice-Based Signatures 8.3.4.1 Basic Idea 8.3.4.2 Insecure Scheme 8.3.4.3 Fixing the Scheme 8.3.5 Learning with Errors (LWE) 8.3.5.1 LWE Optimizations 8.3.5.2 LWE-based NIST Submissions 8.4 Code-based Schemes 8.4.1 Non-cryptographic Error-correcting Codes 8.4.1.1 Invention Step 8.4.1.2 Codeword Creation Step 8.4.1.3 Misfortune Step 8.4.1.4 Diagnosis Step 8.4.2 The Parity-Check Matrix 8.4.3 Cryptographic Public Key Code-based Scheme 8.4.3.1 Neiderreiter Optimization 8.4.3.2 Generating a Public Key Pair 8.4.3.3 Using Circulant Matrices 8.5 Multivariate Cryptography 8.5.1 Solving Linear Equations 8.5.2 Quadratic Polynomials 8.5.3 Polynomial Systems 8.5.4 Multivariate Signature Systems 8.5.4.1 Multivariate Public Key Signatures 8.6 Homework Chapter 9 Authentication of People 9.1 Password-based Authentication 9.1.1 Challenge-Response Based on Password 9.1.2 Verifying Passwords 9.2 Address-based Authentication 9.2.1 Network Address Impersonation 9.3 Biometrics 9.4 Cryptographic Authentication Protocols 9.5 Who Is Being Authenticated? 9.6 Passwords as Cryptographic Keys 9.7 On-Line Password Guessing 9.8 Off-Line Password Guessing 9.9 Using the Same Password in Multiple Places 9.10 Requiring Frequent Password Changes 9.11 Tricking Users into Divulging Passwords 9.12 Lamport's Hash 9.13 Password Managers 9.14 Web Cookies 9.15 Identity Providers (IDPs) 9.16 Authentication Tokens 9.16.1 Disconnected Tokens 9.16.2 Public Key Tokens 9.17 Strong Password Protocols 9.17.1 Subtle Details 9.17.2 Augmented Strong Password Protocols 9.17.3 SRP (Secure Remote Password) 9.18 Credentials Download Protocols 9.19 Homework Chapter 10 Trusted Intermediaries 10.1 Introduction 10.2 Functional Comparison 10.3 Kerberos 10.3.1 KDC Introduces Alice to Bob 10.3.2 Alice Contacts Bob 10.3.3 Ticket Granting Ticket (TGT) 10.3.4 Interrealm Authentication 10.3.5 Making Password-Guessing Attacks Difficult 10.3.6 Double TGT Protocol 10.3.7 Authorization Information 10.3.8 Delegation 10.4 PKI 10.4.1 Some Terminology 10.4.2 Names in Certificates 10.5 Website Gets a DNS Name and Certificate 10.6 PKI Trust Models 10.6.1 Monopoly Model 10.6.2 Monopoly plus Registration Authorities (RAs) 10.6.3 Delegated CAs 10.6.4 Oligarchy 10.6.5 Anarchy Model 10.6.6 Name Constraints 10.6.7 Top-Down with Name Constraints 10.6.8 Multiple CAs for Any Namespace Node 10.6.9 Bottom-Up with Name Constraints 10.6.9.1 Functionality of Up-Links 10.6.9.2 Functionality of Cross-Links 10.6.10 Name Constraints in PKIX Certificates 10.7 Building Certificate Chains 10.8 Revocation 10.8.1 CRL (Certificate Revocation list 10.8.2 Online Certificate Status Protocol (OCSP) 10.8.3 Good-Lists vs. Bad-Lists 10.9 Other Information in a PKIX Certificate 10.10 Issues with Expired Certificates 10.11 DNSSEC (DNS Security Extensions) 10.12 Homework Chapter 11 Communication Session Establishment 11.1 One-way Authentication of Alice 11.1.1 Timestamps vs. Challenges 11.1.2 One-Way Authentication of Alice using a Public Key 11.2 Mutual Authentication 11.2.1 Reflection Attack 11.2.2 Timestamps for Mutual Authentication 11.3 Integrity/Encryption for Data 11.3.1 Session Key Based on Shared Secret Credentials 11.3.2 Session Key Based on Public Key Credentials 11.3.3 Session Key Based on One-Party Public Keys 11.4 Nonce Types 11.5 Intentional MITM 11.6 Detecting MITM 11.7 What Layer? 11.8 Perfect Forward Secrecy 11.9 Preventing Forged Source Addresses 11.9.1 Allowing Bob to Be Stateless in TCP 11.9.2 Allowing Bob to Be Stateless in IPsec 11.10 Endpoint Identifier Hiding 11.11 Live Partner Reassurance 11.12 Arranging for Parallel Computation 11.13 Session Resumption/Multiple Sessions 11.14 Plausible Deniability 11.15 Negotiating Crypto Parameters 11.15.1 Suites vs. à la Carte 11.15.2 Downgrade Attack 11.16 Homework Chapter 12 IPsec 12.1 IPsec Security Associations 12.1.1 Security Association Database 12.1.2 Security Policy Database 12.1.3 IKE-SAs and Child-SAs 12.2 IKE (Internet Key Exchange Protocol) 12.3 Creating a Child-SA 12.4 AH and ESP 12.4.1 ESP Integrity Protection 12.4.2 Why Protect the IP Header? 12.4.3 Tunnel, Transport Mode 12.4.4 IPv4 Header 12.4.5 IPv6 Header 12.5 AH (Authentication Header) 12.6 ESP (Encapsulating Security Payload) 12.7 Comparison of Encodings 12.8 Homework Chapter 13 SSL/TLS and SSH 13.1 Using TCP 13.2 StartTLS 13.3 Functions in the TLS Handshake 13.4 TLS 1.2 (and Earlier) Basic Protocol 13.5 TLS 1.3 13.6 Session Resumption 13.7 PKI as Deployed by TLS 13.8 SSH (Secure Shell) 13.8.1 SSH Authentication 13.8.2 SSH Port Forwarding 13.9 Homework Chapter 14 Electronic Mail Security 14.1 Distribution Lists 14.2 Store and Forward 14.3 Disguising Binary as Text 14.4 HTML-Formatted Email 14.5 Attachments 14.6 Non-cryptographic Security Features 14.6.1 Spam Defenses 14.7 Malicious Links in Email 14.8 Data Loss Prevention (DLP) 14.9 Knowing Bob's Email Address 14.10 Self-Destruct, Do-Not-Forward, 14.11 Preventing Spoofing of From Field 14.12 In-Flight Encryption 14.13 End-to-End Signed and Encrypted Email 14.14 Encryption by a Server 14.15 Message Integrity 14.16 Non-Repudiation 14.17 Plausible Deniability 14.18 Message Flow Confidentiality 14.19 Anonymity 14.20 Homework Chapter 15 Electronic Money 15.1 ECASH 15.2 Offline eCash 15.2.1 Practical Attacks 15.3 Bitcoin 15.3.1 Transactions 15.3.2 Bitcoin Addresses 15.3.3 Blockchain 15.3.4 The Ledger 15.3.5 Mining 15.3.6 Blockchain Forks 15.3.7 Why Is Bitcoin So Energy-Intensive? 15.3.8 Integrity Checks: Proof of Work vs. Digital Signatures 15.3.9 Concerns 15.4 Wallets for Electronic Currency 15.5 Homework Chapter 16 Cryptographic Tricks 16.1 Secret Sharing 16.2 Blind Signature 16.3 Blind Decryption 16.4 Zero-Knowledge Proofs 16.4.1 Graph Isomorphism ZKP 16.4.2 Proving Knowledge of a Square Root 16.4.3 Noninteractive ZKP 16.5 Group Signatures 16.5.1 Trivial Group Signature Schemes 16.5.1.1 Single Shared Key 16.5.1.2 Group Membership Certificate 16.5.1.3 Multiple Group Membership Certificates 16.5.1.4 Blindly Signed Multiple Group Membership Certificates 16.5.2 Ring Signatures 16.5.3 DAA (Direct Anonymous Attestation) 16.5.4 EPID (Enhanced Privacy ID) 16.6 Circuit Model 16.7 Secure Multiparty Computation (MPC) 16.8 Fully Homomorphic Encryption (FHE) 16.8.1 Bootstrapping 16.8.2 Easy-to-Understand Scheme 16.9 Homework Chapter 17 Folklore 17.1 Misconceptions 17.2 Perfect Forward Secrecy 17.3 Change Encryption Keys Periodically 17.4 Don't Encrypt without Integrity Protection 17.5 Multiplexing Flows over One Secure Session 17.5.1 The Splicing Attack 17.5.2 Service Classes 17.5.3 Different Cryptographic Algorithms 17.6 Using Different Secret Keys 17.6.1 For Initiator and Responder in Handshake 17.6.2 For Encryption and Integrity 17.6.3 In Each Direction of a Secure Session 17.7 Using Different Public Keys 17.7.1 Use Different Keys for Different Purposes 17.7.2 Different Keys for Signing and Encryption 17.8 Establishing Session Keys 17.8.1 Have Both Sides Contribute to the Master Key 17.8.2 Don't Let One Side Determine the Key 17.9 Hash in a Constant When Hashing a Password 17.10 HMAC Rather than Simple Keyed Hash 17.11 Key Derivation 17.12 Use of Nonces in Protocols 17.13 Creating an Unpredictable Nonce 17.14 Compression 17.15 Minimal vs. Redundant Designs 17.16 Overestimate the Size of Key 17.17 Hardware Random Number Generators 17.18 Put Checksums at the End of Data 17.19 Forward Compatibility 17.19.1 Options 17.19.2 Version Numbers 17.19.2.1 Version Number Field Must Not Move 17.19.2.2 Negotiating Highest Version Supported 17.19.2.3 Minor Version Number Field Glossary Math M.1 Introduction M.2 Some definitions and notation M.3 Arithmetic M.4 Abstract Algebra M.5 Modular Arithmetic M.5.1 How Do Computers Do Arithmetic? M.5.2 Computing Inverses in Modular Arithmetic M.5.2.1 The Euclidean Algorithm M.5.2.2 The Chinese Remainder Theorem M.5.3 How Fast Can We Do Arithmetic? M.6 Groups M.7 Fields M.7.1 Polynomials M.7.2 Finite Fields M.7.2.1 What Sizes Can Finite Fields Be? M.7.2.2 Representing a Field M.8 Mathematics of Rijndael M.8.1 A Rijndael Round M.9 Elliptic Curve Cryptography M.10 Rings M.11 Linear Transformations M.12 Matrix Arithmetic M.12.1 Permutations M.12.2 Matrix Inverses M.12.2.1 Gaussian Elimination M.13 Determinants M.13.1 Properties of Determinants M.13.1.1 Adjugate of a Matrix M.13.2 Proof: Determinant of Product is Product of Determinants M.14 Homework Bibliography 9780136643609 TOC 8/2/2022

Read more less

Book SynopsisChris Lukassen has been active in product management for 20+ years, and co-created Scrum.org's Professional Scrum Product Owner - Advanced course. He currently trains product managers in Scrum, leadership, user experience, and metrics. Robbin Schuurman is a product leader, consultant, Professional Scrum Trainer, and leader of Xebia's Product Management Academy. He supports organizations in digital, agile, and product transformations; and helps product owners grow customer impact, improve agility, and shorten time-to-learn. Lukassen and Schuurman co-founded The Value Maximizers.Table of ContentsForeword by Dave West xvii Introduction xxi Part I. The Stances of the Product Owner 1 Chapter 1. Agile Product Management 3 Is It Product Owner or Product Manager? 3 What Is Product Management? 4 Working in a Product-Led, Sales-Led, or Marketing-Led Organization 6 What Is a Product Owner? 7 Different Types of Product Owners 9 Chapter 2. Introducing the Product Owner Stances 3 The Misunderstood Stances of a Product Owner 17 The Preferred Stances of a Product Owner 27 Part I Summary 35 Part II. The Customer Representative 37 Chapter 3. How to Identify and Define Product 39 Introducing the Customer Representative 39 What Is a Product? 43 Chapter 4. Building Customer Empathy 49 Talking to Customers 49 Observing Customers 49 Effectively Dealing with Biases When Collaborating with Customers 51 Chapter 5. Capture Your Customer Insights Via Personas 55 User Personas 55 Creating Personas 56 Chapter 6. Identifying and Expressing Customer Value 61 The Functional Elements of Value 63 Emotional Elements of Value 64 Life-Changing Elements of Value 64 Social-Impact Element of Value 65 Chapter 7. Connecting Product Features to Outcomes and Impacts 67 Connecting Goals, Impacts, Outcomes, and Features 68 Part II Summary 73 Part III. The Visionary 77 Chapter 8. Creating and Communicating Product Vision 79 Introducing: The Visionary 79 Connecting the Product Vision to the Company Mission, Vision, and Values 83 A Product Vision Aligned with the Company Mission and Vision 87 Elements of an Inspiring Product Vision 90 Chapter 9. Communicating the Product Vision Effectively 93 The 3x3 Storytelling Framework 95 The Power of Reasoning 99 Make It SEXI 100 Chapter 10. Crafting Product Goals That Align Stakeholders and Teams 103 What Is a Product Goal? 104 Characteristics of Great Product Goals 106 How to Create Product Goals 108 Inspect and Adapt Product Goals 109 Having Multiple Product Goals: Is That an Option? 110 Chapter 11. Creating the Right Product Roadmap for Your Audience 113 Introduction to Product Roadmaps 113 Types of Product Roadmaps 117 Roadmap 1: The Goal-Oriented Roadmap 118 Roadmap 2: The Now-Next-Later Roadmap 120 Roadmap 3: The User Story Map 122 Roadmap 4: The Visual Roadmap 124 Roadmap 5: The Gantt Chart Roadmap 126 Eleven Tips for Roadmap Creation 128 Chapter 12. Identification of Company Value and Impact 131 Understanding Company Value and Impact 131 Expressing Company Impact 137 Key Value Area 1: Current Value 139 Key Value Area 2: Unrealized Value 141 Key Value Area 3: Time to Market 145 Key Value Area 4: Ability to Innovate 147 Chapter 13. Maximizing Value through Effective Pricing Strategies and Tactics 151 Introduction to Product Pricing 151 The Product Pricing Process 153 Part III Summary 165 Part IV. The Experimenter 169 Chapter 14. Driving Inside-Out Product Innovation 171 Introducing: The Experimenter 171 Inside-Out Innovation Sources 175 Chapter 15. Driving Outside-In Product Innovation 183 Outside-In Innovation Sources 183 Market Segmentation 184 Chapter 16. Thinking Differently: Driving Business Model Innovation 189 Market Analysis and Trends 189 Getting Inspiration from Other Companies 191 The Impact on Your Business 196 The Return of the Business Model Canvas 197 Chapter 17. Selecting Product Experiments to Run 199 The Truth Curve: Select the Right Experiments and Tests 199 Experimentation Techniques Explained 203 Chapter 18. How to Design and Evaluate Experiments and Tests 215 Defining Hypothesis 216 Capture Learnings 218 Chapter 19. Approaches for Scaling Successful Products and Teams 221 Scaling Approaches for People and Teams 221 Typical Antipattern for Scaling People and Teams 224 A Better Approach for Scaling People and Teams 227 Approaches to Scaling the Product or Service 229 Focus on the Product First, Then on People and Teams 230 Eight Effective Strategies for Scaling a Product 232 How Product Owners Contribute to Product Scaling 235 Part IV Summary 237 Part V. The Decision Maker 241 Chapter 20. Improving Accountability, Maturity, and Authority 243 Introducing: The Decision Maker 243 Chapter 21. Evaluating Your Product Decisions 255 Product Management: A Game of Poker or Chess? 255 Evaluating Decisions in an Honest and Transparent Way 258 Chapter 22. Make Better Decisions: Thinking in Bets 259 The Buddy System or Decision Pod 260 Accepting Uncertainty in Decision Making 261 Chapter 23. Navigating Product, Process, and Team Dilemmas and Decisions 263 Making Choices 263 Navigating Dilemmas 265 Chapter 24. Improving the Speed and Quality of Decisions 269 The Cost of Delaying Decisions 269 Fast Decisions Are More Successful than Slow Decisions 270 Special Snowflake Syndrome 273 Why You Should Probably Make Decisions Fast(er) 274 How to Speed Up Your Decision Making 274 Empowered Product Owners 275 Part V Summary 277 Part VI. The Collaborator 281 Chapter 25. How Agile Governance Affects Product Owners 283 Introduction to the Collaborator 283 Introducing Agile Governance 287 Organizational Governance Entails Many Elements 291 Effectively Dealing with Governance 295 Chapter 26. Product Budgeting Done in an Agile Way 297 Three Horizons 298 Budgeting Is Like Product Backlog Management 300 A Strategy and Market Perspective on Budgeting 304 Chapter 27. Creating Contracts That Enable Great Product Ownership and Teamwork 309 What Is a Contract? 310 Who Takes the Risk? 313 Two-Stage Contracts 314 Joe's Bucket 316 Money for Nothing 317 Change for Free 318 Elements of an Agile Contract 319 Part VI Summary 323 Part VII. The Influencer 327 Chapter 28. Stakeholder Management in Complex Environments 329 Introducing: The Influencer 329 Definition of Stakeholder 333 Stakeholder Classification/Categorization 335 Information and Insights to Gather on Stakeholders 338 The Influence of the Stakeholder 340 Chapter 29. Tools for Stakeholder Classification and Grouping 343 The Stakeholder Map 344 The Stakeholder Radar 351 Alternative Stakeholder Identification and Grouping Techniques 357 Chapter 30. Applying Stakeholder Management Strategies and Tactics in Practice 359 Creating a Communication Strategy 359 Tips for Improving Your Stakeholder Management in Practice 362 Chapter 31. How to Influence Stakeholders on All Levels 369 Being a Lyrebird 369 The Process of Communication 371 Four Layers of Communication 374 Building Relationships with Stakeholders 375 Adapting Your Tune to Your Audience 382 Chapter 32. Mastering the Art of No to Optimize Value Creation for the Product 387 What Makes Saying No So Hard? 388 Five Steps toward Saying No Effectively 389 The Jedi Mind Trick 392 Chapter 33. Negotiating With Stakeholders, Customers, and Users 393 Be a Mirror 394 Label Emotions 395 Getting to Yes! 396 How to Tell If a Yes Is Real 398 Bend Their Reality 398 Create the Illusion of Control 400 Guarantee Execution 400 Bargain Hard 401 Find the Black Swan 402 Part VII Summary 405 Closing Summary 409 Index 413

Read more less

Book SynopsisGregor Hohpe leads the enterprise integration practice at ThoughtWorks, Inc., a specialized provider of application development and integration services. Drawing from his extensive experience designing and implementing integration solutions for enterprise clients, Gregor has published a number of papers and articles presenting a no-hype view on enterprise integration, Web services, and Service-Oriented Architectures. He is a frequent speaker at technical conferences around the world. Bobby Woolf is coauthor of The Design Patterns Smalltalk Companion (Addison-Wesley, 1998), and author of articles in IBM DeveloperWorks, Java Developer's Journal, and elsewhere. He has been a tutorial presenter at OOPSLA, JavaEdge, and Smalltalk Solutions, among other conferences. 0321200683AB09122003Table of Contents 1. Solving Integration Problems Using Patterns 2. Integration Styles 3. Messaging Systems 4. Messaging Channels 5. Message Construction 6. Interlude: Simple Messaging 7. Message Routing 8. Message Transformation 9. Interlude: Composed Messaging 10. Messaging Endpoints 11. System Management 12. Interlude: System Management Example 13. Integration Patterns in Practice 14. Concluding Remarks

Read more less

Book SynopsisPublisher's Note: Products purchased from Third Party sellers are not guaranteed by the publisher for quality, authenticity, or access to any online entitlements included with the product.Up-to-date hacks that will breathe life into your Arduino and Raspberry Pi creations!This intuitive DIY guide shows how to wire, disassemble, tweak, and re-purpose household devices and integrate them with your Raspberry Pi and Arduino inventions. Packed with full-color illustrations, photos, and diagrams, Hacking Electronics: Learning Electronics with Arduino and Raspberry Pi, Second Edition, features fun, easy-to-follow projects. Youâll discover how to build an Internet-controlled hacked electric toy, ultrasonic rangefinder, remote-controlled robotic rover, audio amp, slot car brakes and headlightsâeven a smart card reader!â Get up and running on both Arduino and Raspberry P

Read more less

Book SynopsisPython is fast becoming the programming language of choice for hackers, reverse engineers, and software testers because it's easy to write quickly, and it has the low-level support and libraries that make hackers happy. But until now, there has been no real manual on how to use Python for a variety of hacking tasks. You had to dig through forum posts and man pages, endlessly tweaking your own code to get everything working. Not anymore. Gray Hat Python explains the concepts behind hacking tools and techniques like debuggers, trojans, fuzzers, and emulators. But author Justin Seitz goes beyond theory, showing you how to harness existing Python-based security tools and how to build your own when the pre-built ones won't cut it. You'll learn how to: Automate tedious reversing and security tasks Design and program your own debugger Learn how to fuzz Windows drivers and create powerful fuzzers from scratch Have fun with code and library injection, soft and hard hooking techniques, andTable of ContentsFOREWORDACKNOWLEDGMENTSINTRODUCTIONChapter 1: SETTING UP YOUR DEVELOPMENT ENVIRONMENTChapter 2: DEBUGGERS AND DEBUGGER DESIGNChapter 3: BUILDING A WINDOWS DEBUGGERChapter 4: PYDBG--A PURE PYTHON WINDOWS DEBUGGERChapter 5: IMMUNITY DEBUGGER--THE BEST OF BOTH WORLDSChapter 6: HOOKINGChapter 7: DLL AND CODE INJECTIONChapter 8: FUZZINGChapter 9: SULLEYChapter 10: FUZZING WINDOWS DRIVERSChapter 11: IDAPYTHON--SCRIPTING IDA PROChapter 12: PYEMU--THE SCRIPTABLE EMULATOR

Read more less

Book SynopsisMalware analysis is big business, and attacks can cost a company dearly. When malware breaches your defenses, you need to act quickly to cure current infections and prevent future ones from occurring. For those who want to stay ahead of the latest malware, Practical Malware Analysis will teach you the tools and techniques used by professional analysts. With this book as your guide, you'll be able to safely analyze, debug, and disassemble any malicious software that comes your way. You'll learn how to: Set up a safe virtual environment to analyze malware Quickly extract network signatures and host-based indicators Use key analysis tools like IDA Pro, OllyDbg, and WinDbg Overcome malware tricks like obfuscation, anti-disassembly, anti-debugging, and anti-virtual machine techniques Use your newfound knowledge of Windows internals for malware analysis Develop a methodology for unpacking malware and get practical experience with five of the most popular packers Analyze special casesTrade Review"A hands-on introduction to malware analysis. I'd recommend it to anyone who wants to dissect Windows malware."—Ilfak Guilfanov, Creator of IDA Pro"The book every malware analyst should keep handy."—Richard Bejtlich, CSO of Mandiant & Founder of TaoSecurity"This book does exactly what it promises on the cover; it's crammed with detail and has an intensely practical approach, but it's well organised enough that you can keep it around as handy reference."—Mary Branscombe, ZDNet"If you're starting out in malware analysis, or if you are are coming to analysis from another discipline, I'd recommend having a nose."—Paul Baccas, Naked Security from Sophos"An excellent crash course in malware analysis."—Dino Dai Zovi, Independent Security Consultant"The most comprehensive guide to analysis of malware, offering detailed coverage of all the essential skills required to understand the specific challenges presented by modern malware."—Chris Eagle, Senior Lecturer of Computer Science at the Naval Postgraduate School"A great introduction to malware analysis. All chapters contain detailed technical explanations and hands-on lab exercises to get you immediate exposure to real malware."—Sebastian Porst, Google Software Engineer"Brings reverse engineering to readers of all skill levels. Technically rich and accessible, the labs will lead you to a deeper understanding of the art and science of reverse engineering. I strongly recommend this book for beginners and experts alike. I strongly believe this will become the defacto text for learning malware analysis in the future."—Danny Quist, PhD, Founder of Offensive Computing“An awesome book. . . written by knowledgeable authors who possess the rare gift of being able to communicate their knowledge through the written word.”—Richard Austin, IEEE Cipher"If you only read one malware book or are looking to break into the world of malware analysis, this is the book to get."—Patrick Engebretson, IA Professor at Dakota State University and Author of The Basics of Hacking and Pen Testing"An excellent addition to the course materials for an advanced graduate level course on Software Security or Intrusion Detection Systems. The labs are especially useful to students in teaching the methods to reverse engineer, analyze and understand malicious software."—Sal Stolfo, Professor, Columbia University"The explanation of the tools is clear, the presentation of the process is lucid, and the actual detective work fascinating. All presented clearly and hitting just the right level so that developers with no previous experience in this particular area can participate fully. Highly recommended."—Dr. Dobb's"This book is like having your very own personal malware analysis teacher without the expensive training costs."—Dustin Schultz, TheXploit"I highly recommend this book to anyone looking to get their feet wet in malware analysis or just looking for a good desktop reference on the subject."—Pete Arzamendi, 403 Labs“I do not see how anyone who has hands-on responsibility for security of Windows systems can rationalize not being familiar with these tools.”—Stephen Northcutt, SANS Institute"Practical Malware Analysis is another book that should be within reaching distance in anyone’s DFIR shop. I went ahead and purchased PMA hoping the book would improve my knowledge and skills when faced with malware. What I ended up with was knowledge, a process and tools I can use to analyze any program I encounter. PMA gets a five star review (5 out of 5)."—Journey Into Incident Response“Highly recommend it to those looking to enter the malware analysis field.”—Linux Ninja"If you are a beginner to this hacking field, then this book will be an excellent choice for you."—Hackerzzz"I cannot recommend it enough."—Tony Robinson, Security BoulevardTable of ContentsPraise for Practical Malware Analysis; Warning; About the Authors; About the Technical Reviewer; About the Contributing Authors; Foreword; Acknowledgments; Individual Thanks; Introduction; What Is Malware Analysis?; Prerequisites; Practical, Hands-On Learning; What's in the Book?; Chapter 0: Malware Analysis Primer; 1.1 The Goals of Malware Analysis; 1.2 Malware Analysis Techniques; 1.3 Types of Malware; 1.4 General Rules for Malware Analysis; Basic Analysis; Chapter 1: Basic Static Techniques; 2.1 Antivirus Scanning: A Useful First Step; 2.2 Hashing: A Fingerprint for Malware; 2.3 Finding Strings; 2.4 Packed and Obfuscated Malware; 2.5 Portable Executable File Format; 2.6 Linked Libraries and Functions; 2.7 Static Analysis in Practice; 2.8 The PE File Headers and Sections; 2.9 Conclusion; 2.10 Labs; Chapter 2: Malware Analysis in Virtual Machines; 3.1 The Structure of a Virtual Machine; 3.2 Creating Your Malware Analysis Machine; 3.3 Using Your Malware Analysis Machine; 3.4 The Risks of Using VMware for Malware Analysis; 3.5 Record/Replay: Running Your Computer in Reverse; 3.6 Conclusion; Chapter 3: Basic Dynamic Analysis; 4.1 Sandboxes: The Quick-and-Dirty Approach; 4.2 Running Malware; 4.3 Monitoring with Process Monitor; 4.4 Viewing Processes with Process Explorer; 4.5 Comparing Registry Snapshots with Regshot; 4.6 Faking a Network; 4.7 Packet Sniffing with Wireshark; 4.8 Using INetSim; 4.9 Basic Dynamic Tools in Practice; 4.10 Conclusion; 4.11 Labs; Advanced Static Analysis; Chapter 4: A Crash Course in x86 Disassembly; 5.1 Levels of Abstraction; 5.2 Reverse-Engineering; 5.3 The x86 Architecture; 5.4 Conclusion; Chapter 5: IDA Pro; 6.1 Loading an Executable; 6.2 The IDA Pro Interface; 6.3 Using Cross-References; 6.4 Analyzing Functions; 6.5 Using Graphing Options; 6.6 Enhancing Disassembly; 6.7 Extending IDA with Plug-ins; 6.8 Conclusion; 6.9 Labs; Chapter 6: Recognizing C Code Constructs in Assembly; 7.1 Global vs. Local Variables; 7.2 Disassembling Arithmetic Operations; 7.3 Recognizing if Statements; 7.4 Recognizing Loops; 7.5 Understanding Function Call Conventions; 7.6 Analyzing switch Statements; 7.7 Disassembling Arrays; 7.8 Identifying Structs; 7.9 Analyzing Linked List Traversal; 7.10 Conclusion; 7.11 Labs; Chapter 7: Analyzing Malicious Windows Programs; 8.1 The Windows API; 8.2 The Windows Registry; 8.3 Networking APIs; 8.4 Following Running Malware; 8.5 Kernel vs. User Mode; 8.6 The Native API; 8.7 Conclusion; 8.8 Labs; Advanced Dynamic Analysis; Chapter 8: Debugging; 9.1 Source-Level vs. Assembly-Level Debuggers; 9.2 Kernel vs. User-Mode Debugging; 9.3 Using a Debugger; 9.4 Exceptions; 9.5 Modifying Execution with a Debugger; 9.6 Modifying Program Execution in Practice; 9.7 Conclusion; Chapter 9: OllyDbg; 10.1 Loading Malware; 10.2 The OllyDbg Interface; 10.3 Memory Map; 10.4 Viewing Threads and Stacks; 10.5 Executing Code; 10.6 Breakpoints; 10.7 Loading DLLs; 10.8 Tracing; 10.9 Exception Handling; 10.10 Patching; 10.11 Analyzing Shellcode; 10.12 Assistance Features; 10.13 Plug-ins; 10.14 Scriptable Debugging; 10.15 Conclusion; 10.16 Labs; Chapter 10: Kernel Debugging with WinDbg; 11.1 Drivers and Kernel Code; 11.2 Setting Up Kernel Debugging; 11.3 Using WinDbg; 11.4 Microsoft Symbols; 11.5 Kernel Debugging in Practice; 11.6 Rootkits; 11.7 Loading Drivers; 11.8 Kernel Issues for Windows Vista, Windows 7, and x64 Versions; 11.9 Conclusion; 11.10 Labs; Malware Functionality; Chapter 11: Malware Behavior; 12.1 Downloaders and Launchers; 12.2 Backdoors; 12.3 Credential Stealers; 12.4 Persistence Mechanisms; 12.5 Privilege Escalation; 12.6 Covering Its Tracks--User-Mode Rootkits; 12.7 Conclusion; 12.8 Labs; Chapter 12: Covert Malware Launching; 13.1 Launchers; 13.2 Process Injection; 13.3 Process Replacement; 13.4 Hook Injection; 13.5 Detours; 13.6 APC Injection; 13.7 Conclusion; 13.8 Labs; Chapter 13: Data Encoding; 14.1 The Goal of Analyzing Encoding Algorithms; 14.2 Simple Ciphers; 14.3 Common Cryptographic Algorithms; 14.4 Custom Encoding; 14.5 Decoding; 14.6 Conclusion; 14.7 Labs; Chapter 14: Malware-Focused Network Signatures; 15.1 Network Countermeasures; 15.2 Safely Investigate an Attacker Online; 15.3 Content-Based Network Countermeasures; 15.4 Combining Dynamic and Static Analysis Techniques; 15.5 Understanding the Attacker's Perspective; 15.6 Conclusion; 15.7 Labs; Anti-Reverse-Engineering; Chapter 15: Anti-Disassembly; 16.1 Understanding Anti-Disasseeeeeembly; 16.2 Defeating Disassembly Algorithms; 16.3 Anti-Disassembly Techniques; 16.4 Obscuring Flow Control; 16.5 Thwarting Stack-Frame Analysis; 16.6 Conclusion; 16.7 Labs; Chapter 16: Anti-Debugging; 17.1 Windows Debugger Detection; 17.2 Identifying Debugger Behavior; 17.3 Interfering with Debugger Functionality; 17.4 Debugger Vulnerabilities; 17.5 Conclusion; 17.6 Labs; Chapter 17: Anti-Virtual Machine Techniques; 18.1 VMware Artifacts; 18.2 Vulnerable Instructions; 18.3 Tweaking Settings; 18.4 Escaping the Virtual Machine; 18.5 Conclusion; 18.6 Labs; Chapter 18: Packers and Unpacking; 19.1 Packer Anatomy; 19.2 Identifying Packed Programs; 19.3 Unpacking Options; 19.4 Automated Unpacking; 19.5 Manual Unpacking; 19.6 Tips and Tricks for Common Packers; 19.7 Analyzing Without Fully Unpacking; 19.8 Packed DLLs; 19.9 Conclusion; 19.10 Labs; Special Topics; Chapter 19: Shellcode Analysis; 20.1 Loading Shellcode for Analysis; 20.2 Position-Independent Code; 20.3 Identifying Execution Location; 20.4 Manual Symbol Resolution; 20.5 A Full Hello World Example; 20.6 Shellcode Encodings; 20.7 NOP Sleds; 20.8 Finding Shellcode; 20.9 Conclusion; 20.10 Labs; Chapter 20: C++ Analysis; 21.1 Object-Oriented Programming; 21.2 Virtual vs. Nonvirtual Functions; 21.3 Creating and Destroying Objects; 21.4 Conclusion; 21.5 Labs; Chapter 21: 64-Bit Malware; 22.1 Why 64-Bit Malware?; 22.2 Differences in x64 Architecture; 22.3 Windows 32-Bit on Windows 64-Bit; 22.4 64-Bit Hints at Malware Functionality; 22.5 Conclusion; 22.6 Labs; Important Windows Functions; Tools for Malware Analysis; Solutions to Labs; Lab 1-1 Solutions; Lab 1-2 Solutions; Lab 1-3 Solutions; Lab 1-4 Solutions; Lab 3-1 Solutions; Lab 3-2 Solutions; Lab 3-3 Solutions; Lab 3-4 Solutions; Lab 5-1 Solutions; Lab 6-1 Solutions; Lab 6-2 Solutions; Lab 6-3 Solutions; Lab 6-4 Solutions; Lab 7-1 Solutions; Lab 7-2 Solutions; Lab 7-3 Solutions; Lab 9-1 Solutions; Lab 9-2 Solutions; Lab 9-3 Solutions; Lab 10-1 Solutions; Lab 10-2 Solutions; Lab 10-3 Solutions; Lab 11-1 Solutions; Lab 11-2 Solutions; Lab 11-3 Solutions; Lab 12-1 Solutions; Lab 12-2 Solutions; Lab 12-3 Solutions; Lab 12-4 Solutions; Lab 13-1 Solutions; Lab 13-2 Solutions; Lab 13-3 Solutions; Lab 14-1 Solutions; Lab 14-2 Solutions; Lab 14-3 Solutions; Lab 15-1 Solutions; Lab 15-2 Solutions; Lab 15-3 Solutions; Lab 16-1 Solutions; Lab 16-2 Solutions; Lab 16-3 Solutions; Lab 17-1 Solutions; Lab 17-2 Solutions; Lab 17-3 Solutions; Lab 18-1 Solutions; Lab 18-2 Solutions; Lab 18-3 Solutions; Lab 18-4 Solutions; Lab 18-5 Solutions; Lab 19-1 Solutions; Lab 19-2 Solutions; Lab 19-3 Solutions; Lab 20-1 Solutions; Lab 20-2 Solutions; Lab 20-3 Solutions; Lab 21-1 Solutions; Lab 21-2 Solutions;

Read more less

Book SynopsisForensic image acquisition is an important part of postmortem incident response and evidence collection. Digital forensic investigators acquire, preserve, and manage digital evidence to support civil and criminal cases; examine organizational policy violations; resolve disputes; and analyze cyber attacks. Practical Forensic Imaging takes a detailed look at how to secure and manage digital evidence using Linux-based command line tools. This essential guide walks you through the entire forensic acquisition process and covers a wide range of practical scenarios and situations related to the imaging of storage media. You ll learn how to: Perform forensic imaging of magnetic hard disks, SSDs and flash drives, optical discs, magnetic tapes, and legacy technologies Protect attached evidence media from accidental modification Manage large forensic image files, storage capacity, image format conversion, compression, splitting, duplication, secure transfer and storage, and secure disposal PTrade Review“Despite the huge impact of this subject matter, there have been precious few books on the topic to date. Luckily, Practical Forensic Imaging steps in now to fill the gap. An excellent addition to any bookshelf.”—Forensic Focus“I am a big fan of this book, and found it to contain the right amount of technical content coupled with important concepts and concerns surrounding forensic imaging. I’d encourage anyone in DFIR who is imaging regularly or looking to increase their Linux skills to check out a copy of the book.”—505 Forensics“Cybercrime and digital forensics expert Bruce Nikkel describes the use of open source command line technology to obtain and manage forensic data. Target readers are the expanding number of forensic practitioners including forensic and electronic discovery technicians in legal, auditing, and consulting firms; incident response teams; law enforcement forensic specialists; and forensic investigators.”—The Lawyer's PC“It's commonly said that you should assume the bad guys have already breached your networks. The ability to carry out forensic examinations is one of the key skills you'll need in response to that risk, and this book is a solid introduction to acquiring those skills.”—Network Security Newsletter"I loved Bruce Nikkel's book Practical Forensic Imaging from @nostarch - but his new book Practical Linux Forensics is [fire]. Beginner to intermediate, and a good desktop reference."—DFIRScience, @DFIRScienceTable of ContentsIntroductionChapter 0: Digital Forensics OverviewChapter 1: Storage Media Overview<Chapter 2: Linux as a Forensic Acquisition PlatformChapter 3: Forensic Image FormatsChapter 4: Planning and PreparationChapter 5: Attaching Subject Media to an Acquisition HostChapter 6: Forensic Image AcquisitionChapter 7: Forensic Image ManagementChapter 8: Special Image Access TopicsChapter 9: Extracting Subsets of Forensic Images

Read more less

Book SynopsisTo successfully compete in the modern world, organisations are accelerating their digital transformations. It is essential for them to utilise best practice methods when implementing new systems and adopting new technologies. The Super User Model is a proven methodology for delivering digital transformation projects, including large scale transitions.This book is designed to help project, learning and change professionals who are responsible for this delivery by introducing the Super User Model and how to use it. It provides the tools, techniques, and theory needed to plan out where and how Super Users can add value at each phase of a project - across software design, change management, testing, and training - and to manage Super User Networks beyond the transition into business as usual for sustained benefits.If your organisation is investing in new technology, you cannot afford not to use Super Users in taking the latest step in your digital transformation journey.

Read more less

Book SynopsisAfter twenty years, return to the wild world of Crash Bandicoot with this epic behind-the-scenes look at the new Crash Bandicoot 4: It's About Time! The Crash Bandicoot (TM) series has remained a beloved staple of platform gaming ever since the first game's release in 1996, The Art of Crash Bandicoot (TM)4: It's About Time (TM) is a rich repository overflowing with interviews, quotes, observations and anecdotes, accompanied by a treasure trove of concept art detailing the characters and environments of the game. Gamers of every type will cherish this all-encompassing look into the zany, wild and unpredictable world of Crash Bandicoot (TM).

Read more less

Book Synopsis

Read more less

Book SynopsisWant to learn the Python language without slogging your way through how-to manuals? With Head First Python, you'll quickly grasp Python's fundamentals by working with built-in data structures and functions. You'll build your very own web app, which—once it's ready for prime time—runs in the cloud.

Read more less

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

Read more less

Book SynopsisFor developers who've mastered the basics, this book is the next step on your way to professional-level programming in Rust. It covers everything you need to build and maintain larger code bases, write powerful and flexible applications and libraries, and confidently expand the scope and complexity of your projects. Author Jon Gjengset takes you deep into the Rust programming language, dissecting core topics like ownership, traits, concurrency, and unsafe code. You'll explore key concepts like type layout and trait coherence, delve into the inner workings of concurrent programming and asynchrony with async/await, and take a tour of the world of no_std programming. Gjengset also provides expert guidance on API design, testing strategies, and error handling, and will help develop your understanding of foreign function interfaces, object safety, procedural macros, and much more. You'll Learn: How to design reliable, idiomatic, and ergonomic Rust programs based on best principles; EffectiTrade Review"You'll learn dozens—probably hundreds—of things about how to improve your Rust programming by reading this book."—Tim McNamara, author of Rust in Action"One of Rust's weaknesses as a language is there's a lot of beginner content and a lot of advanced content, but any intermediate content is just nonexistent or requires quite the struggle to learn. Jon Gjengset has done a wonderful job of distilling those next steps into an easy to read book."—Michael Gattozzi, Senior Software Engineer, Fastly"For a long time, people have asked me what they should read after The Rust Programming Language. Rust for Rustaceans is that book. This book will teach you how to effectively *use* Rust, after you've understood the core syntax and semantics of the language itself. Rust has a rich number of tools for you to choose from, and Rust for Rustaceans will show them all off, and teach you how to properly take advantage of all the richness Rust has to offer."—Steve Klabnik, co-author of The Rust Programming Language"Rust for Rustaceans is such a good book (for folks who already know rust)!" —Ron Bowes, @iagox86Table of ContentsChapter 1: Rust Programming MindsetChapter 2: FoundationsChapter 3: Types and TraitsChapter 4: Designing InterfacesChapter 5: Error HandlingChapter 6: Project StructureChapter 7: TestingChapter 8: MacrosChapter 9: Asynchronous ProgrammingChapter 10: Unsafe RustChapter 11: ConcurrencyChapter 12: Foreign Function InterfaceChapter 13: no_stdChapter 14: Interacting with Large ProjectsChapter 15: Putting It TogetherIndex

Read more less

Book SynopsisIt's all in the name: Learn You a Haskell for Great Good! is a hilarious, illustrated guide to this complex functional language. Packed with the author's original artwork, pop culture references, and most importantly, useful example code, this book teaches functional fundamentals in a way you never thought possible. You'll start with the kid stuff: basic syntax, recursion, types and type classes. Then once you've got the basics down, the real black belt master-class begins: you'll learn to use applicative functors, monads, zippers, and all the other mythical Haskell constructs you've only read about in storybooks. As you work your way through the author's imaginative (and occasionally insane) examples, you'll learn to: Laugh in the face of side effects as you wield purely functional programming techniques Use the magic of Haskell's 'laziness' to play with infinite sets of data Organize your programs by creating your own types, type classes, and modules Use Haskell's elegant input/Trade Review"The thing that's most impressive about Learn You a Haskell for Great Good! is how well-written it is. This book is just fantastic."—Gregory Collins, Google Switzerland"Managed to walk me through all important Haskell concepts without ever making any of the material sound complicated. A good introduction to functional programming."—Marijn Haverbeke, author of Eloquent JavaScript"This is a fantastic book and I highly recommend it as the first book on Haskell—and possibly even the second."—Michael Fogus, author of The Joy of Clojure"A fantastic, fun, thorough introduction to Haskell, spiced up by Miran's great sense of humor and zany illustrations."—Brent Yorgey, The Math Less Traveled"Miran Lipovača has done a fantastic job of writing a book aimed at beginning Haskell programmers. I like his very straightforward writing style of introducing each topic with the minimum of complexity."—Bryan Bell, Math and More"This is a remarkable book and may be just what this beautiful language was missing."—Michael Kohl, Citizen428"This book is the best way I know to obtain the Haskell foundation you need for fluency."—Jeremy Bowers, Jerf.org"This is a terrific book. It makes what might otherwise seem impenetrable mathy-code and makes it fun and approachable."—Simon ReynoldsTable of ContentsIntroductionChapter 1: Starting OutChapter 2: Believe the TypeChapter 3: Syntax in FunctionsChapter 4: Hello Recursion!Chapter 5: Higher-Order FunctionsChapter 6: ModulesChapter 7: Making Our Own Types and Type ClassesChapter 8: Input and OutputChapter 9: More Input and More OutputChapter 10: Functionally Solving ProblemsChapter 11: Applicative FunctorsChapter 12: MonoidsChapter 13: A Fistful of MonadsChapter 14: For a Few Monads MoreChapter 15: ZippersColophonUpdates

Read more less

Book SynopsisInvent Your Own Computer Games with Python will teach you how to make computer games using the popular Python programming language even if you ve never programmed before! Begin by building classic games like Hangman, Guess the Number, and Tic-Tac-Toe, and then work your way up to more advanced games, like a text-based treasure hunting game and an animated collision-dodging game with sound effects. Along the way, you ll learn key programming and math concepts that will help you take your game programming to the next level. Learn how to: Combine loops, variables, and flow control statements into real working programs Choose the right data structures for the job, such as lists, dictionaries, and tuples Add graphics and animation to your games with the pygame module Handle keyboard and mouse input Program simple artificial intelligence so you can play against the computer Use cryptography to convert text messages into secret code Debug your programs and find common errors As you woTrade Review“Pretty close to the ultimate how-to-learn python book. First, it combines an easy ramp up from expecting you to know virtually nothing to having you try out – and understand – Python. Second, it provides the code, the tools, and the explanations required for you build a number of increasingly sophisticated games and the know-how to branch out to creating games completely on your own.”—Computerworld“Many of the games include flowcharts so the reader will better understand the logic needed to complete the game, and I was especially happy to see a few chapters focus on topics not necessary limited to games such as Cartesian coordinates and using the built-in Debugger.”—GeekDad“This is an excellent way to learn Python, if you are a kid or not. Little kids can learn with their adult guide, and older kids will eat this book up in an afternoon or two.”—Greg Laden, National Geographic's ScienceBlogs“This book is a great entry point for beginning programmers that 'gamifies' coding, allowing readers to immediately apply the concepts covered, rather than teaching basics with little application.”—School Library Connection"If games are your thing, this would be the perfect book to learn Python."—Rajat, @argent_codesTable of ContentsChapter 1: The Interactive ShellChapter 2: Writing ProgramsChapter 3: Guess the NumberChapter 4: JokesChapter 5: Dragon RealmChapter 6: Using the DebuggerChapter 7: Designing Hangman with FlowchartsChapter 8: Writing the Hangman CodeChapter 9: Extending HangmanChapter 10: Tic-Tac-ToeChapter 11: BagelsChapter 12: Cartesian CoordinatesChapter 13: Sonar Treasure HuntChapter 14: Caesar CipherChapter 15: ReversiChapter 16: AI SimulationChapter 17: Using Pygame and GraphicsChapter 18: Animating GraphicsChapter 19: Collision Detection and InputChapter 20: Sounds and ImagesChapter 21: Dodger

Read more less

Book SynopsisApplied Julia provides a comprehensive, hands-on language introduction that's packed with examples leveraging real scientific libraries used by researchers in various fields. Solve problems of genuine interest, such as modeling the course of a pandemic, and learn to use Julia as a tool for research. The Julia programming language can be used to write all types of applications, but its features are especially powerful for numerical analysis and computational science. Applied Julia shows readers how to take advantage of Julia's particular strengths, as well as how to write effective and efficient programs. The book takes Julia novices from their very first steps to writing real-world applications for use in fields such as biology, physics, math, statistics, and machine learning. Not only will readers develop the Julia knowledge needed for solving computational problems, but they'll also learn how to explore and visualise data, solve equations, write simulations, and create libraries. AdTrade Review"A great starting point for the reader’s journey into Julia - with the first part covering the fundamentals of the language and second part diving into a variety of different scientific disciplines." —Viral Shah, co-creator of the Julia programming language and CEO of JuliaHub"This is a nice deep dive that covers a lot of ground, from the basics on how to define arrays and use the type system all the way to biochemical modeling and scientific machine learning. Lee gives a very nice in-depth treatment, showing not only the most standard ways to do things, but also some different library options along with a good explanation of the pros and cons to the choices. I think this is a great book for any Julia user's shelf."—Christopher Rackauckas, Applied Mathematics Instructor, Massachusetts Institute of Technology"Practical Julia is clear, concise, and complete, exactly what you want in an introductory book. It’s also really interesting; the author has an engaging voice and a knack for good examples. Along with a general introduction to Julia, he provides real-world illustrations of applying Julia to specific problems in biology, physics, statistics, machine learning, and other areas. Highly recommended."—David Chappell, Principal of Chappell & AssociatesTable of ContentsIntroductionPART I: LEARNING JULIAChapter 1: Getting StartedChapter 2: Language BasicsChapter 3: Modules and PackagesChapter 4: The Plotting SystemChapter 5: CollectionsChapter 6: Functions, Metaprogramming, and ErrorsChapter 7: Diagrams and AnimationsChapter 8: The Type SystemPART II: APPLICATIONSChapter 9: PhysicsChapter 10: StatisticsChapter 11: BiologyChapter 12: MathematicsChapter 13: Scientific Machine LearningChapter 14: Signal and Image ProcessingChapter 15: Parallel ProcessingIndex

Read more less

Book SynopsisThe Arduino platform provides a virtually limitless range of creative opportunities to musicians who are interested to explore new technologies. In Arduino for Musicians, Brent Edstrom provides a comprehensive guide to the underlying technologies enabling the creation of custom instruments that respond to light, touch, breath, and other forms of control.Trade Review"I heartily recommend this book as a way to get started with Arduino or electronics even for non-musicians. But if you ever wanted to make your own Moog synth or Theremin (and who hasn't) then you will love this book."--Dr. Simon Monk, author and maker "A comprehensive and easy to use guide for everything you may need to know about how to use the Arduino for musical applications. The book is well-organized, allowing both technical novices and experienced music technologists to find the information and guidance they may be looking for."--Gil Weinberg, Professor and Director, Georgia Tech Center for Music Technology "Edstrom has developed a very useful resource for musicians interested in using microcomputer controllers and software tools in Arduino for Musicians. This publication, organized in three sections, serves not only as an introduction for those just learning the world of the Arduino, but also for those learning to use the open-source electronics platform to apply creative applications of the core concepts for the more advanced projects. The intermediate and advanced sections are written in a casual narrative style with well-organized sequencing. The book is a welcome addition as a resource or required text for undergraduate or graduate students enrolled in music technology or related courses in multimedia performance."--G. David Peters, Professor and Head of Graduate Studies, Music and Arts Technology, Indiana University - IUPUITable of ContentsTable of Contents Forward Chapter 1 Getting Started Chapter 2 Introduction To Programming Chapter 3 Introduction To Electronics Chapter 4 Interfacing With Arduino Chapter 5 Music Instrument Digital Interface (MIDI) I/O Chapter 6 Real-Time Input: Musical Expression Chapter 7 Music-Making Shields Chapter 8 Programming Part II Chapter 9 Audio Output and Sound Synthesis Chapter 10 Audio Input Chapter 11 Finalizing Projects Chapter 12 Standalone Arduino Chapter 13 MIDI Hand Drum Project Chapter 14 Stella Synthesizer Project Chapter 15 Step Sequencer Project Chapter 16 Emöte MIDI Controller Notes Bibliography Appendix A: MIDI Control Changes Appendix B: MMC Commands Appendix C: Introduction to Bit Twiddling Index

Read more less

Book SynopsisDiscover all the amazing things you can do with Arduino Arduino is a programmable circuit board that is being used by everyone from scientists, programmers, and hardware hackers to artists, designers, hobbyists, and engineers in order to add interactivity to objects and projects and experiment with programming and electronics.Table of ContentsIntroduction 1 Part I: Getting Started with Arduino Projects 7 Chapter 1: Exploring the World of Arduino 9 Chapter 2: Setting Up Your Workspace and Tools 19 Chapter 3: Understanding the Basics 41 Part II: Basic Arduino Projects 63 Chapter 4: The All-Seeing Eye 65 Chapter 5: Making a Light Pet 85 Chapter 6: Making a Scrolling Sign 107 Chapter 7: Building an Arduino Clock 127 Part III: The Interactive Home and Garden 153 Chapter 8: Building a Keypad Entry System 155 Chapter 9: Building an RFID Tag Reader 181 Chapter 10: Building an Automated Garden 201 Chapter 11: Building a Tweeting Pet Door 221 Chapter 12: Building a Home Sensing Station 243 Part IV: Advanced Arduino Projects 273 Chapter 13: Building a GPS Data Logger 275 Chapter 14: Building a Remote-Controlled Car 299 Chapter 15: Building an LED Cube 323 Part V: The Part of Tens 349 Chapter 16: Ten Great Arduino Resources 351 Chapter 17: Ten Troubleshooting Tips 359 Index 369

Read more less

Book SynopsisLearn to program with C++ quickly with this helpful For Dummies guideBeginning Programming with C++ For Dummies, 2nd Edition gives you plain-English explanations of the fundamental principles of C++, arming you with the skills and know-how to expertly use one of the world's most popular programming languages.Table of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 2 How This Book Is Organized 3 Part I: Getting Started with C++ Programming 3 Part II: Writing a Program: Decisions, Decisions 4 Part III: Becoming a Procedural Programmer 4 Part IV: Data Structures 4 Part V: Object-Oriented Programming 4 Part VI: Advanced Strokes 5 Part VII: The Part of Tens 5 Icons Used in This Book 5 Beyond the Book 6 Where to Go from Here 6 Part I: Getting Started with C++ Programming 7 Chapter 1: What Is a Program? 9 How Does My Son Differ from a Computer? 9 Programming a “Human Computer” 11 Creating the algorithm 11 Setting the tire-changing language 12 Constructing the program 13 Computer processors 17 Computer Languages 17 High-level languages 19 The C++ language 20 Chapter 2: Installing Code::Blocks 21 Reviewing the Compilation Process 21 Installing Code::Blocks 23 Windows installation 23 Ubuntu Linux installation 26 Mac OS installation 27 Setting up Code::Blocks 31 Testing the Code::Blocks Installation 33 Creating the project 34 Testing your default project 37 Chapter 3: Writing Your First Program 41 Creating a New Project 41 Filename extensions 43 Entering Your Program 44 Building the Program 46 Finding What Could Go Wrong 47 Misspelled commands 47 Missing semicolon 49 Using the Online Material 50 Running the Program 51 How the Program Works 51 The template 51 The Conversion program 53 Part II: Writing a Program: Decisions, Decisions 55 Chapter 4: Integer Expressions 57 Declaring Variables 57 Variable names 58 Assigning a value to a variable 59 Initializing a variable at declaration 60 Integer Constants 61 Expressions 62 Binary operators 62 Unraveling compound expressions 63 Unary Operators 65 The Special Assignment Operators 67 Chapter 5: Character Expressions 69 Defining Character Variables 69 Encoding characters 70 Example of character encoding 73 Encoding Strings of Characters 75 Special Character Constants 75 Chapter 6: if I Could Make My Own Decisions 79 The if Statement 79 Comparison operators 80 Say “No” to “No braces” 83 What Else Is There? 84 Nesting if Statements 86 Compound Conditional Expressions 89 Chapter 7: Switching Paths 93 Controlling Flow with the switch Statement 93 Control Fell Through: Did I break It? 96 Implementing an Example Calculator with the switch Statement 97 Chapter 8: Debugging Your Programs, Part I 101 Identifying Types of Errors 101 Avoiding Introducing Errors 102 Coding with style 102 Establishing variable naming conventions 103 Finding the First Error with a Little Help 104 Finding the Run-Time Error 105 Formulating test data 106 Executing the test cases 106 Seeing what’s going on in your program 107 Part III: Becoming a Procedural Programmer 109 Chapter 9: while Running in Circles 111 Creating a while Loop 111 Breaking out of the Middle of a Loop 114 Nested Loops 117 Chapter 10: Looping for the Fun of It 121 The for Parts of Every Loop 121 Looking at an Example 123 Getting More Done with the Comma Operator 125 Chapter 11: Functions, I Declare! 129 Breaking Your Problem Down into Functions 129 Understanding How Functions Are Useful 130 Writing and Using a Function 131 Returning things 132 Reviewing an example 133 Passing Arguments to Functions 135 Function with arguments 136 Functions with multiple arguments 137 Exposing main() 137 Defining Function Prototype Declarations 139 Chapter 12: Dividing Programs into Modules 141 Breaking Programs Apart 141 Breaking Up Isn’t That Hard to Do 142 Creating Factorialcpp 143 Creating an #include file 145 Including #include files 146 Creating maincpp 148 Building the result 149 Using the Standard C++ Library 149 Variable Scope 150 Chapter 13: Debugging Your Programs, Par t 2 151 Debugging a Dys-Functional Program 151 Performing unit level testing 153 Outfitting a function for testing 155 Returning to unit test 159 Part IV: Data Structures 163 Chapter 14: Other Numerical Variable Types 165 The Limitations of Integers in C++ 165 Integer round-off 166 Limited range 166 A Type That “doubles” as a Real Number 167 Solving the truncation problem 168 When an integer is not an integer 168 Discovering the limits of double 169 Variable Size — the “long” and “short” of It 172 How far do numbers range? 174 Types of Constants 175 Passing Different Types to Functions 176 Overloading function names 177 Mixed-mode overloading 177 Chapter 15: Arrays 181 What Is an Array? 181 Declaring an Array 182 Indexing into an Array 183 Looking at an Example 184 Initializing an Array 187 Chapter 16: Arrays with Character 189 The ASCII-Zero Character Array 189 Declaring and Initializing an ASCIIZ Array 190 Looking at an Example 191 Looking at a More Detailed Example 193 Foiling hackers 197 Do I Really Have to Do All That Work? 198 Chapter 17: Pointing the Way to C++ Pointers 203 What’s a Pointer? 203 Declaring a Pointer 204 Passing Arguments to a Function 206 Passing arguments by value 206 Passing arguments by reference 209 Putting it together 211 Reference argument types 213 Playing with Heaps of Memory 214 Do you really need a new keyword? 214 Don’t forget to clean up after yourself 215 Looking at an example 216 Chapter 18: Taking a Second Look at C++ Pointers 221 Pointers and Arrays 221 Operations on pointers 222 Pointer addition versus indexing into an array 224 Using the pointer increment operator 227 Why bother with array pointers? 230 Operations on Different Pointer Types 231 Constant Nags 231 Differences Between Pointers and Arrays 233 My main() Arguments 233 Arrays of pointers 234 Arrays of arguments 235 Chapter 19: Programming with Class 241 Grouping Data 241 The Class 242 The Object 243 Arrays of Objects 244 Looking at an Example 246 Chapter 20: Debugging Your Programs, Par t 3 253 A New Approach to Debugging 253 The solution 254 Entomology for Dummies 255 Starting the debugger 257 Fixing the (first) bug 264 Finding and fixing the second bug 265 Part V: Object-Oriented Programming 269 Chapter 21: What Is Object-Oriented Programming? 271 Abstraction and Microwave Ovens 271 Procedural nachos 273 Object-oriented nachos 273 Classification and Microwave Ovens 274 Why Build Objects This Way? 275 Self-Contained Classes 276 Chapter 22: Structured Play: Making Classes Do Things 277 Activating Our Objects 277 Creating a Member Function 278 Defining a member function 279 Naming class members 280 Calling a member function 281 Accessing other members from within a member function 282 Keeping a Member Function after Class 284 Overloading Member Functions 285 Chapter 23: Pointers to Objects 287 Pointers to Objects 287 Arrow syntax 288 Calling all member functions 288 Passing Objects to Functions 289 Calling a function with an object value 289 Calling a function with an object pointer 290 Looking at an example 292 Allocating Objects off the Heap 296 Chapter 24: Do Not Disturb: Protected Members 299 Protecting Members 299 Why you need protected members 300 Making members protected 301 So what? 303 Who Needs Friends, Anyway? 304 Chapter 25: Getting Objects Off to a Good Start 307 The Constructor 308 Limitations on constructors 309 Can I see an example? 310 Constructing data members 312 Destructors 315 Looking at an example 316 Destructing data members 318 Chapter 26: Making Constructive Arguments 321 Constructors with Arguments 321 Looking at an example 322 Overloading the Constructor 326 The Default default Constructor 330 Constructing Data Members 332 Initializing data members with the default constructor 332 Initializing data members with a different constructor 334 Looking at an example 337 New with C++ 2011 340 Chapter 27: Coping with the Copy Constructor 341 Copying an Object 341 The default copy constructor 342 Looking at an example 344 Creating a Copy Constructor 346 Avoiding Copies 349 Part VI: Advanced Strokes 351 Chapter 28: Inheriting a Class 353 Advantages of Inheritance 354 Learning the lingo 355 Implementing Inheritance in C++ 355 Looking at an example 356 Having a HAS_A Relationship 360 Chapter 29: Are Virtual Functions for Real? 361 Overriding Member Functions 361 Early binding 362 Ambiguous case 364 Enter late binding 366 When Is Virtual Not? 369 Virtual Considerations 371 Chapter 30: Overloading Assignment Operators 373 Overloading an Operator 374 Overloading the Assignment Operator Is Critical 374 Looking at an Example 376 Writing Your Own (or Not) 379 Chapter 31: Performing Streaming I/O 381 How Stream I/O Works 381 Stream Input/Output 383 Creating an input object 383 Creating an output object 385 Open modes 386 What is binary mode? 386 Hey, file, what state are you in? 387 Other Member Functions of the fstream Classes 391 Reading and writing streams directly 393 Controlling format 396 What’s up with endl? 399 Manipulating Manipulators 399 Using the stringstream Classes 400 Chapter 32: I Take Exception! 405 The Exception Mechanism 406 Examining the exception mechanism in detail 408 Special considerations for throwing 409 Creating a Custom Exception Class 410 Restrictions on exception classes 414 Part VII: The Part of Tens 415 Chapter 33: Ten Ways to Avoid Bugs 417 Enable All Warnings and Error Messages 417 Adopt a Clear and Consistent Coding Style 418 Comment the Code While You Write It 419 Single-Step Every Path in the Debugger at Least Once 419 Limit the Visibility 420 Keep Track of Heap Memory 420 Zero Out Pointers after Deleting What They Point To 421 Use Exceptions to Handle Errors 421 Declare Destructors Virtual 422 Provide a Copy Constructor and Overloaded Assignment Operator 422 Chapter 34: Ten Features Not Covered in This Book 423 The goto Command 423 The Ternary Operator 424 Binary Logic 425 Enumerated Types 425 Namespaces 425 Pure Virtual Functions 426 The string Class 426 Multiple Inheritance 427 Templates and the Standard Template Library 427 Lambda Functions 428 Index 429

Read more less