My software is mostly procedural at heart. I've been told time and time again that Object Oriented Programming (OOP) offers great benefits over. Object Thinking, David West. Preface. Microsoft Press CONFIDENTIAL 10/16/ AM. Page 2 of Preface. Extreme Programming (XP) and the various. In OBJECT THINKING, esteemed object technologist David West contends that PDF downloads — text only, not the figures — of each chapter are available.
|Language:||English, Spanish, French|
|Genre:||Health & Fitness|
|ePub File Size:||27.80 MB|
|PDF File Size:||8.18 MB|
|Distribution:||Free* [*Regsitration Required]|
David West. M . thinking and then applied it in the real world with notable success. object thinking device or tool will likely be viewed as anachronistic. In OBJECT THINKING, esteemed object technologist David West contends that the mindset makes the programmer—not the tools and techniques. Delving into the history, philosophy, and even politics of object-oriented programming, West reveals how the best programmers rely on analysis. In OBJECT THINKING, esteemed object technologist David West contends that the mindset makes the programmer—not the tools and techniques. Delving into.
Structured programming says: Responsibilities should be distributed among the community of objects in a balanced manner. Chapter Two: Ben Nadel Jun 11, at 8: In this kind of a context, who would handle the actual creation of the Task item? David West.
A big part of me is always like, "yeah, but what IF someone forgets to write it together that way? Now, I know that may sound crazy, because the "someone" in this situation is Me: But, it just feels weird: James, That's a really good catch. You're right: It should leave that up to the list. It should simply say, "Hey, List! Is this change ok with you? Ben, It really comes down to a sound design.
As I'm sure you're aware, a huge part of the development process is actually consumed, not by the original development, but by the maintenance of that code and the expansion of it.
This is why it is really critical to spend time thinking about the delegation of work and outlining of interactions between objects. It sounds like a lot of work, for sure, and it can be.
The reward is actually somewhat bittersweet. If you design your object library really well and the code is really robust, you find that it is really easy to expand it to do new things. On the other hand, if the code is that well built, if you have to work on the internals and you didn't document the hell out of it, it may take you a while to understand what all you were doing in there.
Jaime Metcher and myself had continued the conversation a bit, offline. But, I wanted to post it here since I think it adds value. Re creation - definitely the latter, i. There's been a fair bit written in the OO literature about the importance of encapsulating object creation. Naked constructors are definitely a code smell to me. Re setters: There are a lot more trade-offs here, so the answer isn't as clear to me.
However, I can say a couple of things: There's a tendency to expose way too many setters. A lot of fields don't need and shouldn't have public setters. Instead they should be wrapped up in public API methods. It's the API method that will guarantee validity and consistency. It's not reasonable to expect validity and consistency from atomic field operations.
In practice, I've never found a need to change the unique name of an object once assigned, so I don't have a setter at all for these fields. In a modeling sense I wonder whether the notion of a mutable yet unique value makes sense at all. No doubt someone will be able to point out a use case where this is needed.
BTW, in the interests of full disclosure I should say that my comments here come from my Java experience. I moved this kind of code to Java at around CF7 because at the time CF was too slow to really support a collection-based approach. Maybe that's changed with the recent versions, but I couldn't say. So I'm treating this as an OO design discussion, acknowledging that implementation practicalities might get in the way. Plus, it allows the Task constructor to take items such as a List reference in its init method that might otherwise be awkward to have on hand.
Or, might require setter-based injection I tend to prefer constructor based injection when possible because I think it makes the object feel "safer". I think CF is getting much faster. I still think you wouldn't want to create large numbers of components at any one time; but, from what I've seen, life is much better in the last releases of the language. I agree with you about the setters - I would also try to limit then, I think.
But, as to the unique naming, one thing I can think of that I come across often is a user having to have a unique email within a system; and, being able to change that email over time.
Fair point re the email address. Although - do you really just go ahead and call user. Or do you send a confirmation to the old email address, then ask for a password, then confirm the new email address etc.? You get my point - this is a much more heavyweight process than calling a setter. Where the uniqueness check sits in all of this is almost irrelevant - it can even be done in batch mode. I just get the feeling that anytime you do need to change a "unique" value it's often more like this than just a simple setter.
You know, the weird thing is - and not saying this with any implication about how you should or should not think about it - this stuff does feel entirely natural to me and pretty much always has, ever since I first picked up Smalltalk in Hell, I get it wrong as much or more than anyone else, but I feel right at home the whole time I'm coding up my next OO bug: Is it just a matter of picking a coding style that fits one's innate thought habits?
I wish I knew. True - unique email addresses do usually entail some more process than just calling a setter. But, when it comes down to actually persisting it, I would probably do something like:.
I think for me, the biggest hurdle is just thinking about multiple objects coordinate. It's just a small, simple context; but it sheds light on how different my "procedural" mind may really see things.
It seems small enough in scope to be doable, yet complex enough to show off coordination and cooperation of the objects. Ben, If you didn't design it well, you have all the benefits of OOP, but it becomes more difficult to extend the functionality. Any immature design and I've written my share will eventually reach a point where it becomes difficult to extend the functionality. Take a look at what James pointed out above. If we had proceeded with the design I'd written out, we would have encountered difficulty if the list wanted a different way to identify or validate the task.
Even the fix that James provided potentially limits the list by only providing the new name instead of a potentially altered task. What's my own experience? I design and write up an object library with the resources available at the time, including: As I work with my object library and extend it, I will encounter an obstacle.
At that point, I can either spend the time to rework the object library or simply shoehorn it into doing what I need it to do and remember that when I want to rework the whole library next time.
Each time I rework the library, the design matures and I bask in the glory of having written a better version. I eventually run into the obstacle with that version and go through the process again. As the one who recommended the book to you, I feel a little bad you didn't find it as revelatory as I did.
But I'm glad you got something out of it, and the discussion here is great. I would say that your critiques, especially about the length, and wanting to see more examples worked through, are valid. My overall feeling, though, was that the insights were so deep that they made up for the book's flaws many times over.
Also, glad you enjoyed Carlo's blog. The Fowler book Patterns of Enterprise Application Architecture is pretty much entirely example based, so you may enjoy that one more. Though I'd warn that it too is a bit of a slog, despite being very good.
For a much more accessible, but still very good non-slog, also completely example based, check out:. I'd be pretty confident that with your programming experience, even if you don't know any Ruby it wouldn't matter at all, and you'd still be able to follow all the examples.
This book is sort of the mirror image of the West book -- all practical advice and examples with very little underlying philosophy and history.
So having got the history under your belt already, it might make a good complement. I definitely have a mental hurdle when it comes to discovering better design over time. My brain has this insane urge to just understand how you do something right the first time: But, everyone agrees with you - it's not about doing it right the first time, it's about getting it right over time, and embracing the refactor and more information comes to light. Please, don't feel bad at all. I appreciate all that you have contributed to the conversation.
And, the more points of view I get, the more confident I am that I will some day, some how understand all this stuff: I actually read the Sandi Metz book a few months ago. I now know all there is to know about calculating gear ratios and preparing for bicycle trips: It was a really interesting book. I haven't reviewed it yet because I needed to let it sink in. I think I read through it a bit fast I tend to get over-eager with these types of books, looking for the "answer".
I did like a lot of her double-dispatch stuff. And, all the TDD stuff as well. I've long tried to evaluate the efficacy of development theorem vs.
Not to wax capitalist, but the "right way" is the one that doesn't produce errors, makes clients happy, and gets one paid. I deal primarily in a seriously undisciplined OOP product, and I would echo what someone else said Download Snippet of Chapter Five, click here.
Chapter Six: Method Process and Models. Two decades of object methodology; purpose and use of method; a syncretic approach; and models semantic net, object cube, interaction diagram, static relation diagram, object state chart. Download Snippet of Chapter Six, click here.
Chapter Seven: Domain understanding; domain anthropology; object definition; heuristics; contracts and collaboration graphs; and class hierarchy integration.
Download Snippet of Chapter Seven, click here. Chapter Eight: Object structure knowledge required ; object structure draft protocol ; object structure event notification ; interface prototypes and state models; and modeling object constraints. Download Snippet of Chapter Eight, click here. Chapter Nine: Download Snippet of Chapter Nine, click here. It will work sometimes. Skip to content.
Permalink Dismiss Join GitHub today GitHub is home to over 31 million developers working together to host and review code, manage projects, and build software together.
Sign up. Find file Copy path. Cannot retrieve contributors at this time.
Raw Blame History. David West. The author believes that management have been sold the idea that strict formal processes will make better sofware The only consistently reliable approach to good software is, simply, good people. Industry puts so much emphasis on tools and processes because not sure how to "upgrade" average developers to good developers widespread belief that there are not enough "good" developers to go round belief that good developers were "flaky" and not to be trusted - tended to be "artists" Agile methods focus on attitudes, behaviour, culture and adaptive heuristics people things rather than formal processes The goal should be producing better developers rather than producing better software because better software comes from better developers.
He also has some stats on object size responsibilities per class: Excerpt From: Object thinking focuses on the problem space, computer thinking focuses on the solution space Different languages have different tools in the "solution space" e.
You signed in with another tab or window.