Z++ and Distributed Computing

For decades now we have been using same software development technologies and yet no new idea has emerged beyond email exchanges. Handheld devices play videos and are capable of connecting to the Internet for downloading music, games and at times for receiving alert text messages. The leap to next level of software, true distributed software, requires fundamental renovations at both ends top and bottom.

Language is the final frontier for entering the era of distributed communicating applications. Gluing several languages together does not elevate our technological capabilities, only exponentially raises unnecessary complexity and therefore the cost of development and maintenance. An expressive distributed language for Autonomous Agents and Communicating Distributed Processes demands an underlying distributed operating system.

Z++ language, powered by Z47 Processor, enables the cooperation of all types of operating systems in running distributed software. What can be developed rather naturally in Z++ cannot be accomplished with the sum of all contemporary languages and gluing technologies.

The failure of XML demonstrates that Web Services require a fundamentally different approach. Z++ tell/hear signaling solves this problem by providing the technology of Asynchronous Function Call. The requesting Z47 initially sends the signature of a function to the provider Z47, and if the server accepts the requests, only then the actual data is sent in binary. The server can also use tell/hear signals to inform the client of completion of service. Since a server can itself seek a requested service from other servers, ISPs and other service providers can use this technology for the implementation of realistic Web Services as was envisaged a few years earlier. It is interesting to note that the use of tell/hear signaling in Z++ is quite straightforward. What we have described here is the protocol followed by Z47 processors, which is transparent to a Z++ application.

Services are generally provided via Internet, and PHP is extensively used for the implementation of services, or as a facilitator. Since PHP can directly invoke local and remote Z++ applications, even in these cases the use of PHP becomes rather trivial as a facilitator. The actual services can be implemented entirely in Z++.

Turning our attention to Original Equipment Manufacturers (OEM), we see that they either pack handheld devices with their own products, or support some virtual machine for the community of their developers. An OEM can attract more than single developers at home by moving away from an old technology of the sixties, known as Virtual Machine. Languages based on this technology cannot evolve any further as observed over past decades. The Z47 Processor is in fact a self-contained Distributed Operating System, of about 500K in size. OEMs only needs to add their GUI maker to the Z++ object-oriented layer for Graphical User Interface thereby providing its developers with a coherent and elegantly expressive language far beyond the sum of all available languages.

With regard to scientists researching intelligent software, the problem here is that intelligent software confined to a single node has limited use. Realistic intelligent applications are distributed in nature and therefore need a means of communication. The prevailing concepts of Remote Procedure Call (RPC) and Communicating Sequential Processes (CSP) are inadequate for the type of communication needed for sophisticated intelligent software. In context of Z++ language, an Autonomous Agent is an application that simply travels to another node. Other than the travel statement, the entire operation is transparent to the Z++ application. An application travels as a live Z47 process to another Z47 node. The process begins execution on the destination node as if it never moved at all. Thus, a Z47 process is capable of continuing its execution as it travels from node to node.

As for communication mechanism, the tell/hear signaling mechanism of Z++ furnishes the linguistic abstraction of Communicating Concurrent Processes (CCS). In CCS model, one node tells its data to another node that is hearing it. The teller does not wait as in RPC, but it can also hear at a later time. This simple and natural mechanism allows Z++ applications to communicate as they go. The data transmission is in binary and transparent to the application.

This category of researchers now have the technology for designing intelligent distributed software for communicating robots in a factory, objects flying in the sky and down to Nano-Technology. The impedance in fleshing out this type of software is due to inadequacy of CSP and RPC, while XML is essentially a nuisance.

Computer scientists are interested in discovering new and better ways of developing software. Linguistic improvements are the most critical issues of this domain of research. However, it is not possible to make a whole new language for every discovery. The language under research for new ideas must be monotonically extensible so that new discoveries can become part of the language in an orthogonal manner. There should not be any loss from what the language was used for in order to incorporate a new abstraction. Z++ is powered by a self-contained extensible distributed operating system. That qualifies Z++ as the only candidate for this type of research.

Computer scientists can now engage in further research towards the development of reliable applications that cannot be envisaged at our time. Leaving Z++ out, relative to the available technology some contemporary research ideas seem more like science fiction. Indeed, while Autonomous Agents are native to Z++ it is impossible to implement such agents with strong mobility outside of Z++. Furthermore, Z++ already solves a few other problems such as Component-oriented Development and developing by teams spread in different geographical locations.

Entering the next stage of software engineering requires breaking the barrier of linguistic impedance. Engineers of different backgrounds design the engine, the electric system and the brake system of a car. Nonetheless, all these engineers use various parts of mathematics that even a mathematician cannot master in its entirety. In the same vain, software engineers need not master the entire Z++ language for purposes of development. Nevertheless, the whole team will be able to speak the same familiar language regardless of the vastness of the application under research, design and development.

Finally, apart from containing the abstractions for solving some outstanding software problems, a language must be coherent and lack partial and weak mechanisms, which create traps for software engineers. C++ is an ad hoc extension of C, which also imports all the weakness of a needed assembly language, and borrows some elegance from Simula. Originally C++ was meant for developing applications, not just more complex system programs than C could manage.

For engineers Z++ is a greatly enhanced superset of C++. An object-oriented design of the familiar database SQL statements is simply part of the Z++ language. Furthermore, threading and graphical user interface are also designed in accordance to object-oriented paradigm. Z++ classes and tasks, template or not, can specify Invariants and Constraints. In addition, template instantiations can be constrained via pattern specifications. Enumerations are extensible and notions like mutex are simply built-in types. Z++ Collections with their Shared Methods extend object-oriented notions horizontally. While this is a brief description of part of the super language Z++, engineers will find it much easier to develop applications in Z++ as compared to C++.