Code Reuse Quotes

Reusing existing code is the name of the game here, not just because it’s easier, but because I’d rather use code that works and has been tested, than create stuff from scratch.

Abstraction is useful in software because it allows the programmer to: • hide irrelevant detail, and concentrate on essentials. • present a “black box” interface to the outside world. The interface specifies the valid operations on the object, but does not indicate how the object will implement them internally. • break a complicated system down into independent components. This in turn localizes knowledge, and prevents undisciplined interaction between components. • reuse and share code.

In order to optimize the memory-dominated effects, let us try using the same method we used in Example 6-6 in order to reduce the number of allocations we make in our numpy code. Allocations are quite a bit worse than the cache misses we discussed previously. Instead of simply having to find the right data in RAM when it is not found in the cache, an allocation also must make a request to the operating system for an available chunk of data and then reserve it. The request to the operating system generates quite a lot more overhead than simply filling a cache — while filling a cache miss is a hardware routine that is optimized on the motherboard, allocating memory requires talking to another process, the kernel, in order to complete. In order to remove the allocations in Example 6-9, we will preallocate some scratch space at the beginning of the code and then only use in-place operations. In-place operations, such as +=, *=, etc., reuse one of the inputs as their output. This means that we don’t need to allocate space to store the result of the calculation.

Programmers become so familiar with code reuse that they often copy existing techniques even when they aren't actually copying code.

Notably, the core of NASA's approach to creating reusable classes does not involve "designing for reuse." NASA identifies reuse candidates at the ends of their projects. They then perform the work needed to make the classes reusable as a special project at the end of the main project or as the first step in a new project. This approach helps prevent "gold-plating"—creation of functionality that isn't required and that unnecessarily adds complexity.

When people write software, they are not writing it for themselves. In fact, they are not even writing primarily for the computer. Rather, good programmers know that code is written for the next human being who has to read it in order to maintain or reuse it. If that person cannot understand the code, it’s all but useless in a realistic development scenario.

Programming languages, their features, readability, and interoperation Code reuse across platforms (server vs web vs mobile) Early error detection (compile-time vs runtime error detection, breadth of validation) Availability and cost of hiring the right talent; learning curve for new hires Readability and refactorability of code Approach to code composition, embracing the change Datastore and general approach to data modeling Application-specific data model, and the blast radius from changing it Performance and latency in all tiers and platforms Scalability and redundancy Spiky traffic patterns, autoscaling, capacity planning Error recovery Logging, telemetry, and other instrumentation Reducing complexity User interfaces and their maintainability External APIs User identity and security Hardware and human costs of the infrastructure and its maintenance Enabling multiple concurrent development workstreams Enabling testability Fast-tracking development by adopting third-party frameworks

reuse is easiest within a project instead of between them. A manager's success depends on performance on a given project and not on performance over several projects. And preparing code for reuse requires additional work, not only by the reuse expert but also by developers. Therefore, preparing for reuse has a cost for any given project.

Our guild features were recently implemented by Jeremy Wood, who tested his new code with interior level designers Cameron, Dana, Jose, and Aaron by making them officers and allowing them to invite and promote other players. It was a lackluster test because there wasn’t very much to do other than using guild-chat to chat about the guild-chat feature—which wasn’t a very exciting discussion—but that was the first WoW guild-chat conversation, nevertheless. And what was the first WoW guild christened? “Assmaster.” Jeremy reused the name Assmaster as the first team arena name, too. The moniker foreshadowed the level of sophistication the game would soon enjoy. Whenever fans are given a modicum of creative control in a computer game, they fill it with penises and profanity, and developers aren’t any better.

Local power is also the realm of the small nonprofit, church, and civic association. A handful of people, properly organized, can drive enormous changes in a city’s dynamics. I’ll offer yet another example from Portland, Oregon. A group of water-conservation enthusiasts, frustrated at the illegal status of graywater reuse in the city and state, formed an organization called Recode. Although many in the group were young, among them they had built solid relationships with a number of local officials, business leaders, and other key people in the politics of the area. Recode pooled their respective connections to gather together relevant stakeholders, such as health officials, state legislature staff, the plumbing board, and developers. To the surprise of all, everyone at the meeting supported graywater use. So, everyone wondered, what was up? A state legislature staffer in attendance zeroed in on the main obstacle: There was no provision in the state codes for graywater. Legally, all of Oregon’s water fell into one of two categories, potable water or sewage. Since graywater was not potable, it had to be considered sewage. The staffer told them, “So, all we need to do is create a third water category, graywater.” They drafted a resolution doing that, got it to their state representative, and it passed at the next legislative session. After three subsequent years of bureaucratic wrangling and gentle pressure from Recode, graywater use became legal in Oregon. Recode then tackled urban composting toilets as their next target for legalization.

Standards make it easier to reuse ideas and components, recruit people with relevant experience, encapsulate good ideas, and wire components together. However, the process of creating standards can sometimes take too long for industry to wait, and some standards lose touch with the real needs of the adopters they are intended to serve.

Call an error-processing routine/object. Another approach is to centralize error handling in a global error-handling routine or error-handling object. The advantage of this approach is that error-processing responsibility can be centralized, which can make debugging easier. The tradeoff is that the whole program will know about this central capability and will be coupled to it. If you ever want to reuse any of the code from the system in another system, you'll have to drag the error-handling machinery along with the code you reuse.

NASA identifies reuse candidates at the ends of their projects. They then perform the work needed to make the classes reusable as a special project at the end of the main project or as the first step in a new project. This approach helps prevent "gold-plating"—creation of functionality that isn't required and that unnecessarily adds complexity.

Java includes inheritance, or the ability to derive new classes from existing classes. The derived class, also called a subclass, inherits all the data and functions of the existing class, referred to as the parent class. A subclass can add new data members to those inherited from the parent class. As far as methods are concerned, the subclass can reuse the inherited methods as is, change them, and/or add its own new methods. For example, the subclass VerbosePerson could be derived from the class Person, with the difference between instances of the Person class and instances of the VerbosePerson class being the way they identify themselves. The following code creates the subclass VerbosePerson and changes only the implementation of the method identifySelf:

NASA's Software Engineering Laboratory studied ten projects that pursued reuse aggressively (McGarry, Waligora, and McDermott 1989). In both the object-oriented and the functionally oriented approaches, the initial projects weren't able to take much of their code from previous projects because previous projects hadn't established a sufficient code base. Subsequently, the projects that used functional design were able to take about 35 percent of their code from previous projects. Projects that used an object-oriented approach were able to take more than 70 percent of their code from previous projects. If you can avoid writing 70 percent of your code by planning ahead, do it!

I have also seen many a team’s morale and productivity destroyed by having a mandated framework thrust upon them. In a drive to improve code reuse, more and more work is placed into a centralized framework until it becomes an overwhelming monstrosity.

We have come to the end of our vocabulary list and have not included one of the most mentioned terms in object literature—reuse. There are several reasons for this. First, reuse is not a goal of object thinking; composability is. Composable objects will be reused as a matter of course, so reuse is but a byproduct of a more general goal. Second, there are ways to obtain reuse that are not related to object thinking—code libraries, for example—and the distraction is not really helpful. Lastly, reuse was once touted as the premier benefit of object orientation—a claim that proved to be highly overstated. Worse, perhaps, was the claim that maximum reuse could best be obtained via inheritance. Object thinking claims to lead to the discovery and crafting of composable objects. The goal is to create a mindset that leads to evolving flexible applications and systems that directly reflect and support an application domain. Reuse will emerge, but it is not a driving force.

By coding functions and classes in module files, we’ve ensured that they naturally support reuse. And by coding our software as classes, we’ve ensured that it naturally supports extension.

Inheritance is best at coding extensions based on direct customization (like our Manager specialization of Person). Composition is well suited to scenarios where multiple objects are aggregated into a whole and directed by a controller layer class. Inheritance passes calls up to reuse, and composition passes down to delegate.

Specific Architectural Topics Is the overall organization of the program clear, including a good architectural overview and justification? Are major building blocks well defined, including their areas of responsibility and their interfaces to other building blocks? Are all the functions listed in the requirements covered sensibly, by neither too many nor too few building blocks? Are the most critical classes described and justified? Is the data design described and justified? Is the database organization and content specified? Are all key business rules identified and their impact on the system described? Is a strategy for the user interface design described? Is the user interface modularized so that changes in it won’t affect the rest of the program? Is a strategy for handling I/O described and justified? Are resource-use estimates and a strategy for resource management described and justified for scarce resources like threads, database connections, handles, network bandwidth, and so on? Are the architecture’s security requirements described? Does the architecture set space and speed budgets for each class, subsystem, or functionality area? Does the architecture describe how scalability will be achieved? Does the architecture address interoperability? Is a strategy for internationalization/localization described? Is a coherent error-handling strategy provided? Is the approach to fault tolerance defined (if any is needed)? Has technical feasibility of all parts of the system been established? Is an approach to overengineering specified? Are necessary buy-vs.-build decisions included? Does the architecture describe how reused code will be made to conform to other architectural objectives? Is the architecture designed to accommodate likely changes? General Architectural Quality Does the architecture account for all the requirements? Is any part overarchitected or underarchitected? Are expectations in this area set out explicitly? Does the whole architecture hang together conceptually? Is the top-level design independent of the machine and language that will be used to implement it? Are the motivations for all major decisions provided? Are you, as a programmer who will implement the system, comfortable with the architecture?