Noun

=== Buko Obele ===
https://www.infoq.com/news/2007/11/oop-beyond-verb-noun 
http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html 
https://web.archive.org/web/20080224022022/http://blogs.concedere.net:8080/blog/discipline/ The main problem with the Visitor Pattern, besides all the hacky accept methods that end up polluting your domain, is that it leads to a pretty confusing runtime model. Because the control-flow logic is distributed throughout the entire domain in the aforementioned accept methods it becomes difficult to know what's happening when. It can also lead to subtle bugs as inevitably somebody forgets to pass a Visitor on to its children in the accept method. In a big codebase this can quickly become a big problem.The underlying issue with the Visitor pattern is the tension between its official motivation and its real motivation. The "official" motivation is to "add behavior" to a set of domain classes. But the real motivation is to declaratively map a function across a set of domain functions. The problem isn't merely one of adding behavior but encapsulating the "routing logic" needed to write a function of a domain. The Visitor Pattern doesn't scale precisely because it fails to capture this routing logic inside a single class.
An alternative to the classic Visitor Pattern is the Domain Function Pattern. The Domain Function Pattern involves creating a single abstract class that encapsulates the logic of mapping members of a hierarchy to some result. In Java5 an implementation might look like: 
https://web.archive.org/web/20080225135903/http://blogs.concedere.net:8080/blog/discipline/software%20engineering/ 
One immediate -- and useful -- consequence of the distinction is that right away we can see that programming is a hopelessly futile endeavor. Unlike mathematicians, programmers are very much not in the solution business. Rather they're in the much less glamorous "problem maintenance" business.
Andthis is why applying the noun/verb metaphor(https://web.archive.org/web/20080309152650/http://weblog.raganwald.com/2007/10/too-much-of-good-thing-not-all.html) to object oriented programming doesn't make any sense; simply, objects are not nouns and methods are not verbs. In the everyday reality of language subjects and verbs are independent concepts that can be hung together loosely to paint a picture. The word 'person' in a sentence isn't dependent upon any notion of a particular verb, it always exists prior and apart from the sentence. In practice we would never say that a person who can't, for example, 'run' isn't a person because 'person' is its own word. But in object oriented design precisely the opposite is true: the person type (concept) is defined by its ability to 'run' and objects that don't know to run are strictly not persons. In object oriented design concepts do not exist separately and apart from their methods at all -- instead, the whole point is that they are strictly constituted by their methods. So all the talk of subjects and verbs may be a decent way to explain object oriented design but it's self-evidently the wrong approach to doing object oriented design.
https://web.archive.org/web/20080224023613/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=Why-Programming-is-Hopeless-and-Futile-Worse-Than-Failure-Is-Not-an-Option.html
https://web.archive.org/web/20070819010416/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=The-Value-of-Abstraction.html
https://web.archive.org/web/20080224023613/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=Why-Programming-is-Hopeless-and-Futile-Worse-Than-Failure-Is-Not-an-Option.html
https://web.archive.org/web/20080224045602/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=Design-Is-Inevitable-Programming-is-Not-Art.html The use of the word "behavior" in object oriented design is misleading. It's a great way to start thinking about objects but it's an idea that inevitably leads to all sorts of problems. The problem is that objects "behave" in the same way that mathematical functions "behave" -- that is, not at all. The addition of state complicates things but the distinction between objects and functions is badly misunderstood here; in the strictest sense objects are functions as they map inputs to outputs. And as a practical consequence for software architecture neither functions nor objects are any kind of end goal: the concepts involved in any architecture may be influenced by a programming language but this relationship is not strictly derivative at all.
But here's the thing: while metaphor is essential to language it happens to be completely absent in mathematics and programming. There are no metaphors at all in software and this is exactly why building software is so hard.
=== Obele on design patterns ===
https://web.archive.org/web/20080329050656/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=Who-Needs-Design-Patterns-Anyways.html Part of the big question of design patterns is just how important they really are to any codebase. On the surface the logic behind the argument that all design patterns should be melded into the core language seems very similar to the logic that pushed C programmers from 'programming with structs' to doing true object-oriented programming using a newer language. The key distinction between the two may lie in the expressive power of something like OO -- a whole new language paradigm -- compared to something like the iterator design pattern. A program that fails to utilize objects is going to be very different than a program simply fails to utilize the iterator pattern.
This is why Cedric's defense of design patterns as "nuts and bolts" is persuasive. Every programmer already knows from experience that there's a big, big gap between design patterns and working, maintainable software. Picking the right design patterns is important only in the way that picking good, solid wood and other quality materials to build a house with is important. While design patterns may contribute to the quality of end product they rarely exert enough influence to change the end product in itself. They are not paradigm shifts that open up whole new fields or possibilities nor do they cause order-of-magnitude shifts in software development. They are just, as Cedric suggests, good materials.
The bigger point to all this has to do with the nature of the challenge most programmers face in their day to day jobs. I think Atwood is simply mistaken to believe that programmers are being overwhelmed by the complexity of their tools. In fact the problem of 'boilerplate design pattern code' says nothing about the quality of the language; it says only that the programmer are working at the wrong level of abstraction and are the victims of that all too common sickness: bad design. Picking another language is not the cure for this disease. (More than likely it's only going to make things worse!) On a deeper level, Dominus is simply wrong to assert that patterns tell you what to design; in fact the GoF design patterns exist to tell you what not to design. Rather than reducing programmers to fancy "macro processors" design patterns free programmers to concentrate on those issues that are really central to their problem domain.
(In reality, I think Dominus and Atwood are saying two very different things. Dominus is simply stating that Design Patterns are no replacement for a universal domain language. This makes a lot of sense. Unfortunately he terribly confuses the issue with some very poorly chosen examples and nonsensical terminology. Ironically it's Atwood who actually makes the extraordinary claim that Design Patterns are a form of complexity that increase the size of the problem domain rather than reduce it. I suppose this kind of word confusion is the danger in taking the analogy between software construction and building construction too literally.)
This is all just another way of saying that software engineering is the only field of engineering where 80% of the problem is figuring out the problem. Programming languages, much like any other tool a programmer employs, are only useful only to the extent that they can define, sharpen and communicate the actual problem. Those who insist that programming is an art don't seem to appreciate this harsh truth. Programming is an art, yes, but it is the art of creating systems that are easy to interpret, understand, use and ultimately grow and maintain over time. Systems that even a computer can understand. This is the exact opposite of great art! Rather than seeking out tools that offer maximum flexibility programmers should seek out those tools that offer just enough flexibility and no more. Design Patterns are just such a tool. They are useful because, while they are not silver bullets by any means, they are reliable nuts and bolts widely understood by computers and programmers alike.
https://web.archive.org/web/20080225135903/http://blogs.concedere.net:8080/blog/discipline/software%20engineering/
https://web.archive.org/web/20080214151031/http://steve-yegge.blogspot.com:80/2008/02/portrait-of-n00b.html
https://web.archive.org/web/20080103032322/http://alumni.media.mit.edu:80/~mt/thesis/mt-thesis-2.2.html
=== Fire with fire ===
Tue Dec 18 02:00:10 UTC 2007
Category [software engineering/]
One radical solution to the the problem of software development is to abandon the language of 'problems' and 'solutions'. Software doesn't solve problems and perhaps continuing to pretend otherwise does more harm than good. The notion that developers should descend from the high planes of abstract thought and bearing The Solution (tm) is really little more than an artistic conceit.
What might we put in its place?
One alternative metaphor is that came up recently is that of law enforcement. In this model software engineers are engaged in a never-ending effort to reduce "crime" and increase "public order" so that users are free to enjoy themselves and do their work in a "safe neighborhood." It's an interesting metaphor because it embraces the essentially defensive nature of most software development. It also injects a healthy bit of realism into the process; the notion that technology will solve all our problems is revealed to be as fanciful as the notion that we can completely eliminate crime. But the process is also far from hopeless; a methodical, evidence-driven mentality can produce real progress. Such a mentality would certainly be an improvement for those software shops that are forever focused on meeting arbitrary deadlines and yet never seem to make any real progress.
Another interesting alternative is suggested by open-source. Heree transparency and feedback are raised as the fundamental values. Community over code offers a truly radical alternative to traditional Command and Control development. The walls between programmers, management and customers are torn down and everybody is invited to contribute as equals and drive the project forwards. But the idea of "code as commons" could certainly irritate a few developers who might chafe at any "interference" by management and customers into purely "technical" matters that they don't understand.
And then there's the internet itself which is rapidly changing the who/what/when/why of software development. What's emerging is a radically platform-oriented view of software. Here the task of developers is no longer to develop be-all-end-all solutions but rather to empower users by putting the appropriate tools and data directly into user's hands. Here the most successful developers are the integrators, they leverage the vast power and inclusiveness of the web by thinking big. The least successful developers are those that invest in closed, proprietary technologies.
A lot is determined by the language you use and the way you look at things. Programmers like to look at themselves as problem solvers, authors, artists and inventors whose primary focus is summoning up solutions out of nothing. But what's interesting about each of these models is that they focus much less on simply writing code and much more on harnessing and controlling the tremendous new forces unleashed by the information age. This is the case to be made for a fierce engineering pragmatism; a preference for systems and processes that help real people deal with real pressures instead of opting for the latest shiny-new-thing. The simple recognition that we might focus less on whizbang solutions, fancy language technologies and creating technology and focus more on metrics, community and using technology could go a long way.
It's an interesting and extremely valuable quirk of the human brain that the exact same statement can mean completely different things to different people. For example, consider: 
All software should be a tool or language because it reduces your risk of failure.
I agree 100%. But starting with the same premise I'd draw almost the exact opposite conclusions. For example:
The idea is to create a language around the problem you're trying to solve in order to make it easier to solve the problem.
https://web.archive.org/web/20080222164703/http://lispy.wordpress.com:80/2007/12/12/meet-the-new-problem-same-as-the-old-problem/#comments
https://web.archive.org/web/20080224023613/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=Why-Programming-is-Hopeless-and-Futile-Worse-Than-Failure-Is-Not-an-Option.html
https://web.archive.org/web/20080329045114/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=The-Problem-Is-Choice.html
https://web.archive.org/web/20080224025311/http://blogs.concedere.net:8080/blog/discipline/software+engineering/?permalink=The-Engineers-Motto.html
=== links ===
No true Scotsman, https://archive.is/pfQvK for noun confusion
Oop , Debasish Ghosh
Indirection isn't abstraction
oop concedere.net
:https://www.infoq.com/news/2007/11/oop-beyond-verb-noun The word 'person' in a sentence isn't dependent upon any notion of a particular verb […]. In practice we would never say that a person who can't, for example, 'run' isn't a person […]. In object oriented design concepts do not exist separately and apart from their methods at all -- instead, the whole point is that they are strictly constituted by their methods.
Methods are procedures, indeed the hash table can't exist independently from the functions that will transform it, whether stuffed inside of struct(class) or outside of it, because mapping inputs to outputs is the only goal in programming.
http://debasishg.blogspot.com/2007/11/towards-more-powerful-abstractions-in.html
Category:Oop
Category:Oop design patterns