A computer without a machine code

Almost all current computing is based on a technology that is now over sixty years old, using a single instruction machine code. Applications now consist of huge amounts of these single instructions, often running into the hundreds of millions of code lines. Some attempts have been made to simplify this by generating reusable groups of these single instructions, called subroutines, or modules. Groups of these modules have been themselves grouped together in the form of libraries. These basic structures all use the same, now obsolete, single instruction clusters.

When applications are analysed it is found that they use a relatively small set of basic functions. This paper outlines how these basic functions can be placed on programmable logic cards, eliminating the old and outdated machine code technology. In this mode applications become a string of characters giving the sequence in which these logic elements are to be processed, in effect being a technology DNA approach. The approach should replace current technology over a period of time.

Earlier developments
Before the development of the DNAT approach (DNA Technology), the concept was proven to be workable by creating in machine code the equivalent of the logic modules (known as Genetix) and testing them with a variety of simple and some quite complex applications. The more complex ones were for a hospital information system covering multiple hospital functions, a business credit data base similar to Dun and Bradstreet, on line accounting, a clone of a major accounts receivable package, and others. Most recently a Java run system was cloned, enabling it to be placed on a smart card chip.

From little acorns mighty software can be grown
Powerful and complicated personal computer programs could be many times smaller than today’s software if they were written using a Canadian programming technique.

The new approach, from Genetix Software of Ottawa manages this feat by doing away with the need for a separate operating system and by building up all the programs from little pieces of shared code.

The software has been inspired by a 60-year-old thought experiment by the mathematician Alan Turing, who suggested that a theoretical device, now known as the Universal Turing machine, could perform any computational task by combining a series of very simple operations.

“With Turing machines being conceptually simple, the design put forward by Bernard Hodson has relevance in nanotechnology in that we will want to get the simplest possible hardware running the smallest possible software. If construction command sequences can be compressed in a similar way, assembler control machinery could be greatly simplified.” (Foresight Nanotech Institute web site).

The assembler referred to here is a tiny machine placing atoms in particular locations, A nano-computer will be constructed atom by atom with software that can then be placed in the nano-computer, enabling it to reproduce itself.

Bloor Research UK
A Turing Machine consists of:
● A Paper Tape
● The Turing Machine
● A Rule List

Our own conclusion is that Genetrix does indeed implement a Turing architecture. The Universal Turing Machine is not a matter of religious purity, it is a matter of practical software engineering.

If we consider the English language, it consists of a relatively simple alphabet of 26 letters. These letters are all that is required to compose the full vocabulary of the language.

DNA enables the creation of billions of different beings, 20 odd chromosomes and several hundred genes.

In the same way that DNA strings are put together, applications are generated by Genetix. Just as we are now learning to splice genes into existing strings in Biology, we can do the same thing with applications.

All use the same 'software genes', the only difference in the applications being in the sequence in which the 'software genes' are processed. Many of the same genes will be used or, if you like, reused.

Bloor had concluded that Professor Hodson knew more about computing than most software engineers that he had previously encountered, and he had encountered a number of intellectual giants from the IT world.

The Turing Paradigm is this:
All software consists of processes that transform data in one way or another. Therefore software can be constructed as a related collection of data transforming processes. As such, all applications have the same underlying structure. We believe that this is the most radical development in computing since the invention of the compiler and if it is accepted, it will change the whole industry. A page has been turned and a new chapter in the history of computing has begun.

In our opinion, the Genetix Turing Machine is the most significant development in computing since the invention of the compiler.

Architecture of the computer without machine code
1. External application development language.

The development of applications for the computer without machine code is a fully independent operation that can be done in any ethnic language or in a language that is specifically oriented to a profession such as medicine or engineering, what might be called a BASIC GENETIX. How is this achieved? Each command is assigned a unique character (which need not be known by the developer), and can have parameters associated with it (which may be zero, again with no need for the developer to know). Numeric parameters do not need further identification, except for those used for arithmetic operations which will be converted to a condensed system notation.

This approach, when run through a small translator, converts an application to a string of bytes which are independent of the language used to create the application, which means that, provided certain rules are met, which will be made public, a translated application will run on the computer without machine code. As a corollary it also lends itself to applications on demand, with very small bandwidth needed.

A statement line such as arith alpha = beta + gamma would generate a byte string such as #24+6* where # is the code designating an arithmetic operation, 2,4,6 represent the order of appearance in the application of alpha, beta, gamma. The + sign is not interpreted as a variable because of its location relative to the other variables, which means that, depending on the command, additional numeric parameters can be introduced.

The byte code string can be generated anywhere, on any system, in any ethnic language, and should be publicly available. If the rules in developing the byte string are not followed it is almost certain that the application will be rejected when it reaches the run system.

Probably over 95% of current application developers will be involved with this language only, with only a few being needed for the computer without machine code itself. For these 95% it may be somewhat boring not getting involved with the likes of assembly language oriented Java, but it should make for accelerated application development by many more people in many more ethnic environments because of the removal of the technical knowledge that is needed by Java, C++ and other application programming environments.

2. Linkage of the external language to the numerically coded internal logic modules

A table exists within the run system linking the relative number of the command from the application to a string of internal logic elements that enable that command to be processed. This is generally of small length and is the only linkage between the byte string generator described earlier and the run system. Each command line linkage is a unique string of bytes defining the logic processes to be carried out and is to all intents an independent entity. New commands, when they are created, will require an addition to the indicated table and the defining logic elements to carry out the new command.

The overall logic diagram (in preliminary form at the moment) gives a visual image of the relationship of the command numeric code to the internal logic modules which, in turn, gives the internal logic linkages to the actual logic of the run system, whether it be in the computer without machine code, or in a conventional computer system where the run logic modules consist of a few machine instructions.

3. Numerically coded internal logic modules with linkage to the run logic modules.

The crux of the development is in this segment
The run logic elements are each given a byte code identifier. Only a small number are used at present, leaving considerable room for expansion. Associated with that identifier are linked parameter byte codes. While a parameter is included within the byte code it may also be followed by additional parameters.

So far everything has been a character. In the current structure developed thus far there are 128 possible run logic functions, each of which can be associated with 256 coded parameters, giving up to 32,768 available items to be included in a final run system. Even with the prototype system developed thus far it is possible to do a variety of applications.

There is no relationship between the parameters used in this activity and the parameters used in the application command stream.

Most of the internal logic modules are between 40 and 100 bytes, quite a few being less, a minor few being more, giving a very compact run system. The prototype is quits empty, leaving room for considerable expansion.

4. Run logic modules with option of hardware or software implementation.

The run system consists of a series of small logic processing modules. These can either be placed on programmable logic cards or on a conventional computer such as smart cards with microcontrollers, PC’s with Intel chips, or even Cray supercomputers (although in this case, while applications will run it would be preferable to convert the prototype to a 64 bit platform, which could give an exponential expansion capability).

These run logic modules in terms of conventional computers need only a few machine code instructions each so the overall conventional computer in this mode has a very tiny footprint. A development took place earlier ideas where the concepts were used to develop a run time Java, called Origin-J that operated on an AVR RISC microcontroller. While the concept can be used to emulate other languages it is a serious waste of talent to do so, except for the conversion of existing legacy applications in Java, Cobol etc.

Most of the run logic modules employ very simple logic and hence can straightforwardly be placed on a programmable logic card. The number of logic modules is so small, however, and the logic capacity of programmable logic cards is so high that it will be possible to place several copies of the run system on such cards and run them in parallel. There are some people in cyberspace who think that this approach is ideally suited to the development of nano size computers, which also would operate without machine code.

5. Integration of hardware logic modules with additional high power chips.

As will be seen in the prototype diagram the run logic modules are independently attached to what might be considered a ‘control box’ and, even with the present system, there is room for dozens more logic modules (at least another 100 or so). While not yet thoroughly explored it suggests that high-powered additional chips can be attached by simple logic devices to work with the system, augmenting existing operations. Such things as chips for high speed graphics, JPEG image processing, MPEG movies, mobile telephony, and the like, could be used with the run system.

6. Interim parallel running with conventional computers, gradually absorbing all their application activity.

The obvious question with what has been discussed so far is ‘how can the IT industry accept and adopt the architecture described’. Industry will not be interested in changing everything over at once to this type of architecture, so how might it be done. Just as people were initially loath to switch from the horse to the ‘new fangled’ motorcar the same situation will likely occur here, but the answer lies with the programmable logic card itself.

You can place one of the programmable logic cards within a conventional computer and have it do things in parallel to whatever else is going on. An evaluation needs to take place over what are immediately adaptable applications but undoubtedly email and mobile telephony would be included in the early adaptation. In the case of email a logic feature would be added so that people with systems containing the programmable logic card could communicate with each other, without any spam being introduced, transmitting encrypted messages to each other. Logic can easily be included within the computer without machine code to ensure that any message coming through is from someone with a similar status (i.e. a programmable logic card with encryption). The encryption itself would include hidden, checkable codes of authenticity. When users realise the value of this they would want to expand the capability to mobile telephony and then to a variety of sophisticated applications, reducing the load on the conventional computer until there is no need for a conventional machine. Other obvious areas are secure smart cards and embedded systems.

Using this architecture for safety critical systems could restore companies such a Rolls Royce to reasonable profitability, by offering software for their engine and safety control systems that is thoroughly checked out and changes only infrequently, (hence saving them a fortune in the current constant testing needed when software changes are made with the operating systems and languages they are using today).

Note that no operating system is mentioned and none is needed. Because the system is so small, (as compared to the 700 million bytes of a typical operating system), and because application themselves are so compact, most of the needed applications of an enterprise will be stored in memory, or can be called electronically as needed from an enterprise holding storage, as illustrated by Turing in 1936 when he envisaged a single computer holding all needed functionality, wher functions could be called at will. Even so, there could be a number of application libraries available so that less used applications can be transmitted on demand, with little bandwidth needed for transmission.

7. Potential impact on the Information Technology and financial market industries

The architecture introduces a whole new paradigm which, if not handled carefully, could disrupt the industry. Not only could it disrupt the industry it could also disrupt the financial markets. There will be disruption, nevertheless, but it should be possible to control it so that little real long term damage is done although some will fall by the wayside as a result of its introduction. Just as the horse was mainly phased out as the popularity of the motorcar increased so will this new paradigm phase out the conventional computer. The irony is that the concept of using programmable logic cards for general purpose software was developed in the 1950’s by this author, using a general purpose plug board wiring system that was in all respects equivalent, but by no means as powerful, as the current programmable logic boards.

The positive aspects
1. A big demand for programmable logic cards, with current vendors augmented by a new group of vendors, plus a temporary (till they are phased out) software requirement to integrate the cards with existing operating systems.

2. Creation of a number of vendors offering certifiable strings of byte codes meeting the standard open source criteria

3. Establishment of a standards group to control the further development of the external language carefully monitored.

4. Test groups to establish application control (e.g. for email) and operating standards, including encryption protocol to be used. Once the concept has been established there will be exponential growth of its use for major applications.

5. Mobile telephony would be an early target because of the relative simplicity of such an operation, to be followed as a secondary target by the secure linkage of mobile systems with enterprise data base systems and email, as well as images. Mobile phone vendors who accept the concept will grow significantly, those not doing so will fade away.

6. Other targets would be the processing of JPEG pictures and MPEG images associated with soundtrack. The JPEG process is quite simple and is demonstrable even with current work. The MPEG is somewhat more complicated but still entirely feasible, although it may be preferable to integrate the concept with a movie chip.

7. Early work involved integration with high-speed networks, using optical switches with the intermediary of a hardware chip. This would develop further.

8. Its usefulness has already been demonstrated for smart cards and embedded systems, the concept should be put forward as a standard for smart cards and embedded systems including activation of mechanical equipment, such as needed for pipeline control, aircraft and engine control, and spacecraft.

9. Its use for Safety Critical systems could have a very significant pay-off. Such systems require expensive re-checking whenever there is a change to the application source code or to the compilers in use or to the operating system employed. The computer without machine code is a constant, verifiable by any number of checks in the software logic mode and by specific control switches in the programmable logic mode, eliminating a major cost hurdle.

10. The approach is considered by many to be ideal for developing nano size computers. This can create entirely new industries with unique opportunities for those with initiative.

11. The bandwidth required for an application is so small that it makes applications on demand a realistic proposition. Perhaps we will see a series of application libraries with the byte codes transmitted either for free or for a small rental fee.

Negative aspects
1. Application development using a universal language will be boring to many of today’s programmers, a number of whom will pull out of the industry, offset by many new people joining the industry, tempted by the simplicity of development. The internal logic modules have a more difficult learning curve but because there is only a single set of logic and not hundreds of computer programs, the personnel demand will not be significantly strong. These people will demand and can expect premium salaries. The most difficult task, at least in the short run, will be finding personnel capable of converting run logic modules to ‘fly’ on a programmable logic card. These people will become the elite of IT.

2. As the proposed system has no real need for an operating system as they presently exists there would seem to be no incentive to have any further such systems developed, and to phase current systems out, with a consequent negative effect on the vendors of such systems.

3. There is reason to believe that the developed system will offer high security and be intrusion free. There will be joy in IT land that spammers, hackers, system intruders and the like will be out in the cold (one of my own motives for developing this system) but less joy with those companies who offer security, anti virus and anti spamming software.

4. Having been an academic for a few years I know how slowly academia adapts to innovation. Once the approach is widely held there will be a need to revamp significantly the teaching on compilers, languages and operating systems, with greater emphasis on logic and how it is integrated.

5. The system is so small it will occupy very little hardware, even when loaded with scores of applications. It will rid us of horrendously sized operating systems, bloated software such as that often found with databases, and the proliferation of security software. This wil have an adverse effect on hard drive vendors, maybe all that will be needed will be USB’s. Logic flow of computer without machine code, with the same logic being able to be on a computer so that new items can be tested first conventially and then placed on the programmable logic cards.

Start up logic
Get first character of byte code stream.
Initialise a value
Proceed to differentiation logic
End of start up logic

Differentiation logic
Examine byte code character and either generate invalid message and quit or, generate farewell message and quit or, depending on character either go to internal logic module and transfer logic module or, go to logic for processing run logic modules end of differentiation logic.

Logic for handling logic, internal codes of logic modules.

Determine if code is a transfer value or a logic value. If a transfer value then, determine if last operation generated a true or false condition.

Determine value of transfer code, Obtain next byte character and go to differentiation logic, otherwise go to logic array.

End of logic for handling logic internal codes of logic and transfer modules. Logic to process run logic modules Note that each logic modules is an independent entity.

From the value of the byte code determine which parameter and which logic module is to be used, go to that module. Go to differentiation logic.

End of logic to process run logic modules‘*’. The modules can be either in conventional code of a few instructions in length or a set of functions on a programmable logic card, using a very simple logic structure.

The independent modules will do such things as: generates messages, accept data from a keyboard, set a parameter to a required numeric, increment a value, move data, decrement a value, query a value for a particular character, add two values, test two values, do disk operations, etc.

Because all modules are independent of each other they can be thoroughly tested before being added to the system.