by | Released December 2014 | ISBN: 013404973X

Understanding Applied Hierarchical Reuse is the gateway to achieving dramatic practical productivity gains for any enterprise engaged in large-scale C++ software development, spanning many versions of many products maintained over a substantial period of time.   DescriptionIn this video training, John Lakos surveys problems associated with very large scale C++ development, and the cohesive techniques to address those problems, culminating in a proven component-based methodology refined through his practical experience at Bloomberg. The real-world application of this methodology—including three levels of aggregation, acyclic dependencies, nominal cohesion, fine-grained factoring, class categories, narrow contracts, and thorough component-level testing—will be demonstrated using the recently released open-source distribution of Bloomberg's foundation libraries. After watching the video, viewers will be in an excellent position to selectively delve deeper into the various separate aspects of this comprehensive development methodology. Skill Level• Intermediate • Advanced Topics Covered• Hierarchical Reuse • Sound Physical Design • Components, Packages, and Package Groups • Logical/Physical Synergy • Value Semantics • (Unique) Vocabulary Types • Design by Contract (DbC) • Defensive Programming • Component-Level Test Drivers • Peer Review • Static Analysis Tools • (Customizable) Defensive Checks • Fully Factored SolutionsWho Should Take This Course• Enterprise Architects, Team Leads, and Senior Software Developers looking to better understand how to organize and package their software to achieve more efficient, firm-wide (hierarchical) reuse.Course Requirements• Some familiarity with developing fairly large software systems. • A good (but not necessarily expert) understanding of the C/C++ family of programming languages.  Lesson 1: GoalsIn the first part of this talk, John distinguishes between fine-grained, hierarchical software reuse with the software reuse that is typical of our industry. He also compares the cost of creating highly reusable software (which has  very high standards of design, implementation, documentation, and verification) to the benefits of that investment.Lesson 2: Process and ArchitectureIn the second part of this talk, John differentiates between the  logical design of software (in brief, the partitioning of software into classes and functions) and the  physical design of software (the partitioning of software into files and libraries). He explains the pitfalls of ignoring the relationship between these two dimensions of software engineering and presents a set of principles and specific rules for the creation of components, packages (of components), and package groups (organization that supports the creation of highly reusable software).Lesson 3: Design and ImplementationIn the third part of this talk, John explores many aspects of implementing high quality software. He describes categorization of classes that enable users to solve application problems in terms of well-understood, standard types (a form of design pattern). Chief among these well-known types is the  value-semantic type. The author's exploration of design-by-contract shows how defining  narrow contracts for our interfaces (i.e., contracts that allow for undefined behavior in some circumstances) make possible defensive programing techniques that help achieve correctness during development while avoiding needless checks in production. Finally, he shows documentation rules that have been applied rigorously and effectively over a very large and diverse set of libraries.Lesson 4: Verification and TestingThe fourth part of this talk shows how organization of software into components that have no cyclic dependencies, all written to very clearly defined contracts, provides us with software units that are amenable to extremely comprehensive, scalable testing. Moreover, levelization reappears as a way to organize the testing of the many methods of individual classes.Lesson 5: The Bloomberg Development (BDE)The final part of this talk shows that the principles and rules presented in the first parts are not mere philosophical ideals but have been used to create the BDE libraries, foundation software for a major commercial enterprise. A portion of BDE is now available as open source, so this part provides a brief introduction to facilities that are available for reuse and study.About LiveLessons Video TrainingLiveLessons Video Training series publishes hundreds of hands-on, expert-led video tutorials covering a wide selection of technology topics designed to teach you the skills you need to succeed. This professional and personal technology video series features world-leading author instructors published by your trusted technology brands: Addison-Wesley, Cisco Press, IBM Press, Pearson IT Certification, Prentice Hall, Sams, and Que. Topics include IT Certification, Programming, Web Development, Mobile Development, Home and Office Technologies, Business and Management, and more. View all LiveLessons on InformIT at:  http://www.informit.com/livelessons Show and hide more

1. Introduction
   • Large-Scale C++ LiveLessons—Workshop: Introduction 00:00:40
2. Lesson 1: Goals
   • What's the Problem? 00:03:50
   • What Is Hierarchical Reuse? 00:16:26
   • Achieving Wide-Spread Reuse 00:22:17
3. Lesson 2: Process and Architecture
   • Introduction: The "Big Ball of Mud" 00:05:45
   • Regular, Fine-Grained "Components"--Part 1 00:29:22
   • Regular, Fine-Grained "Components"--Part 2 00:26:29
   • Logical/Physical Coherence 00:04:59
   • Logical and Physical Name Cohesion 00:19:40
   • From Development to Deployment 00:03:38
4. Lesson 3: Design and Implementation
   • The Value of a Value 00:20:58
   • Classifying Classes 00:08:27
   • (Unique) Vocabulary Types 00:14:17
   • Template Parameters/Policies 00:16:47
   • Design-by-Contract (DbC) 00:26:32
   • Appropriately Narrow Contracts 00:24:57
   • An Overriding Customer Focus 00:16:57
5. Lesson 4: Verification and Testing
   • Component-Level Testing 00:25:23
   • Peer Review and Static Analysis 00:04:08
   • Defensive (Precondition) Checks 00:12:39
6. Lesson 5: Bloomberg Development Environment
   • The BSL Package Group 00:05:16
   • Custom Memory Allocators in BDL 00:03:58
   • Designing with Components 00:14:48
7. Summary
   • Large-Scale C++ LiveLessons—Workshop: Summary 00:01:52
Show and hide more



9780134049731.large.scale.c.livelessonsworkshop.OR.part1.rar

9780134049731.large.scale.c.livelessonsworkshop.OR.part2.rar