Why jVantage?

From jVantage

A quick comparison of traditional development verses jVantage development.

	Traditional Development	jVantage
Form Validation	Often requires custom validation logic for each input form.	Data dictionary types allow you to associate validators with field types that can be reused throughout your applications. Dictionary types can be validated against valid value lists, invalid value lists, regular expressions, required field modifiers and more. Use the dictionary types that ship with jVantage, or create your own. Changes to dictionary types can be done at any time without requiring new code, or the need to retest or rebuild your applications.
Access Control	Controlling user access to application data can require enormous effort and code that is difficult to manage and control.	The Access Control Panel allows you to control user access to application resources down to the field level. In fact, you can selectively hide fields or specify customized field visibility (such as read-only) on a group by group bases. This can be done on the fly for any application at any time.
SSL	Ensuring that sensitive data is always properly encrypted can be a management and programmatic nightmare. This can require hard-coded logic to be added to your applications to encrypt data that should not be transmitted in the clear.	With jVantage, protecting sensitive data is as simple as checking a check-box. Once you indicate that a specific type of data should always be encrypted, jVantage will watch for that data and encrypt it automatically when it appears on your user interfaces*.
File Uploading	Adding file upload capabilities to applications requires adding handlers that can parse multi-part messages. This is a difficult problem. Furthermore, associating uploaded images with application data is even more difficult. Where should the uploaded files be stored? How should the application manage and track uploaded artifacts so they are associated with the proper application records? This can add significant overhead and cost to applications.	With jVantage, adding up loadable documents and images is as simple as adding a new field (using the up loadable dictionary type) to your application entities. jVantage transparently handles all the rest. All of it.
e-mail support	Email capabilities are usually added to Java applications using the JavaMail API. Although this is a good approach, it is usually implemented via a tightly-coupled approach that does not allow for enterprise level reuse. Instead, the email library and necessary code is inserted into all application that must send email.	jVantage provides an Email service that can be accessed and utilized throughout your enterprise without requiring development of any email services. First, simply configure jVantage with the email credentials to allow it to communicate with your email server via the simple configuration page in jVantage (accessed from the Root Context page). Then, simply bind to the service from anywhere in your enterprise and send emails without requiring any of your applications to know anything about email. The only thing required is to create instances of the EmailMessage (a plain Java Object - POJO) object and pass it to the email service.
Entity Relationships	Defining relationships between application entities requires custom code in your applications as well as database schemas that properly reflect them.	jVantage automatically builds the database and application infrastructure required to implement relationships between entities of your applications -- from the application layer, clear down to the database layer. This includes the troublesome Many-to-Many relationships, which can require database join-tables and an enormous amount of application logic. With jVantage, simply define a Many-to-Many relationship and jVantage does all the rest for you. From the top of the development stack to the bottom. You're done.
Logging	Although many powerful logging packages are available for Java (and other) programming languages, implementing a sound and well-planned logging approach is often a matter trial-and-error. This can make log files inconsistent, hard to use and even impact performance.	jVantage utilizes the log4j logging framework. This means that logging is already inherent to all the applications you build with jVantage. Furthermore, the log level (verbosity), ultimate output destination and format of your logs can be exhaustively customized via external log4j configuration files. In fact, if you set your log verbosity setting to DEBUG, you can trace every mouse-click that users enter on your jVantage applications to entries throughout your log files. And, without touching your application logic, you can configure your log files to automatically roll-over every day, or even divert them to a relational database rather than the file system. Finally, you can leverage ChainSaw and other third-party tools to get the most out of your logs.
Session Management	Session management is the approach applications take to track information about what users are doing from one activity to the next. Many web applications utilize the HTTP Session (from the Web Container) to handle this type of information. However, this presents a problem when back-end (EJB container hosted resources or EIS resources) need access to shared user session information too. Poor session management can result in enormous performance impacts and wasted memory since information must be looked up over and over. Furthermore, when information is unnecessarily looked up it is often duplicated in your JVM's memory.	jVantage employs a session management approach wherein all user session information is shared among Web Container resources and EJB container resources. Furthermore, this information is even shared across application boundaries so that a user's session data can be leveraged efficiently by all applications within your application server (this can be restricted via the security settings of your application server if needed). In fact, session management is such an intrinsic notion in jVantage, that at any time you can open and search through the session information of logged in users by using the Session Viewer tool. You can also insert objects into user sessions via custom programming -- even leverage specialized session containers that allow your applications to specify a shelf-life for objects. When the shelf-life expires, jVantage will remove the object from the session automatically, thus freeing memory resources.
Context Sensitive Help	Documentation is a long-standing problem of application development. Keeping documentation in sync with the ongoing evolution of applications is difficult, to say the least; almost always requiring substantial effort on the part of developers and technical writers.	jVantage offers built-in support for context sensitive help. In fact, as you interactively build your applications, jVantage leverages the meta information from various descriptions, mouse-over help, dictionary attributes, and so on, to automatically generate context sensitive, online help for the application. This is all done on-the-fly. Simply create applications, generate the XML data set and your online help is ready to view. From there, you can insert custom text and images into the help to provide additional information about the application. And, since jVantage utilizes the Apache Velocity template engine for help rendering, your custom changes are never overwritten when you regenerate new XML data sets. Instead, your custom content is preserved and the new generated application data is interpolated to keep your help and applications in sync.
Keyword Searching	Keyword searching is a means of allowing users to search for application data by executing a search from within that application. The simple truth here is that almost no applications support keyword searching -- there is simply too much overhead to make the feature worth while. Issues such as, how to keep data up-to-date, how to be sure that the user has authorization to view all of the records that match the search criteria, or even, how to specify which information from a matching record should be displayed. The search result list must be created using field-mapping, since the search pool will most likely be heterogeneous. Once a record is displayed, can the user select it to navigate to a full view of that record (or entity)? It's just too much.	jVantage supports keyword searching for all your applications. Just specify which fields of your entities should be shown in the search result lists and you're done. All the remaining infrastructure for supporting the search is free. In fact, jVantage will even make sure that the user who executes the search has proper access to all matching data before showing it. Then, to go to the matching entity instance, the user need only select it from the list.

• If you develop custom user interfaces or modify page content externally through the use of triggers, it may be necessary to add logic to your custom code to ensure sensitive data is properly encrypted.