diff --git a/naked-objects/README.md b/naked-objects/README.md index 8ed8210de..7a98c4818 100644 --- a/naked-objects/README.md +++ b/naked-objects/README.md @@ -3,42 +3,37 @@ title: Naked Objects category: Architectural language: en tag: - - Decoupling - - Extensibility - - Presentation + - Architecture + - Business + - Decoupling + - Domain + - Enterprise patterns + - Instantiation + - Object composition + - Persistence --- +## Also known as + +* Transparent Objects + ## Intent -> The naked object design pattern is a way to build user interfaces (UIs) for software applications that is based on the idea of direct manipulation. This means that users interact directly with the underlying domain objects of the application, without any intermediary UI elements. - -> The naked object pattern is implemented by exposing the domain objects to the user in a way that is both meaningful and accessible. This is typically done by generating a UI automatically from the domain object definitions. The UI presents the domain objects to the user in a simple and straightforward way, allowing them to create, retrieve, update, and delete objects, as well as invoke methods on them. - -> The naked object pattern has a number of advantages, including: - -> 1. Reduced development time and cost: The naked object pattern can significantly reduce the time and cost required to develop and maintain a software application. This is because the UI is generated automatically, and the domain objects are designed to be both user-visible and manipulatable. - -> 2. Empowered users: The naked object pattern gives users direct access to the underlying domain objects of the application. This allows them to interact with the application in a way that is natural and intuitive. - -> 3. Increased flexibility and adaptability: The naked object pattern is highly flexible and adaptable. This is because the UI is generated from the domain object definitions, which means that the UI can be easily changed as the domain model evolves. +To enable the rapid development of maintainable systems by representing all business objects directly and automatically creating the user interface from these definitions. ## Explanation -**In plain words** +Real-world example -> Imagine you are building a software application to manage a customer database. You could use the naked object pattern to build the UI for this application as follows: +> Consider a real-world example where a company develops a customer relationship management (CRM) system using the Naked Objects design pattern. In this CRM system, each business object, such as "Customer," "Order," and "Product," is represented directly as an object in the system. The user interface is automatically generated based on these domain objects, allowing sales representatives to view and edit customer information, track orders, and manage inventory without needing a separately designed UI. +> +> This approach ensures that any changes in the business logic or domain model are immediately reflected in the user interface, significantly reducing the development and maintenance time. For instance, if a new field, "Loyalty Points," is added to the "Customer" object to track rewards, this field automatically appears in the CRM's user interface without additional UI development. This keeps the system flexible and closely aligned with the evolving business needs. -> 1. Define the domain objects for your application. This includes objects such as Customer, Order, and Product. +In plain words -> 2. Implement the business logic for your application on these domain objects. For example, you could implement methods to create a new customer, add a product to an order, or calculate the total price of an order. +> The Naked Objects design pattern automatically generates a user interface from domain objects, allowing for rapid development and easy maintenance by ensuring the UI directly reflects the underlying business model. -> 3. Use a naked object framework to generate a UI for your application from the domain object definitions. - -> The generated UI will present the domain objects to the user in a simple and straightforward way. The user will be able to create, retrieve, update, and delete customers, orders, and products, as well as invoke methods on them. - -For example, the user could create a new customer by entering the customer's name, address, and phone number into the UI. The user could also retrieve a list of all customers by clicking a button. To update a customer's information, the user could simply change the corresponding values in the UI and click a save button. - -**Wikipedia says** +Wikipedia says > Naked objects is an architectural pattern used in software engineering. It is defined by three principles: > @@ -47,11 +42,7 @@ For example, the user could create a new customer by entering the customer's nam > > The naked object pattern's innovative feature arises by combining the 1st and 2nd principles into a 3rd principle: 3. The user interface shall be entirely automatically created from the definitions of the domain objects. This may be done using reflection or source code generation. -## Programmatic example - -> Certainly, here's a programmatic example section for the Naked Objects pattern: - -## Programmatic Example +**Programmatic example** In the context of the Naked Objects pattern, let's consider a simplified example with domain objects representing books and authors. The example demonstrates how the Naked Objects pattern can be applied to create a user interface for managing a library catalog. @@ -89,11 +80,11 @@ public class Author { } ```` +In this example, we define two domain objects: Book and Author. The Book class has properties for the title and author, as well as an action to borrow the book. The Author class has a property for the author's name, a collection of books they have written, and an action to create a new book. -> In this example, we define two domain objects: Book and Author. The Book class has properties for the title and author, as well as an action to borrow the book. The Author class has a property for the author's name, a collection of books they have written, and an action to create a new book. +With the Naked Objects framework or tool, the user interface for managing books and authors can be automatically generated based on these domain object definitions. Users can interact with the generated UI to create, retrieve, update, and delete books and authors directly through a user-friendly interface. -> With the Naked Objects framework or tool, the user interface for managing books and authors can be automatically generated based on these domain object definitions. Users can interact with the generated UI to create, retrieve, update, and delete books and authors directly through a user-friendly interface. -> Here's how you can use these domain objects to create and interact with books and authors programmatically: +Here's how you can use these domain objects to create and interact with books and authors programmatically: ```java var author = new Author(); @@ -103,51 +94,43 @@ book.setAuthor(author); book.borrow(); var booksByAuthor = author.getBooks(); - ``` -> This example demonstrates how the Naked Objects pattern can be implemented in a Java-based application with domain objects for books and authors. Users can directly manipulate these domain objects through the generated user interface. +This example demonstrates how the Naked Objects pattern can be implemented in a Java-based application with domain objects for books and authors. Users can directly manipulate these domain objects through the generated user interface. ## Applicability -> The naked objects pattern is applicable to a wide range of software applications, but it is particularly well-suited for applications where users need to have direct access to the underlying data model. This is often the case in business applications, such as: - -* Customer relationship management (CRM) systems -* Enterprise resource planning (ERP) systems -* Human resources (HR) systems -* Order management systems -* Inventory management systems -* Asset management systems -* Project management systems -* Knowledge management systems - -> The naked objects pattern can also be used to build UIs for scientific and engineering applications, such as: - -* Data analysis applications -* Simulation applications -* Modeling applications -* Visualization applications ->In general, the naked objects pattern is a good choice for any application where users need to be able to create, retrieve, update, and delete data, as well as run complex reports and analyses on that data. +* When aiming to create a system where the domain objects can be easily understood and manipulated without an explicit user interface design. +* For applications requiring a dynamic, adaptable UI that reflects the underlying domain model with minimal developer intervention. ## Known uses -> 1. Here are some specific examples of applications that have been built using the naked objects pattern: -> 2. The Department of Social and Family Affairs in Ireland uses the naked objects pattern for its Child Benefit Administration system. +* Enterprise applications where business rules and domain logic are primary. +* Systems that benefit from a dynamic and adaptive user interface. -> 3. The UK National Health Service uses the naked objects pattern for its Electronic Patient Record system. +## Consequences -> 4. The Australian Taxation Office uses the naked objects pattern for its tax return processing system. +Benefits: -> 5. The US Department of Defense uses the naked objects pattern for its logistics management system. +* Rapid development +* Improved maintainability +* Easy domain understanding +* Alignment between the UI and business model -## Quick start +Trade-offs: -Apache Isis is a Java framework that implements the naked objects pattern. Check out their [starter app](https://isis.apache.org/docs/2.0.0-M9/starters/simpleapp.html) to get started on building an application. +* Reduced UI flexibility +* Potential over-exposure of the domain model +* Reliance on framework capabilities + +## Related Patterns + +Active Record: Similar in exposing domain models directly, but Active Record typically involves persistence aspects as well. +Domain-Driven Design: Shares the focus on domain modeling but without the automatic UI generation of Naked Objects. ## Credits * [Richard Pawson - Naked Objects](http://downloads.nakedobjects.net/resources/Pawson%20thesis.pdf) * [Apache Isis - Introducing Apache Isis](https://isis.apache.org/versions/1.16.0/pages/downloadable-presentations/resources/downloadable-presentations/IntroducingApacheIsis-notes.pdf) - - -```` +* [Domain-Driven Design: Tackling Complexity in the Heart of Software](https://amzn.to/3wlDrze) +* [Naked Objects](https://amzn.to/3yhrfQr)