Object Oriented Programming Quotes

Object-oriented programming offers a sustainable way to write spaghetti code. It lets you accrete programs as a series of patches.

Code without tests is bad code. It doesn't matter how well written it is; it doesn't matter how pretty or object-oriented or well-encapsulated it is. With tests, we can change the behavior of our code quickly and verifiably. Without them, we really don't know if our code is getting better or worse.

All race conditions, deadlock conditions, and concurrent update problems are due to mutable variables.

PHP as an object oriented programming language should be judged by how well it does the job, not on a preconceived notion of what a scripting language should or shouldn't do.

Armstrong: I think the lack of reusability comes in object-oriented languages, not in functional languages. Because the problem with object-oriented languages is they've got all this implicit environment that they carry around with them. You wanted a banana but what you got was a gorilla holding the banana and the entire jungle.

Here is a minimal list of the things that every software professional should be conversant with: • Design patterns. You ought to be able to describe all 24 patterns in the GOF book and have a working knowledge of many of the patterns in the POSA books. • Design principles. You should know the SOLID principles and have a good understanding of the component principles. • Methods. You should understand XP, Scrum, Lean, Kanban, Waterfall, Structured Analysis, and Structured Design. • Disciplines. You should practice TDD, Object-Oriented design, Structured Programming, Continuous Integration, and Pair Programming. • Artifacts: You should know how to use: UML, DFDs, Structure Charts, Petri Nets, State Transition Diagrams and Tables, flow charts, and decision tables. Continuous

As usual, though, if you find yourself running into a wall, stop running into a wall!

One was how computers could be networked; the second was how object-oriented programming worked.

But while you can always write 'spaghetti code' in a procedural language, object-oriented languages used poorly can add meatballs to your spaghetti.

var person = {name: "John",                surname: "Smith",                address: {                  street: "13 Duncannon Street",                  city: "London",                  country: "United Kingdom"                }};

The most powerful kind of code constructs other code that has been bundled with just the right amount of curated data; such a bundle is not just a “function pointer” but a closure (in a functional language) or an object (in an object-oriented language).

I grow little of the food I eat, and of the little I do grow I did not breed or perfect the seeds. I do not make any of my own clothing. I speak a language I did not invent or refine. I did not discover the mathematics I use. I am protected by freedoms and laws I did not conceive of or legislate, and do not enforce or adjudicate. I am moved by music I did not create myself. When I needed medical attention, I was helpless to help myself survive. I did not invent the transistor, the microprocessor, object oriented programming, or most of the technology I work with. I love and admire my species, living and dead, and am totally dependent on them for my life and well being.

Every night, millions of Americans spend their free hours watching television rather than engaging in any form of social interaction. What are they watching? In recent years we have seen reality television become the most popular form of television programming. To discover the nature of our current “reality,” we might consider examples such as Survivor, the series that helped spawn the reality TV revolution. Every week tens of millions of viewers watched as a group of ordinary people stranded in some isolated place struggled to meet various challenges and endure harsh conditions. Ah, one might think, here we will see people working cooperatively, like our ancient ancestors, working cooperatively in order to “win”! But the “reality” was very different. The conditions of the game were arranged so that, yes, they had to work cooperatively, but the alliances by nature were only temporary and conditional, as the contestants plotted and schemed against one another to win the game and walk off with the Grand Prize: a million dollars! The objective was to banish contestants one by one from the deserted island through a group vote, eliminating every other contestant until only a lone individual remained—the “sole survivor.” The end game was the ultimate American fantasy in our Age of Individualism: to be left completely alone, sitting on a mountain of cash! 　　While Survivor was an overt example of our individualistic orientation, it certainly was not unique in its glorification of rugged individualists on American television. Even commercial breaks provide equally compelling examples, with advertisers such as Burger King, proclaiming, HAVE IT YOUR WAY! The message? America, the land where not only every man and every woman is an individual but also where every hamburger is an individual! 　　Human beings do not live in a vacuum; we live in a society. Thus it is important to look at the values promoted and celebrated in a given society and measure what effect this conditioning has on our sense of independence or of interdependence

For example, consider a stack (which is a first-in, last-out list). You might have a program that requires three different types of stacks. One stack is used for integer values, one for floating-point values, and one for characters. In this case, the algorithm that implements each stack is the same, even though the data being stored differs. In a non-object-oriented language, you would be required to create three different sets of stack routines, with each set using different names. However, because of polymorphism, in Java you can create one general set of stack routines that works for all three specific situations. This way, once you know how to use one stack, you can use them all. More generally, the concept of polymorphism is often expressed by the phrase “one interface, multiple methods.” This means that it is possible to design a generic interface to a group of related activities. Polymorphism helps reduce complexity by allowing the same interface to be used to specify a general class of action.

You normally shouldn’t do this, though — it’s not the Python way.

Cohesion: each function should have a single, unified purpose. When designed well, each of your functions should do one thing — something you can summarize in a simple declarative sentence. If that sentence is very broad (e.g., “this function implements my whole program”), or contains lots of conjunctions (e.g., “this function gives employee raises and submits a pizza order”), you might want to think about splitting it into separate and simpler functions.

getattr employs the inheritance search protocol, and some of the names we’re listing here are not stored on the instance itself.

Python programmers are able to write large OOP frameworks and applications without private declarations — an interesting finding about access controls in general that is beyond the scope of our purposes here.

This method is a bit trickier to use, though, because assigning to any self attributes within __setattr__ calls __setattr__ again, potentially causing an infinite recursion loop (and a fairly quick stack overflow exception!).

If you wish to use this method, you can avoid loops by coding instance attribute assignments as assignments to attribute dictionary keys. That is, use self.__dict__['name'] = x, not self.name = x; because you’re not assigning to __dict__ itself, this avoids the loop:

Third, and perhaps most subtle, the display methods also have the potential to trigger infinite recursion loops in rare contexts — because some objects’ displays include displays of other objects, it’s not impossible that a display may trigger a display of an object being displayed, and thus loop. This is rare and obscure enough to skip here, but watch for an example of this looping potential to appear for these methods in a note near the end of the next chapter in its listinherited.py example’s class, where __repr__ can loop.

Of course, as I’ve pointed out numerous times in this book, type checking is usually the wrong thing to do in Python programs (we code to object interfaces, not object types), and the more general isinstance built-in is more likely what you’ll want to use in the rare cases where instance class types must be queried.

In fact, type itself derives from object, and object derives from type, even though the two are different objects — a circular relationship that caps the object model and stems from the fact that types are classes that generate classes:

This search order is called the new-style MRO for “method resolution order” (and often just MRO for short when used in contrast with the DFLR order). Despite the name, this is used for all attributes in Python, not just methods.

within a class statement only, any names that start with two underscores but don’t end with two underscores are automatically expanded to include the name of the enclosing class at their front.

Technically speaking, classes belong in the callable objects category too, but we normally call them to generate instances rather than to do actual work —

Factories can be a major undertaking in a strongly typed language such as C++ but are almost trivial to implement in Python.

everything is a “first class” object in Python —

In new-style classes (optional in 2.X and standard in 3.X), the attribute search is usually as before, but in diamond patterns proceeds across by tree levels before moving up, in a more breadth-first fashion. This order is usually called the new-style MRO, for method resolution order, though it’s used for all attributes, not just methods.

In a sense, mix-in classes are similar to modules: they provide packages of methods for use in their client subclasses.

Although it’s possible to emulate true access controls in Python classes, this is rarely done in practice, even for large systems.

I took 17 computer science classes and made an A in 11 of them. 1 point away from an A in 3 of them and the rest of them didn't matter. Math is a tool for physics,chemistry,biology/basic computation and nothing else. CS I(Pascal Vax), CS II(Pascal Vax), Sr. Software Engineering, Sr. Distributed Systems, Sr. Research, Sr. Operating Systems, Sr. Unix Operating Systems, Data Structures, Sr. Object Oriented A&D, CS (perl/linux), Sr. Java Programming, Information Systems Design, Jr. Unix Operating Systems, Microprocessors, Programming Algorithms, Calculus I,II,III, B Differential Equations, TI-89 Mathematical Reasoning, 92 C++ Programming, Assembly 8086, Digital Computer Organization, Discrete Math I,II, B Statistics for the Engineering & Sciences (w/permutations & combinatorics) -- A-American Literature A-United States History 1865 CLEP-full year english CLEP-full year biology A-Psychology A-Environmental Ethics

PYTHONPATH and .pth files offer more permanent ways to modify the path — the first per user, and the second per installation.

Common practice dictates that overloaded operators should work the same way that built-in operator implementations do.

On the other hand, you might decide to use operator overloading if you need to pass a user-defined object to a function that was coded to expect the operators available on a built-in type like a list or a dictionary.

the attributes of a namespace object are usually implemented as dictionaries, and class inheritance trees are (generally speaking) just dictionaries with links to other dictionaries.

but slots — and other “virtual” attributes — won’t be reported as instance data.

Because shelves are Python objects containing Python objects, we can process them with normal Python syntax and development modes. Here, the interactive prompt effectively becomes a database client:

ZODB, for example, is similar to Python’s shelve but addresses many of its limitations, better supporting larger databases, concurrent updates, transaction processing, and automatic write-through on in-memory changes (shelves can cache objects and flush to disk at close time with their writeback option, but this has limitations: see other resources).

Although we can store functions in dictionaries, too, using them to process implied instances is nowhere near as natural and structured as it is in classes.

In a sense, a module is like a single-instance class, without inheritance, which corresponds to an entire file of code.

Class attributes can also be created, though, by assigning attributes to the class anywhere a reference to the class object exists — even outside the class statement.

Again, though, they may be created by assignment anywhere a reference to the instance appears, even outside the class statement. Normally, all instance attributes are initialized in the __init__ constructor method; that way, later method calls can assume the attributes already exist.

Operator overloading is coded in a Python class with specially named methods; they all begin and end with double underscores to make them unique. These are not built-in or reserved names; Python just runs them automatically when an instance appears in the corresponding operation.

Despite its syntax details, Python’s class system really is largely just a matter of searching for an attribute in a tree of objects, along with a special first argument for functions.

Although other techniques (such as enclosing scope reference closures) can save details, too, instance attributes make this very explicit and easy to understand.

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.

On a related note, you can also code multiple __init__ methods within the same class, but only the last definition will be used; see Chapter 31 for more details on multiple method definitions.

Like a def, a class statement is an object builder, and an implicit assignment — when run, it generates a class object and stores a reference to it in the name used in the header.

Every time you use an expression of the form object.attr where object is an instance or class object, Python searches the namespace tree from bottom to top, beginning with object, looking for the first attr it can find.

In other words, the age-old acronym KISS still applies: Keep It Simple — followed either by a word that is today too sexist (Sir), or another that is too colorful for a family-oriented book like this...

As the prior section suggested, these classes usually return their objects directly for single-iteration behavior, or a supplemental object with scan-specific state for multiple-scan support.

remember that generator functions simply return objects with methods that handle next operations run by for loops at each level, and don’t produce any results until iterated; and

that’s why we need recursion here: the number of nested loops is arbitrary, and depends on the length of the sequence permuted:

By yielding results as it goes, the walker does not require its clients to wait for an entire tree to be scanned.

Notice that compilation happens when a file is being imported. Because of this, you will not usually see a .pyc byte code file for the top-level file of your program, unless it is also imported elsewhere — only imported files leave behind .pyc files on your machine.

Best practice in all Pythons recommends listing all your imports at the top of a module file; it’s not required, but makes them easier to spot.

To minimize the chances of name collisions like this, Python programmers often prefix methods not meant for external use with a single underscore: _gatherAttrs in our case.

A better and less commonly used solution would be to use two underscores at the front of the method name only: __gatherAttrs for us. Python automatically expands such names to include the enclosing class’s name, which makes them truly unique when looked up by the inheritance search. This is a feature usually called pseudoprivate class attributes, which we’ll expand on in Chapter 31 and deploy in an expanded version of this class there.

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.

We’ll use from to load in our script, just because it’s a bit less to type.

All the statements inside the class statement run when the class statement itself runs (not when the class is later called to make an instance).

In general, though, any type of name assignment at the top level of a class statement creates a same-named attribute of the resulting class object.

In Chapter 32, we’ll also meet Python static methods (akin to those in C++), which are just self-less functions that usually process class attributes.

Assignments to instance attributes create or change the names in the instance, rather than in the shared class.

Assignments to instance attributes create or change the names in the instance, rather than in the shared class. More generally, inheritance searches occur only on attribute references, not on assignment:

Normally we create instance attributes by assigning them in class __init__ constructor methods, but this isn’t the only option.

That is, a class is a local scope and has access to enclosing local scopes, but it does not serve as an enclosing local scope to further nested code.

In fact, within Python, instance and class objects are mostly just dictionaries with links between them.

Python “best practice” rule of thumb is to use docstrings for functional documentation (what your objects do) and hash-mark comments for more micro-level documentation (how arcane bits of code work).

Inheritance-tree climbing happens only on attribute reference, not on attribute assignment.

attribute access (a.k.a. qualification)

any function that contains a yield statement is turned into a generator function.

Technically, instance creation first triggers the __new__ method, which creates and returns the new instance object, which is then passed into __init__ for initialization.

We’ll see one use case for __new__ when we study metaclasses in Chapter 40; though rare, it is sometimes also used to customize creation of instances of immutable types.

for calls iter, which calls __iter__

give people a tool, and they’ll code for a day; teach them how to build tools, and they’ll code for a lifetime. This

you can do everything in Python that you can in Perl, but

JavaScript doesn’t have a classical object-oriented model, where you create objects from classes. In fact, JavaScript doesn’t have classes at all. In JavaScript, objects inherit behavior from other objects, which we call prototypal inheritance, or inheritance based on prototypes.

JavaScript has a very powerful object model, but one that is a bit different than the status quo object-oriented language. Rather than the typical class-based object-oriented system, JavaScript instead opts for a more powerful prototype model, where objects can inherit and extend the behavior of other objects. What

pdb also includes a postmortem function (pdb.pm()) that you can run after an exception occurs, to get information from the time of the error. See

In the Python way of thinking, explicit is better than implicit, and simple is better than complex.1

This description requires elaboration when the value and the slice being assigned overlap: L[2:5]=L[3:6], for instance, works fine because the value to be inserted is fetched before the deletion happens on the left.

In general terms, the loop else simply provides explicit syntax for a common coding scenario — it is a coding structure that lets us catch the “other” way out of a loop, without setting and checking flags or conditions.

In Python, practicality often beats aesthetics.

when in Pythonland, do as Pythonistas do, not as C programmers do.

The name used as the assignment target in a for header line is usually a (possibly new) variable in the scope where the for statement is coded. There’s not much unique about this name; it can even be changed inside the loop’s body, but it will automatically be set to the next item in the sequence when control returns to the top of the loop again.

I don’t predict the demise of object-oriented programming, by the way. Object-oriented programming offers a sustainable way to write spaghetti code.

one way in which Scala is more object-oriented than Java is that classes in Scala cannot have static members.

let

from directly.

PART II Introduction To Object-Oriented Programming

As an educator, I’ve sometimes found the rate of change in Python and its libraries to be a negative, and have on occasion lamented its growth over the years. This is partly because trainers and book authors live on the front lines of such things — it’s been my job to teach the language despite its constant change, a task at times akin to chronicling the herding of cats!

freedom of expression is great for art, but lousy for engineering.

As the 1970s drew to a close, and Commodore, Tandy, Altair, and Apple began to emerge from the sidelines, PARC director Bert Sutherland asked Larry Tesler to assess what some analysts were already predicting to be the coming era of “hobby and personal computers.” “I think that the era of the personal computer is here,” Tesler countered; “PARC has kept involved in the world of academic computing, but we have largely neglected the world of personal computing which we helped to found.”41 His warning went largely unheeded. Xerox Corporation’s parochial belief that computers need only talk to printers and filing cabinets and not to each other meant that the “office of the future” remained an unfulfilled promise, and in the years between 1978 and 1982 PARC experienced a dispersal of core talent that rivals the flight of Greek scholars during the declining years of Byzantium: Charles Simonyi brought the Alto’s Bravo text editing program to Redmond, Washington, where it was rebooted as Microsoft Word; Robert Metcalf used the Ethernet protocol he had invented at PARC to found the networking giant, 3Com; John Warnock and Charles Geschke, tiring of an unresponsive bureaucracy, took their InterPress page description language and founded Adobe Systems; Tesler himself brought the icon-based, object-oriented Smalltalk programming language with him when he joined the Lisa engineering team at Apple, and Tim Mott, his codeveloper of the Gypsy desktop interface, became one of the founders of Electronic Arts—five startups that would ultimately pay off the mortgages and student loans of many hundreds of industrial, graphic, and interaction designers, and provide the tools of the trade for untold thousands of others.

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.

Object-oriented programming had boldly promised “to model the world.” Well, the world is a scary place where bad things happen for no apparent reason, and in this narrow sense I concede that OO does model the world.

Containment is the simple idea that a class contains a primitive data element or object. A lot more is written about inheritance than about containment, but that's because inheritance is more tricky and error-prone, not because it's better. Containment is the work-horse technique in object-oriented programming.

I don’t predict the demise of object-oriented programming, by the way. Though I don’t think it has much to offer good programmers, except in certain specialized domains, it is irresistible to large organizations. Object-oriented programming offers a sustainable way to write spaghetti code. It lets you accrete programs as a series of patches. Large organizations always tend to develop software this way, and I expect this to be as true in a hundred years as it is today.

a way, processes in Elixir are like objects in an object-oriented system (but they have a better sense of humor).