Naked Objects

from Wikipedia, the free encyclopedia

Comparison of conventional layered architecture (left) versus layered architecture with naked objects

Naked Objects is an architecture pattern from the field of software technology . It is defined by the following three principles:

All business logic should be encapsulated on the specialist objects. This principle doesn't just apply to naked objects: it's just an emphatic commitment to encapsulation.
The graphical user interface is intended to be a direct representation of the technical objects, with all user actions explicitly consisting in the creation or retrieval of technical objects and / or calling up methods for these objects. This principle is not unique to naked objects either; it's just a specific interpretation of an Object Oriented User Interface (OOUI). The original idea of the design pattern of the naked objects results from the combination of these two, which form the third principle:
The user interface should be created 100% automatically from the definition of the technical objects. This can be done using various technologies including source code generation; Implementations of the design pattern of the naked objects to date have favored the technique of reflection . This achieves a clear separation between technical logic and display logic, which in particular supports the single responsibility principle .

The Naked Objects architecture pattern was first presented in 2001 at the OOPSLA conference under the name Expressive Systems: A Radical Approach to Business Systems Design by Richard Pawson and Simon Dobson. It was later described in detail by Richard Pawson in his dissertation.

Naked objects are often compared to the Model View Controller (MVC) architecture pattern. The foreword to the dissertation - written by Trygve Reenskaug , the inventor of MVC - describes that naked objects are closer to the original idea of MVC than most interpretations and implementations of MVC.

aims

The first two principles (“Complete images of the business logic in specialist objects” and “Direct representation of the user interface through specialist objects”) are not new and are also partly widespread in IT. They are based on an uncompromising interpretation of the data encapsulation principle and a rather unusual approach to creating graphical user interfaces . Only the combination of the first two principles and their logical continuation in the third principle (the automatic generation of the GUI) support the goals of the architecture pattern of the naked objects:

Improved requirements elicitation: By using naked objects, the specialist classes and their functions are directly visible on the user interface. This facilitates the use of a common language ( ubiquitous language ), in particular between users (the user interface), analysts (the requirements) and developers (the user interface and the specialist classes). This common language helps the process of requirements elicitation tremendously. Combined with the other advantages of naked objects, it is possible to develop functional prototypes together with the users.
More productive software development: When using naked objects and a corresponding development tool, the mostly manual and often non-trivial mapping between the graphical user interface and the technical logic layer is no longer necessary. Richard Pawson's dissertation on naked objects, for example, contains two implementations of the same application: one based on a conventional four-tier architecture, the other based on naked objects.
More agile software development: Technical changes to requirements can be implemented much more quickly using naked objects. This is mainly due to the fact that naked objects support the single responsibility principle and that business logic and input logic are clearly separated from each other. Changing requirements therefore do not have to be implemented in the user interface in addition to the technical logic, which promotes productivity in agile software development projects.; However, many technical experts are convinced that there is no longer any agile software development when the processes and methods are also modeled. It is the basic understanding of agile methods not to work according to rigid processes and methods (problem patterns), but to quickly discard them in rapidly changing iterations. The fundamental controversy is and was domain engineering versus agile methods, i.e. opportunistic (agile) versus strategic (formal) methods.
Higher quality in architecture and technical logic: So that software can be implemented using naked objects architecture patterns, it is necessary to design a domain model that can be mapped 1: 1 on the user interface. This ensures that the domain model actually meets user requirements. The strictly enforced separation of business logic and input logic enforces a more correct architecture.; The higher quality in architecture and technical logic achieved in this way increases the changeability of the application, which in turn is helpful for agility in software development and maintenance, with the reservation that the agility no longer exists.
Easier implementation of object-oriented user interfaces (OOUI): By generating the user interfaces from the domain model, object-oriented user interfaces are created automatically. Object-oriented user interfaces, on the other hand, promise better design options, in particular due to the noun-noun style for interactions (instead of the usual verb-noun style).

Cons and criticism

Suitability of object-oriented user interfaces

All these disadvantages and criticisms do not relate exclusively to naked objects, but also to the ideas combined in naked objects.

commitment

Probably the first operational use of the Naked Objects architectural pattern was in November 2002 by the Department of Social and Family Affairs in Ireland. The implemented application for the administration of child benefits was one of several enterprise applications of the Department of Social and Family Affairs, which were implemented using naked objects. Richard Pawson processed the experience gained, including the reactions of users, in his dissertation. In particular, the reusability of the technical objects achieved through naked objects across several requirement areas was rated positively. The initial naked objects architecture used was developed by Fujitsu, but later ported to the open source framework Naked Objects for Java and further developed.

Connection with other technologies

Object-oriented persistence mechanisms: Object-oriented persistence mechanisms such as object-relational mapping or object databases deal with the replacement of the data access layer under the technical objects. They thus complement the naked objects architecture pattern and lead to an architecturally fully implemented single responsibility principle, an architecture centered on the specialist objects.
Agile software development: Some groups consider that Naked Objects supports the techniques of agile software development in various ways - in particular by supporting iterative implementation and involving users in the requirements process. The implementation of naked objects in the Department of Social and Family Affairs described above also brought positive insights into the use of naked objects in agile software development projects.; Another point of view is brought about by representatives of the highly functional system and concept descriptions of requirements and domain engineering. The more non-functional (system-to-environment relationship) the system or concept description is, the more agile a system is. Therefore agile methods contradict the domain layer of naked objects. Current research is aimed at scaling this boundary between the two with methods, which - logically imperative - with increasing maturity and capacity (quality) is again only a functional description (system-to-system relationship). The aim of Requirements (RE) and Systems Engineering (SE) is to increase the degree of maturity from a still quite non-functional concept to a functional system description that can be implemented, measured, tested and finally applied and improved - so-called conceptualization. Therefore, one sees the establishment of agile methods such as XP, SCRUM and others as the status quo of chaos to maintain oneself and not, as required by professional RE, to progressively reduce it through domain engineering, such as domain layers in naked objects, so that it there is little need for agile methods. This is why some experts are of the opinion that professional RE is not at all compatible with agile methods such as SCRUM or XP.
Domain-driven design: Domain-driven design (DDD) is not an architecture pattern like naked objects, but a procedure for modeling the technical logic. Like Naked Objects, DDD assumes that the entire technical logic is to be mapped in specialist objects. Since domain-driven design deals exclusively with the technical logic, it does not make the requirement that the user interface be a direct representation of the technical objects. This requirement of naked objects, however, facilitates the implementation of DDD, since the domain model becomes much more visible for users and analysts, which in particular also contributes to the spread of the ubiquitous language required by DDD .

Frameworks

There are now a number of frameworks for various programming languages that support the naked objects architecture pattern:

Java :
- NoWicket, an open source framework for web applications based on Apache Wicket
- gengui, an open source framework for swing applications
- Domain Object Explorer
- JMatter, an open source framework for creating business applications for workgroups
- Apache Isis
- Sanssouci
- Dynamo
- Lablz - Data objects as Web Applications
.NET :
- dotObjects
- Naked Objects for .NET
- TrueView for .NET
C ++ :
- Typical Objects for C ++
PHP :
- NakedPhp

See also

Domain-driven design - procedure model for modeling complex software systems expanded by naked objects

Architecture patterns - additional patterns that can be reused for software architecture
Model View Controller - comparable architecture pattern
Software architecture
Graphical user interface
CRUD frameworks

literature

Richard Pawson, Robert Matthews: Naked Objects . Wiley, 2002, ISBN 978-0-470-84420-5 (English, nakedobjects.org [accessed March 14, 2010]).
Dan Haywood: Domain-Driven Design using Naked Objects . Ed .: Pragmatic Programmers. Pragmatic Programmers, 2009, ISBN 978-1-934356-44-9 (English, Domain-Driven Design using Naked Objects ).

Web links

Naked Objects - Home page for Naked Objects for Java with general information about Naked Objects

Individual evidence

^ OOPSLA 2001 Technical Program. Retrieved on March 20, 2010 (English): "In expressive systems, core business objects show through directly to users, and all user actions are initiated through a noun-verb style of interaction on those objects. Having users and developers speak a common language improves the process of requirements analysis and prototype development. "
^ Richard Pawson, Robert Matthews: Naked objects: a technique for designing more expressive systems . In: Association for Computing Machinery (Ed.): ACM SIGPLAN Notices . tape 36 , no. December 12 , 2001, ISSN 0362-1340 , p. 61-67 (English, acm.org [accessed March 20, 2010]).

^ ^A ^b ^c Richard Pawson: Naked Objects . Ed .: Department of Computer Science, Trinity College, University of Dublin. June 2004 (English, nakedobjects.net [PDF; accessed on March 20, 2010]).

^ Jef Raskin: The Humane Interface . New Directions for Designing Interactive Systems. Addison-Wesley Longman, Amsterdam 2000, ISBN 978-0-201-37937-2 (English).

^ Larry L. Constantine: The Emperor Has No Clothes: Naked Objects Meet the Interface . Constantine & Lockwood, December 2002 (English, foruse.com [PDF; accessed March 20, 2010]).

^ Fujitsu: The Department of Social and Family Affairs. (No longer available online.) Archived from the original on November 29, 2007 ; Retrieved on March 21, 2010 (English): "Fujitsu designed a solution that achieves the department's vision, namely to create business components as the basis for building flexible and responsive business applications in Naked Objects Architecture." Info: The archive link was automatically inserted and not yet checked. Please check the original and archive link according to the instructions and then remove this notice.

↑ Department of Social & Family Affairs: The ongoing development of the Department's Service Delivery Modernization program. (No longer available online.) April 23, 2007, formerly in the original ; accessed on March 21, 2010 (English). ( Page no longer available , search in web archives ) Info: The link was automatically marked as defective. Please check the link according to the instructions and then remove this notice.@1@ 2
^ Richard Pawson, Vincent Wade: Agile Development Using Naked Objects . In: 4th International Conference, XP 2003 Genova, Italy, May 25-29, 2003 Proceedings . Extreme Programming and Agile Processes in Software Engineering, No. 2675 . Springer, 2003, ISBN 978-3-540-40215-2 , ISSN 1611-3349 , doi : 10.1007 / 3-540-44870-5_13 (English, metapress.com [accessed on March 21, 2010]).
↑ Requirements Engineering - Axel van Lamswerde, 2009, John Wiley & Sons Ltd (Publisher), 978-0-470-01270-3 (ISBN) - https://www.lehmanns.de/shop/mathematik-informatik/6230206- 9780470012703-requirements-engineering
↑ Software Product Line Engineering - Pohl, Böckle, van der Linde, 2005. Springer Vlg. - http://www.springer.com/us/book/9783540243724
^ System Requirements Analysis . 2nd Edition. Elsevier (publisher), 2013, ISBN 978-0-12-417107-7 , elsevier.com
^ Dan Haywood: Domain-Driven Design using Naked Objects . Ed .: Pragmatic Programmers. Pragmatic Programmers, 2009, ISBN 978-1-934356-44-9 (English, Domain-Driven Design using Naked Objects ).
↑ NoWicket on GitHub.com
↑ Gengui on Sourceforge.net