Holub on Patterns 211
| Holub on Patterns: Learning Design Patterns by Looking at Code | |
| author | Allen Holub |
| pages | 414 |
| publisher | Apress |
| rating | 9 |
| reviewer | James Edward Gray II |
| ISBN | 159059388X |
| summary | Design Patterns taught through Real World Programs. |
If I can level any complaint against this book, it's probably that the title doesn't properly convey the goodness locked within. Holub on Patterns is short for Allen Holub on Design Patterns. Allen Holub is a long time expert on Design and Design Patterns, so he's the man you want to learn it from. Still, if I could name this book, it would be Object Oriented Design Voodoo. (Note: This is probably why I don't work for Apress or any other publisher.)
The book's subtitle is "Learning Design Patterns by Looking at Code." That probably conveys the work's focus a little better and it also gives away one of the book's best features: sensational examples. (These examples are in Java, another area where Holub is a well-known authority, but the concepts taught apply to Object Oriented Programming in any language.)
Titles aside, this book really is the best work I've read on design patterns. If you don't already know, design patterns are the recurring patterns of object-oriented software implementations. Luckily, you don't have to know anything about them to read this book. The author covers many patterns in rich detail from the beginning. Even if you do know your design patterns well, I'll wager Holub still has a trick or two to impress you with.
Holub discusses patterns in their ideal pure form, but much more importantly he shows them as they occur "in the wild," with multiple variations. He covers the downside of each pattern, weights the trade-offs of using them, and even gives a handful of cases where he felt they were impractical. He does all this right in the middle of complex real-world examples so you can see each point he's making. That's actual programming, folks. The good, the bad and the choices we programmers make are well presented, and that's rare in a programming text.
The book opens with two chapters that more or less cover why we need design patterns at all. Did you know getters/setters are bad? Did you know that subclassing is dangerous? If you said No to either question, you need this book and these two chapters in particular will get you up to speed on good OO practices. This section of the book is mostly theory, light on examples.
The next two chapters (covering over 250 pages) make up the heart of the book. Holub examines two examples in exhaustive detail. The first is his implementation of The Game of Life. You've probably implemented that on your TI calculator, but Holub sure didn't. He admits that his implementation is "Toy Code," but it's a robust example that involves eleven design patterns. The second example is production code, a mini database complete with SQL interpreter. This code is also swimming in pattern usage, and Holub gives you the guided tour.
I've already said these examples are great, but that claim begs some elaboration. First, we're talking about hundreds of lines of code in many of these listings. These aren't the usual contrived junk. What's more, one class may be participating in multiple patterns. Making any sense of these examples would be almost impossible if the author wasn't flawless in explaining the key points and always dropping hints about what you need to notice. This isn't light reading. It's work, but the rewards are there and it'll pay off if you really spend the effort to understand how the code works.
Finally, the book closes with an appendix that gives more typical recipe-card style listings of all the design patterns discussed throughout the text. This is a nice reference after you've finished the tricky stuff. If you're new to design patterns, you might start here, before the book throws you into the lion's den with its massive examples.
Just in case I haven't sold you on this title yet, I better mention the gorgeous hard back binding. Brilliant and sexy. How can you beat that?
Holub on Patterns is a very approachable way to learn a lot about design patterns. If you already know how much patterns can improve your object-oriented programming, you'll really enjoy Holub's presentation of the topic. If you don't yet grasp Design Patterns or haven't enjoyed other works on the subject, you'll just have to trust me: You want this book.
You can purchase Holub on Patterns: Learning Design Patterns by Looking at Code from bn.com. Slashdot welcomes readers' book reviews -- to see your own review here, read the book review guidelines, then visit the submission page.
Witch doctors (Score:3, Funny)
Great, now we're getting book reviews by witch doctors!
Homestar quote... (Score:1)
What? Is that supposed to be some sort of witch's brew?
Official site (Score:5, Informative)
Getters/setters bad? (Score:5, Interesting)
Can someone explain why accessor and mutator methods (I assume this is what he means by "getters/setters") are bad?
Re:Getters/setters bad? (Score:2, Insightful)
Properties allow you to wrap your fields with business logic and validation, so I don't see what's so bad about that.
Re:Getters/setters bad? (Score:3, Interesting)
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:5, Insightful)
My guess is that in some instances, publically accessible getter/setter methods can be construed to be "exposing the underlying implementation" of a class. Of course, that just means you need to judiciously use getter and setter methods.
That's my guess at least. I suppose I should read the book.
Re:Getters/setters bad? (Score:2)
My guess is that in some instances, publically accessible getter/setter methods can be construed to be "exposing the underlying implementation" of a class. Of course, that just means you need to judiciously use getter and setter methods.
Hmm, so don't make them all public? I agree that classes should only let you get and set things that are meaningful outside the class by things like V
Re:Getters/setters bad? (Score:4, Informative)
It took some time before Holub convinced me with his articles on Javaworld. But when I was convinced, I looked forward to the release of his book, which I have bought immediately.
BTW. Accessor/Mutator methods aren't bad always though, for example, when you use them to access a non-object-oriented part of your software system (e.g. file system / database / GUI widgets)..
Re:Getters/setters bad? (Score:3, Insightful)
Re:Getters/setters bad? (Score:4, Informative)
Re:Getters/setters bad? (Score:2)
More-OO-than-thou religious fanatics (Score:4, Insightful)
Then there was the "inheritance is bad" deal where everything is to be done with composition and you have to write gobs of forwarding methods between the object and the object it contains.
Now there is this "Get/Set is harmful" -- no, "Evil" I say because this is a matter of religion. So what are you supposed to do when you need to get some representation of state out of an object -- to display it? Can you do a getStateValue()? Oh, no! You have to hand that object an AWT graphics context object and have the object render itself. So much for reusing that object outside of Java.
Or in another Golub article referenced on this topic, you are not supposed to have set functions to initialize an object to a required state -- you are supposed to pass your object a "Visitor" or "Strategy" object that supplies the state -- through what? An interface with a whole raft of get functions?
Suppose the approach was, "Do you have a whole lot of get methods on an object? Why are they there? Is it because you need to retrieve the state of an object to print it out? Have you considered giving your object a Print() method and getting rid of all of the get methods? Are you concerned that your object is now hard-wired into a particular print driver? Have you considered implementing an abstract print interface and implementing void Print(IPrintInterface my_printer) as the Print method?"
But no. The approach is that get/set is "evil" or "smells bad" or some such thing. An object with get/set is a kind of shame and you have to go to extreme contortions in your code, spinning off bunches of classes you never needed before to avoid the embarrassment of having get/set.
Draw thyself?! (Score:3, Insightful)
When I first read that, I assumed you were joking, and had just made that up as an absurd example to exaggerate the author's point. Then I read TFA, and realised that Holub himself advocated exactly that. Talk about getting your priorities completely wrong!
G
Re:Getters/setters bad? (Score:5, Informative)
Re:Getters/setters bad? (Score:4, Insightful)
Apparently the argument against getter / setter functions goes..
While the logic is sound, I think that item #2 is debatable.. If you design an object and mindlessly add get/set functions for every piece of private data in the object, then you're probably guilty of exposing the implementation. But if you design the object's public interface first, and decide on the private data afterwards, I would guess that you're probably in the clear to have used get/set functions "correctly." IMO it's not the functions themselves that are the problem, but rather the adherence to correct design principles.
Re:Getters/setters bad? (Score:2, Funny)
That's why we don't call hash tables HashTables, we call them "unorderedBagsIndexedByArbitraryKeysWithConstantT
Re:Getters/setters bad? (Score:4, Insightful)
But you don't code to the interface(api) of a HashTable. You code to the Map interface, which is described as: "
An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value."
And you don't(Should not) give a HashTable to a method. Give it a Map insted. The only place in your code where the exact type matters, is where you create the object.
That most people call them hashtables insted of associative array(or maps) are because they mix implementation and interface.
I once did implement a Map using a linked list. Not effective, but a nice way to show the difference between interface and implementation.
Re:Getters/setters bad? (Score:3, Insightful)
Map someMapINeed = new HashMap();
so that the implementation chosen (HashMap, the Java 1.2+ expression of the general idea of a hash table) is present only at that one spot, the rest of the code doesn't care about the Hashness of it, it just uses it as a Map.
It is a common "smell" in Java code, to refer to something specific (HashMap) in a parameter list (most commonly) when you only need the generic.
Re:Getters/setters bad? (Score:4, Insightful)
As I said just like the old days.
Re:Getters/setters bad? (Score:2)
Not that I'd see this as the most gigantic leap ever done in programming, but it adds to a general repertoire of best practices, which, as a whole, is imho a lot more than just "coming ba
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:2)
I agree entirely. Too much of anythi
Re:Getters/setters bad? (Score:3, Insightful)
Data objects are just groupings of data. The member variables should be public and accessible to it's users.
Interface objects, however, encapsulate their data. They don't require the user to know about their internal data members and only provide methods members that the outside world can use to perform actions with that object.
In the first case, you don't need getters and setters because the members are already public
Re:Getters/setters bad? (Score:5, Insightful)
Having public members is generally a bad idea and gives me nightmares of old C structures. Here is the reason that you should use set/get methods:
1. Debugging - Try and trace a variable every time it is set when the variables are public. Wonder why you can't figure where it is going wrong? Adding 100 break points? Using set/get here can save hours of debugging.
2. No loss of Speed - most compilers will optomize your set/get functions if they are inline, so there is no performance penalty (atleast for c++).
3. Maintainance - Suppose that when data member A is updated, now a count needs to be kept. Using a setter function allows you to change code in one 1 place. Also, suppose a variable type changes from an int to a double. You can still keep around the integer setters/getters for older classes and use new accessor for the new methods for objects that need it.
From the article, its not that setters/getters are bad themselves, but that overuse of them is bad. Here is the key quote: Don't ask for the information you need to do the work; ask the object that has the information to do the work for you.
Re:Getters/setters bad? (Score:2)
Make data members private, except in behaviorless aggregates (C-style structs).
We've gone round and round on this where I work but the long and the short it is that Sutter and Alexandrescu are correct. Large collections of setters/getters are generally signs of a bad design. If you have a struct that maybe has some basic functionality that isn't germain to the purpose of the class then simplify it and put it in structs. If it does something then design it so
Re:Getters/setters bad? (Score:3, Insightful)
Re:Getters/setters bad? (Score:3, Insightful)
At some stage you will have to get some data from an object. Very simple example, lets say you are writing up a shopping cart. Add item objects to the cart. How will this cart keep track of the subtotal without querying the item objects as to their price?
OK, we have:
cart.add(item);
At some stage the cart object will have to call: item.getPrice();
Very simple example, but I a
Re:Getters/setters bad? (Score:2)
Hmm...
Re:Getters/setters bad? (Score:2)
The key concept is encapsulation. If you expose your attribute (price) to the whole world, then an unlimited number of clients can couple themselves to this, creating brittle code. So use a Builder pattern [c2.com]. Define an interface for exporting information about your Item object. For som
Re:Getters/setters bad? (Score:2)
Do you often write a shopping application, and then find that the items for sale no longer have a price? Ensuring that the Price type is user-defined (if only as a synonym for double at first) should be plenty of future-proofing for now.
Re:Getters/setters bad? (Score:3, Informative)
Consider this, the addToCart() method is implemented in the Item object. Elsewhere in the system, we want to implement an Invoice object. The Invoice
Re:Getters/setters bad? (Score:2)
item.addToCart()
Item object must know that it is being added to a cart. Item object must internally in the addToCart() method call Cart methods to add itself anyway - how else will the Ca
Re:Getters/setters bad? (Score:4, Interesting)
Data objects are just groupings of data. The member variables should be public and accessible to it's users.
This is the only thing I disagree with in that. I believe that a get/set interface to data objects is in fact the only right place for get/setters.
Why? Because you might want to abstract that data object into something more intelligent in a later refactoring, and then you have the burden of replacing every variable reference in everything that touches that class. Nasty, nasty stuff, and it's better to design that nastiness out in the first place.
I believe in no public member variables, as a general rule (breakable, of course, on occasion, but terribly rarely), as it causes too tight a binding between classes and the value objects that are passed around (called 'tying' by some). This may put me at odds with Holub (I haven't read this book yet), but it wouldn't be the first time.
Holub is an EXCEPTIONALLY good introductory author, very easy to read, and clearly brings you to the point he's trying to make. However, I recall coming back to his C books after many years as a professional developer, re-reading them out of curiousity, and realizing that he was teaching a few principles that were questionable at best, and ignored at-the-time best practices. Now it's very possible that he would also think they are questionable these days, but putting them in a book lends them an air of authority through time.
I'll probably pick up the book, as more examples of good pattern use are always valuable, but as an engineer who has developed countless classes where 'value objects' become more intelligent, I strongly recommend against direct member variable access.
-- Morgan Schweers, CyberFOX!
Re:Getters/setters bad? (Score:3, Insightful)
Re:Getters/setters bad? (Score:2)
A telling quote from Holub's article on his site about getters/setters...
We do know how we will use the classes, so you don't have to waste time building unnecessary flexibility.
His article actually explicitly is against the public accessible groupings of data, preferring instead what is (to me) equally distasteful, which is having the 'data objects' know everything that could be done with them, and contain the functionality to do it all. This is fine if you never need flexibility in your dat
Re:Getters/setters bad? (Score:4, Insightful)
Of course, being a programmer also means knowing when to break the rules, and there will be some times when you can't avoid using them. IIRC, a lot of Java stuff requires them. I prefer not to use Java if I can avoid it.
Re:Getters/setters bad? (Score:2)
Actually, it's "only" many (most) Java data-binding libraries/frameworks that require them; and even then, Objects in question are mere data containers (data transfer/access objects etc). So avoiding the whole language is bit silly, if the main reason is avoiding having to create get/set methods. Java as a programming language has no dependency on such methods.
However, I also strongly dislike the "automatic" (ie. add ge
Re:Getters/setters bad? (Score:2)
Hmmm, I must be new to Java programming then. Some languages may use properties instead, but whats the difference? Anyway, people tend to forget that Java is a language that has little rules, and is thus easy to learn and parse (use Eclipse, and you know what I'm talking about). Adding properties etc. etc. would break that design decission. Just don't use get/set sparingly (think about your interface) and you're fine. Most java IDE's out there can create getters and
Re:Getters/setters bad? (Score:3, Insightful)
Having the IDE create them automatically is going the wrong way, encouraging bad programming habits and illustrating the IDE designer's failure to comprehend the nature of object oriented design.
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:3, Informative)
1. I see a lot of code where *every* attribute is assigned a get/set method as a matter of course (someone probably hit the "select all" button when generating them in the IDE of choice). Without additional "defensive code" inside this is tantamount to simply making everything public (shiver). Only expose what you have to.
2. An object composed purely of getter/setters really is nothing more than a data container. Good OO practice suggests that obj
Re:Getters/setters bad? (Score:2, Insightful)
Best practices may be generally preferable to other practices, but won't apply in every situation. Be pragmatic people!
And to those of you talking about 'data classes', you're betraying a C-like heritage where data resided in structs or unions because of language limitations. Please keep your OO misconceptions to yourselves!
Re:Getters/setters bad? (Score:2)
If you have a rule object whose job is to compute the scoring moves of a game, you shouldn't be asking it "what is the score of a headshot?" You should be telling it "I made a headshot" and let it worry about the score.
If you start having other parts of the app getting that intimate knowledge, your app "crusts over". Now, if you change the scoring rules regarding headshots, not only do you have a rules engine to upd
Re:Getters/setters bad? (Score:2, Informative)
class Foo {
public int getValue() { return m_value; }
public void setValue(int v) { m_value = v; }
private int m_value = 0;
}
and now this:
class Foo {
public int m_value = 0;
}
There is absolutely no difference in functionality here, so there is no need for getter/setter for something which does not get any benefit of scope.
If you has something like this, then it makes sense to have a getter/setter:
class Foo {
public int getValue() { return 2 * m_value + 10; }
pub
Re:Getters/setters bad? (Score:2)
Well, there is no difference in functionality in this version, but when I later want to change it so that m_value is actually MValueService.getWidgetCount() in the simpler version I can't unless I control every single class that uses this class and accesses the variable I now want to hide.
Plan for the future, and don't expose instance variables except in private inner classes and other very limited use containers.
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:2, Insightful)
Change is inevitable. You've got to plan for it. So, 6 months down the road when you realize that you need to change this requirement and add some functionality you won't be able to because you've directly exposed the member without hiding it behind a getter/setter.
Re:Getters/setters bad? (Score:2)
He's saying that if you need to access data in an object, you have probably failed to properly design your objects. He's saying that you should minimize any data access and any data sharing between objects. If some object has information that you need in order to do something, tell the object to do it for you.
Thus, if you feel the need for getters and setters, you've made a mistake elsewhere.
Whether or not that's always good advice I'll leave to someone who is
Re:Getters/setters bad? (Score:2, Informative)
Actually by having accessors and then using them in other parts of your code you will have to refactor tons of code anytime the data behind the accessors changes. If you have other objects that need to manipulate data from another object ("data object"), then your these manipulations should be done by the "data object." If that's not possible (like your the manipulation needs data from multiple objects) then your des
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:2)
Calling the routine literally get and set shows no 'object orientation'. Therefore you consider them bad because of stylistic ideals which is to think in actions rather than programatically.
Like all rules (like speeding when driving) it takes experience to know when to
(not) Short Plain-English Version Answer (Score:3, Interesting)
As a peice of mental oragmi (and to fold my own self in here, instead of _just_ trying to paraphrase this guy).
There is nothing wrong (IMHO) to exposing parts of your thing via accessors and setters AS LONG AS you think of thes
Re:Getters/setters bad? (Score:2)
I think his chain of reasoning (and mine
- Software design is a separate activity, different from coding.
- Good software designs must stick to their underlying paradigm (OO in this case) as much as possible, to reap as much of its benefits as possible.
- Encapsulation is a quality that provides mos
Re:Getters/setters bad? (Score:2)
Besides that, he tries to emphasize design process, to invite us to keep in mind OO principles while looking for an ideal design first, and to
Re:Getters/setters bad? (Score:2)
It's a bad design that promotes bad usage.
Consider the extreme case, where all attributes (sub-objects) of the main object are accessable and mutable: in this case, there's little real difference between the object in question and a C struct.
You've gained nothing over a C struct other than the ability to call it an object.
Except to essentially log any calls to getter/setters -- but you ca
Re:Getters/setters bad? (Score:3, Informative)
Re:Getters/setters bad? (Score:3, Insightful)
In the same sense that using a chainsaw is dangerous, but not necessarily bad.
Re:Getters/setters bad? (Score:3, Insightful)
Polymorphism a the building block of OO, not inheritance. It's a shame that so few popular languages make this clear.
Re:Getters/setters bad? (Score:2)
Re:Getters/setters bad? (Score:2)
I agree that composition should often be favoured over inheritance, but I think there are several reasons for this. The bottom line is that inheritance is most useful as a mechanism for allowing implicit type coercion via polymorphism. If you don't need to use polymorphism, inheritance is just another tool for organising your code, and it's often over-used in that context where simpler things like composition would avoid cluttering the class hierarchy, issues with anonymous base subobjects that could be nam
Applicability to other forms of development (Score:4, Interesting)
In the interim before the appearance of such works, I've been trying to keep an informal list of patterns I've unearthed through practice, but my ability to codify patterns cannot match that of someone like Holub. :-)
sounds promising (Score:2, Interesting)
Check out "Pattern Hatching" by John Vlissides (Score:4, Informative)
Design pattern fans should check out Pattern Hatching: Design Patterns Applied [amazon.com] by John Vlissides, one of the Gang of Four. Short, but interesting reading.
EricHow to detect Internet Explorer [ericgiguere.com]
Another pompous "expert"? (Score:5, Informative)
Before perusing this discussion, you may want to get some perspective by reading Unskilled and Unaware of It: How Difficulties in Recognizing One's Own Incompetence Lead to Inflated Self-Assessments by Justin Kruger and David Dunning (Journal of Personality and Social Psychology,
Well, I didn't know much about this guy. But anybody who defends his position by referring to this psychology paper doesn't score too high in my book. If you're not familiar with the paper, it basically asserts that stupid people don't realize how stupid they are. So referring to this paper is a subtle way of saying "you're stupid, and you don't know it".
But I'll give him the benefit of the doubt.. after all some other pompous experts [dbdebunk.com] have referred to that paper yet raise important points based on sound theory. I.e., there is not necessarily a correlation between being an assmunch and being *wrong*.
So now I read his papers on getters/setters and he claims this is "bad" because it assumes an implementation of the underlying value:
Excuse me but having to declare orderTotal to be any particular type is a *JAVA* thing, and not universal to OO programming. In Ruby for instance:
No types or assumptions here. Since Ruby is fully OO, this will work even if amount.value returns a Fixnum, a Float, or a SomethingElseEntirely.
He says a "better" way is:
But this is just syntax. In Ruby I would just write:
And it doesn't matter what the types (classes) are.
Poor guy is stuck in a statically typed Java hell, with distinctions between primitive types and objects, of course he's gonna think getters/setters are evil and he's gonna become obsessed with keeping his data hidden in a box or behind opaque methods! I can just imagine his code filled with thousands of builder objects with 2-3 levels of abstraction .. and it will just be a grotesque simulation of a true dynamic language in the end, with everything completely decoupled.
I don't know if I should bother reading any more of his writings since I don't use Java.... is the rest of his work "how to get around Java's shortcomings" or is there something a general purpose OO practitioner might find useful???
Ruby Needs Data Encapsulation Too (Score:2, Interesting)
Poor guy is stuck in a statically typed Java hell, with distinctions between primitive types and objects, of course he's gonna think getters/setters are evil and he's gonna become obsessed with keeping his data hidden in a box or behind opaque methods! I can just imagine his code filled with thousands of builder objects with 2-3 levels of abstraction .. and it will just be a grotesque simulation of a true dynamic language in the end, with everything completely decoupled.
This is totally off base. You're
Re:Another pompous "expert"? (Score:2)
Re:Another pompous "expert"? (Score:3, Interesting)
Re:Another pompous "expert"? (Score:4, Insightful)
I think you are missing his point. In ruby, as in SmallTalk, or any other real OO language, "+=" is just a message (in this case, one that is automatically defined when you define "+"), to say that it's better or worse than another semantically equivalent message is just silly.
Yes, they are semantically distinct in Java, but that is a statement about Java, not about OO programming.
-- MarkusQ
Everybody seems to be confusing everything :-( (Score:2)
The surprising thing here is that nobody seems to be considering that there are more than two concepts at work here: sure you've got the "total" and the "money to add", but you also have the operation of adding two monetary values together, and the operation of assigning that result to yield a new total.
It doesn't matter whether you call the summation operation "+=" or "addTo" or "funkyTypeConvertingSummationAlgorithm". The operation is dependent on both the total and the amount, or more precisely on how
Re:Another pompous "expert"? (Score:3, Interesting)
Strongly typed != Statically typed
You are confusing two concepts here. Smalltalk, for example, is dynamically typed yet it doesn't have all the casting about that C does; the typing is strong and dynamic while C's is static and weak/leaky. What gets you into trouble is the weak/leaky typing, not the dynamic typing.
-- MarkusQ
Re:Another pompous "expert"? (Score:2)
If you don't have the option of aliasing, casting, untagged unions, etc. in the language either, your point may well hold. As it stands, strongly typed languages generally leak (allow the programmer to "get around" the formal specification) more than dynamically typed languages--enough so that there is no net advantage.
Plus
Should be titled "Holub on Java Patterns" (Score:4, Insightful)
There's some truth in what you say (Score:2)
However, the original Gang of Four patterns book rather disproves your assertion:
" The dirty unacknowledged secret of design patterns is that they're strongly coupled to a language. "
The examples in that book are all given in C++ and Smalltalk, which are pretty much at opposite ends of the O-O spectrum, and yet the patterns are applicabl
Re:Should be titled "Holub on Java Patterns" (Score:3, Interesting)
Re:Should be titled "Holub on Java Patterns" (Score:2, Insightful)
The examples sound great, but... (Score:5, Interesting)
I mean, yea, "getters/setters are bad", in public APIs. Getters are bad- unless you need to vend an object and can't afford the overhead of creating entirely new instances when you do so. Setters are _definitely_ bad- unless they're private or are data that act as input for your object, which it recieves from controller-layer objects.
Sure, "inheritance is dangerous" as anyone who has ever written an object-oriented program from scratch and had to modify it can tell you. Inheritance is also the key to code reuse, and can be very powerful when done correctly- do you really want to re-write a section of logic that's shared by 5 other objects ?
These things have their place. They're good targets for "is evil" [javaworld.com]-type articles [javaworld.com] because they're often used when they should not be. But to call them "evil" and "bad" without proper qualification? It smacks of unprofessional behavior, at best.
I'm a bit puzzled by claims that use of getter/setter methods and, more puzzling, inheritance, are indications that you haven't solved your problem in an object-oriented manner, or that your problem isn't object-oriented... because, well... not all problems are best solved by object-oriented methods, even if you're using an object-oriented language to do so. Sometimes, you need a variable and a loop... what's wrong with that?
At some point, my model code is going to have to give my view code some objects to display... what, I'm not supposed to use getters there? At some point my view code is going to want to tell my model code about an object the user modified... I'm not supposed to use a setter there? I often think folks who write such blanket statements as "accessors are bad" are just trying to spark some flames.
Re:The examples sound great, but... (Score:2)
Well, to be fair, I'm not sure you're right. I've personally used "extend" to do all sorts of good things in Java. Often the subclass is simple and just adds one or two methods. Why would you have to subclass other classes just because you subclass one, again?
If someone writing in Java seems obsessed with making object
Intuitive (Score:5, Interesting)
But the reason why I questioned the OO paradigm was not the paradigm in its purity, but the implementations that I so often saw in real life. Some of the architectural designs that I witnessed did not make any sense and were artificially created to be more complex than the problem at hand required. What is worse, I have seen 'architects' who got into those positions without any merit. I have witnessed architects who think their position is justified because they spend another 4 weeks in the beginning of every project 'rethinking' the ACLs. I have witnessed an 'architect' that was supposed to design a system, but who instead sat down with a programmer, did a bunch of handwaving, and left the programmer without any idea and without documentation on how things are supposed to be done, and it was not a simple thing for that guy who was still a beginner. I cannot count the number of times where I (as a contractor) in different companies was put into a position where I had to solve the problems created by these 'architects' as well as by 'managers' and the marketting people.
Yes, I remember having a conversation about getters, setters about 4 years ago, I was convinced that those things are a horrid idea as well as extends (for almost the same reasons given in the article). I was attacked on more than just the techno-level. It is hard, it is not easy at all to work around bad design decisions, where someone just does something because it is either a pattern they read, or the marketting says it has to be done that way because there was this meeting with an IBM guy, who bought all the managers year-long golf memberships.
What I appreciate in people is the ability to think for themselves and to make decisions on when something is appropriate. I am also a realist, I know that noone on this planet can be perfect 100% of the time. We get tired, we have schedules, we just want to do things fast and dirty, we resist structure because it is easier that way. But those of us who are good enjoy going through all of this nonsense and figuring out sensible ways to still deliver a good system.
Re:Intuitive (Score:2)
Done patting yourself on the back yet?
Why is it that in every OO thread there's always one of these no substance, self congratulatory comments that hits +5?
Re:Intuitive (Score:2)
Re:goat.cx links above. (Score:1, Offtopic)
Re:Bring back procedural languages (Score:3, Insightful)
One common pattern with maintained code is the cancerous growth of special cases to deal with new requirements. Over time, the special cases dwarf the original code, and it becomes very hard to even figure ou
Re:Bring back procedural languages (Score:2)
I agree that this is a huge problem. But OO does not seem to be the answer. Subtyping for specialization assumes a few things that don't pan out in reality.
First is the granularity. Sometimes you need to override only 1/3 of an existing method. Either you have to mak
Re:Bring back procedural languages (Score:3, Interesting)
Anyway, what I've noticed is that up until the past couple of years, not many people really had an idea of how to do Object Oriented programming al
Re:Bring back procedural languages (Score:2, Informative)
OO started with Simula and Smalltalk, with Simula67 being the object oriented base of C++.
And if you don't know what you're doing in a particular paradigm you usually end up with dreck nobody wants to maintain.
Re:Bring back procedural languages (Score:2, Insightful)
What, so often, people fail to realize is that software is designed to be built in layers. See the TCP/IP stack, fo
Need to understand motivating factors (Score:2)
Try Perl's non-OOP equivalents (Score:2, Informative)
Philip Crow wrote a very original piece on how to avoid OOP and still use patterns with Perl's special built-in features
http://www.perl.com/pub/a/2003/08/15/design3.htm l
Re:Bring back procedural languages (Score:2)
In my last project I had a moment in between the deadlines, where I was able to actually do some OO design for a piece of functionality in the system. (a java GUI playing talking to C++ over JNI and playing videos.) The functionality I needed to add was an on screen display for video properties (you press up, and the current property is increased by 1, you press pgup, and you go to the next property, and all of this is overlaid on the video display.) So I had a choice. I co
Re:Bring back procedural languages (Score:2)
Re:Bring back procedural languages (Score:2)
Re:Bring back procedural languages (Score:2)
The properties are in a table. The table consists of these fields:
property name, property type, property default value.
The functionality of switching between properties is the selection of a row on table. This is in code. Also, the behavior of each of the property widgets is in code. In Windows you could, in C world, say that property type specifies the Window class.
The user interface is i
Re:Bring back procedural languages (Score:2)
Re:Bring back procedural languages (Score:2)
Re:Bring back procedural languages (Score:2)
What about multi-tier? (Score:2, Interesting)
I program in PHP, and without OOP, I wouldn't be able to use very nifty template classes which simplify my web job, not minutes or hours, but days.
The problem with OOP is that if you don't know best-use practices and think before writing (i.e. use UML), you're sure to make a bloody mess.
Think of OOP as 3D as procedural programming was 2D. A building in 3D is certainly m
Re:Bring back procedural languages (Score:2)
From bottom to top:
layer 0 is the server memory mapped file access layer
layer 1 is the memory mapped block allocation layer
layer 2 is the memory mapped skip list layer
layer 3 is the profile engine layer
layer 4 is the profile task layer. this is the vm implementation
layer 5 is the socket listening layer and multithreaded job scheduler.
then, on the client
layer 6 is the socket layer
layer 7 is the compiler parse thread
layer 8 is the compiler tokenizer thread - yes, v