• 

  Effective Software Testing: A Developer's Guide

  In Effective Software Testing you will learn how to: * Engineer tests with a much higher chance of finding bugs * Read code coverage metrics and use them to improve your test suite * Understand when to use unit tests, integration tests, and system tests * Use mocks and stubs to simplify your unit testing * Think of pre-conditions, post-conditions, invariants, and contracts * Implement property-based tests * Utilize coding practices like dependency injection and hexagonal architecture that make your software easier to test * Write good and maintainable test code Effective Software Testing teaches you a systematic approach to software testing. YouGÇÖll master easy-to-apply techniques to create strong test suites that are specifically engineered for your code. Following real-world use cases and detailed code samples, youGÇÖll soon be engineering tests that find the bugs hiding in edge cases and the parts of code you would never think of testing! Along the way, youGÇÖll develop an intuition for testing that can save years of learning by trial and error. Go beyond unit tests! Great software testing makes the entire development process more efficient, from understanding your code before you write it to catching bugs in tricky corner cases.Effective Software Testing teaches you a systematic approach to software testing. YouGÇÖll master easy-to-apply techniques to create strong test suites that are specifically engineered for your code. Following real-world use cases and detailed code samples, youGÇÖll soon be engineering tests that find the bugs hiding in edge cases and the parts of code you would never think of testing! Along the way, youGÇÖll develop an intuition for testing that can save years of learning by trial and error.

  • Shop: buecher
  • Price: 51.99 EUR excl. shipping
• 

  Growing Object-Oriented Software, Guided by Tests

  Foreword by Kent BeckThe authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows." --Ward Cunningham "At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper." --Robert C. Martin"If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book."--Michael FeathersTest-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this simple idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and "grow" software that is coherent, reliable, and maintainable. Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you'll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes - Implementing TDD effectively: getting started, and maintaining your momentum throughout the project- Creating cleaner, more expressive, more sustainable code- Using tests to stay relentlessly focused on sustaining quality - Understanding how TDD, Mock Objects, and Object-Oriented Design come together in the context of a real software development project- Using Mock Objects to guide object-oriented designs- Succeeding where TDD is difficult: managing complex test data, and testing persistenceand concurrency

  • Shop: buecher
  • Price: 34.99 EUR excl. shipping
• 

  Practical Entity Framework Core 6: Database Access for Enterprise Applications

  Take a developer journey that paves the way to enterprise-level database access from .NET and C# using the object-relational mapper (ORM) of choice. This second edition is revised to cover Entity Framework Core 5 and 6 (EF) and includes new content on table-per-type mapping, LINQ improvements (filtered includes), many-to-many navigation changes, split queries, simple logging using the DBCommandInterceptor, and other improvements available in EF Core 6. Real-world examples and considerations are presented in this book to help you create robust and efficient database solutions. Throughout the text, actual problems, questions, and common pitfalls are provided to help you recognize optimal solutions for maximum success in the different application scenarios you might encounter. Practical Entity Framework Core 6 focuses on the code first approach to developing a database. Taking the code first approach allows the entire database to be built and maintained in code using EF Core 6 so there is never a situation in which you cannot restore the database schema. Additionally, the code first approach creates an entirely transparent record of changes to the database that is easily tracked in source control systems such as GitHub. Emphasis throughout the book is on leaving you well positioned to architect and lead data development efforts for your organization.What You Will LearnBuild robust and maintainable databases using a code first approachCreate and execute stored procedures, triggers, and functionsAnalyze and optimize performance of database queriesEnsure data integrity through keys, constraints, and relationshipsEncrypt your database columns at rest with TDE and Always-On Encryption Leverage the FluentAPI and attributes for entity configurationWho This Book Is For.NET developers who work with enterprise-level applications and need to interact with data structures and data within the back end data store, developers who want to take a code first approach to building database applications to prevent conflicts and optimize efficiency, and those who are moving into full-stack roles, or into senior and architectural roles, and will be responsible for database design and implementation

  • Shop: buecher
  • Price: 44.99 EUR excl. shipping
• 

  Complete Guide to Test Automation

  Rely on this robust and thorough guide to build and maintain successful test automation. As the software industry shifts from traditional waterfall paradigms into more agile ones, test automation becomes a highly important tool that allows your development teams to deliver software at an ever-increasing pace without compromising quality.Even though it may seem trivial to automate the repetitive tester's work, using test automation efficiently and properly is not trivial. Many test automation endeavors end up in the "graveyard" of software projects. There are many things that affect the value of test automation, and also its costs. This book aims to cover all of these aspects in great detail so you can make decisions to create the best test automation solution that will not only help your test automation project to succeed, but also allow the entire software project to thrive.One of the most important details that affects the success of the test automation is how easy it is to maintain the automated tests. Complete Guide to Test Automation provides a detailed hands-on guide for writing highly maintainable test code.What You'll LearnKnow the real value to be expected from test automationDiscover the key traits that will make your test automation project succeedBe aware of the different considerations to take into account when planning automated tests vs. manual testsDetermine who should implement the tests and the implications of this decisionArchitect the test project and fit it to the architecture of the tested applicationDesign and implement highly reliable automated testsBegin gaining value from test automation earlierIntegrate test automation into the business processes of the development teamLeverage test automation to improve your organization's performance and quality, even without formal authorityUnderstand how different types of automated tests will fit into your testing strategy, including unit testing, load and performance testing, visual testing, and moreWho This Book Is ForThose involved with software development such as test automation leads, QA managers, test automation developers, and development managers. Some parts of the book assume hands-on experience in writing code in an object-oriented language (mainly C# or Java), although most of the content is also relevant for nonprogrammers.

  • Shop: buecher
  • Price: 34.99 EUR excl. shipping
• 

  Applying UML and Patterns

  This third edition again delivers a clear path for students and professionals to learn and apply object-oriented analysis and design. The first two editions of this book have achieved gross sales of more than 60,000 units through the domestic retail channel Timely and up-to-date; compliant with UML 2.0 and the latest trends in design patterns and object-oriented analysis and design More gold from one of the leading names in software engineering: Craig Larman! The mastery of object-oriented analysis and design (OOA/D) principles and concepts is critical for anyone seeking to create robust and maintainable object systems. This third edition presents a well-defined roadmap, so the reader can move along a step-by-step process from requirements gathering all the way to code generation. The author teaches the skill of OOA/D using the latest version of the industry standard modeling language (UML 2.0). He also allows the reader to learn and apply the popular concept of design patterns, and therefore helps readers accelerate their mastery of analysis and design. The author retains his thorough treatment of a single case study to help readers gain a big picture of successful software development. Once again, this book delivers, and furthers Craig Larman's name among software engineering luminaries. Product Description "This edition contains Larman's usual accurate and thoughtful writing. It is a very good book made even better." -Alistair Cockburn, author, Writing Effective Use Cases and Surviving OO Projects"Too few people have a knack for explaining things. Fewer still have a handle on software analysis and design. Craig Larman has both." -John Vlissides, author, Design Patterns and Pattern Hatching"People often ask me which is the best book to introduce them to the world of OO design. Ever since I came across it Applying UML and Patterns has been my unreserved choice." -Martin Fowler, author, UML Distilled and Refactoring"This book makes learning UML enjoyable and pragmatic by incrementally introducing it as an intuitive language for specifying the artifacts of object analysis and design. It is a well written introduction to UML and object methods by an expert practitioner." -Cris Kobryn, Chair of the UML Revision Task Force and UML 2.0 Working Group A brand new edition of the world's most admired introduction to object-oriented analysis and design with UML Fully updated for UML 2 and the latest iterative/agile practices Includes an all-new case study illustrating many of the book's key points Applying UML and Patterns is the world's #1 business and college introduction to "thinking in objects"-and using that insight in real-world object-oriented analysis and design. Building on two widely acclaimed previous editions, Craig Larman has updated this book to fully reflect the new UML 2 standard, to help you master the art of object design, and to promote high-impact, iterative, and skillful agile modeling practices. Developers and students will learn object-oriented analysis and design (OOA/D) through three iterations of two cohesive, start-to-finish case studies. These case studies incrementally introduce key skills, essential OO principles and patterns, UML notation, and best practices. You won't just learn UML diagrams-you'll learn how to apply UML in the context of OO software development. Drawing on his unsurpassed experience as a mentor and consultant, Larman helps you understand evolutionary requirements and use cases, domain object modeling, responsibility-driven design, essential OO design, layered architectures, "Gang of Four" design patterns, GRASP, iterative methods, an agile approach to the Unified Process (UP), and much more. This edition's extensive improvements include A stronger focus on helping you master OOA/D through case studies that demonstrate key OO principles and patterns, while also applying the UML New coverage of UML 2, Agile Modeling, Test-Driven Development, and refactoring Many new tips on combining iterative and evolutionary development with OOA/D Updates for easier study, including new learning aids and graphics New college educator teaching resources Guidance on applying the UP in a light, agile spirit, complementary with other iterative methods such as XP and Scrum Techniques for applying the UML to documenting architectures A new chapter on evolutionary requirements, and much more Applying UML and Patterns, Third Edition, is a lucid and practical introduction to thinking and designing with objects-and creating systems that are well crafted, robust, and maintainable. Features + Benefits This third edition again delivers a clear path for students and professionals to learn and apply object-oriented analysis and design. The first two editions of this book have achieved gross sales of more than 60,000 units through the domestic retail channelCraig Larman again delivers a clear path for students to learn object-oriented analysis and design through his clear and precise writing style. Larman teaches newcomers to OOA/D learn how to "think in objects" by presenting three iterations of a single, cohesive case study, incrementally introducing the requirements and OOA/D activities, principles, and patterns that are most critical to success.

  • Shop: buecher
  • Price: 55.99 EUR excl. shipping
• 

  Large-Scale C++ Volume I (eBook, PDF)

  Writing reliable and maintainable C++ software is hard. Designing such software at scale adds a new set of challenges. Creating large-scale systems requires a practical understanding of logical design - beyond the theoretical concepts addressed in most popular texts. To be successful on an enterprise scale, developers must also address physical design, a dimension of software engineering that may be unfamiliar even to expert developers. Drawing on over 30 years of hands-on experience building massive, mission-critical enterprise systems, John Lakos shows how to create and grow Software Capital. This groundbreaking volume lays the foundation for projects of all sizes and demonstrates the processes, methods, techniques, and tools needed for successful real-world, large-scale development. Up to date and with a solid engineering focus, Large-Scale C++, Volume I: Process and Architecture, demonstrates fundamental design concepts with concrete examples. Professional developers of all experience levels will gain insights that transform their approach to design and development by understanding how to Raise productivity by leveraging differences between infrastructure and application development Achieve exponential productivity gains through feedback and hierarchical reuse Embrace the component's role as the fundamental unit of both logical and physical design Analyze how fundamental properties of compiling and linking affect component design Discover effective partitioning of logical content in appropriately sized physical aggregates Internalize the important differences among sufficient, complete, minimal, and primitive software Deliver solutions that simultaneously optimize encapsulation, stability, and performance Exploit the nine established levelization techniques to avoid cyclic physical dependencies Use lateral designs judiciously to avoid the "heaviness" of conventional layered architectures Employ appropriate architectural insulation techniques for eliminating compile-time coupling Master the multidimensional process of designing large systems using component-based methods This is the first of John Lakos's three authoritative volumes on developing large-scale systems using C++. This book, written for fellow software practitioners, uses familiar C++ constructs to solve real-world problems while identifying (and motivating) modern C++ alternatives. Together with the forthcoming Volume II: Design and Implementation and Volume III: Verification and Testing, Large-Scale C++ offers comprehensive guidance for all aspects of large-scale C++ software development. If you are an architect or project leader, this book will empower you to solve critically important problems right now - and serve as your go-to reference for years to come. Register your book for convenient access to downloads, updates, and/or corrections as they become available. See inside book for details.

  • Shop: buecher
  • Price: 36.95 EUR excl. shipping
• 

  Hands-On System Design: Learn System Design, Scaling Applications, Software Development Design Patterns with Real Use-Cases (eBook, ePUB)

  The ultimate guide to ace your system designing interviews. KEY FEATURES ● Provides step-by-step solutions to real-world problems related to system design and development.● Includes detailed explanations of each OOPs idea and design pattern, along with code snippets in the C++ style.● Contains illustrations and demonstrations that describe the technologies enabling modern scalable systems. DESCRIPTION Scaling software application is the focus of this book, which takes the reader on an in-depth journey. You'll have a better understanding of how to create a scalable, enterprise-level application after reading this guide. The book discusses system design principles, computer networks, major networking protocols, strategies for scaling data access, and various architectural styles for creating the system. A thorough examination of various technologies such as Cache Memory, CDN, Load Balancers, and Messaging Queues are conducted and their implementation. The book also demonstrates how you can use these combinations of technologies in the best way to build a scalable enterprise-level system. The examination of several architectural styles for system design assists you in choosing the best path for architecting your system. Additionally, the book explores object-oriented programming concepts and design patterns that facilitate the creation of clean, maintainable code. The reader will develop an intuitive knowledge of numerous tools and approaches for creating a scalable system by using several actual system design examples. This book can tackle any system design problem you may meet in your current position or interviews. You'll learn how to design a system from scratch, and the examples in the book will help you to improve your skills. WHAT YOU WILL LEARN● Acquaint yourself with the fundamentals of computer networks and major networking protocols.● Gain an understanding of various technologies to develop a distributed scalable application.● Develop the capacity to approach any system design problem with a unique perspective.● Gain insight into programming design patterns and object-oriented principles.● Investigate several methods for expanding data access.● Discover many architectural styles for system design. WHO THIS BOOK IS FORThe book is intended for software developers, system design engineers, aspiring system architects, IT professionals and students who want to learn how to construct a scalable application or prepare for system design interviews. Basic knowledge of programming and computer architecture is recommended but not demanded to grasp the book. AUTHOR BIO Harsh Kumar Ramchandani completed his Bachelor of Engineering in Computer Science from NSIT, Delhi (Delhi University) in 2015. Harsh has 6+ years of experience in Software Development. He has worked on various areas like designing scalable distributed applications, Compiler Development, Android Application Development and Performance Optimization.

  • Shop: buecher
  • Price: 9.49 EUR excl. shipping
• 

  Effective Software Testing (eBook, ePUB)

  Go beyond basic testing! Great software testing makes the entire development process more efficient. This book reveals a systemic and effective approach that will help you customize your testing coverage and catch bugs in tricky corner cases. In Effective Software Testing you will learn how to: Engineer tests with a much higher chance of finding bugs Read code coverage metrics and use them to improve your test suite Understand when to use unit tests, integration tests, and system tests Use mocks and stubs to simplify your unit testing Think of pre-conditions, post-conditions, invariants, and contracts Implement property-based tests Utilize coding practices like dependency injection and hexagonal architecture that make your software easier to test Write good and maintainable test code Effective Software Testing teaches you a systematic approach to software testing that will ensure the quality of your code. It's full of techniques drawn from proven research in software engineering, and each chapter puts a new technique into practice. Follow the real-world use cases and detailed code samples, and you'll soon be engineering tests that find bugs in edge cases and parts of code you'd never think of testing! Along the way, you'll develop an intuition for testing that can save years of learning by trial and error. About the technology Effective testing ensures that you'll deliver quality software. For software engineers, testing is a key part of the development process. Mastering specification-based testing, boundary testing, structural testing, and other core strategies is essential to writing good tests and catching bugs before they hit production. About the book Effective Software Testing is a hands-on guide to creating bug-free software. Written for developers, it guides you through all the different types of testing, from single units up to entire components. You'll also learn how to engineer code that facilitates testing and how to write easy-to-maintain test code. Offering a thorough, systematic approach, this book includes annotated source code samples, realistic scenarios, and reasoned explanations. What's inside Design rigorous test suites that actually find bugs When to use unit tests, integration tests, and system tests Pre-and post-conditions, invariants, contracts, and property-based tests Design systems that are test-friendly Test code best practices and test smells About the reader The Java-based examples illustrate concepts you can use for any object-oriented language. About the author Dr. Maurício Aniche is the Tech Academy Lead at Adyen and an Assistant Professor in Software Engineering at the Delft University of Technology. Table of Contents 1 Effective and systematic software testing 2 Specification-based testing 3 Structural testing and code coverage 4 Designing contracts 5 Property-based testing 6 Test doubles and mocks 7 Designing for testability 8 Test-driven development 9 Writing larger tests 10 Test code quality 11 Wrapping up the book

  • Shop: buecher
  • Price: 35.65 EUR excl. shipping
• 

  Designing Data-Intensive Applications

  Designing Data-Intensive Applications - The Big Ideas Behind Reliable Scalable and Maintainable Systems: ab 48.29 €

  • Shop: ebook.de
  • Price: 48.29 EUR excl. shipping
• 

  Distributed Services with Go

  Distributed Services with Go - Your Guide to Reliable Scalable and Maintainable Systems: ab 47.99 €

  • Shop: ebook.de
  • Price: 47.99 EUR excl. shipping

---

---