Object-oriented programming (OOP) Books

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

Read more less

Book SynopsisMartin Fowler is an independent consultant who has applied objects to pressing business problems for more than a decade. He has consulted on systems in fields such as health care, financial trading, and corporate finance. His clients include Chrysler, Citibank, UK National Health Service, Andersen Consulting, and Netscape Communications. In addition, Fowler is a regular speaker on objects, the Unified Modeling Language, and patterns. Table of Contents Preface. Why bother with the UML? Structure of the book. Changes for the Third Edition. Acknowledgements. 1. Introduction. What Is the UML? Ways of Using the UML. How We Got to the UML. Notations and Meta-Models. UML Diagrams. What is Legal UML? The Meaning of UML. UML is not enough. Where to Start with the UML. Looking for More Information. 2. Development Process. Iterative and Waterfall Processes. Predictive and Adaptive Planning. Agile Processes. Rational Unified Process. Fitting a Process to a Project. Fitting the UML into a process. Understanding Legacy Code. Choosing a Development Process. Where to Find Out More. 3. Class Diagrams: The Essentials. Properties. Attributes. Associations. Multiplicity. Programming Interpretation of Properties. Bi-directional Associations. Operations. Generalization. Notes and Comments. Dependency. Constraint Rules. When to Use Class Diagrams. Where to Find Out More. 4. Sequence Diagrams. Creating and deleting participants. Loops, conditionals and the like. Synchronous and Asynchronous Calls. When to use Sequence Diagrams. 5. Class Diagrams: Advanced Concepts. Keywords. Responsibilities. Static Operations and Attributes. Aggregation and Composition. Derived Properties. Interfaces and Abstract Classes. Read Only and Frozen. Reference Objects and Value Objects. Qualified Associations. Classification and Generalization. Multiple and Dynamic Classification. Association Class. Template (Parameterized) Class. Enumerations. Active Class. Visibility. Messages. 6. Object Diagrams. When to use Object Diagrams. 7. Package Diagrams. Packages and Dependencies. Package Aspects. Implementing Packages. Where to Find Out More. When to Use Package Diagrams. 8. Deployment Diagrams. When to use deployment diagrams. 9. Use Cases. Content of a Use Case. Use Case Diagrams. Levels of Use Cases. Use cases and features (or stories). When to Use Use Cases. Where to Find Out More. 10. State Machine Diagrams. Internal Activities. Activity States. Superstates. Concurrent States. Implementing State Diagrams. When to Use State Diagrams. Where to Find Out More. 11. Activity Diagrams. Decomposing an action. Partitions. Signals. Tokens. Flows and Edges. Pins and Transformations. Expansion Regions. Flow Final. Join Specifications. And there's more. When to Use Activity Diagrams. Where to Find Out More. 12. Communication Diagrams. When to use Communication Diagrams. 13. Composite Structures. When to Use Composite Structures. 14. Component Diagrams. When to use Component Diagrams. 15. Collaborations. When to Use Collaborations. 16. Interaction Overview Diagrams. When to use Interaction Overview Diagrams. 17. Timing Diagrams. When to use Timing Diagrams. Appendix A Changes between UML Versions. Revisions to the UML. Changes in UML Distilled. Changes from UML 1.0 to 1.1. Type and Implementation Class. Complete and Incomplete Discriminator Constraints. Composition. Immutability and Frozen. Returns on Sequence Diagrams. Use of the Term "Role". Changes from UML 1.2 (and 1.1) to 1.3 (and 1.5). Use Cases. Activity Diagrams. Changes from UML 1.3 to 1.4. Changes from UML 1.4. to 1.5. From UML 1.x to UML 2.0. Class Diagrams (Basic). Interaction Diagrams. Class Diagrams (Advanced). State Diagrams. Activity Diagrams. Bibliography. Index.

Read more less

Book SynopsisC++ Programming in easy steps, 7th edition shows you how to program in the powerful C++ native system language. Now, in its seventh edition, this guide gives complete examples that illustrate each aspect with colorized source code.C++ Programming in easy steps, 7th edition begins by explaining how to install a free C++ compiler so that you can quickly begin to create your own executable programs by copying the book’s examples. It demonstrates all the C++ language basics before moving on to provide examples of Object Oriented Programming (OOP). C++ is not platform-dependent, so programs can be created on any operating system. Most illustrations in this book depict output on the Windows operating system (purely because it is the most widely-used desktop platform) but the examples can also be created on other platforms such as Linux or macOS. The book concludes by demonstrating how you can use your acquired knowledge to create programs graphically using a modern C++ Integrated Development Environment (IDE), such as Microsoft’s Visual Studio. C++ Programming in easy steps, 7th edition has an easy-to-follow style that will appeal to: Anyone who wants to begin programming in C++.Programmers looking to advance from an interpreted programming language, such as Python, who want to harness the superior speed of C++.Students who are studying C++ Programming at school or college. Those seeking a career in computing who need a fundamental understanding of Object Oriented Programming. This book makes no assumption that you have previous knowledge of any programming language, so it is suitable for the beginner to programming in C++, whether you know C or not.

Read more less

Book SynopsisWith this book, you'll learn the Java language with a unique method that goes beyond how-to manuals. Through puzzles, mysteries, and soul-searching interviews with famous Java objects, you'll quickly get up to speed on Java's fundamentals and advanced topics including lambdas, streams, generics, threading, networking, and the dreaded desktop GUI.

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

Book SynopsisDr. Erich Gamma is technical director at the Software Technology Center of Object Technology International in Zurich, Switzerland. Dr. Richard Helm is a member of the Object Technology Practice Group in the IBM Consulting Group in Sydney, Australia. Dr. Ralph Johnson is a faculty member at the University of Illinois at Urbana-Champaign's Computer Science Department. John Vlissides is a member of the research staff at the IBM T. J. Watson Research Center in Hawthorne, New York. He has practiced object-oriented technology for more than a decade as a designer, implementer, researcher, lecturer, and consultant. In addition to co-authoring Design Patterns: Elements of Reusable Object-Oriented Software, he is co-editor of the book Pattern Languages of Program Design 2 (both from Addison-Wesley). He and the other co-authors of Design Patterns are recipients of the 1998 Dr. Dobb's Journal Excellence in Programming Award. 020163Table of Contents 1. Introduction. 2. A Case Study: Designing a Document Editor. 3. Creational Patterns. 4. Structural Pattern. 5. Behavioral Patterns. 6. Conclusion. Appendix A: Glossary. Appendix B: Guide to Notation. Appendix C: Foundation Classes. Bibliography. Index.

Read more less

Book SynopsisCoding for Beginners in easy steps, 3rd edition will appeal to anyone, of any age, who wants to begin coding computer programs. Use this guide to help you quickly create a programming environment on your computer, then, in easy steps, learn how to: Write Python code to create your programsStore information in data structuresControl program flow using control structuresCreate re-usable blocks of program codeCode powerful algorithms and classes for Object Oriented Programming (OOP) All features are illustrated using the Python language color-coding convention, and all code is available to download free ? making it even easier! Includes comparison examples in C, C++ and Java to give you a rounded view of computer coding. Ideal for newcomers to programming, including youngsters needing to learn coding for the school curriculum ? all in easy steps!This third edition is updated for the latest version of Python (Python 3.13).

Read more less

Book SynopsisComing to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce. The challenge is learning to use those features effectively - so that your software is correct, efficient, maintainable, and portable. That's where this practical book comes in.

Read more less

Book SynopsisMartin Fowler is Chief Scientist at ThoughtWorks. He describes himself as an author, speaker, consultant and general loud-mouth on software development. Fowler concentrates on designing enterprise software: exploring what makes a good design and what practices are needed to create one.Table of Contents Preface 1. Refactoring, a First Example 2. Principles in Refactoring 3. Bad Smells in Code 4. Building Tests 5. Toward a Catalog of Refactorings 6. Composing Methods 7. Moving Features between Objects 8. Organizing Data 9. Simplifying Conditional Expressions 10. Making Method Calls Simpler 11. Dealing with Generalization 12. Big Refactorings 13. Refactoring, Reuse, and Reality 14. Refactoring Tools 15. Putting It All Together

Read more less

Book SynopsisStanley B. Lippman has retired back to the Catalina Foothills where he is working on EEEK!, a computational model of the nervous system of the House Mouse, and An Off By One Error, a speculative novel set in the Northwestern Rain Forest. During his professional career, Stanley served as Distinguished Consultant for the Jet Propulsion Laboratory, Architect for the Visual C++ development group at Microsoft, member of technical staff at Bell Laboratories, two stints in Massive Multiplayer Online Gaming, and a surprisingly long stint in Feature Animation at Disney, DreamWorks, Pixar, and PDI. Stanley will be most remembered for his many years working with Dr. Stroustrup on the implementation of cfront, the standard implementation of C++ until the ISO standard. Josée Lajoie, now at Pixar, was a member of IBM Canada's C/C++ compiler development team, and chaired the core language working group for the original ANSI/ISO C++ standardization committeeTable of ContentsPreface xxiii Chapter 1: Getting Started 1 1.1 Writing a Simple C++ Program 2 1.2 A First Look at Input/Output 5 1.3 A Word About Comments 9 1.4 Flow of Control 11 1.5 Introducing Classes 19 1.6 The Bookstore Program 24 Chapter Summary 26 Defined Terms 26 Part I: The Basics 29 Chapter 2: Variables and Basic Types 31 2.1 Primitive Built-in Types 32 2.2 Variables 41 2.3 Compound Types 50 2.4 const Qualifier 59 2.5 Dealing with Types 67 2.6 Defining Our Own Data Structures 72 Chapter Summary 78 Defined Terms 78 Chapter 3: Strings, Vectors, and Arrays 81 3.1 Namespace using Declarations 82 3.2 Library string Type 84 3.3 Library vector Type 96 3.4 Introducing Iterators 106 3.5 Arrays 113 3.6 Multidimensional Arrays 125 Chapter Summary 131 Defined Terms 131 Chapter 4: Expressions 133 4.1 Fundamentals 134 4.2 Arithmetic Operators 139 4.3 Logical and Relational Operators 141 4.4 Assignment Operators 144 4.5 Increment and Decrement Operators 147 4.6 The Member Access Operators 150 4.7 The Conditional Operator 151 4.8 The Bitwise Operators 152 4.9 The sizeof Operator 156 4.10 Comma Operator 157 4.11 Type Conversions 159 4.12 Operator Precedence Table 166 Chapter Summary 168 Defined Terms 168 Chapter 5: Statements 171 5.1 Simple Statements 172 5.2 Statement Scope 174 5.3 Conditional Statements 174 5.4 Iterative Statements 183 5.5 Jump Statements 190 5.6 try Blocks and Exception Handling 193 Chapter Summary 199 Defined Terms 199 Chapter 6: Functions 201 6.1 Function Basics 202 6.2 Argument Passing 208 6.3 Return Types and the return Statement 222 6.4 Overloaded Functions 230 6.5 Features for Specialized Uses 236 6.6 Function Matching 242 6.7 Pointers to Functions 247 Chapter Summary 251 Defined Terms 251 Chapter 7: Classes 253 7.1 Defining Abstract Data Types 254 7.2 Access Control and Encapsulation 268 7.3 Additional Class Features 271 7.4 Class Scope 282 7.5 Constructors Revisited 288 7.6 static Class Members 300 Chapter Summary 305 Defined Terms 305 Part II: The C++ Library 307 Chapter 8: The IO Library 309 8.1 The IO Classes 310 8.2 File Input and Output 316 8.3 string Streams 321 Chapter Summary 324 Defined Terms 324 Chapter 9: Sequential Containers 325 9.1 Overview of the Sequential Containers 326 9.2 Container Library Overview 328 9.3 Sequential Container Operations 341 9.4 How a vector Grows 355 9.5 Additional string Operations 360 9.6 Container Adaptors 368 Chapter Summary 372 Defined Terms 372 Chapter 10: Generic Algorithms 375 10.1 Overview 376 10.2 A First Look at the Algorithms 378 10.3 Customizing Operations 385 10.4 Revisiting Iterators 401 10.5 Structure of Generic Algorithms 410 10.6 Container-Specific Algorithms 415 Chapter Summary 417 Defined Terms 417 Chapter 11: Associative Containers 419 11.1 Using an Associative Container 420 11.2 Overview of the Associative Containers 423 11.3 Operations on Associative Containers 428 11.4 The Unordered Containers 443 Chapter Summary 447 Defined Terms 447 Chapter 12: Dynamic Memory 449 12.1 Dynamic Memory and Smart Pointers 450 12.2 Dynamic Arrays 476 12.3 Using the Library: A Text-Query Program 484 Chapter Summary 491 Defined Terms 491 Part III: Tools for Class Authors 493 Chapter 13: Copy Control 495 13.1 Copy, Assign, and Destroy 496 13.2 Copy Control and Resource Management 510 13.3 Swap 516 13.4 A Copy-Control Example 519 13.5 Classes that Manage Dynamic Memory 524 13.6 Moving Objects 531 Chapter Summary 549 Defined Terms 549 Chapter 14: Overloaded Operations and Conversions 551 14.1 Basic Concepts 552 14.2 Input and Output Operators 556 14.3 Arithmetic and Relational Operators 560 14.4 Assignment Operators 563 14.5 Subscript Operator 564 14.6 Increment and Decrement Operators 566 14.7 Member Access Operators 569 14.8 Function-Call Operator 571 14.9 Overloading, Conversions, and Operators 579 Chapter Summary 590 Defined Terms 590 Chapter 15: Object-Oriented Programming 591 15.1 OOP: An Overview 592 15.2 Defining Base and Derived Classes 594 15.3 Virtual Functions 603 15.4 Abstract Base Classes 608 15.5 Access Control and Inheritance 511 15.6 Class Scope under Inheritance 617 15.7 Constructors and Copy Control 622 15.8 Containers and Inheritance 630 15.9 Text Queries Revisited 634 Chapter Summary 649 Defined Terms 649 Chapter 16: Templates and Generic Programming 651 16.1 Defining a Template 652 16.2 Template Argument Deduction 678 16.3 Overloading and Templates 694 16.4 Variadic Templates 699 16.5 Template Specializations 706 Chapter Summary 713 Defined Terms 713 Part IV: Advanced Topics 715 Chapter 17: Specialized Library Facilities 717 17.1 The tuple Type 718 17.2 The bitset Type 723 17.3 Regular Expressions 728 17.4 Random Numbers 745 17.5 The IO Library Revisited 752 Chapter Summary 769 Defined Terms 769 Chapter 18: Tools for Large Programs 771 18.1 Exception Handling 772 18.2 Namespaces 785 18.3 Multiple and Virtual Inheritance 802 Chapter Summary 816 Defined Terms 816 Chapter 19: Specialized Tools and Techniques 819 19.1 Controlling Memory Allocation 820 19.2 Run-Time Type Identification 825 19.3 Enumerations 832 19.4 Pointer to Class Member 835 19.5 Nested Classes 843 19.6 Union: A Space-Saving Class 847 19.7 Local Classes 852 19.8 Inherently Nonportable Features 854 Chapter Summary 862 Defined Terms 862 Appendix A: The Library 865 A.1 Library Names and Headers 866 A.2 A Brief Tour of the Algorithms 870 A.3 Random Numbers 882 Index 887

Read more less

Book SynopsisThis easy-to-follow textbook teaches Java programming from first principles, as well as covering design and testing methodologies. The text is divided into two parts. Each part supports a one-semester module, the first part addressing fundamental programming concepts, and the second part building on this foundation, teaching the skills required to develop more advanced applications.This fully updated and greatly enhanced fourth edition covers the key developments introduced in Java 8, including material on JavaFX, lambda expressions and the Stream API.Topics and features: begins by introducing fundamental programming concepts such as declaration of variables, control structures, methods and arrays; goes on to cover the fundamental object-oriented concepts of classes and objects, inheritance and polymorphism; uses JavaFX throughout for constructing event-driven graphical interfaces; includes advanced topics such as interfaces and lambda expressions, generics, collection classes and exceptions; explains file-handling techniques, packages, multi-threaded programs, socket programming, remote database access and processing collections using streams; includes self-test questions and programming exercises at the end of each chapter, as well as two illuminating case studies; provides additional resources at its associated website (simply go to springer.com and search for "Java in Two Semesters"), including a guide on how to install and use the NetBeans™ Java IDE.Offering a gentle introduction to the field, assuming no prior knowledge of the subject, Java in Two Semesters is the ideal companion to undergraduate modules in software development or programming.Table of ContentsPart I: Semester One The First Step Building Blocks Selection Iteration Methods Arrays Classes and Objects Implementing Classes Inheritance Introducing JavaFX Case Study – Part 1 Case Study – Part 2 Part II: Semester Two Interfaces and Lambda Expressions Exceptions The Java Collections Framework Advanced JavaFX JavaFX: Interacting with the User Working with Files Packages Multi-Threaded Programs Advanced Case Study The Stream API Working with Sockets Java in Context

Read more less

Book SynopsisLenny Delligatti holds the OMG Certified Systems Modeling Professional (OCSMP): Model Builder Advanced certification. As a senior systems engineer with Lockheed Martin, he created SysML models for NASA's Mission Control Center: 21st Century (MCC-21) project at Johnson Space Center. Lenny is a member of the Object Management Group (OMG) SysML Revision Task Force (RTF). He has delivered hundreds of hours of training to hundreds of systems and software engineers, enabling many to earn certifications and lead MBSE projects.Trade Review"In keeping with the outstanding tradition of Addison-Wesley's technical publications, Lenny Delligatti's SysML Distilled does not disappoint. Lenny has done a masterful job of capturing the spirit of OMG SysML as a practical, standards-based modeling language to help systems engineers address growing system complexity. This book is loaded with matter-of-fact insights, starting with basic MBSE concepts to distinguishing the subtle differences between use cases and scenarios to illumination on namespaces and SysML packages, and even speaks to some of the more esoteric SysML semantics such as token flows." -Jeff Estefan, Principal Engineer, NASA's Jet Propulsion Laboratory "The power of a modeling language, such as SysML, is that it facilitates communication not only within systems engineering but across disciplines and across the development life cycle. Many languages have the potential to increase communication, but without an effective guide, they can fall short of that objective. In SysML Distilled, Lenny Delligatti combines just the right amount of technology with a common-sense approach to utilizing SysML toward achieving that communication. Having worked in systems and software engineering across many domains for the last 30 years, and having taught computer languages, UML, and SysML to many organizations and within the college setting, I find Lenny's book an invaluable resource. He presents the concepts clearly and provides useful and pragmatic examples to get you off the ground quickly and enables you to be an effective modeler." -Thomas W. Fargnoli, Lead Member of the Engineering Staff, Lockheed Martin "This book provides an excellent introduction to SysML. Lenny Delligatti's explanations are concise and easy to understand; the examples well thought out and interesting." -Susanne Sherba, Senior Lecturer, Department of Computer Science, University of Denver "Lenny hits the thin line between a reference book for SysML to look up elements and an entertaining book that could be read in its entirety to learn the language. A great book in the tradition of the famous UML Distilled." -Tim Weilkiens, CEO, oose "More informative than a PowerPoint, less pedantic than an OMG Profile Specification, SysML Distilled offers practicing systems engineers just the right level of the motivation, concepts, and notation of pure OMG SysML for them to attain fluency with this graphical language for the specification and analysis of their practical and complex systems." -Lonnie VanZandt, chief architect, No Magic, Inc. "Delligatti's SysML Distilled is a most aptly named book; it represents the distillation of years of experience in teaching and using SysML in industrial settings. The author presents a very clear and highly readable view of this powerful but complex modeling language, illustrating its use via easy-to-follow practical examples. Although intended primarily as an introduction to SysML, I have no doubt that it will also serve as a handy reference for experienced practitioners." -Bran Selic, president, Malina Software Corp. "SysML is a rather intimidating modeling language, but in this book Lenny makes it really easy to understand, and the advice throughout the book will help practitioners avoid numerous pitfalls and help them grasp and apply the core elements and the spirit of SysML. If you are planning on applying SysML, this is the book for you!" -Celso Gonzalez, senior developer, IBM Rational "SysML Distilled is a great book for engineers who are starting to delve into model-based systems engineering. The space system examples capture the imagination and express the concepts in a simple but effective way." -Matthew C. Hause, chief consulting engineer, Atego and chair, OMG UPDM Group "I've been deeply involved with OMG since the 1990s, but my professional needs have not often taken me into the SysML realm. So I thought I'd be a good beta tester for Lenny's book. To my delight, I learned a great deal reading through it, and I know you will too." -Doug Tolbert, distinguished engineer, Unisys, and member, OMG Board of Directors and Architecture Board "SysML Distilled provides a clear and comprehensive description of the language component of model-based systems engineering, while offering suggestions for where to find information about the tool and methodology components. There is evidence throughout the book that the author has a deep understanding of SysML and its application in a system development process. I will definitely be using this as a textbook in the MBSE courses I teach." -J. D. Baker, OCUP, OCSMP, member of the OMG Architecture Board "SysML Distilled is the desktop companion that many SysML modelers have needed for their bookshelves. Lenny has the experience and certifications to help you through your day-to-day modeling questions. This book is not a tutorial, nor is it the encyclopedic compendium of all things SysML. If you model using SysML, this will become your daily companion, as it is meant to be used regularly. I believe your copy will soon be dog-eared, with sticky notes throughout." -Dr. Robert Cloutier, Stevens Institute of Technology "SysML is utilized today in a wide range of applications, including deep space robotic spacecraft and down-to-earth agricultural equipment. This book concisely presents SysML in a manner that is both refreshingly accessible for new learners and quite handy for seasoned practitioners." -Russell Peak, MBSE branch chief, Aerospace Systems Design Lab, Georgia Tech "SysML Distilled is a wonderfully written, knowledgeable, and concise addition to systems modeling literature. The lucid explanations lead a newcomer by the hand into modeling reasonably complex systems, and the wealth and depth of the coverage of the most-used aspects of the SysML modeling language stretch to even enabling advanced intermediate depictions of most systems. It also serves as a handy reference. Kudos to Mr. Delligatti for gifting the world with this very approachable view of systems modeling." -Bobbin Teegarden, CTO/chief architect, OntoAge and Board Member, No Magic, Inc.Table of ContentsForeword by Rick Steiner xvii Foreword by Richard Soley xix Preface xxv Acknowledgments xxxi About the Author xxxiii Chapter 1: Overview of Model-Based Systems Engineering 1 1.1 What Is MBSE? 2 1.2 The Three Pillars of MBSE 4 1.3 The Myth of MBSE 9 Chapter 2: Overview of the Systems Modeling Language 11 2.1 What SysML Is–and Isn’t 11 2.2 Yes, SysML Is Based on UML–but You Can Start with SysML 13 2.3 SysML Diagram Overview 14 2.4 General Diagram Concepts 17 Chapter 3: Block Definition Diagrams 23 3.1 Purpose 23 3.2 When Should You Create a BDD? 24 3.3 The BDD Frame 24 3.4 Blocks 26 3.5 Associations: Another Notation for a Property 44 3.6 Generalizations 49 3.7 Dependencies 52 3.8 Actors 53 3.9 Value Types 55 3.10 Constraint Blocks 57 3.11 Comments 59 Chapter 4: Internal Block Diagrams 63 4.1 Purpose 63 4.2 When Should You Create an IBD? 64 4.3 Blocks, Revisited 64 4.4 The IBD Frame 65 4.5 BDDs and IBDs: Complementary Views of a Block 66 4.6 Part Properties 67 4.7 Reference Properties 67 4.8 Connectors 68 4.9 Item Flows 71 4.10 Nested Parts and References 72 Chapter 5: Use Case Diagrams 77 5.1 Purpose 77 5.2 When Should You Create a Use Case Diagram? 77 5.3 Wait! What’s a Use Case? 78 5.4 The Use Case Diagram Frame 81 5.5 Use Cases 82 5.6 System Boundary 83 5.7 Actors 83 5.8 Associating Actors with Use Cases 84 5.9 Base Use Cases 85 5.10 Included Use Cases 85 5.11 Extending Use Cases 87 Chapter 6: Activity Diagrams 89 6.1 Purpose 89 6.2 When Should You Create an Activity Diagram? 90 6.3 The Activity Diagram Frame 90 6.4 A Word about Token Flow 92 6.5 Actions: The Basics 93 6.6 Object Nodes 95 6.7 Edges 99 6.8 Actions, Revisited 102 6.9 Control Nodes 112 6.10 Activity Partitions: Allocating Behaviors to Structures 119 Chapter 7: Sequence Diagrams 123 7.1 Purpose 123 7.2 When Should You Create a Sequence Diagram? 124 7.3 The Sequence Diagram Frame 125 7.4 Lifelines 125 7.5 Messages 129 7.6 Destruction Occurrences 138 7.7 Execution Specifications 139 7.8 Constraints 141 7.9 Combined Fragments 144 7.10 Interaction Uses 151 Chapter 8: State Machine Diagrams 155 8.1 Purpose 155 8.2 When Should You Create a State Machine Diagram? 156 8.3 The State Machine Diagram Frame 156 8.4 States 158 8.5 Transitions 162 8.6 Pseudostates 171 8.7 Regions 173 Chapter 9: Parametric Diagrams 177 9.1 Purpose 177 9.2 When Should You Create a Parametric Diagram? 178 9.3 Blocks, Revisited 179 9.4 The Parametric Diagram Frame 182 9.5 Constraint Properties 184 9.6 Constraint Parameters 185 9.7 Value Properties 185 9.8 Binding Connectors 187 Chapter 10: Package Diagrams 189 10.1 Purpose 189 10.2 When Should You Create a Package Diagram? 190 10.3 The Package Diagram Frame 190 10.4 Notations for Namespace Containment 191 10.5 Dependencies between Packages 193 10.6 Importing Packages 193 10.7 Specialized Packages 194 10.8 Shades of Gray: Are You Looking at a Package Diagram or a Block Definition Diagram? 198 Chapter 11: Requirements Diagrams 201 11.1 Purpose 201 11.2 When Should You Create a Requirements Diagram? 202 11.3 The Requirements Diagram Frame 202 11.4 Requirements 204 11.5 Requirements Relationships 205 11.6 Notations for Requirements Relationships 209 11.7 Rationale 213 Chapter 12: Allocations: Cross-Cutting Relationships 215 12.1 Purpose 215 12.2 There’s No Such Thing as an Allocation Diagram 216 12.3 Uses for Allocation Relationships 216 12.4 Notations for Allocation Relationships 219 12.5 Rationale 224 Appendix A: SysML Notation Desk Reference 227 Appendix B: Changes between SysML Versions 245 Bibliography 253 Index 255

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 SynopsisThe design and analysis of efficient data structures has long been recognized as a key component of the Computer Science curriculum. Goodrich and Tomassia's approach to this classic topic is based on the object-oriented paradigm as the framework of choice for the design of data structures.Table of Contents1 Java Primer 2 Object-Oriented Design 3 Fundamental Data Structures 4 Algorithm Analysis 5 Recursion 6 Stacks, Queues, and Deques 7 List and Iterator ADTs 8 Trees 9 Priority Queues 10 Maps, Hash Tables, and Skip Lists 11 Search Trees 12 Text Processing13 Sorting and Selection 14 Graph Algorithms 15 Memory Management and B-Trees

Read more less

Book SynopsisIf you're one of the many developers uncertain about concurrent and multithreaded development, this practical cookbook will change your mind. With more than 75 code-rich recipes, author Stephen Cleary demonstrates parallel processing and asynchronous programming techniques, using libraries and language features in .NET and C#.

Read more less

Book SynopsisUnlike any other programming language, Haskell is purely functionalwith a strong type system and lazy evaluation. It is arguable the mostinteresting language but also has the reputation of being one of themost challenging to learn. Learning Haskell doesn't have to bedifficult, and this book can help! Get Programming with Haskell introduces you to the Haskell languagewithout drowning you in academic jargon and heavy functionalprogramming theory. By working through 43 easy-to-follow lessons,you'll learn Haskell by doing Haskell. This book starts with firstconcepts, building your knowledge with concrete examples andexercises. You'll learn to think the Haskell way, as you start tounderstand the language and how to use it effectively. And you'll reallyappreciate the crystal-clear illustrations, quick-checks, and open-endedtasks that make sure you're solid on each new concept before you movealong! KEY FEATURES• Full of interesting examples• Easy approach to functional programming basics• Write safe, predictable code with fewer bugs• Lots of illustrations and exercises Readers should have some experience with JavaScript, Python orRuby. No functional programming or math skills required. ABOUT THE TECHNOLOGYHaskell is a purely functional programming language. It treats programs asmuch like math as you can, requires you to think more than you type, andcan express the idea of infinite lists in code! These are just the more obviousfeatures that make Haskell unlike any other programming language AUTHOR BIOWill Kurt currently works as a Data Scientist at Quick Sprout. With aformal background in both Computer Science (MS) and English Literature(BA) he is fascinated with explaining complex technical topics as clearlyand generally as possible. He has taught a course section on Haskell at theUniversity of Nevada, Reno and given workshops on FunctionalProgramming. He also blogs about probability at CountBayesie.com.

Read more less

Book SynopsisTable of ContentsForeword xv Preface xvii Acknowledgments xxi About the Authors xxiii PART I: INTRODUCTION 1 Chapter 1: What Is the Point of Test-Driven Development? 3 Software Development as a Learning Process 3 Feedback Is the Fundamental Tool 4 Practices That Support Change 5 Test-Driven Development in a Nutshell 6 The Bigger Picture 7 Testing End-to-End 8 Levels of Testing 9 External and Internal Quality 10 Chapter 2: Test-Driven Development with Objects 13 A Web of Objects 13 Values and Objects 13 Follow the Messages 14 Tell, Don’t Ask 17 But Sometimes Ask 17 Unit-Testing the Collaborating Objects 18 Support for TDD with Mock 19 Chapter 3: An Introduction to the Tools 21 Stop Me If You’ve Heard This One Before 21 A Minimal Introduction to JUnit 4 21 Hamcrest Matchers and assertThat() 24 jMock2: Mock Objects 25 PART II: THE PROCESS OF TEST-DRIVEN DEVELOPMENT 29 Chapter 4: Kick-Starting the Test-Driven Cycle 31 Introduction 31 First, Test a Walking Skeleton 32 Deciding the Shape of the Walking Skeleton 33 Build Sources of Feedback 35 Expose Uncertainty Early 36 Chapter 5: Maintaining the Test-Driven Cycle 39 Introduction 39 Start Each Feature with an Acceptance Test 39 Separate Tests That Measure Progress from Those That Catch Regressions 40 Start Testing with the Simplest Success Case 41 Write the Test That You’d Want to Read 42 Watch the Test Fail 42 Develop from the Inputs to the Outputs 43 Unit-Test Behavior, Not Methods 43 Listen to the Tests 44 Tuning the Cycle 45 Chapter 6: Object-Oriented Style 47 Introduction 47 Designing for Maintainability 47 Internals vs. Peers 50 No And’s, Or’s, or But’s 51 Object Peer Stereotypes 52 Composite Simpler Than the Sum of Its Parts 53 Context Independence 54 Hiding the Right Information 55 An Opinionated View 56 Chapter 7: Achieving Object-Oriented Design 57 How Writing a Test First Helps the Design 57 Communication over Classification 58 Value Types 59 Where Do Objects Come From? 60 Identify Relationships with Interfaces 63 Refactor Interfaces Too 63 Compose Objects to Describe System Behavior 64 Building Up to Higher-Level Programming 65 And What about Classes? 67 Chapter 8: Building on Third-Party Code 69 Introduction 69 Only Mock Types That You Own 69 Mock Application Objects in Integration Tests 71 PART III: A WORKED EXAMPLE 73 Chapter 9: Commissioning an Auction Sniper 75 To Begin at the Beginning 75 Communicating with an Auction 78 Getting There Safely 79 This Isn’t Real 81 Chapter 10: The Walking Skeleton 83 Get the Skeleton out of the Closet 83 Our Very First Test 84 Some Initial Choices 86 Chapter 11: Passing the First Test 89 Building the Test Rig 89 Failing and Passing the Test 95 The Necessary Minimum 102 Chapter 12: Getting Ready to Bid 105 An Introduction to the Market 105 A Test for Bidding 106 The AuctionMessageTranslator 112 Unpacking a Price Message 118 Finish the Job 121 Chapter 13: The Sniper Makes a Bid 123 Introducing AuctionSniper 123 Sending a Bid 126 Tidying Up the Implementation 131 Defer Decisions 136 Emergent Design 137 Chapter 14: The Sniper Wins the Auction 139 First, a Failing Test 139 Who Knows about Bidders? 140 The Sniper Has More to Say 143 The Sniper Acquires Some State 144 The Sniper Wins 146 Making Steady Progress 148 Chapter 15: Towards a Real User Interface 149 A More Realistic Implementation 149 Displaying Price Details 152 Simplifying Sniper Events 159 Follow Through 164 Final Polish 168 Observations 171 Chapter 16: Sniping for Multiple Items 175 Testing for Multiple Items 175 Adding Items through the User Interface 183 Observations 189 Chapter 17: Teasing Apart Main 191 Finding a Role 191 Extracting the Chat 192 Extracting the Connection 195 Extracting the SnipersTableModel 197 Observations 201 Chapter 18: Filling In the Details 205 A More Useful Application 205 Stop When We’ve Had Enough 205 Observations 212 Chapter 19: Handling Failure 215 What If It Doesn’t Work? 215 Detecting the Failure 217 Displaying the Failure 218 Disconnecting the Sniper 219 Recording the Failure 221 Observations 225 PART IV: SUSTAINABLE TEST-DRIVEN DEVELOPMENT 227 Chapter 20: Listening to the Tests 229 Introduction 229 I Need to Mock an Object I Can’t Replace (without Magic) 230 Logging Is a Feature 233 Mocking Concrete Classes 235 Don’t Mock Values 237 Bloated Constructor 238 Confused Object 240 Too Many Dependencies 241 Too Many Expectations 242 What the Tests Will Tell Us (If We’re Listening) 244 Chapter 21: Test Readability 247 Introduction 247 Test Names Describe Features 248 Canonical Test Structure 251 Streamline the Test Code 252 Assertions and Expectations 254 Literals and Variables 255 Chapter 22: Constructing Complex Test Data 257 Introduction 257 Test Data Builders 258 Creating Similar Objects 259 Combining Builders 261 Emphasizing the Domain Model with Factory Methods 261 Removing Duplication at the Point of Use 262 Communication First 264 Chapter 23: Test Diagnostics 267 Design to Fail 267 Small, Focused, Well-Named Tests 268 Explanatory Assertion Messages 268 Highlight Detail with Matchers 268 Self-Describing Value 269 Obviously Canned Value 270 Tracer Object 270 Explicitly Assert That Expectations Were Satisfied 271 Diagnostics Are a First-Class Feature 271 Chapter 24: Test Flexibility 273 Introduction 273 Test for Information, Not Representation 274 Precise Assertions 275 Precise Expectations 277 “Guinea Pig” Objects 284 PART V: ADVANCED TOPICS 287 Chapter 25: Testing Persistence 289 Introduction 289 Isolate Tests That Affect Persistent State 290 Make Tests Transaction Boundaries Explicit 292 Testing an Object That Performs Persistence Operations 294 Testing That Objects Can Be Persisted 297 But Database Tests Are S-l-o-w! 300 Chapter 26: Unit Testing and Threads 301 Introduction 301 Separating Functionality and Concurrency Policy 302 Unit-Testing Synchronization 306 Stress-Testing Passive Objects 311 Synchronizing the Test Thread with Background Threads 312 The Limitations of Unit Stress Tests 313 Chapter 27: Testing Asynchronous Code 315 Introduction 315 Sampling or Listening 316 Two Implementations 318 Runaway Tests 322 Lost Updates 323 Testing That an Action Has No Effect 325 Distinguish Synchronizations and Assertions 326 Externalize Event Sources 326 Afterword: A Brief History of Mock Objects 329 Appendix A: jMock2 Cheat Sheet 335 Appendix B: Writing a Hamcrest Matcher 343 Bibliography 347 Index 349

Read more less

Book SynopsisGet ready to take on Pythonwithapracticaland job-focused guide Job Ready Pythonoffers readers a straightforward and elegant approach to learning Python that emphasizes hands-on and employable skillsyou can apply to real-world environments immediately. Based on therenownedmthreeGlobal Academy and Software Guild training program, this book will get you up to speed in the basics of Python, loops and data structures, object-oriented programming, and data processing.You'll alsoget: Thorough discussions ofExtract, Transform, and Load (ETL) scripting in PythonExplorations of databases, including MySQL, and MongoDBall commonly used database platforms in the fieldSimple, step-by-step approaches to dealing with dates and times, CSV files, and JSON files Ideal forPython newbies looking to make a transition to an exciting new career,Job Ready Pythonalso belongs on the bookshelves of Python developershoping to brush up on the fundamentals with an authoritative and practical new handbook.Table of ContentsAbout the Authors v About the Technical Writer v About the Technical Editor v Acknowledgments vi Introduction xvii Part I: Getting Started with Python 1 Lesson 1: Setting Up a Python Programming Environment 3 Python Overview 4 Using Replit Online 4 Getting Started with Jupyter Notebook 14 A Quick Look at Visual Studio Code 21 Using Python from the Command Line 24 Summary 26 Exercises 26 Lesson 2: Understanding Programming Basics 29 The Future of Computer Programming 30 Programming Languages 32 Data Types and Variables 37 Variables 40 Constants 44 Summary 46 Exercises 46 Lesson 3: Exploring Basic Python Syntax 49 Using with Single- Line Commands 51 Using Semicolons 52 Continuing with Backslash 54 Working with Case Structure 55 Adding Comments 56 Using the Input Function 57 Storing Input 59 Understanding Variable Types 61 Displaying Variable Values 62 Naming Variables 64 Summary 65 Exercises 65 Lesson 4: Working with Basic Python Data Types 69 Review of Data Types 70 Number Data Types 70 Identifying Data Types 72 Mathematical Operations 74 Pemdas 77 Common Math Functions 81 Math Library Functions 83 Using Numbers with User Input 86 Boolean Types and Boolean Operations 89 Logic Operations 92 Comparative Operators 95 Summary 96 Exercises 97 Lesson 5: Using Python Control Statements 101 Control Structures Review 101 Understanding Sequence Control Structure 102 Understanding Selection Statements 103 Understanding Conditional Statements 106 If- Else Statements 108 Working with Nested Conditions 109 Embedding Conditions 112 Summary 114 Exercises 114 Lesson 6: Pulling It All Together: Income Tax Calculator 117 Getting Started 118 Step 1: Gather Requirements 118 Step 2: Design the Program 120 Step 3: Create the Inputs 120 Step 4: Calculate the Taxable Income 122 Step 5: Calculate the Tax Rate 124 Step 6: Update the Application 133 Step 7: Address the UI 136 On Your Own 139 Summary 139 Part II: Loops and Data Structures 141 Lesson 7: Controlling Program Flow with Loops 143 Iterations Overview 144 The Anatomy of a Loop 144 The for Loop 145 The while Loop 146 for vs. while Loops 149 Strings and String Operations 151 Iterating through Strings 164 Summary 167 Exercises 167 Lesson 8: Understanding Basic Data Structures: Lists 173 Data Structure Overview—Part 1 174 Creating Lists 175 Determining List Length 179 Working with List Indexes 179 Negative Indexing in Lists 182 Slicing Lists 184 Adding Items to a List 189 Inserting List Items 190 Removing List Items 192 Concatenating Lists 196 List Comprehension 197 Sorting Lists 199 Copying Lists 200 Summary 202 Exercises 202 Lesson 9: Understanding Basic Data Structures: Tuples 205 Tuples and Tuple Operations 206 Tuple Index Values 209 Negative Indexing in Tuples 210 Slicing Tuples 212 Immutability 213 Concatenating Tuples 216 Searching Tuples 217 Summary 218 Exercises 219 Lesson 10: Diving Deeper into Data Structures: Dictionaries 223 Data Structure Overview— Part 2 224 Getting Started with Dictionaries 224 Generating a Dictionary 227 Retrieving Items from a Dictionary 230 Using the keys() Method 233 Using the items() Method 234 Reviewing the keys(), values(), and items() Methods 236 Using the get() Method 239 Using the pop() Method 241 Working with the in Operator 245 Updating a Dictionary 246 Duplicating a Dictionary 249 Clearing a Dictionary 254 Summary 255 Exercises 255 Lesson 11: Diving Deeper into Data Structures: Sets 259 Sets 260 Retrieving Items from a Set 261 Adding Items to a Set 262 Creating an Empty Set 262 Understanding Set Uniqueness 263 Searching Items in a Set 265 Calculating the Length of a Set 267 Deleting Items from a Set 268 Clearing a Set 270 Popping Items in a Set 272 Deleting a Set 273 Determining the Difference Between Sets 274 Intersecting Sets 277 Combining Sets 278 Summary 279 Exercises 279 Lesson 12: Pulling It All Together: Prompting for an Address 283 Step 1: Getting Started 284 Step 2: Accept User Input 285 Step 3: Display the Input Value 286 Step 4: Modify the Output 287 Step 5: Split a Text Value 288 Step 6: Display Only the House Number 290 Step 7: Display the Street Name 291 Step 8: Add the Period 292 Summary 293 Lesson 13: Organizing with Functions 295 Functions Overview 295 Defining Functions in Python 296 Function Syntax 300 Default Input Values 301 Parameter Syntax 303 Arbitrary Arguments 304 Keyword Arguments 306 Arbitrary Keyword Arguments 306 Summary 308 Exercises 309 Part III: Object- Oriented Programming in Python 311 Lesson 14: Incorporating Object- Oriented Programming 313 Object- Oriented Programming Overview 314 Defining Classes 314 Creating Objects 316 Working with Methods 319 Class Attributes 324 Summary 330 Exercises 330 Lesson 15: Including Inheritance 333 Understanding Inheritance 334 Creating a Parent Class 335 Creating a Child Class 335 Inheriting at Multiple Levels 338 Overriding Methods 340 Summary 343 Exercises 344 Lesson 16: Pulling It All Together: Building a Burger Shop 349 Requirements for Our Application 350 Plan the Code 350 Create the Classes 351 Create the Food Item Class 352 Create the Main File 357 Display the Output 364 Tie the Code Files Together 364 Summary 368 Part IV: Data Processing with Python 369 Lesson 17: Working with Dates and Times 371 Getting Started with Dates and Times 372 Getting the Current Date and Time 376 Splitting a Date String 377 Using datetime Attributes 379 Creating Custom datetime Objects 380 Compare datetime Values 381 Working with UTC Format 383 Applying Timestamps 384 Arithmetic and Dates 387 Calculating the Difference in Days 388 Using Date without Time 390 Using Time without Date 392 Summary 394 Exercises 394 Calculator 1: Time Duration 396 Calculator 2: Add or Subtract Time from a Date 397 Calculator 3: Age Calculator 397 Lesson 18: Processing Text Files 399 File Processing Overview 401 Introduction to File Input/Output 402 Processing Text Files 404 Opening a File 404 Reading Text from a File 406 Add Content to a File 412 Overwriting the Contents of a File 415 Creating a New File 417 Using the os Module 418 Deleting a File 419 Summary 421 Exercises 421 Lesson 19: Processing CSV Files 425 Reading CSV Files 426 Using the DictReader Class 430 Creating a Dataset List 432 Using writerow() 434 Appending Data 436 Writing Rows as Lists 439 Writing Rows from Dictionaries 440 Summary 444 Exercises 444 Lesson 20: Processing JSON Files 447 Processing JSON Files 448 Creating a JSON File with dump() 448 Converting to JSON with dumps() 449 Formatting JSON Data 450 Using json.loads() 452 Iterating through JSON Data 454 Reading and Writing JSON Data 457 Summary 460 Exercises 461 Part V: Data Analysis and Exception Handling 465 Lesson 21: Using Lambdas 467 Creating a Lambda Function 468 Working with Multiple Inputs 469 Placing Lambda Functions inside a Function 471 Using the map() Function 472 Combining Map and Lambda Functions 475 Using the filter() Function 477 Combining a Filter and a Lambda 479 Using the reduce() Function 480 Summary 486 Exercises 486 Lesson 22: Handling Exceptions 491 Built- In Exceptions 492 Working with try and except 493 Working with Multiple Excepts 495 Combining Exception Types 498 Using Multiple Operations in a try 500 Using the raise Keyword 501 Exploring the General Exception Classes 502 Adding finally 505 Summary 506 Exercises 506 Lesson 23: Pulling It All Together: Word Analysis in Python 511 Examine the Data 512 Read the Data 514 Tokenize the Dataset 517 Count the Words in Each Review 524 Summary 528 Lesson 24: Extracting, Transforming, and Loading with ETL Scripting 531 ETL Scripting in Python 532 Design and Implement Custom ETL Scripts 532 The extract Class 534 The transform Class 546 The load Class 569 Summary 582 Exercises 582 Lesson 25: Improving ETL Scripting 585 Converting to Static Methods for the extract Class 586 Converting to Static Methods for the transform Class 588 Summary 607 Exercises 608 Part VI: Appendices 611 Appendix A: Flowcharts 613 Flowchart Basics 613 Common Flowcharting Shapes 615 Appendix B: Creating Pseudocode 621 What Is Pseudocode? 621 Appendix C: Installing MySQL 623 MySQL Installation 623 Verify the Installation 628 The MySQL Notifier 630 Appendix D: Installing Vinyl DB 631 Database Structure 631 Create the Database 632 Appendix E: Installing MongoDB 637 Installing MongoDB Community Server 637 Running MongoDB 642 Appendix F: Importing to MongoDB 643 Index 645

Read more less

Book SynopsisThink Java is a hands-on introduction to computer science and programming used by many universities and high schools around the world. Its conciseness, emphasis on vocabulary, and informal tone make it particularly appealing for readers with little or no experience.

Read more less

Book SynopsisWith DApps built on the Ethereum blockchain, users can establish persistent, reliable ownership records for actions such as buying a car or a house with smart contracts to enforce blockchain-based verification before a transaction can be completed. Building Ethereum ĐApps introduces readers to decentralized applications based on the Ethereum blockchain platform. They’ll discover how to design smart contracts to enforce transaction rules, and then implement them in Ethereum's JavaScript-like Solidity language. Key Features · Understanding decentralized applications and the underlying technologies · Learning the key components of the Ethereum platform · Implementing smart contracts in Solidity Audience Written for developers with intermediate experience in an OO language or in JavaScript. Some understanding and experience with blockchain concepts is helpful. Author Bio Roberto Infante is an independent software development consultant who specializes in finance. Throughout his career, he has worked on a variety of innovative projects, such as the first internet mortgage approval system in the UK and one of the first online insurance underwriting systems in London.

Read more less

Book SynopsisRuby is one of the most important programming languages in use for web development. It powers the Rails framework, which is the backing of some of the most important sites on the web. The Pickaxe Book, named for the tool on the cover, is the definitive reference on Ruby, a highly-regarded, fully object-oriented programming language. This updated edition is a comprehensive reference on the language itself, with a tutorial on the most important features of Ruby - including pattern matching and Ractors - and describes the language through Ruby 3.2. Would you like to go from first idea to working code much, much faster? Do you currently spend more time satisfying the compiler instead of your clients or end users? Are you frustrated with demanding languages that seem to get in your way instead of helping you get the work done? Are you using Rails and want to dig deeper into the underlying Ruby language? If so, then we've got a language and book for you! Ruby is a fully object-oriented language. The combination of the power of a pure object-oriented language with the convenience of a scripting language makes Ruby a favorite tool of programmers that want to get things done quickly and cleanly. This comprehensive reference manual for Ruby includes a description of the most important standard library modules, built-in classes, and modules. It also includes all the new and changed syntax and semantics introduced through Ruby 3.2, including pattern matching and Ractors, and describes the language through Ruby 3.2. What You Need: This book assumes you have a basic understanding of object-oriented programming. In general, Ruby programmers tend to favor the the command line for running their code, and they tend to use text editors rather than IDEs. Ruby runs on Windows, Linux, and MacOS.

Read more less

Book SynopsisMachine Learning Engineering in Action lays out an approach to building deployable, maintainable production machine learning systems. You will adopt software development standards that deliver better code management, and make it easier to test, scale, and even reuse your machine learning code! You will learn how to plan and scope your project, manage cross-team logistics that avoid fatal communication failures, and design your code's architecture for improved resilience. You will even discover when not to use machine learning—and the alternative approaches that might be cheaper and more effective. When you're done working through this toolbox guide, you will be able to reliably deliver cost-effective solutions for organizations big and small alike. Following established processes and methodology maximizes the likelihood that your machine learning projects will survive and succeed for the long haul. By adopting standard, reproducible practices, your projects will be maintainable over time and easy for new team members to understand and adapt. Trade Review“Anice view on practical data science and machine learning. Great reading fornewbies, some interesting views for seasoned practitioners.” Johannes Verwijnen “Amust read for those looking to balance the planning and experimentationlifecycle.” Jesús Antonino Juárez Guerrero “Apractical book to help engineers understand the workflow of machine learningprojects.” Xiangbo Mao “Donot implement your ML model into production without reading this book!” Lokesh Kumar

Read more less

Book SynopsisWith this book, experienced C++ developers will get a thorough, practical, and unparalleled overview of software design with this modern language.

Read more less

Book SynopsisUnlock the power of Python in ArcGIS Pro with this definitive, easy-to-follow guide designed for users with limited programming or scripting experience.Get started learning to write Python scripts to automate tasks in ArcGIS Pro with Python Scripting for ArcGIS Pro. This book begins with the fundamentals of Python programming and then dives into how to write useful Python scripts that work with spatial data in ArcGIS Pro. You'll learn how to use geoprocessing tools; describe, create, and update data; and execute specialized tasks. With step-by-step instructions, practical examples, and insightful guidance, you'll be able to write scripts that will automate and improve your ArcGIS Pro workflows.This third edition has been revised for ArcGIS Pro 3.2 and Python 3.9.18 and includes updated images; a fully updated chapter 2; and expanded chapters 4, 8, 9, and 10.The key topics you will learn include: Python fundamentals Setting up a Python editor Automating geoprocessing tasks using ArcPy Exploring and manipulating spatial and tabular data Working with geometries using cursors Working with rasters and map algebra Map scripting Debugging and error handling Helpful points to remember, key terms, and review questions are included at the end of each chapter to reinforce your understanding of Python. Corresponding data and tutorials are available online.Whether you're new to Python or already have some experience, Python Scripting for ArcGIS Pro is the go-to resource for learning the versatility of Python coding to solve problems and enhance productivity and efficiency in ArcGIS Pro.

Read more less

Book SynopsisMethods for managing complex software construction following the practices, principles and patterns of Domain-Driven Design with code examples in C# This book presents the philosophy of Domain-Driven Design (DDD) in a down-to-earth and practical manner for experienced developers building applications for complex domains.Table of ContentsINTRODUCTION xxxv PART I: THE PRINCIPLES AND PRACTICES OF DOMAIN‐DRIVEN DESIGN CHAPTER 1: WHAT IS DOMAIN‐DRIVEN DESIGN? 3 The Challenges of Creating Software for Complex Problem Domains 4 Code Created Without a Common Language 4 A Lack of Organization 5 The Ball of Mud Pattern Stifles Development 5 A Lack of Focus on the Problem Domain 6 How the Patterns of Domain‐Driven Design Manage Complexity 6 The Strategic Patterns of DDD 6 Distilling the Problem Domain to Reveal What Is Important 7 Creating a Model to Solve Domain Problems 7 Using a Shared Language to Enable Modeling Collaboration 7 Isolate Models from Ambiguity and Corruption 8 Understanding the Relationships between Contexts 9 The Tactical Patterns of DDD 9 The Problem Space and the Solution Space 9 The Practices and Principles of Domain‐Driven Design 11 Focusing on the Core Domain 11 Learning through Collaboration 11 Creating Models through Exploration and Experimentation 11 Communication 11 Understanding the Applicability of a Model 12 Constantly Evolving the Model 12 Popular Misconceptions of Domain‐Driven Design 12 Tactical Patterns Are Key to DDD 12 DDD Is a Framework 13 DDD Is a Silver Bullet 13 The Salient Points 13 CHAPTER 2: DISTILLING THE PROBLEM DOMAIN 15 Knowledge Crunching and Collaboration 15 Reaching a Shared Understanding through a Shared Language 16 The Importance of Domain Knowledge 17 The Role of Business Analysts 17 An Ongoing Process 17 Gaining Domain Insight with Domain Experts 18 Domain Experts vs Stakeholders 18 Deeper Understanding for the Business 19 Engaging with Your Domain Experts 19 Patterns for Effective Knowledge Crunching 19 Focus on the Most Interesting Conversations 19 Start from the Use Cases 20 Ask Powerful Questions 20 Sketching 20 Class Responsibility Collaboration Cards 21 Defer the Naming of Concepts in Your Model 21 Behavior‐Driven Development 22 Rapid Prototyping 23 Look at Paper‐Based Systems 24 Look For Existing Models 24 Understanding Intent 24 Event Storming 25 Impact Mapping 25 Understanding the Business Model 27 Deliberate Discovery 28 Model Exploration Whirlpool 29 The Salient Points 29 CHAPTER 3: FOCUSING ON THE CORE DOMAIN 31 Why Decompose a Problem Domain? 31 How to Capture the Essence of the Problem 32 Look Beyond Requirements 32 Capture the Domain Vision for a Shared Understanding of What Is Core 32 How to Focus on the Core Problem 33 Distilling a Problem Domain 34 Core Domains 35 Treat Your Core Domain as a Product Rather than a Project 36 Generic Domains 37 Supporting Domains 37 How Subdomains Shape a Solution 37 Not All Parts of a System will be Well Designed 37 Focus on Clean Boundaries over Perfect Models 38 The Core Domain Doesn’t Always Have to Be Perfect the First Time 39 Build Subdomains for Replacement Rather than Reuse 39 What if You Have no Core Domain? 39 The Salient Points 40 CHAPTER 4: MODEL‐DRIVEN DESIGN 41 What Is a Domain Model? 42 The Domain versus the Domain Model 42 The Analysis Model 43 The Code Model 43 The Code Model Is the Primary Expression of the Domain Model 44 Model‐Driven Design 44 The Challenges with Upfront Design 44 Team Modeling 45 Using a Ubiquitous Language to Bind the Analysis to the Code Model 47 A Language Will Outlive Your Software 47 The Language of the Business 48 Translation between the Developers and the Business 48 Collaborating on a Ubiquitous Language 48 Carving Out a Language by Working with Concrete Examples 49 Teach Your Domain Experts to Focus on the Problem and Not Jump to a Solution 50 Best Practices for Shaping the Language 51 How to Create Effective Domain Models 52 Don’t Let the Truth Get in the Way of a Good Model 52 Model Only What Is Relevant 54 Domain Models Are Temporarily Useful 54 Be Explicit with Terminology 54 Limit Your Abstractions 54 Focus Your Code at the Right Level of Abstraction 55 Abstract Behavior Not Implementations 55 Implement the Model in Code Early and Often 56 Don’t Stop at the First Good Idea 56 When to Apply Model‐Driven Design 56 If It’s Not Worth the Effort Don’t Try and Model It 56 Focus on the Core Domain 57 The Salient Points 57 CHAPTER 5: DOMAIN MODEL IMPLEMENTATION PATTERNS 59 The Domain Layer 60 Domain Model Implementation Patterns 60 Domain Model 62 Transaction Script 65 Table Module 67 Active Record 67 Anemic Domain Model 67 Anemic Domain Model and Functional Programming 68 The Salient Points 71 CHAPTER 6: MAINTAINING THE INTEGRITY OF DOMAIN MODELS WITH BOUNDED CONTEXTS 73 The Challenges of a Single Model 74 A Model Can Grow in Complexity 74 Multiple Teams Working on a Single Model 74 Ambiguity in the Language of the Model 75 The Applicability of a Domain Concept 76 Integration with Legacy Code or Third Party Code 78 Your Domain Model Is not Your Enterprise Model 79 Use Bounded Contexts to Divide and Conquer a Large Model 79 Defining a Model’s Boundary 82 Define Boundaries around Language 82 Align to Business Capabilities 83 Create Contexts around Teams 83 Try to Retain Some Communication between Teams 84 Context Game 85 The Difference between a Subdomain and a Bounded Context 85 Implementing Bounded Contexts 85 The Salient Points 89 CHAPTER 7: CONTEXT MAPPING 91 A Reality Map 92 The Technical Reality 92 The Organizational Reality 93 Mapping a Relevant Reality 94 X Marks the Spot of the Core Domain 94 Recognising the Relationships between Bounded Contexts 95 Anticorruption Layer 95 Shared Kernel 96 Open Host Service 97 Separate Ways 97 Partnership 98 An Upstream/Downstream Relationship 98 Customer‐Supplier 99 Conformist 100 Communicating the Context Map 100 The Strategic Importance of Context Maps 101 Retaining Integrity 101 The Basis for a Plan of Attack 101 Understanding Ownership and Responsibility 101 Revealing Areas of Confusion in Business Work Flow 102 Identifying Nontechnical Obstacles 102 Encourages Good Communication 102 Helps On‐Board New Starters 102 The Salient Points 103 CHAPTER 8: APPLICATION ARCHITECTURE 105 Application Architecture 105 Separating the Concerns of Your Application 106 Abstraction from the Complexities of the Domain 106 A Layered Architecture 106 Dependency Inversion 107 The Domain Layer 107 The Application Service Layer 108 The Infrastructural Layers 108 Communication Across Layers 108 Testing in Isolation 109 Don t Share Data Schema between Bounded Contexts 109 Application Architectures versus Architectures for Bounded Contexts 111 Application Services 112 Application Logic versus Domain Logic 114 Defining and Exposing Capabilities 114 Business Use Case Coordination 115 Application Services Represent Use Cases, Not Create, Read, Update, and Delete 115 Domain Layer As an Implementation Detail 115 Domain Reporting 116 Read Models versus Transactional Models 116 Application Clients 117 The Salient Points 120 CHAPTER 9: COMMON PROBLEMS FOR TEAMS STARTING OUT WITH DOMAIN‐DRIVEN DESIGN 121 Overemphasizing the Importance of Tactical Patterns 122 Using the Same Architecture for All Bounded Contexts 122 Striving for Tactical Pattern Perfection 122 Mistaking the Building Blocks for the Value of DDD 123 Focusing on Code Rather Than the Principles of DDD 123 Missing the Real Value of DDD: Collaboration, Communication, and Context 124 Producing a Big Ball of Mud Due to Underestimating the Importance of Context 124 Causing Ambiguity and Misinterpretations by Failing to Create a UL 125 Designing Technical‐Focused Solutions Due to a Lack of Collaboration 125 Spending Too Much Time on What’s Not Important 126 Making Simple Problems Complex 126 Applying DDD Principles to a Trivial Domain with Little Business Expectation 126 Disregarding CRUD as an Antipattern 127 Using the Domain Model Pattern for Every Bounded Context 127 Ask Yourself: Is It Worth This Extra Complexity? 127 Underestimating the Cost of Applying DDD 127 Trying to Succeed Without a Motivated and Focused Team 128 Attempting Collaboration When a Domain Expert Is Not Behind the Project 128 Learning in a Noniterative Development Methodology 128 Applying DDD to Every Problem 129 Sacrificing Pragmatism for Needless Purity 129 Wasted Effort by Seeking Validation 129 Always Striving for Beautiful Code 130 DDD Is About Providing Value 130 The Salient Points 130 CHAPTER 10: APPLYING THE PRINCIPLES, PRACTICES, AND PATTERNS OF DDD 131 Selling DDD 132 Educating Your Team 132 Speaking to Your Business 132 Applying the Principles of DDD 133 Understand the Vision 133 Capture the Required Behaviors 134 Distilling the Problem Space 134 Focus on What Is Important 134 Understand the Reality of the Landscape 135 Modeling a Solution 135 All Problems Are Not Created Equal 136 Engaging with an Expert 136 Select a Behavior and Model Around a Concrete Scenario 137 Collaborate with the Domain Expert on the Most Interesting Parts 137 Evolve UL to Remove Ambiguity 138 Throw Away Your First Model, and Your Second 138 Implement the Model in Code 139 Creating a Domain Model 139 Keep the Solution Simple and Your Code Boring 139 Carve Out an Area of Safety 140 Integrate the Model Early and Often 140 Nontechnical Refactoring 140 Decompose Your Solution Space 140 Rinse and Repeat 141 Exploration and Experimentation 142 Challenge Your Assumptions 142 Modeling Is a Continuous Activity 142 There Are No Wrong Models 142 Supple Code Aids Discovery 143 Making the Implicit Explicit 143 Tackling Ambiguity 144 Give Things a Name 145 A Problem Solver First, A Technologist Second 146 Don’t Solve All the Problems 146 How Do I Know That I Am Doing It Right? 146 Good Is Good Enough 147 Practice, Practice, Practice 147 The Salient Points 147 PART II: STRATEGIC PATTERNS: COMMUNICATING BETWEEN BOUNDED CONTEXTS CHAPTER 11: INTRODUCTION TO BOUNDED CONTEXT INTEGRATION 151 How to Integrate Bounded Contexts 152 Bounded Contexts Are Autonomous 153 The Challenges of Integrating Bounded Contexts at the Code Level 153 Multiple Bounded Contexts Exist within a Solution 153 Namespaces or Projects to Keep Bounded Contexts Separate 154 Integrating via the Database 155 Multiple Teams Working in a Single Codebase 156 Models Blur 156 Use Physical Boundaries to Enforce Clean Models 157 Integrating with Legacy Systems 158 Bubble Context 158 Autonomous Bubble Context 158 Exposing Legacy Systems as Services 160 Integrating Distributed Bounded Contexts 161 Integration Strategies for Distributed Bounded Contexts 161 Database Integration 162 Flat File Integration 163 RPC 164 Messaging 165 REST 165 The Challenges of DDD with Distributed Systems 165 The Problem with RPC 166 RPC Is Harder to Make Resilient 167 RPC Costs More to Scale 167 RPC Involves Tight Coupling 168 Distributed Transactions Hurt Scalability and Reliability 169 Bounded Contexts Don’t Have to Be Consistent with Each Other 169 Eventual Consistency 169 Event‐Driven Reactive DDD 170 Demonstrating the Resilience and Scalability of Reactive Solutions 171 Challenges and Trade‐Offs of Asynchronous Messaging 173 Is RPC Still Relevant? 173 SOA and Reactive DDD 174 View Your Bounded Contexts as SOA Services 175 Decompose Bounded Contexts into Business Components 175 Decompose Business Components into Components 176 Going Even Further with Micro Service Architecture 178 The Salient Points 180 CHAPTER 12: INTEGRATING VIA MESSAGING 181 Messaging Fundamentals 182 Message Bus 182 Reliable Messaging 184 Store‐and‐Forward 184 Commands and Events 185 Eventual Consistency 186 Building an E‐Commerce Application with NServiceBus 186 Designing the System 187 Domain‐Driven Design 187 Containers Diagrams 188 Evolutionary Architecture 191 Sending Commands from a Web Application 192 Creating a Web Application to Send Messages with NServiceBus 192 Sending Commands 197 Handling Commands and Publishing Events 200 Creating an NServiceBus Server to Handle Commands 200 Configuring the Solution for Testing and Debugging 201 Publishing Events 204 Subscribing to Events 206 Making External HTTP Calls Reliable with Messaging Gateways 208 Messaging Gateways Improve Fault Tolerance 208 Implementing a Messaging Gateway 209 Controlling Message Retries 212 Eventual Consistency in Practice 215 Dealing with Inconsistency 215 Rolling Forward into New States 215 Bounded Contexts Store All the Data They Need Locally 216 Storage Is Cheap—Keep a Local Copy 217 Common Data Duplication Concerns 223 Pulling It All Together in the UI 224 Business Components Need Their Own APIs 225 Be Wary of Server‐Side Orchestration 226 UI Composition with AJAX Data 226 UI Composition with AJAX HTML 226 Sharing Your APIs with the Outside World 227 Maintaining a Messaging Application 227 Message Versioning 228 Backward‐Compatible Message Versioning 228 Handling Versioning with NServiceBus’s Polymorphic Handlers 229 Monitoring and Scaling 233 Monitoring Errors 233 Monitoring SLAs 234 Scaling Out 235 Integrating a Bounded Context with Mass Transit 235 Messaging Bridge 236 Mass Transit 236 Installing and Configuring Mass Transit 236 Declaring Messages for Use by Mass Transit 238 Creating a Message Handler 239 Subscribing to Events 239 Linking the Systems with a Messaging Bridge 240 Publishing Events 242 Testing It Out 243 Where to Learn More about Mass Transit 243 The Salient Points 243 CHAPTER 13: INTEGRATING VIA HTTP WITH RPC AND REST 245 Why Prefer HTTP? 247 No Platform Coupling 247 Everyone Understands HTTP 247 Lots of Mature Tooling and Libraries 247 Dogfooding Your APIs 247 RPC 248 Implementing RPC over HTTP 248 SOAP 249 Plain XML or JSON: The Modern Approach to RPC 259 Choosing a Flavor of RPC 263 REST 264 Demystifying REST 264 Resources 264 Hypermedia 265 Statelessness 265 REST Fully Embraces HTTP 266 What REST Is Not 267 REST for Bounded Context Integration 268 Designing for REST 268 Building Event‐Driven REST Systems with ASP.NET Web API 273 Maintaining REST Applications 303 Versioning 303 Monitoring and Metrics 303 Drawbacks with REST for Bounded Context Integration 304 Less Fault Tolerance Out of the Box 304 Eventual Consistency 304 The Salient Points 305 PART III: TACTICAL PATTERNS: CREATING EFFECTIVE DOMAIN MODELS CHAPTER 14: INTRODUCING THE DOMAIN MODELING BUILDING BLOCKS 309 Tactical Patterns 310 Patterns to Model Your Domain 310 Entities 310 Value Objects 314 Domain Services 317 Modules 318 Lifecycle Patterns 318 Aggregates 318 Factories 322 Repositories 323 Emerging Patterns 324 Domain Events 324 Event Sourcing 326 The Salient Points 327 CHAPTER 15: VALUE OBJECTS 329 When to Use a Value Object 330 Representing a Descriptive, Identity‐Less Concept 330 Enhancing Explicitness 331 Defining Characteristics 333 Identity‐Less 333 Attribute‐Based Equality 333 Behavior‐Rich 337 Cohesive 337 Immutable 337 Combinable 339 Self‐Validating 341 Testable 344 Common Modeling Patterns 345 Static Factory Methods 345 Micro Types (Also Known as Tiny Types) 347 Collection Aversion 349 Persistence 35 NoSQL 352 SQL 353 Flat Denormalization 353 Normalizing into Separate Tables 357 The Salient Points 359 CHAPTER 16: ENTITIES 36 Understanding Entities 362 Domain Concepts with Identity and Continuity 362 Context‐Dependent 363 Implementing Entities 363 Assigning Identifiers 363 Natural Keys 363 Arbitrarily Generated IDs 364 Datastore‐Generated IDs 368 Pushing Behavior into Value Objects and Domain Services 369 Validating and Enforcing Invariants 371 Focusing on Behavior, Not Data 374 Avoiding the “Model the Real‐World” Fallacy 377 Designing for Distribution 378 Common Entity Modeling Principles and Patterns 380 Implementing Validation and Invariants with Specifications 380 Avoid the State Pattern; Use Explicit Modeling 382 Avoiding Getters and Setters with the Memento Pattern 385 Favor Hidden‐Side‐Effect‐Free Functions 386 The Salient Points 388 CHAPTER 17: DOMAIN SERVICES 389 Understanding Domain Services 390 When to Use a Domain Service 390 Encapsulating Business Policies and Processes 390 Representing Contracts 394 Anatomy of a Domain Service 395 Avoiding Anemic Domain Models 395 Contrasting with Application Services 396 Utilizing Domain Services 397 In the Service Layer 397 In the Domain 398 Manually Wiring Up 399 Using Dependency Injection 400 Using a Service Locator 400 Applying Double Dispatch 401 Decoupling with Domain Events 402 Should Entities Even Know About Domain Services? 403 The Salient Points 403 CHAPTER 18: DOMAIN EVENTS 405 Essence of the Domain Events Pattern 406 Important Domain Occurrences That Have Already Happened 406 Reacting to Events 407 Optional Asynchrony 407 Internal vs External Events 408 Event Handling Actions 409 Invoke Domain Logic 409 Invoke Application Logic 410 Domain Events’ Implementation Patterns 410 Use the .Net Framework’s Events Model 410 Use an In‐Memory Bus 412 Udi Dahan’s Static DomainEvents Class 415 Handling Threading Issues 417 Avoid a Static Class by Using Method Injection 418 Return Domain Events 419 Use an IoC Container as an Event Dispatcher 421 Testing Domain Events 422 Unit Testing 422 Application Service Layer Testing 424 The Salient Points 425 CHAPTER 19: AGGREGATES 427 Managing Complex Object Graphs 428 Favoring a Single Traversal Direction 428 Qualifying Associations 430 Preferring IDs Over Object References 431 Aggregates 434 Design Around Domain Invariants 435 Higher Level of Domain Abstraction 435 Consistency Boundaries 435 Transactional Consistency Internally 436 Eventual Consistency Externally 439 Special Cases 440 Favor Smaller Aggregates 441 Large Aggregates Can Degrade Performance 441 Large Aggregates Are More Susceptible to Concurrency Conflicts 442 Large Aggregates May Not Scale Well 442 Defining Aggregate Boundaries 442 eBidder: The Online Auction Case Study 443 Aligning with Invariants 444 Aligning with Transactions and Consistency 446 Ignoring User Interface Influences 448 Avoiding Dumb Collections and Containers 448 Don’t Focus on HAS‐A Relationships 449 Refactoring to Aggregates 449 Satisfying Business Use Cases—Not Real Life 449 Implementing Aggregates 450 Selecting an Aggregate Root 450 Exposing Behavioral Interfaces 452 Protecting Internal State 453 Allowing Only Roots to Have Global Identity 454 Referencing Other Aggregates 454 Nothing Outside An Aggregate’s Boundary May Hold a Reference to Anything Inside 455 The Aggregate Root Can Hand Out Transient References to the Internal Domain Objects 456 Objects within the Aggregate Can Hold References to Other Aggregate Roots 456 Implementing Persistence 458 Access to Domain Objects for Reading Can Be at the Database Level 460 A Delete Operation Must Remove Everything within the Aggregate Boundary at Once 461 Avoiding Lazy Loading 461 Implementing Transactional Consistency 462 Implementing Eventual Consistency 463 Rules That Span Multiple Aggregates 463 Asynchronous Eventual Consistency 464 Implementing Concurrency 465 The Salient Points 468 CHAPTER 20: FACTORIES 469 The Role of a Factory 469 Separating Use from Construction 470 Encapsulating Internals 470 Hiding Decisions on Creation Type 472 Factory Methods on Aggregates 474 Factories for Reconstitution 475 Use Factories Pragmatically 477 The Salient Points 477 CHAPTER 21: REPOSITORIES 479 Repositories 479 A Misunderstood Pattern 481 Is the Repository an Antipattern? 481 The Difference between a Domain Model and a Persistence Model 482 The Generic Repository 483 Aggregate Persistence Strategies 486 Using a Persistence Framework That Can Map the Domain Model to the Data Model without Compromise 486 Using a Persistence Framework That Cannot Map the Domain Model Directly without Compromise 487 Public Getters and Setters 487 Using the Memento Pattern 488 Event Streams 49 Be Pragmatic 491 A Repository Is an Explicit Contract 492 Transaction Management and Units of Work 493 To Save or Not To Save 497 Persistence Frameworks That Track Domain Object Changes 497 Having to Explicitly Save Changes to Aggregates 498 The Repository as an Anticorruption Layer 499 Other Responsibilities of a Repository 500 Entity ID Generation 500 Collection Summaries 502 Concurrency 503 Audit Trails 506 Repository Antipatterns 506 Antipatterns: Don’t Support Ad Hoc Queries 506 Antipatterns: Lazy Loading Is Design Smell 507 Antipatterns: Don’t Use Repositories for Reporting Needs 507 Repository Implementations 508 Persistence Framework Can Map Domain Model to Data Model without Compromise 509 NHibernate Example 509 RavenDB Example 543 Persistence Framework Cannot Map Domain Model Directly without Compromise 557 Entity Framework Example 558 Micro ORM Example 577 The Salient Points 593 CHAPTER 22: EVENT SOURCING 595 The Limitations of Storing State as a Snapshot 596 Gaining Competitive Advantage by Storing State as a Stream of Events 597 Temporal Queries 597 Projections 599 Snapshots 599 Event‐Sourced Aggregates 600 Structuring 600 Adding Event‐Sourcing Capabilities 601 Exposing Expressive Domain‐Focused APIs 602 Adding Snapshot Support 604 Persisting and Rehydrating 605 Creating an Event-Sourcing Repository 605 Adding Snapshot Persistence and Reloading 607 Handling Concurrency 609 Testing 610 Building an Event Store 611 Designing a Storage Format 612 Creating Event Streams 614 Appending to Event Streams 614 Querying Event Streams 615 Adding Snapshot Support 616 Managing Concurrency 618 A SQL Server‐Based Event Store 621 Choosing a Schema 621 Creating a Stream 622 Saving Events 623 Loading Events from a Stream 624 Snapshots 625 Is Building Your Own Event Store a Good Idea? 627 Using the Purpose‐Built Event Store 627 Installing Greg Young’s Event Store 628 Using the C# Client Library 627 Running Temporal Queries 632 Querying a Single Stream 632 Querying Multiple Streams 634 Creating Projections 635 CQRS with Event Sourcing 637 Using Projections to Create View Caches 638 CQRS and Event Sourcing Synergy 638 Event Streams as Queues 639 No Two‐Phase Commits 639 Recapping the Benefits of Event Sourcing 639 Competitive Business Advantage 639 Expressive Behavior‐Focused Aggregates 639 Simplified Persistence 640 Superior Debugging 640 Weighing the Costs of Event Sourcing 640 Versioning 640 New Concepts to Learn and Skills to Hone 640 New Technologies to Learn and Master 641 Greater Data Storage Requirements 641 Additional Learning Resources 641 The Salient Points 641 PART IV: DESIGN PATTERNS FOR EFFECTIVE APPLICATIONS CHAPTER 23: ARCHITECTING APPLICATION USER INTERFACES 645 Design Considerations 646 Owned UIs versus Composed UIs 646 Autonomous 646 Authoritative 647 Some Help Deciding 648 HTML APIs versus Data APIs 649 Client versus Server‐Side Aggregation/Coordination 649 Example 1: An HTML API‐Based, Server‐Side UI for Nondistributed Bounded Contexts 651 Example 2: A Data API‐Based, Client‐Side UI for Distributed Bounded Contexts 658 The Salient Points 667 CHAPTER 24: CQRS: AN ARCHITECTURE OF A BOUNDED CONTEXT 669 The Challenges of Maintaining a Single Model for Two Contexts 670 A Better Architecture for Complex Bounded Contexts 670 The Command Side: Business Tasks 672 Explicitly Modeling Intent 672 A Model Free from Presentational Distractions 674 Handling a Business Request 675 The Query Side: Domain Reporting 676 Reports Mapped Directly to the Data Model 676 Materialized Views Built from Domain Events 678 The Misconceptions of CQRS 679 CQRS Is Hard 679 CQRS Is Eventually Consistent 679 Your Models Need to Be Event Sourced 680 Commands Should Be Asynchronous 680 CQRS Only Works with Messaging Systems 680 You Need to Use Domain Events with CQRS 680 Patterns to Enable Your Application to Scale 680 Scaling the Read Side: An Eventually Consistent Read Model 681 The Impact to the User Experience 682 Use the Read Model to Consolidate Many Bounded Contexts 682 Using a Reporting Database or a Caching Layer 682 Scaling the Write Side: Using Asynchronous Commands 683 Command Validation 683 Impact to the User Experience 684 Scaling It All 684 The Salient Points 685 CHAPTER 25: COMMANDS: APPLICATION SERVICE PATTERNS FOR PROCESSING BUSINESS USE CASES 687 Differentiating Application Logic and Domain Logic 689 Application Logic 689 Infrastructural Concerns 690 Coordinating Full Business Use Cases 698 Application Services and Framework Integration 698 Domain Logic from an Application Service’s Perspective 700 Application Service Patterns 700 Command Processor 701 Publish/Subscribe 704 Request/Reply Pattern 706 async/await 708 Testing Application Services 709 Use Domain Terminology 709 Test as Much Functionality as Possible 710 The Salient Points 712 CHAPTER 26: QUERIES: DOMAIN REPORTING 713 Domain Reporting within a Bounded Context 714 Deriving Reports from Domain Objects 714 Using Simple Mappings 714 Using the Mediator Pattern 718 Going Directly to the Datastore 720 Querying a Datastore 721 Reading Denormalized View Caches 724 Building Projections from Event Streams 726 Setting Up ES for Projections 727 Creating Reporting Projections 728 Counting the Number of Events in a Stream 729 Creating As Many Streams As Required 729 Building a Report from Streams and Projections 730 Domain Reporting Across Bounded Contexts 733 Composed UI 733 Separate Reporting Context 734 The Salient Points 736 INDEX 737

Read more less

Book SynopsisIt's easier to learn how to program a computer than it has ever been before. Now everyone can learn to write programs for themselves - no previous experience is necessary. Chris Pine takes a thorough, but lighthearted approach that teaches you the fundamentals of computer programming, with a minimum of fuss or bother. Whether you are interested in a new hobby or a new career, this book is your doorway into the world of programming. Computers are everywhere, and being able to program them is more important than it has ever been. But since most books on programming are written for other programmers, it can be hard to break in. At least it used to be. Chris Pine will teach you how to program. You'll learn to use your computer better, to get it to do what you want it to do. Starting with small, simple one-line programs to calculate your age in seconds, you'll see how to write interactive programs, to use APIs to fetch live data from the internet, to rename your photos from your digital camera, and more. You'll learn the same technology used to drive modern dynamic websites and large, professional applications. Whether you are looking for a fun new hobby or are interested in entering the tech world as a professional, this book gives you a solid foundation in programming. Chris teaches the basics, but also shows you how to think like a programmer. You'll learn through tons of examples, and through programming challenges throughout the book. When you finish, you'll know how and where to learn more - you'll be on your way. What You Need: All you need to learn how to program is a computer (Windows, macOS, or Linux) and an internet connection. Chris Pine will lead you through setting set up with the software you will need to start writing programs of your own.

Read more less

Book SynopsisTackle complex spatial data tasks effortlessly with this easy-to-follow guide to writing specialized Python scripts and developing tools for spatial data?in ArcGIS Pro.Advanced Python Scripting for ArcGIS Pro?follows up on the topics explained in?Python Scripting for ArcGIS Pro?(Esri Press, 2024) and is now updated for ArcGIS Pro 3.2.Intended for users who have a good foundation in Python, this book explores how to develop scripts into tools and notebooks to share with others, use third-party packages, and learn other more specialized tasks. By the end of this book, you'll be confident in writing more advanced scripts, developing them into tools and notebooks, and sharing them with others.The key topics you will learn include: Creating custom functions and classes Writing specialized scripts using?ArcPy Creating Python script tools and Python toolboxes Sharing scripts and tools Managing Python packages and environments Migrating scripts from Python 2 to 3 NumPy, Pandas, and Matplotlib Creating and using notebooks ArcGIS API for Python and?Jupyter?Notebook Helpful points to remember, key terms, and review questions are included at the end of each chapter to reinforce your understanding of Python. Companion data and tutorials are available online.Packed with advanced techniques and practical examples, Advanced Python Scripting for ArcGIS Pro?is perfect for more experienced ArcGIS Pro users who are looking to upgrade their Python skills and enhance their workflows.

Read more less

Book SynopsisCreate your first 2D, 3D, and AR/VR games with the awesome Unity game platform. With this hands-on beginner's guide, you'll start building games fast! In Unity in Action, Third Edition, you will learn how to: Create characters that run, jump, and bump into things Build 3D first-person shooters and third-person action games Construct 2D card games and side-scrolling platformers Script enemies with AI Improve game graphics by importing models and images Design an intuitive user interface for your games Play music and spatially-aware sound effects Connect your games to the internet for online play Deploy your games to desktop, mobile, and the web Thousands of new game developers have chosen Joe Hocking's Unity in Action as their first step toward Unity mastery. This fully updated third edition comes packed with fully refreshed graphics, Unity's latest features, and coverage of the augmented and virtual reality toolkits. Using your existing coding skills, you'll write custom code instead of just clicking together premade scripts. You'll master the Unity toolset from the ground up, adding the skills you need to go from application coder to game developer. Build your next game without sweating the low-level details. The Unity game engine handles the heavy lifting, so you can focus on game play, graphics, and user experience. With support for C#, a huge ecosystem of production-quality prebuilt assets, and a strong dev community, Unity will get your game idea off the drawing board and onto the screen! You can even use Unity for more than game development, with new tools for VR and augmented reality that are perfect for developing useful apps.Trade ReviewThis is the best resource, bar none, for an introduction to Unity and fundamental game programming concepts. Erik Hansson This book is a wonderful introduction to Unity. I believe this book will be very useful to readers from a wide range of backgrounds. Everything is explained very well and is easy to read and understand. Kent R. Spillner This is a great introduction to Unity. I think it could even be used as the foundation for a high school or college course. Robert Walsh If you want to start building games as a hobby or a profession, this is a good place to start! Bradley Irby A great introduction to learning Game development with Unity and C#. The author steps you through all the elements of Unity so if you've never used Unity before, don't worry about it. Owain Williams If you already have some programming experience, this book on Unity can really help you connect into a new platform and enable you to create a game! James Matlock

Read more less

Book SynopsisAlan Shalloway is founder, CEO, and principal consultant of Net Objectives, an object-oriented consulting and training organization. An object-oriented consultant and software developer for over 20 years, he is a frequent speaker at leading development conferences, including SD Expo, Java One, OOP, and OOPSLA. He is a certified Scrum master. He is co-author of An Introduction to XML and its Family of Technologies. Shalloway holds a master's degree in computer science from MIT. James R. Trott currently works as a senior consultant for a large financial institution in the Pacific Northwest. He has used object-oriented and pattern-based analysis techniques throughout his 20-year career in knowledge management and knowledge engineering. He holds a master of science in applied mathematics, an MBA, and a master of arts in intercultural studies. Copyright Pearson Education. All rights reserved.Table of ContentsI. AN INTRODUCTION TO OBJECT-ORIENTED SOFTWARE DEVELOPMENT. 1. The Object-Oriented Paradigm. Overview. Before the Object-Oriented Paradigm: Functional Decomposition. The Problem of Requirements. Dealing with Changes: Using Functional Decomposition. Dealing with Changing Requirements. The Object-Oriented Paradigm. Object-Oriented Programming in Action. Special Object Methods. Summary. Review Questions. 2. The UML-The Unified Modeling Language. Overview. What Is the UML? Why Use the UML? The Class Diagram. Interaction Diagrams. Summary. Review Questions. II. THE LIMITATIONS OF TRADITIONAL OBJECT-ORIENTED DESIGN. 3. A Problem That Cries Out for Flexible Code. Overview. Extracting Information from a CAD/CAM System. Understand the Vocabulary. Describe the Problem. The Essential Challenges and Approaches. Summary. Review Questions. 4. A Standard Object-Oriented Solution. Overview. Solving with Special Cases. Summary. Review Questions. III. DESIGN PATTERNS. 5. An Introduction to Design Patterns. Overview. Design Patterns Arose from Architecture and Anthropology. Moving from Architectural to Software Design Patterns. Why Study Design Patterns? Other Advantages of Studying Design Patterns. Summary. Review Questions. 6. The Facade Pattern. Overview. Introducing the Facade Pattern. Learning the Facade Pattern. Field Notes: The Facade Pattern. Relating the Facade Pattern to the CAD/CAM Problem. Summary. Review Questions. 7. The Adapter Pattern. Overview. Introducing the Adapter Pattern. Learning the Adapter Pattern. Field Notes: The Adapter Pattern. Relating the Adapter Pattern to the CAD/CAM Problem. Summary. Review Questions. 8. Expanding Our Horizons. Overview. Objects: The Traditional View and the New View. Encapsulation: The Traditional View and the New View. Find What Is Varying and Encapsulate It. Commonality and Variability Analysis and Abstract Classes. The Qualities of Agile Coding. Summary. Review Questions. 9. The Strategy Pattern. Overview. An Approach to Handling New Requirements. The International E-Commerce System Case Study: Initial Requirements. Handling New Requirements. The Strategy Pattern. Field Notes: Using the Strategy Pattern. Summary. Review Questions. 10. The Bridge Pattern. Overview. Introducing the Bridge Pattern. Learning the Bridge Pattern: An Example. An Observation About Using Design Patterns. Learning the Bridge Pattern: Deriving It. The Bridge Pattern in Retrospect. Field Notes: Using the Bridge Pattern. Summary. Review Questions. 11. The Abstract Factory Pattern. Overview. Introducing the Abstract Factory Pattern. Learning the Abstract Factory Pattern: An Example. Learning the Abstract Factory Pattern: Implementing It. Field Notes: The Abstract Factory Pattern. Relating the Abstract Factory Pattern to the CAD/CAM Problem. Summary. Review Questions. IV. PUTTING IT ALL TOGETHER: THINKING IN PATTERNS. 12. How Do Experts Design? Overview. Building by Adding Distinctions. Summary. Review Questions. 13. Solving the CAD/CAM Problem with Patterns. Overview. Review of the CAD/CAM Problem. Thinking in Patterns. Thinking in Patterns: Step 1. Thinking in Patterns: Step 2a. Thinking in Patterns: Step 2b. Thinking in Patterns: Step 2c. Thinking in Patterns: Steps 2a and 2b Repeated (Facade). Thinking in Patterns: Steps 2a and 2b Repeated (Adapter). Thinking in Patterns: Steps 2a and 2b Repeated (Abstract Factory). Thinking in Patterns: Step 3. Comparison with the Previous Solution. Summary. Review Questions. V. TOWARD A NEW PARADIGM OF DESIGN. 14. The Principles and Strategies of Design Patterns. Overview. The Open-Closed Principle. The Principle of Designing from Context. The Principle of Encapsulating Variation. Abstract Classes vs. Interfaces. The Principle of Healthy Skepticism. Summary. Review Questions. 15. Commonality and Variability Analysis. Overview. Commonality and Variability Analysis and Application Design. Solving the CAD/CAM Problem with CVA. Summary. Review Questions. 16. The Analysis Matrix. Overview. In the Real World: Variations. The International E-Commerce System Case Study: Handling Variation. Field Notes. Summary. Review Questions. 17. The Decorator Pattern. Overview. A Little More Detail. The Decorator Pattern. Applying the Decorator Pattern to the Case Study. Another Example: Input/Output. Field Notes: Using the Decorator Pattern. The Essence of the Decorator Pattern. Summary. Review Questions. VI. OTHER VALUES OF PATTERNS. 18. The Observer Pattern. Overview. Categories of Patterns. More Requirements for the International E-Commerce Case Study. The Observer Pattern. Applying the Observer to the Case Study. Field Notes: Using the Observer Pattern. Summary. Review Questions. 19. The Template Method Pattern. Overview. More Requirements for the International E-Commerce Case Study. The Template Method Pattern. Applying the Template Method to the International E-Commerce Case Study. Using the Template Method Pattern to Reduce Redundancy. Field Notes: Using the Template Method Pattern. Summary. Review Questions. VII. FACTORIES. 20. Lessons from Design Patterns: Factories. Overview. Factories. The Universal Context Revisited. Factories Follow Our Guidelines. Limiting the Vectors of Change. Another Way to Think About It. Different Roles of Factories. Field Notes. Summary. Review Questions. Overview. 21. The Singleton Pattern and the Double-Checked Locking Pattern. Introducing the Singleton Pattern. Applying the Singleton Pattern to the Case Study. A Variant: The Double-Checked Locking Pattern. Reflections. Field Notes: Using the Singleton and Double-Checked Locking Patterns. Summary. Review Questions. 22. The Object Pool Pattern. Overview. A Problem Requiring the Management of Objects. The Object Pool Pattern. Observation: Factories Can Do Much More Than Instantiation. Summary. Review Questions. 23. The Factory Method Pattern. Overview. More Requirements for the Case Study. The Factory Method Pattern. Factory Method Pattern and Object-Oriented Languages. Field Notes: Using the Factory Method Pattern. Summary. Review Questions. 24. Summary of Factories. Overview. Steps in the Software Process. Parallels in Factories and XP Practices. Scaling Systems. VIII. ENDINGS AND BEGINNINGS. 25. Design Patterns Reviewed: A Summation and a Beginning. Overview. A Summary of Object-Oriented Principles. How Design Patterns Encapsulate Implementations. Commonality and Variability Analysis and Design Patterns. Decomposing a Problem Domain into Responsibilities. Patterns and Contextual Design. Relationships Within a Pattern. Design Patterns and Agile Coding Practices. Field Notes. Summary. Review Questions. 26. Bibliography. Design Patterns Explained: The Web Site Companion. Recommended Reading. Recommended Reading for Java Programmers. Recommended Reading for C++ Programmers. Recommended Reading for COBOL Programmers. Recommended Reading on eXtreme Programming. Recommended Reading on General Programming. Personal Favorites. Index.

Read more less

Book SynopsisUML 2 For Dummies covers UML 2. 0, the latest version of UML, expected out in March 2003. This book shows how to use UML to model systems. It provides practical advice and examples that enable readers to understand and demystify the standard UML models and extract key information from them.Table of ContentsIntroduction 1 Part I: UML and System Development 7 Chapter 1: What’s UML About, Alfie? 9 Chapter 2: Following Best Practices 19 Part II: The Basics of Object Modeling 37 Chapter 3: Objects and Classes 39 Chapter 4: Relating Objects That Work Together 61 Chapter 5: Including the Parts with the Whole 83 Chapter 6: Reusing Superclasses: Generalization and Inheritance 93 Chapter 7: Organizing UML Class Diagrams and Packages 111 Part III: The Basics of Use-Case Modeling 129 Chapter 8: Introducing Use-Case Diagrams 131 Chapter 9: Defining the Inside of a Use Case 147 Chapter 10: Relating Use Cases to Each Other 161 Part IV: The Basics of Functional Modeling 175 Chapter 11: Introducing Functional Modeling 177 Chapter 12: Capturing Scenarios with Sequence Diagrams 189 Chapter 13: Specifying Workflows with Activity Diagrams 213 Chapter 14: Capturing How Objects Collaborate 227 Chapter 15: Capturing the Patterns of Behavior 247 Part V: Dynamic Modeling 259 Chapter 16: Defining the Object’s Lives with States 261 Chapter 17: Interrupting the States by Hosting Events 277 Chapter 18: Avoiding States of Confusion 293 Part VI: Modeling the System’s Architecture 313 Chapter 19: Deploying the System’s Components 315 Chapter 20: Breaking the System into Packages/Subsystems 339 Part VII: The Part of Tens 359 Chapter 21: Ten Common Modeling Mistakes 361 Chapter 22: Ten Useful UML Web Sites 371 Chapter 23: Ten Useful UML Modeling Tools 377 Chapter 24: Ten Diagrams for Quick Development 383 Index 393

Read more less

Book SynopsisTake the first step in raising your coding skills to the next level, and test your Java knowledge on tricky programming tasks, with the help of the pirate Captain CiaoCiao. This is the first of two volumes which provide you with everything you need to excel in your Java journey, including tricks that you should know in detail as a professional, as well as intensive training for clean code and thoughtful design that carries even complex software.Features: About 200 tasks with commented solutions on different levels For all paradigms: object-oriented, imperative, and functional Clean code, reading foreign code, and object-oriented modeling With numerous best practices and extensively commented solutions to the tasks, these books provide the perfect workout for professional software development with Java.

Read more less

Book Synopsis

Read more less

Book SynopsisUnleash the power of JavaFX for a wide range of devices JavaFX For Dummies gives you access to an innovative software platform that allows you to create and deliver rich Internet applications that can run across a wide variety of connected devices.Table of ContentsIntroduction 1 About This Book 1 Foolish Assumptions 2 How This Book Is Organized 3 Part I: Getting Started with JavaFX 3 Part II: JavaFX Controls 3 Part III: Enhancing Your Scenic Design 3 Part IV: Making Your Programs Come Alive 4 Part V: The Part of Tens 4 Icons Used in This Book 4 Beyond the Book 5 Where to Go from Here 5 Part I: Getting Started with JavaFX 7 Chapter 1: Hello, JavaFX! 9 Chapter 2: Looking Closer at JavaFX Programming 31 Chapter 3: Handling Events 49 Chapter 4: Setting the Stage and Scene Layout 67 Chapter 5: Using Layout Panes to Arrange Your Scenes 93 Chapter 6: Getting Input from the User 117 Part II: JavaFX Controls 141 Chapter 7: Introducing the JavaFX Node Hierarchy 143 Chapter 8: Choosing from a List 155 Chapter 9: Working with Tables 185 Chapter 10: Making Menus 209 Part III: Enhancing Your Scenic Design 225 Chapter 11: More about Layout Panes for Precise Scene Design 227 Chapter 12: Skinning Your Application with CSS 255 Chapter 13: Drawing Shapes 267 Chapter 14: Adding Special Effects 289 Part IV: Making Your Programs Come Alive 307 Chapter 15: Using Properties to Create Dynamic Scenes 309 Chapter 16: Using Images and Media 327 Chapter 17: Animating Your Scenes 341 Chapter 18: Targeting Touch Devices 365 Part V: The Part of Tens 375 Chapter 19: Ten More JavaFX Controls 377 Chapter 20: Ten Steps to Building a 3D World 389 Index 407

Read more less

Book SynopsisTable of ContentsIntroduction 1 Book 1: Java Basics 5 Chapter 1: Welcome to Java 7 Chapter 2: Installing and Using Java Tools 17 Chapter 3: Working with TextPad 31 Book 2: Programming Basics 37 Chapter 1: Java Programming Basics 39 Chapter 2: Working with Variables and Data Types 59 Chapter 3: Working with Numbers and Expressions 97 Chapter 4: Making Choices 127 Chapter 5: Going Around in Circles (or, Using Loops) 149 Chapter 6: Pulling a Switcheroo 177 Chapter 7: Adding Some Methods to Your Madness 195 Chapter 8: Handling Exceptions 215 Book 3: Object-Oriented Programming 237 Chapter 1: Understanding Object-Oriented Programming 239 Chapter 2: Making Your Own Classes 253 Chapter 3: Working with Statics 273 Chapter 4: Using Subclasses and Inheritance 283 Chapter 5: Using Abstract Classes and Interfaces 305 Chapter 6: Using the Object and Class Classes 327 Chapter 7: Using Inner Classes and Anonymous Classes 355 Chapter 8: Working with Packages and the Java Module System 365 Book 4: Strings and Other Data Types 387 Chapter 1: Working with Strings 389 Chapter 2: Using Regular Expressions 411 Chapter 3: Working with Dates and Times 429 Chapter 4: Using the BigDecimal Class 451 Book 5: Data Structures 471 Chapter 1: Introducing Data Structures 473 Chapter 2: Using Arrays 503 Chapter 3: Using the ArrayList Class 535 Chapter 4: Using the LinkedList Class 549 Chapter 5: Creating Generic Collection Classes 561 Chapter 6: Using Maps and Trees 575 Book 6: Algorithms 595 Chapter 1: Introducing Algorithms 597 Chapter 2: Using Recursion 613 Chapter 3: Sorting 625 Chapter 4: Searching 637 Book 7: Programming Techniques 657 Chapter 1: Programming Threads 659 Chapter 2: Using Functional Programming and Lambda Expressions 689 Chapter 3: Consuming Web Services with HttpClient 705 Book 8: JavaFX 727 Chapter 1: Hello, JavaFX! 729 Chapter 2: Handling Events 751 Chapter 3: Setting the Stage and Scene Layout 769 Chapter 4: Using Layout Panes to Arrange Your Scenes 791 Chapter 5: Getting Input from the User 825 Chapter 6: Choosing from a List 841 Index 869

Read more less

Book SynopsisArduino is the open source electronics prototyping platform that has taken the Maker Movement by storm. This thorough introduction, updated for the latest Arduino release, helps you start prototyping right away. From obtaining the required components to putting the final touches on your project, all the information you need is here! Getting started with Arduino is a snap. To use the introductory examples in this guide, all you need is an Arduino Uno or Leonardo, along with a USB cable and an LED. The easy-to-use, free Arduino development environment runs on Mac, Windows, and Linux. In Getting Started with Arduino, you'll learn about: Interaction design and physical computing The Arduino board and its software environment Basics of electricity and electronics Prototyping on a solderless breadboard Drawing a schematic diagram Talking to a computer--and the cloud--from Arduino Building a custom plant-watering system

Read more less

Book Synopsisf you program in C++ you've been neglected. Test-driven development (TDD) is a modern software development practice that can dramatically reduce the number of defects in systems, produce more maintainable code, and give you the confidence to change your software to meet changing needs. But C++ programmers have been ignored by those promoting TDD--until now. In this book, Jeff Langr gives you hands-on lessons in the challenges and rewards of doing TDD in C++. Modern C++ Programming With Test-Driven Development, the only comprehensive treatment on TDD in C++ provides you with everything you need to know about TDD, and the challenges and benefits of implementing it in your C++ systems. Its many detailed code examples take you step-by-step from TDD basics to advanced concepts. As a veteran C++ programmer, you're already writing high-quality code, and you work hard to maintain code quality. It doesn't have to be that hard. In this book, you'll learn: * how to use TDD to improve legacy C++ systems * how to identify and deal with troublesome system dependencies * how to do dependency injection, which is particularly tricky in C++ * how to use testing tools for C++ that aid TDD * new C++11 features that facilitate TDD As you grow in TDD mastery, you'll discover how to keep a massive C++ system from becoming a design mess over time, as well as particular C++ trouble spots to avoid. You'll find out how to prevent your tests from being a maintenance burden and how to think in TDD without giving up your hard-won C++ skills. Finally, you'll see how to grow and sustain TDD in your team. Whether you're a complete unit-testing novice or an experienced tester, this book will lead you to mastery of test-driven development in C++. What You Need * A C++ compiler running under Windows or Linux, preferably one that supports C++11. Examples presented in the book were built under gcc 4.7.2. * Google Mock 1.6 (downloadable for free; it contains Google Test as well) or an alternate C++ unit testing tool. Most examples in the book are written for Google Mock, but it isn't difficult to translate them to your tool of choice. * A good programmer's editor or IDE. * cmake, preferably. Of course, you can use your own preferred make too. CMakeLists.txt files are provided for each project. Examples provided were built using cmake version 2.8.9. * Various freely-available third-party libraries are used as the basis for examples in the book. These include: - cURL - JsonCpp - Boost (filesystem, date_time/gregorian, algorithm, assign) Several examples use the boost headers/libraries. Only one example uses cURL and JsonCpp.

Read more less

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

Read more less

Book SynopsisThe design of application programming interfaces can affect the behavior, capabilities, stability, and ease of use of end-user applications. This book helps you learn how to design a good API for large-scale long-term projects. With C++ code to illustrate each concept, it covers the various strategies of API development.Trade Review"Martin Reddy draws from his experience on large scale, collaborative software projects to present patterns and practices that provide real value to individual developers as well as organizations. API Design for C++ explores often overlooked issues, both technical and non- technical, contributing to successful design decisions that produce high quality, robust, and long-lived APIs." --Eric Gregory, Software Architect, Pixar Animation Studios"Intended for programmers with intermediate to advanced skills in the C++ programming language, this guide to the building of useful and robust application programming interfaces (APIs) provides practical instruction for software engineers developing systems on which downstream software engineers depend. The work provides a methodical approach to API design covering solution based API design, performance, versioning, documentation, testing, scripting, extensibility and libraries. The work includes numerous illustrations and code examples and access to additional online resources is provided. Reddy is a software development consultant." --Book News, Reference & ResearchTable of ContentsIntroduction 1. Qualities 2. Patterns 3. Design 4. Styles 5. C++ Usage 6. Performance 7. Versioning 8. Documentation 9. Testing 10. Scripting 11. Extensibility Appendix A: Libraries Bibliography Index

Read more less

Book SynopsisObject Oriented Data Analysis is a framework that facilitates inter-disciplinary research through new terminology for discussing the often many possible approaches to the analysis of complex data. Such data are naturally arising in a wide variety of areas. This book aims to provide ways of thinking that enable the making of sensible choices.The main points are illustrated with many real data examples, based on the authors'' personal experiences, which have motivated the invention of a wide array of analytic methods.While the mathematics go far beyond the usual in statistics (including differential geometry and even topology), the book is aimed at accessibility by graduate students. There is deliberate focus on ideas over mathematical formulas.Trade ReviewI wrote a report last year on an earlier draft of the book. I was enthusiastic then and I remain so. I can see the book being very popular both with graduate students and with more advanced researchers in disciplines such as Statistics, Biology, Computer Science and Engineering. There is lots of common sense advice, a lot of informative graphs, and not too much theory…I regard the manuscript as a breath of fresh air in an area where there can be a tendency to make the material overly technical."-John Kent, University of Leeds"We need this book badly in statistics. This field, like most in the mathematical sciences tends to generate a literature that offers more and more exposition of research on less and less. The authors say this well in their first two pages, where they point out how much of statistical practice, literature and software assumes data in the form of a two-dimensional table. As in functional data analysis, the theoreticians will sniff and grouch about the lack of theory, but this quickly follows as they see the opportunities for more intense mathematical effort in the area. Both authors are high levels theoreticians in their own right."-Jim Ramsay, McGill University"The chapters I have read are very informative and convey the deep insight of two senior specialists in the field. This is very valuable, especially for younger scientists that want to quickly grasp the fundamentals of the field…The particular strength of this book is that is connects classical statistics, "classical" machine learning and statistics on non-Euclidean spaces with one another…This is a book I have been waiting for and I love to read it in detail and profit from it for research and teaching, once it is finished."-Stephan F. Huckemann, Georgia-Augusta-University Goettingen"This textbook represents an exciting and timely project highlighting the importance of non-Euclidean data across different scientific applications. It uses numerous examples to motivate this scientific approach, to engage researchers from different backgrounds and experiences. The textbook starts by introducing OODA–overview, contexts, and preliminaries. The main focus of the textbook is on statistical case studies driven by non-Euclidean data. The principal component analysis is frequently used as a primary data analysis tool, extracting interesting patterns from the data. Then the textbook moves into specific methods – distance-based methods, visualizations, shapes, curves, and trees. In the last part, the manuscript focuses on pattern analysis techniques – clustering, classification, smoothing, and asymptotics. I strongly recommend the publication of this textbook. This manuscript covers important and fast-developing topic areas that are important in many applications."-Anuj Srivastava, Florida State University"(...) this monograph is destined, without doubt, to become the classic introductory text on OODA. Graduate students contemplating research in statistics and/or data science who have studied introductory courses in multivariate analysis and smoothing and robust methods will find it a gentle introduction, and also an inspiring one because it identifies many areas of the field that are in their infancy and which need to be more fully developed. It also provides great insight into how classical methods perform in not so standard setups, particularly for high dimensional data, and describes alternatives to them having enhanced performance. Its extensive bibliography constitutes an essential resource for those embarking on research into statistical and data science methodology for contexts involving complex data."-Arthur Pewsey, in Journal of the Royal Statistical Society, Series A, March 2022Table of Contents What is OODA? Breadth of OODA Data Object Definition Exploratory and Confirmatory Analyses OODA P6 Data Visualization Distance Based Methods Manifold Data Analysis FDA Curve Registration Graph Structured Data Objects Classification - Supervised Learning Clustering - Unsupervised Learning High Dimensional Inference High Dimensional Asymptotics Smoothing and SiZer Robust Methods PCA Details and Variants OODA Context and Related Areas

Read more less

Book SynopsisIf you're interested in applying FP concepts to your Java code, this book is for you. You'll learn how, when, and why to use FP concepts such as immutability and pure functions to write more concise, reasonable, and future-proof code.

Read more less

Book Synopsis

Read more less

Book SynopsisObject Design Style Guide captures dozens of techniques for creating pro-quality OO code that can stand the test of time. Examples are in an instantly-familiar pseudocode, teaching techniques you can apply to any OO language, from C++ to PHP. The design rules for different types of objectsBest practices for naming objectsTesting an object’s behavior instead of its implementationExercises for each chapter to test your design skills

Read more less