Uniface (programming language)

Low code development platform

Uniface is a low code development and deployment platform for enterprise applications that can run in a large range of runtime environments, including mobile, mainframe, web, Service oriented architecture (SOA), Windows, Java EE, and NET. Uniface is used to create mission critical applications. Uniface applications are platform independent and database independent. Uniface provides an integration framework that enables Uniface applications to integrate with all major DBMS products such as Oracle, Microsoft SQL Server, MySQL and IBM Db2. In addition, Uniface also supports file systems such as RMS, Sequential files, operating system text files and a wide range of other technologies, such as IBM mainframe based products (CICS, IMS), web services, SMTP, POP email, LDAP directories, NET, ActiveX, Component Object Model (COM), C(++) programs, and Java. Uniface operates under Microsoft Windows, various flavors of Unix, Linux, OpenVMS and IBM i.

Uniface can be used in complex systems that maintain enterprise data supporting business processes such as point of sale and web based online shopping, financial transactions, salary administration, and inventory control. It is currently used by thousands of companies in more than 30 countries, with an effective installed base of millions of end users. Uniface applications range from client/server to web, and from data entry to workflow, as well as portals that are accessed locally, via intranets and the internet. Originally developed in the Netherlands by Inside Automation, later Uniface B. V., the product and company were acquired by Detroit based Compuware Corp in 1994, and in 2014 was acquired by Marlin Equity Partners and continued as Uniface B. V. global headquartered in Amsterdam. In February 2021, Uniface was acquired by Rocket Software, headquartered in Waltham, Massachusetts, USA.

Uniface applications are developed on with the Uniface Development Environment. Originally, it was possible to develop on Apple and DEC platforms; now, Windows is the supported platform for development. Uniface applications development is model driven and component based. The data structure, business rules, and default behavior of the application are captured in the Application Model. Model definitions can be reused and inherited by components, which can override inherited definitions and provide component specific behavior and characteristics. Templates improve productivity and enforce consistency when defining models.

The application model defines entities (tables), fields, keys (indexes), and relationships together with referential integrity. Each entity and field in the model has properties and a set of triggers. Business rules are added to the model declaratively by setting properties and procedurally by adding Proc code (Uniface's procedural language) in triggers. Triggers are containers for code. Some triggers represent user or system events, for example, Occurrence Gets Focus, Read or Leave Field. Others cover matters such as validation or act as place holders for methods associated with the particular object. The use of model level triggers enables Uniface to collect properties and behavior within business objects, separating logical from the physical data structures. It makes it possible to define default behavior once, for reuse throughout the application, speeding development and facilitating the 3 tier application architecture. Each entity (table) is first defined in the Application Model from where it can be exported to the physical database in the form of CREATE TABLE scripts.

Objects described in the application model are reused by components. Developers embed objects from the model on the component by drawing them on the layout canvas (for presentation components), or inserting them into a tree view of the component structure. They can also add component level objects that are not in the application model, such as control fields, menus, and component variables. The properties and triggers defined in the application model are inherited by being copied into the component. The definitions can be changed at the component level to provide specific functionality. This breaks the link between the application model and the component (although it is possible to restore the link to the model). If the model code or properties are changed at the model level, all components holding that object need only be recompiled to collect the new definitions. This provides benefits in maintenance and ensures that the rules associated with the object are available wherever it is used.

Uniface maintains a database of its own metadata for the purposes of reuse—application models, component definitions, component layouts, procedural code, and so on. The repository is proprietary and intended for access via the Uniface Development Environment, to ensure repository integrity. However, the repository structure is documented, making it possible (though not recommended) to interface directly with it for, for example, reporting. By using a centralized repository, application development can be shared over teams of software developers. Uniface can integrate with any version control system (VCS) that supports the Microsoft Common Source Code Control Interface Specification. The VCS functionality available within Uniface depends on the VCS used, because software vendors have interpreted and implemented the MS CSCC API differently.

Uniface applications can be deployed on platforms from mainframe through mobile, without changing the code. The components (and other objects such as startup shells, menus, toolbars (panels), glyphs, global and included Proc entries) are compiled into runtime objects that can be packaged into zip files and deployed onto any platform. The runtime objects are executed using a virtual machine and a platform specific interpreter. (Java later followed Uniface in this respect). Components can be compiled on one machine and executed on another, providing the Uniface Virtual Machine is present. The Uniface Router and Uniface Server make Uniface scalable and make is possible to run processes asynchronously.

Uniface accesses the many databases and file systems it supports by means of database connectors (or drivers). DBMS connectors map and convert Uniface data types to the most suitable format of the particular storage medium. At runtime, it is possible to pass parameters to invoke (or disable) database specific extensions. Provided the database connector is licensed, it is possible to convert between different data sources. Uniface also provides an API, the Database Connector Interface, which can be used to create proprietary connectors for any SQL based database.

Licensing is managed through the Compuware Distributed License Manager (DLM), a server based system of distributing licenses to clients on request, precluding the need for them to be held locally.

Originally called UNIS, the product was created in The Netherlands in 1984 by Inside Automation, a company that was headed by Bodo Douqué, with Frits Kress as Technical Director. By 1986, both the product and the company had changed their name to Uniface. (An early logo for the product included a red capital A which reflected the red capital A in the Inside Automation logo.) Uniface was developed on the principles of the American National Standards Institute, (ANSI), 3 schema architecture. First proposed in 1975, this was a standard approach to the building of database management systems consisting of 3 schema (or metamodels):
Conceptual schema—definition of all the data items and relationships between them. There is only one conceptual schema per database. Uniface implements the conceptual schema as the Application Model (in various Uniface versions known as the Business Object Model and the Application Object Model). External schema—different external (user) views of the data. There can be many external schemas for a database. Uniface implements external schemas as components. During Uniface's evolution, the External Schema became forms; hidden forms, which ran in the background without displaying to the user, became services; services split into session services for objects of the business tier and entity services that may be either business or data tier. Forms that were printed instead of being displayed became report components. The server page (USP) was introduced for web development, and later the dynamic server page was introduced to support Web 2.0 functionality. Internal schema—definition of the physical representation of the stored data. Uniface leaves the internal schema to the many relational database systems to which it could be connected, enabling it to be database independent. Uniface was developed on the DEC VAX machine, using the native VAX file management system RMS. A vestige of this is still seen in today's product by its continued use of a “GOLD” key to change modes (DEC VT terminals actually had a gold or a yellow key on the keyboard. Today the “GOLD” is simply mapped to the numeric keyboard + key, or a function key). Early versions of the product were bundled with the Sybase RDBMS under the name FastBuild, although it was not limited to accessing only that database. Uniface has continuously evolved to handle new technologies and application architectures. This has been critical to its success because applications built with Uniface can be migrated, updated and modernized without losing the original development investment.