DaVinci 1.0 Alpha review

DaVinci is a comprehensive framework for model-driven Web Engineering. DaVinci is designed as a complete toolkit which consists of

License: GPL (GNU General Public License) File size: 0K Developer: DaVinci Team

0

DaVinci is a comprehensive framework for model-driven Web Engineering.

DaVinci is designed as a complete toolkit which consists of three parts: the DaVinci Modeling Framework, the DaVinci Architecture Layer and the DaVinci Runtime Library.

Characteristics:

A fundamental difference to existing Web Engineering frameworks is the architectural concept of DaVinci which is specified in the DaVinci Architectural Layer. The architecture is based on the assumption that, for a Web application (by contrast to a more document-centric Web site) the hypermedia paradigm is more circumstance than useful.

A classical Web site is based on URLs, hyperlinks, and various kinds of resources which is the basic concept of hypermedia systems like the Web.
In the scope of DaVinci, a Web application is more like a traditional application running in the browser. Thus the bahavioural (or functional) aspect is much more important than pages. Pages are generated and transient. Therefore, the basic idea of DaVinci was to eleminate the classical hypermedia paradigm and to inject an additional layer between the Servlet Container and the application (see figure showing the DaVinci Stack).

The DaVinci Architectural Layer provides concepts which are missing in the Servlet API but essential for Web applications. While other projects (e.g. Java Server Faces or Struts) do not re-define the interaction process, DaVinci defines a dedicated GUI model as well as an interaction process.

These four important aspects outline the main characteristics of the DaVinci Web Engineering Framework:

A Web application is not just a set of Web pages, it's rather a piece of software with application logic and business state. Thus, the notion of a user session is fundamental.

The view state is part of the session. It is based on a hierarchical view tree model with switchable sub-trees. This allows to change the GUI during the session, but always keeps the GUI in a certain, deterministic state.

Instead of refering to documents, URLs are refering to actions that can be invoked. When modeling an application with DaVinci, the GUI including all interaction spots (buttons, forms, etc.) is well defined allowing the incorporation of CASE tools.
Application logic is modeled using traditional methods and indepenently of the views.

The DaVinci Architectural Layer

The figure below shows the DaVinci Stack. Between the Servlet Container and a DaVinci Web Application there is the DaVinci Architectural Layer.

The DaVinci Modeling Framework

The DaVinci Modeling Framework is a UML-based toolkit for modeling DaVinci applications. It defines the modeling process starting with use cases and storyboarding, then defining the GUI (user-experience model), the database design and finally the application logic which can be done using UML thoroughly. The DaVinci Modeling Framework will provide a rich set of CASE tools which will facilitate and automate the modeling process.

There is already a simple View Stubs Generator which takes a view tree configuration file and generates all views (JSP files) based on configurable skeleton templates. The generator can be found in the package at.davinci.casetools.

The DaVinci Runtime Library

This is the JAVA library containing all required classes for running DaVinci applications. In other words, this is the implementation of the DaVinci Architectural Layer. Currently it also includes all development libraries and CASE tools. But these will be extracted and become part of the DaVinci Modeling Framework in future.

Generic client/server applications

The framework is designed in such a way as to enable the development of any client/server applications. This means, the DaVinci Architectural Layer can be decoupled from the Servlet Context/Web Server-bundle and run on-top of an autonomous DaVinci kernel module. Different FrontController implementations enable the integration of different client/server communication protocols (e.g. FTP, POP3, plain socket communication, etc.).

Thus it's possible to use a POP3-FrontController, which will react on incoming e-mails. This can seamlessly migrate different communication channels within a business application and enable business workflows, that are not only based on HTTP, but also on E-Mail, FTP, etc. The framework can also be used for writing arbitrary socket-based server applications (for example a socket-based configuration utility running on an embedded device, etc.)

Currently there is a SocketController, which can be connected with an arbitrary telnet client, and a ConsoleRenderer which will render the state of the view tree into plain text.

Requirements:
Java 1.5 (For running the sample application, the runtime environment (JRE) is sufficient. But for developing DaVinci-based applications you will need the complete Java SDK)
Tomcat 5.0 (not tested with any other version or servlet container yet, but should work to)
DaVinci uses tag libraries and therefore depends on jstl.jar, which is included already. Another dependency is the Ostermiller Base64 library, which is also included. You don't have to care about dependencies.

Quick Start:

To demonstrate the framework in a running environment, you can download the DaVinci Sample Application. You only need a Java Runtime and a Servlet Container (e.g. Tomcat).

The application already includes the DaVinci Runtime Library (davinci-runtime.jar)!
If you have no Tomcat installed, download Apache Tomcat (tested with version 5) and configure it for your system.

Download the DaVinci Sample Application from SourceForge. The sample application is just one file "ROOT.war", which is a J2EE Web Archive. This file already includes the DaVinci Runtime Library in the directory "WEB-INF/lib". Alternatively you can compile it from CVS sources (see downloads section for details).

Configure the sample application: extract the archive ROOT.war using unzip to a folder called ROOT and open the file ROOT/WEB-INF/web.xml in your favorite editor.

Adjust the < param-value > of the servlet parameter webapp_dir (search for it!) to the following path:

[TOMCAT_HOME]/webapps/ROOT
where [TOMCAT_HOME] is the tomcat directory. This path must point to the document root directory of the DaVinci application.

Alternatively you can adjust users and access roles in ROOT/WEB-INF/access.xml because to demonstrate the implicit rights management down to the action level some actions are restricted!

(@developers: if you know how to fetch this information from the servlet container similar to the Apache environment variable DOCUMENT_ROOT, please tell me how!!).

Deploy the sample application: asure that there is no file called .../tomcat5/webapps/ROOT.war or .../tomcat5/webapps/ROOT directory (otherwise temporarily move them to another folder) and put the generated directory ROOT into .../tomcat5/webapps.

That's all. Be sure Tomcat is running and point your web browser to http://localhost:8080/davinci and the sample application should start.