The Model of a Modern MultiValue Environment
MultiValue technology has proven its worth over the years. But it sometimes struggles to meet modern demands for features and capabilities such as interactive web interfaces, SQL access to data, compatibility with Java or .NET, web services, security, and distributed systems.
Granted, you can achieve most of those things using existing MultiValue environments, but it's rarely easy. And MultiValue application providers lose business because their legacy environments haven't really kept up with today's technology.
That invites the question: What should the ideal modern MultiValue environment look like? This article will outline several must-have elements.
1. An Easy Migration Path
Any MultiValue environment will be worthless if you can't preserve and leverage the work you've already done. To make the migration process as painless as possible, the ideal MultiValue environment will include:
- A Way To Preserve Your Data — Programs and data must be imported directly into the new environment.
- A Way To Preserve Your Business Logic -— The modern MultiValue environment must support MultiValue Basic as a server-side scripting language. Procs, Paragraphs, dictionaries, MultiValue queries, and common TLC commands should also be implemented.
- A Way To Preserve Your Skill Set — Remember, not only will you be moving your applications to a modern environment, you will be moving yourself. The new environment must allow you to continue to be productive using your existing MultiValue development skills, even as you start to master new ones.
2. A World-class Database Engine
MultiValue technology is known for its speed and ability to handle complex data. The ideal MultiValue environment will provide:
- Efficiency — Traditionally, MultiValue technology has used hash files for data storage. But there are other highly optimized storage mechanisms that provide better performance, maintainability, and scalability. An ideal MultiValue data engine will eliminate the need for file re-sizing, and allow data to be stored in Item ID order without sacrificing performance.
- Data Integrity — Data integrity should be achieved by using an intermediate journal (for example, a write image journal) that manages the update to the physical database via background processes. Additionally, a separate journal for all database updates should be part of the system to provide further integrity as well as the ability to replicate data to a secondary server.
- Scalability — Initially, your applications may serve just a handful of users or handle a few dozens of Web requests an hour. But, if successful, you'll need an environment that can scale to many tens of thousands of users, millions of transactions a day, terabytes of data, and operate in a distributed server environment.
- Easy Administration — There should be a browser-based system management portal for easy system administration. System management functions should be available via APIs that can be used in MultiValue Basic programs.
The ideal MultiValue environment will itself be secure, and it will provide mechanisms for you to build security features into your new and existing applications. It should be internationally certified and provide capabilities for:
- Supporting Existing Application Security — Many existing MultiValue applications have been developed with a menu-based security module that is application-user oriented. Any existing security features must be supported in the new environment.
- Establishing Identity — Users must be able to prove they are who they say they are. Several authentication mechanisms should be supported, such as Kerberos, operating system-based methods, LDAP, and database login. For those environments with strongly protected perimeters, it should be possible to disable authentication.
- Controlling User Access — Once authenticated, a determination must be made as to what the user is allowed to access. In the ideal environment, users will be permitted access to resources based on their security role. The environment will make it easy to manage users and provision them with the appropriate security access.
- Knowing What Happened — A verifiable and trustworthy trail of actions related to the system is needed. The auditing features of your environment should provide a paper trail of authentication and authorization actions and the ability to reconstruct security related incidents.
- Protecting Data "At Rest" — The ability to encrypt data stored on disk is a must. In the ideal environment, encryption/decryption should occur as data is written/read from disk. In addition to your data, indices, bitmap images (if they are stored in your database), incremental backup maps, pointers, and allocation maps need to be encrypted.
- Encryption/decryption should be very fast, but your environment should also allow you to tailor the level of encryption, so that you can balance your security and performance needs.
4. An Easy-To-Use Development Environment
Any modern IDE will be a client-side installation that can, based on security and permissions, connect to any server, and allow remote development and debugging. Wizards for common tasks are the norm. In addition, the model MultiValue development environment will include:
- MultiValue Basic syntax checking and colorizing;
- A MultiValue command shell that supports direct execution of MultiValue Basic code, largely eliminating the need for test programs;
- A MultiValue debugger that works both from the IDE and the command shell;
- Graphical tools for the design of rich, interactive web interfaces and reports that are MultiValue data-aware.
5. Support for Objects
Today, the most widely used programming technologies (Java, .NET, C++, XML, etc.) are object-oriented, so it is vital that your MultiValue environment enables object access to data. That means:
- Full support for object modeling concepts such as encapsulation, multiple inheritance, polymorphism, embedded objects, collections, and relationships.
- You can create object definitions to access existing MultiValue data.
- MultiValue Basic has been extended to handle objects and object syntax.
- MultiValue Basic can be used as a scripting language for object methods.
6. Compatibility with Other Technologies
Customers don't want to be tied to any one technology, so the more open an environment, the better. The ideal MultiValue environment will make it easy to access data using:
- SQL — Data access via ODBC and JDBC is essential, since the majority of data analysis and reporting tools use SQL. Projecting MultiValue data to SQL can often be a difficult and time-consuming task. The model MultiValue environment will make it extremely easy to provide ODBC/JDBC access to data.
- Java — Java is one of the most popular development technologies in the world. The ideal MultiValue environment should be able to project data as Java objects, create objects from Java object definitions, and even allow the use of Java to directly manipulate data structures.
- .NET — Your MultiValue environment should also be compatible with .NET, providing both ADO and proxy class connectivity.
- XML — It should be possible to automatically create data objects from XML files, and automatically create XML files from data objects. Additionally, a complete XML API should be part of the environment.
- Other Object-Oriented Technologies — For the greatest possible openness, the ideal MultiValue environment will be able to project data to C++, Perl, Python, etc. As new object-oriented technologies are invented, your MultiValue technology partner should be able (and willing) to expand your connectivity options.
7. Support for Web Services and SOA
Web services and service-oriented architecture (SOA) in general are becoming a popular way to build composite applications. At the very least, a modern development environment needs to be able to:
- Publish Web Services — You should be able to easily transform any MultiValue Basic program or subroutine into a web service. This will entail casting the code as SOAP-formatted XML and creating the WSDL (Web Services Definition Language) definition.
- Consume Web Services — You should be easily able to read WSDL definitions and make published web services available to MultiValue programs.
- Secure Web Services — Your environment should support the WS-Security standard for SOAP message headers, and be able to encrypt the body of SOAP messages. It should support client-side login using either the WS-Security Login via SSL, or the (less secure) HTTP User authentication via SSL.
A model MultiValue environment may also give you capabilities for connecting services, allowing you to use MultiValue Basic for business process orchestration, business rules, workflow, and business process monitoring.
8. Real-Time Business Intelligence Capabilities
Increasingly, end users are asking for applications that provide immediate, actionable information about their businesses. The ideal MultiValue environment will enable you to enhance your new and existing applications with embedded real-time business intelligence features.
9. A Responsive, Dedicated MultiValue Technology Partner
Although not an element of your MultiValue environment per se, choosing the right MultiValue technology partner is of the utmost importance. You need a partner who is financially stable, innovative, and who considers MultiValue to be a core technology in their development strategy.
With a technology partner who believes and invests in MultiValue technology, you can rest assured that your modern MultiValue environment will continue to keep up with the times. The ideal partner will also provide world-class customer support, and be truly dedicated to helping you succeed.