Framework - as described in the NakedObjects
Book, by Richard Pawson, Robert Matthews: ISBN 0470844205
, and available for download from their web site http://www.nakedobjects.org/
Framework is a generic implementation of a DirectManipulation
interface for your (Java) business objects. It exposes your Behavioraly Complete business objects (see BehavioralCompleteness
) to the user for DirectManipulation
by the end users, through a standard, generic, automatically generated user interface.
- Saves development time and money: You implement business objects with user-visible behaviors; user interface and persistence are provided for you.
- Empowers users:
- The system's model is directly visible and manipulatiable by the users.
- Objects and functionality can be manipulated in a variety of ways to achieve the intended work result, enabling the users to pursue their work in the most effective way for them at the time, rather than being constrained by predefined scripts.
- Primarily useful for "expert" users -- in the sense that they have to understand the business model and the business processes they are trying to achieve. This approach won't be as useful for users who need heavy scripting and hand-holding to successfully accomplish a process.
Framework does "AutoGenCrudScreens
," but that's not the main reason to use it.
the user interface to DirectManipulation
of the business objects you define.
Thus, it imposes a discipline and simplicity on your design that forces you to make your data and operations meaninful to your users -- because they'll be directly visible and manipulatiable by your users.
is a radical DesignPattern
that has users using DirectManipulation
of program objects instead of having a UserInterface
between the user and the system objects. The basic idea is that most user interfaces get in the way by intervening between the users and the actual system objects, enforcing process oriented interactions and introducing UI - object synchronization problems. Giving the user the ability to interact directly with the objects and enforcing a 1:1 relationship between what the user sees on the screen and the objects used to represent them allows the users to become problem solvers rather than process followers. This pattern increases flexibility and empowers the users to find creative ways to solve problems.
toolkit is available from http://www.nakedobjects.org/
The "Naked Objects" book, by Richard Pawson, Robert Matthews: ISBN 0470844205
(...as printed and distributed on dead tree carcasses. ;-)
"In line with our philosophy of making our ideas freely-available we have put the full text of the book on-line."
say the authors.
(At the moment, the images in the last section of Appendix A are missing from the online version. So... Go buy the real book! ;-)
Articles, books, and other descriptive material:
"The Naked Object Architecture Series" articles at The Server Side:
The topic is explored in some more detail at http://www.nakedobjects.org/
and there was an article in JAVAPro magazine (http://www.fawcette.com/javapro/2002_04/magazine/columns/javatecture/
[Free subscription required to read the whole article. First page does not require subscription/login.]
Discussion thread on the yahoo "extremeprogramming" list:
Framework makes it easy to very quickly create projects that make use of the NakedObjects
design pattern. However the toolkit is not fully fleshed out yet and it needs lots of work before it will be truely usable. On the other hand, there does seem to be a small developer community exchanging furtive messages on the NakedObjects
developer mailing list.
The pattern is an old one that certainly floated around the early object communities working in both LispLanguage
, though the implementations probably favored direct manipulation by developers themselves rather than users. The specific framework suggested on nakedobject.org seemed to have some fresh ideas. Let's reserve the wiki word, NakedObjects
, for this framework and the philosophy that goes with it. Let's call similar frameworks DirectManipulators?
and explore their features and attributes on that page.
One interesting instance of this in the LispLanguage
back in the 1980s was InformationLens
and subsequently ObjectLens
-- which seems to be the most recent incarnation of these ideas.
This seems to be a GUI in the true spirit of OS/2 WorkplaceShell?
I thought so too. I actually created this page from an OS/2 offshoot, eComStation :)
Some of the examples in the ExpressiveSystems?
book were eerily similar to the "sandwich" demo that InternationalBusinessMachines
used to demonstrate in the early days of OS/2's Workplace shell.
Part of the reason that I like NakedObjects
so much is that it provides some of the features I'm used to from OS/2 and Newton OS on other operating systems.
A Naked Object regular is Dave Roberts, of IBMs Ease Of Use. He discusses their involvement with OS/2 in this thread http://www.nakedobjects.org/discuss/article.php?id=95&group=nakedobjects
-- Ged Byrne
was developed by RobertMatthews?
and myself. Recently, DaveRoberts?
who was indeed on the original CommonUserAccess
team has gotten quite interested in NakedObjects
and we have both learned much from talking to him. The very strong similarity between the NakedObjects
UI and CUA is, to date, coincidental. However, there are some ideas from the original CUA demos (which Dave showed us) that we now intend to copy. Interestingly, however, the original CUA documentation states clearly that the strongly object-oriented user interface on CUA is *not* a reflection of the underlying structure of the application. The big breakthrough in NakedObjects
was not the UI (had we been more familiar with the original CUA work at the time we might have copied it wholesale) it was realising that this could be a simple reflection of the underlying code structure.
Some critics of the NakedObjects
framework have not noticed that the system is designed to allow for multiple UIs. I have been developing a Swing-based system, called Iduna, that permits alternative viewers to be composed on the fly.
Isn't this just a kind of VisualProgramming
(from the User's perspective) ?
I'd say yes, except that the users aren't programming: They aren't telling or showing the computer how to do something. It's more of a DirectManipulation interface: The user grabs things, moves them around, invokes methods on them, and things happen right then and there. In VisualProgramming, you're describing how to do something later. -- JeffGrigg
is a much more general concept.
Framework is different in that it largely collapses the user interface and database/persistence layer into the business layer, rather than pursuing a generic abstraction.
How can we separate the <concept of Naked Objects> from the <concept of automatically generated user interfaces (AutoGenCrudScreens
) > from the <particular toolkit at http://www.nakedobjects.org/
I, for one, have been confused, thinking for some months that "NakedObjects
" was the general concept that simple CRUD (CreateReadUpdateDelete
) screens could be auto-generated from business objects, and so I entirely missed
the more important aspects of the NakedObjects
toolkit at http://www.nakedobjects.org/
How could we make the NakedObjects
toolkit more visible?
Should we have this page be for the generic concept, and move the framework/toolkit content to NakedObjectsToolkit?
- Others of us may have "entirely missed the more important aspects", too -- so how about some hints? -- DougMerritt''
For some time, every time I saw mention of "NakedObjects
", I said, "Oh; I know what that is. It's 'exposing attributes and methods directly through the user interface.' In other words, it's 'AutoGenCrudScreens
' for routine maintenance, and then you'll tweak the presentation of these screens, to match your desired application / web site style, add a few custom screens to handle special cases, and there you have it -- a typical, conventional application, done more quickly than usual.'" I missed the boat. I didn't really understand how an application built with TheNakedObjectsFramework
is different from auto-generation of conventional CRUD (CreateReadUpdateDelete
TheNakedObjectsFramework provides a useful graphical metaphor for doing DirectManipulation of objects for (most) routine CRUD (CreateReadUpdateDelete) maintenance tasks.
See also DirectToWebFramework