ICL VME

Last updated

Virtual Machine Environment
Developer International Computers Limited, Fujitsu
Written in S3, C
Working stateCurrent
Initial releasemid-1970s
Platforms ICL 2900 Series, ICL Series 39 mainframes
Influenced by Multics, George 3
License Proprietary commercial software
Official website VME site

VME (Virtual Machine Environment) is a mainframe operating system developed by the UK company International Computers Limited (ICL, now part of the Fujitsu group). Originally developed in the 1970s (as VME/B, later VME 2900) to drive ICL's then new 2900 Series mainframes, the operating system is now known as OpenVME incorporating a Unix subsystem, and runs on ICL Series 39 and Trimetra [1] mainframe computers, as well as industry-standard x64 servers. [2]

Contents

Origins

The development program for the New Range system started on the merger of International Computers and Tabulators (ICT) and English Electric Computers in 1968. One of the fundamental decisions was that it would feature a new operating system. A number of different feasibility and design studies were carried out within ICL, the three most notable being:

The chief architect of VME/B was Brian Warboys, who subsequently became professor of software engineering at the University of Manchester. A number of influences can be seen in its design, for example Multics and ICL's earlier George 3 operating system; however it was essentially designed from scratch.

VME/B was viewed as primarily competing with the System/370 IBM mainframe as a commercial operating system, and adopted the EBCDIC character encoding. [3]

History

When New Range was first launched in October 1974, its operating system was referred to as "System B". By the time it was first delivered it had become "VME/B". [4]

VME/K (originally known internally as "System T" for "Tiny") was developed independently (according to Campbell-Kelly, "on a whim of Ed Mack"), and was delivered later with the smaller mainframes such as the 2960. At the time VME/B was still plagued with performance and reliability problems, and the mainly American management team had misgivings about it.

There was also a project known as System D, which was an advanced, highly modular operating system designed for configuring and building customized near real-time applications. Although it was used to bid on a system for British Rail it was subsequently cancelled because of engineering resource constraints.

ICL had sold a large system to the European Space Agency to process data from Meteosat at its operation centre in Darmstadt. A bespoke variant of VME/K, known as VME/ESA was developed on-site to meet the customer's requirements.

Following a financial crisis in 1980, new management was brought into ICL (Christophor Laidlaw as chairman, and Robb Wilmot as managing director). An early decision of the new management was to drop VME/K. [4] [5] Thus in July 1981 "VME2900" was launched: although presented to the customer base as a merger of VME/B and VME/K, it was in reality the VME/B base with a few selected features from VME/K grafted on. This provided the opportunity to drop some obsolescent features, which remained available to customers who needed them in the form of the "BONVME" option.

The "2900" suffix was dropped at System Version 213 (SV213) when ICL launched Series 39 in 1985 as the successor to the original 2900 series; and the "Open" prefix was added after SV294. VME became capable of hosting applications written originally for Unix through a UNIX System V Release 3 based subsystem, called VME/X, adapted to run under VME and using the ASCII character encoding. [6] [7] [8]

In 2007 Fujitsu announced a VME version run as a hosted subsystem, called superNova, within Microsoft Windows, or SUSE or Red Hat Enterprise Linux on x86-64 hardware. [2]

In 2012 the VME user group, AXiS, announced that after almost 40 years it would be disbanding because of the reduced user base. [9]

Fujitsu intended to support VME on customer computers until 2020. [10]

In 2020 Fujitsu transferred 13 HM Revenue and Customs applications from their computers onto Fujitsu's virtual managed VME hosting platform. [11] [12]

As of 2021, the Department for Work and Pensions completely replaced its VME based systems, following the completion of its award winning VME-R replacement programme. https://www.computerweekly.com/news/252498414/DWP-completes-in-house-VME-replacement-project

Architecture

VME is structured as a set of layers, each layer having access to resources at different levels of abstraction. Virtual resources provided by one layer are constructed from the virtual resources offered by the layer below. Access to the resources of each layer is controlled through a set of Access Levels: in order for a process to use a resource at a particular access level, it must have an access key offering access to that level. The concept is similar to the "rings of protection" in Multics. The architecture allows 16 access levels, of which the outer 6 are reserved for user-level code.

Orthogonally to the access levels, the operating system makes resources available to applications in the form of a Virtual Machine. A Virtual Machine can run multiple processes. In practice, a VME Virtual Machine is closer to the concept of a process on other operating systems, while a VME process is more like a thread. The allocation of resources to a virtual machine uses a stack model: when the stack is popped, all resources allocated at that stack level are released. Calls from an application to the operating system are therefore made by a call that retains the same process stack, but with a change in protection level; the resulting efficiency of system calls is one of the features that makes the architecture competitive.

Communication between Virtual Machines is achieved by means of Events (named communication channels) and shared memory areas. The hardware architecture also provides semaphore instructions INCT (increment-and-test) and TDEC (test-and-decrement).

Files and other persistent objects are recorded in a repository called the Catalogue. The file naming hierarchy is independent of the location of a file on a particular tape or disk volume. In days where there was more need for offline storage, this made it easy to keep track of files regardless of their location, and to move files between locations without renaming them. As well as files, the Catalogue keeps track of users and user groups, volumes, devices, network connections, and many other resources. Metadata for files can be held in an object called a File Description. The Catalogue was probably the first example of what would later be called an entity-relationship database.

Interrupts are handled by creating a new stack frame on the stack for the relevant process, handling the interrupt using this new environment, and then popping the stack to return to the interrupted process.

Run-time exceptions, referred to as contingencies, are captured by the Object Program Error Handler (OPEH), which can produce a report (equivalent to a stack trace), either interactively or written to a journal.

OMF

Compiled object code is maintained in a format called OMF (Object Module Format), which is both the compiler output and the format used by the loader. Various compilers are available, as well as utilities, notably the Collector, which links the code in several OMF modules into a single module, for more efficient loading at run-time, and the Module Amender, which allows patching of the instructions in an OMF module to fix bugs, using assembly language syntax.

SCL

The command language for VME is known as SCL (System Control Language).

This is much more recognizably a typed high-level programming language than the job control or shell languages found in most other operating systems: it can be likened to scripting languages such as JavaScript, though its surface syntax is derived from Algol 68.

SCL is designed to allow both line-at-a-time interactive use from a console or from a command file, and creation of executable scripts or programs (when the language is compiled into object module format in the same way as any other VME programming language). The declaration of a procedure within SCL also acts as the definition of a simple form or template allowing the procedure to be invoked from an interactive terminal, with fields validated according to the data types of the underlying procedure parameters or using the default procedure parameter values.

The built-in command vocabulary uses a consistent naming convention with an imperative verb followed by a noun: for example DELETE_FILE or DISPLAY_LIBRARY_DETAILS. The command can be written in full, or in an abbreviated form that combines standard abbreviations for the verb and noun: for example XF (X for DELETE, F for FILE) or DLBD (D for DISPLAY, LB for LIBRARY, D for DETAILS).

SCL is block-structured, with begin/end blocks serving the dual and complementary roles of defining the lexical scope of variable declarations, and defining the points at which resources acquired from the operating system should be released. Variables in the language (which are accessible from applications in the form of environment variables) can have a number of simple types such as strings, superstrings (sequences of strings), booleans, and integers, and are also used to contain references to system resources such as files and network connections.

It is possible to "disassemble" an SCL program from OMF back into SCL source code using the READ_SCL (or RSCL) command. However the output is not always perfect, and will often include errors that would stop re-compilation without user intervention.

A simple code example can be seen on the 99 bottles of beer website. [13]

A more realistic example, where SCL is used to compile a program written in S3, is shown below. This example is taken from the Columbia University Archive of implementations of Kermit. [14] 

BEGIN    WHENEVER       RESULT GT 0 +_       THEN        +_          SEND_RESULT_MESSAGE (RES = RESULT,                               ACT = "QUIT()")    FI      INT KMT_SRC, KMT_OMF, KMT_REL      ASSIGN_LIBRARY (NAM = KERMIT.SOURCE,                    LNA = KMT_SRC)    ASSIGN_LIBRARY (NAM = KERMIT.OMF,                    LNA = KMT_OMF)    ASSIGN_LIBRARY (NAM = KERMIT.REL,                    LNA = KMT_REL)      BEGIN       DELETE_FILE (NAM = *KMT_OMF.KMT_DATA_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_DH_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_EH_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_FH_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_HELP_MTM(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_MAIN_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_PH_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_PP_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_SP_MODULE(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_SP_MTM(101))       DELETE_FILE (NAM = *KMT_OMF.KMT_UI_MODULE(101))         DELETE_FILE (NAM = *KMT_REL.KERMIT(101))       DELETE_FILE (NAM = *KMT_REL.KERMIT_MODULE(101))    END      S3_COMPILE_DEFAULTS (LIS = OBJECT & XREF,                         DIS = ERRORLINES)      S3_COMPILE (INP = *KMT_SRC.KMT_DATA_MODULE(101),                OMF = *KMT_OMF.KMT_DATA_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_DH_MODULE(101),                OMF = *KMT_OMF.KMT_DH_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_EH_MODULE(101),                OMF = *KMT_OMF.KMT_EH_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_FH_MODULE(101),                OMF = *KMT_OMF.KMT_FH_MODULE(101))      NEW_MESSAGE_TEXT_MODULE (CON = *KMT_SRC.KMT_HELP_MTM(101),                             OMF = *KMT_OMF.KMT_HELP_MTM(101))      S3_COMPILE (INP = *KMT_SRC.KMT_MAIN_MODULE(101),                OMF = *KMT_OMF.KMT_MAIN_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_PH_MODULE(101),                OMF = *KMT_OMF.KMT_PH_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_PP_MODULE(101),                OMF = *KMT_OMF.KMT_PP_MODULE(101))      S3_COMPILE (INP = *KMT_SRC.KMT_SP_MODULE(101),                OMF = *KMT_OMF.KMT_SP_MODULE(101))      NEW_MESSAGE_TEXT_MODULE (CON = *KMT_SRC.KMT_SP_MTM(101),                             OMF = *KMT_OMF.KMT_SP_MTM(101))      S3_COMPILE (INP = *KMT_SRC.KMT_UI_MODULE(101),                OMF = *KMT_OMF.KMT_UI_MODULE(101))      COLLECT () ----       INPUT(*KMT_OMF.KMT_DATA_MODULE(101)      &             *KMT_OMF.KMT_DH_MODULE(101)        &             *KMT_OMF.KMT_EH_MODULE(101)        &             *KMT_OMF.KMT_FH_MODULE(101)        &             *KMT_OMF.KMT_HELP_MTM(101)         &             *KMT_OMF.KMT_MAIN_MODULE(101)      &             *KMT_OMF.KMT_PH_MODULE(101)        &             *KMT_OMF.KMT_PP_MODULE(101)        &             *KMT_OMF.KMT_SP_MODULE(101)        &             *KMT_OMF.KMT_SP_MTM(101)           &             *KMT_OMF.KMT_UI_MODULE(101))       NEWMODULE(*KMT_REL.KERMIT_MODULE(101))       SUPPRESS       RETAIN(KERMIT_THE_FROG)       LISTMODULE       PERFORM ++++   COMPILE_SCL (INP = *KMT_SRC.KERMIT(101),              OUT = *KMT_REL.KERMIT(101),              COD = NOTIFWARNINGS,              OPT = FIL)   END

Commands illustrated in this fragment include WHENEVER (declares error handling policy), ASSIGN_LIBRARY (binds a local name for a file directory), DELETE_FILE (Makes a permanent file temporary, and it is then deleted at the END of the block), S3_COMPILE (compiles a program written in S3: this command breaks the usual verb-noun convention), NEW_MESSAGE_TEXT_MODULE (creates a module containing parameterized error messages suitable for localization) and COMPILE_SCL, which compiles an SCL program into object code.

The COLLECT command combines different object code modules into a single module, and is driven by its own local command file which is incorporated inline in the SCL between the delimiters "----" and "++++". The sub-commands INPUT and NEWMODULE identify the names of the input and output modules; SUPPRESS and RETAIN determine the external visibility of named procedures within the collected module; and LISTMODULE requests a report describing the output module.

Note that "." is used to separate the parts of a hierarchic file name. A leading asterisk denotes a local name for a library, bound using the ASSIGN_LIBRARY command. The number in parentheses after a file name is a generation number. The operating system associates a generation number with every file, and requests for a file get the latest generation unless specified otherwise. Creating a new file will by default create the next generation and leave the previous generation intact; this program however is deliberately choosing to create generation 101, to identify a public release.

Enhanced security variants

As a result of ICL's heavy involvement with delivery of computer services to the UK Public Sector, in particular those with special security requirements such as OPCON CCIS, it was an early entrant into the market for Secure Systems.

VME formed a core of ICL's activities in the Secure Systems arena. It had the advantage that as the last large-scale operating system ever designed, and one built from scratch, its underlying architecture encompassed many of the primitives needed to develop a Secure System, in particular the hardware assisted Access Control Registers (ACR) to limit to privileges that could be taken by any process (including Users).

This led to the UK Government's Central Computing and Telecommunications Agency (CCTA) funding Project Spaceman in the mid 1980s for ICL Defence Technology Centre (DTC) to develop an enhanced security variant of VME. ICL launched this as a pair of complementary products, with the commercial release being called High Security Option (HSO), and the public sector release, including Government Furnished Encryption (GFE) technologies, being called Government Security Option (GSO).

HSO and GSO were formally tested under the CESG UK (Security) Evaluation Scheme, one of the predecessors to ITSEC and Common Criteria, and in doing so became the first mainstream operating system to be formally Certified.

Series 39

The Series 39 range introduced Nodal Architecture, a novel implementation of distributed shared memory that can be seen as a hybrid of a multiprocessor system and a cluster design. Each machine consists of a number of nodes, and each node contains its own order-code processor (CPU) and main memory. Virtual machines are typically located (at any one time) on one node, but have the capability to run on any node and to be relocated from one node to another. Discs and other peripherals are shared between nodes. Nodes are connected using a high-speed optical bus, which is used to provide applications with a virtual shared memory. Memory segments that are marked as shared (public or global segments) are replicated to each node, with updates being broadcast over the inter-node network. Processes which use unshared memory segments (nodal or local) run in complete isolation from other nodes and processes.

Development process

VME was originally written almost entirely in S3, a specially-designed system programming language based on Algol 68R (however, VME/K was written primarily in the SFL assembly language). Although a high-level language is used, the operating system is not designed to be independent of the underlying hardware architecture: on the contrary, the software and hardware architecture are closely integrated.

From the early 1990s onwards, some entirely new VME subsystems were written partly or wholly in the C programming language.

From its earliest days, VME was developed with the aid of a software engineering repository system known as CADES, originally designed and managed by David Pearson (computer scientist) and built for the purpose using an underlying IDMS database. CADES is not merely a version control system for code modules: it manages all aspects of the software lifecycle from requirements capture, design methodology and specification through to field maintenance. CADES was used in VME module development to hold separate definitions of data structures (Modes), constants (Literals), procedural interfaces and the core algorithms. Multiple versions ('Lives') of each of these components could exist. The algorithms were written in System Development Language (SDL), which was then converted to S3 source [15] by a pre-processor. Multiple versions of the same modules could be generated.

Application development tools

The application development tools offered with VME fall into two categories:

The toolset on VME is unusually homogeneous, with most customers using the same core set of languages and tools. As a result, the tools are also very well integrated. Third-party tools have made relatively little impression.

For many years the large majority of VME users wrote applications in COBOL, usually making use of the IDMS database and the TPMS transaction processing monitor. Other programming languages included Fortran, Pascal, ALGOL 68RS, Coral 66 and RPG2, but these served minority interests. Later, in the mid 1980s, compilers for C became available, both within and outside the Unix subsystem, largely to enable porting of software such as relational database systems. It is interesting that a PL/I subset compiler was written by the EEC, to assist in porting programs from IBM to ICL hardware.

The compilers developed within ICL share a common architecture, and in some cases share components such as code-generators. Many of the compilers used a module named ALICE [Assembly Language Internal Common Environment] and produced an early form of precompiled code (P-Code) termed ROSE, making compiled Object Module Format (OMF) libraries loadable on any machine in the range. .

System Programming Languages: S3 and SFL

The primary language used for developing both the VME operating system itself and other system software such as compilers and transaction processing monitors is S3. This is a high level language based in many ways on Algol 68, but with data types and low-level functions and operators aligned closely with the architecture of the 2900 series.

An assembly language SFL (System Function Language) is also available. This was used for the development of VME/K, whose designers were not confident that a high-level language could give adequate performance, and also for the IDMS database system on account of its origins as a third-party product. SFL was originally called Macro Assembler Programming LanguagE (MAPLE), but as the 2900 architecture was being positioned as consisting of high level language machines the name was changed at the request of ICL Marketing. It had been developed as a part of the toolkit for System D, which was subsequently cancelled. Related families of assemblers for other architectures (CALM-xx running under VME, PALM-xx developed in Pascal and running on various hosts) were developed for internal use.

Neither S3 nor SFL was ever promoted as a commercial development tool for end-user applications, as neither were normally delivered as a standard part of the operating system, nor were they explicitly marketed as products in their own right. Both SFL and S3 were however available as options to user organisations and third parties who had a specific need for them.

QuickBuild

The QuickBuild application development environment on VME has been highly successful despite the fact that applications are largely locked into the VME environment. This environment is centred on the Data Dictionary System (DDS, also called OpenDDS), an early and very successful attempt to build a comprehensive repository supporting all the other tools, with full support for the development lifecycle. As well as database schemas and file and record descriptions, the dictionary keeps track of objects such as reports and queries, screen designs, and 4GL code; it also supports a variety of models at the requirements capture level, such as entity-relationship models and process models.

The QuickBuild 4GL is packaged in two forms:

Both are high-level declarative languages, using Jackson Structured Programming as their design paradigm. ApplicationMaster is unusual in its approach to application design in that it focuses on the user session as if it were running in a single conversational process, completely hiding the complexity of maintaining state across user interactions. Because the 4GL and other tools such as the screen designer work only with the DDS dictionary, which also holds the database schemas, there is considerable reuse of metadata that is rarely achieved with other 4GLs.

Related Research Articles

Extended Binary Coded Decimal Interchange Code is an eight-bit character encoding used mainly on IBM mainframe and IBM midrange computer operating systems. It descended from the code used with punched cards and the corresponding six-bit binary-coded decimal code used with most of IBM's computer peripherals of the late 1950s and early 1960s. It is supported by various non-IBM platforms, such as Fujitsu-Siemens' BS2000/OSD, OS-IV, MSP, and MSP-EX, the SDS Sigma series, Unisys VS/9, Unisys MCP and ICL VME.

Pascal is an imperative and procedural programming language, designed by Niklaus Wirth as a small, efficient language intended to encourage good programming practices using structured programming and data structuring. It is named after French mathematician, philosopher and physicist Blaise Pascal.

<span class="mw-page-title-main">Modula-3</span>

Modula-3 is a programming language conceived as a successor to an upgraded version of Modula-2 known as Modula-2+. While it has been influential in research circles it has not been adopted widely in industry. It was designed by Luca Cardelli, James Donahue, Lucille Glassman, Mick Jordan, Bill Kalsow and Greg Nelson at the Digital Equipment Corporation (DEC) Systems Research Center (SRC) and the Olivetti Research Center (ORC) in the late 1980s.

An object file is a file that contains machine code or bytecode, as well as other data and metadata, generated by a compiler or assembler from source code during the compilation or assembly process. The machine code that is generated is known as object code.

<span class="mw-page-title-main">International Computers Limited</span> British computer company (1968-2002)

International Computers Limited (ICL) was a British computer hardware, computer software and computer services company that operated from 1968 until 2002. It was formed through a merger of International Computers and Tabulators (ICT), English Electric Computers (EEC) and Elliott Automation in 1968. The company's most successful product line was the ICL 2900 Series range of mainframe computers.

PL/S, short for Programming Language/Systems, is a "machine-oriented" programming language based on PL/I. It was developed by IBM in the late 1960s, under the name Basic Systems Language (BSL), as a replacement for assembly language on internal software projects; it included support for inline assembly and explicit control over register usage.

SCL may refer to:

GT.M is a high-throughput key–value database engine optimized for transaction processing. GT.M is also an application development platform and a compiler for the ISO standard M language, also known as MUMPS.

Direct Machine Environment, abbreviated DME, was a mainframe environment for the ICL 2900 Series of computing systems from International Computers Limited that was developed in the 1970s. DME was more-or-less an ICL 1900 order code processor in microcode, which permitted the ICL 1900 series executive, operating systems and program libraries to operate on the ICL 2900 series.

<span class="mw-page-title-main">ICL 2900 Series</span> UK mainframe computer systems

The ICL 2900 Series was a range of mainframe computer systems announced by the British manufacturer International Computers Limited on 9 October 1974. The company had started development under the name "New Range" immediately on its formation in 1968. The range was not designed to be compatible with any previous machines produced by the company, nor for compatibility with any competitor's machines: rather, it was conceived as a synthetic option, combining the best ideas available from a variety of sources.

The Object Module Format (OMF) is an object file format used primarily for software intended to run on Intel 80x86 microprocessors. It was originally developed by Intel around 1975–1977 for ISIS-II, targetting the 8-bit 8080/8085 processors. This variant later became known as OMF-80. As OMF-86 it was adapted to the 16-bit 8086 processor in 1978. Version 4.0 for the 8086 family was released in 1981 under the name Relocatable Object Module Format, and is perhaps best known to DOS users as an .OBJ file. Versions for the 80286 (OMF-286) and the 32-bit 80386 processors (OMF-386) were introduced in 1981 and 1985, respectively. It has since been standardized by the Tool Interface Standards Committee and was also extended by Microsoft and IBM (IBM-OMF). Intel also adapted the format to the 8051 microcontroller (OMF-51 and AOMF).

S3 is a structured, imperative high-level computer programming language. It was developed by the UK company International Computers Limited (ICL) for its 2900 Series mainframes. It is a system programming language with syntax influenced by ALGOL 68 but with data types and operators aligned to those offered by the 2900 Series. It was the implementation language of the operating system VME.

The ICL Series 39 was a range of mainframe and minicomputer computer systems released by the UK manufacturer ICL in 1985. The original Series 39 introduced the "S3L" processors and microcodes, and a nodal architecture, which is a form of Non-Uniform Memory Access.

CADES was a software engineering system produced to support the design and development of the VME/B Operating System for the ICL New Range - subsequently 2900 - computers.

GEORGE was the name given to a series of operating systems released by International Computers and Tabulators (ICT) in the 1960s, for the ICT 1900 series of computers. These included GEORGE 1, GEORGE 2, GEORGE 3, and GEORGE 4.

The ICL DRS was a range of departmental computers from International Computers Limited (ICL). Standing originally for Distributed Resource System, the full name was later dropped in favour of the abbreviation.

Object Module Format (OMF) may refer to:

<span class="mw-page-title-main">Node.js</span> JavaScript runtime environment

Node.js is a cross-platform, open-source JavaScript runtime environment that can run on Windows, Linux, Unix, macOS, and more. Node.js runs on the V8 JavaScript engine, and executes JavaScript code outside a web browser.

The OS/360 Object File Format is the standard object module file format for the IBM DOS/360, OS/360 and VM/370, Univac VS/9, and Fujitsu BS2000 mainframe operating systems. In the 1990s, the format was given an extension with the XSD-type record for the MVS Operating System to support longer module names in the C Programming Language. This format is still in use by the z/VSE operating system. In contrast, it has been superseded by the GOFF file format on the MVS Operating System and on the z/VM Operating System. Since the MVS and z/VM loaders will still handle this older format, some compilers have chosen to continue to produce this format instead of the newer GOFF format.

ECCE (the Edinburgh Compatible Context Editor) is a text editor for computing systems and operating environments that support a command line interface. It is an original command set which is logical and regular. It was written in the 1960s by Hamish Dewar, an experienced Compiler writer and used this skill to design a command-set which could be easily parsed and coded to allow complex commands to be built up. A technique similar to threaded code in the Forth environment. The current ECCE release is licensed under the BSD License, recoded into C and released by Graham Toal in 2007.

References

  1. ↑ "Today, tomorrow, VME" (PDF). Fujitsu . Archived from the original (PDF) on 22 February 2012.
  2. 1 2 Introduction to superNOVA architecture (PDF) (Report). Fujitsu. January 2007. Archived from the original (PDF) on 28 September 2007.
  3. ↑ Barry J Graham (2002). "Fujitsu OpenVME Costs Compared to IBM Mainframe Costs" (PDF). Fujitsu Services. Archived from the original (PDF) on 1 February 2014. Retrieved 28 January 2014.
  4. 1 2 Campbell-Kelly, Martin (1989). ICL: A Business and Technical History. Clarendon Press. ISBN   0-19-853918-5.
  5. ↑ Knight, Michael (2008). "Beacon 1963-7: A System Design Ahead of its Time?". Computer Resurrection (43).
  6. ↑ Dave Bailey (powerpoint) (30 November 2000). "The Continuing Development of OpenVME". ICL. Retrieved 28 January 2014.
  7. ↑ "ICL's Open VME turns out to be subset of Unix under VME; Applications are coming". Computer Business Review. 10 February 1992. Retrieved 28 January 2014.
  8. ↑ Coates, P. (1993). "VME-X: Making VME Open" (PDF). ICL Technical Journal. ICL: 473. ISSN   0142-1557. Archived from the original (PDF) on 5 March 2016. Retrieved 7 November 2015.
  9. ↑ Cloutt, Harold (2012). "ICL User Group to be disbanded after almost 40 years loyal service to the VME community". AXiS. Retrieved 11 July 2018.
  10. ↑ Clark, Lindsay (21 January 2022). "You might want to consider the cost of not upgrading legacy tech, UK's Department for Work and Pensions told". The Register. Retrieved 24 January 2022.
  11. ↑ Evenstad, Lis (13 October 2020). "HMRC signs five-year £169m contract with Fujitsu for VME platform". Computer Weekly. Retrieved 24 January 2022.
  12. ↑ "United Kingdom-Salford: Application service providers". Tenders Electronic Daily. European Union. 12 October 2020. 2020/S 198-481324. Retrieved 24 January 2022.
  13. ↑ SCL code example on the 99 bottles of beer website
  14. ↑ "Kermit Software Source Code Archive". Columbia University's Kermit Project. 22 August 2011. Retrieved 1 March 2013.
  15. ↑ Juan F Ramil. "Continuing Effort Estimation for Evolution a Case Study" (PDF).

Sources

This page is based on this Wikipedia article
Text is available under the CC BY-SA 4.0 license; additional terms may apply.
Images, videos and audio are available under their respective licenses.