ICL VME facts for kids

VME (which stands for Virtual Machine Environment) is a special type of operating system made for large, powerful computers called mainframes. It was created by a UK company called International Computers Limited (ICL), which is now part of the Fujitsu group.

VME first came out in the mid-1970s. It was designed to run ICL's new 2900 Series mainframes. Over time, it got new names like VME/B and VME 2900. Today, it's known as OpenVME and can even run Unix programs. It works on newer ICL mainframes like the ICL Series 39 and Trimetra, and even on modern x64 servers.

How VME Started

The journey to create VME began in 1968 when two big computer companies, International Computers and Tabulators (ICT) and English Electric Computers, joined together. They decided their new line of computers, called the "New Range," needed a brand-new operating system.

Different Versions of VME

During its development, ICL explored a few different ideas for VME:

• VME/B was planned for the largest computers, like the 2970/2980. It was developed in Kidsgrove and Manchester.
• VME/K was made for medium-sized computers, like the 2960. It was released to the public but later replaced by VME/B.
• VME/T was a special idea for computers that could keep working even if parts failed. This idea was ahead of its time!

The main person behind VME/B was Brian Warboys. The design of VME was inspired by other operating systems like Multics and ICL's own George 3. VME/B was designed to compete with IBM's large mainframe systems.

VME's Journey Through Time

When the "New Range" computers first came out in 1974, their operating system was simply called "System B." By the time it was delivered to customers, it had been renamed "VME/B."

Changes and Updates

VME/K was developed separately and came out later for smaller mainframes. At first, VME/B had some issues with how fast it ran and how reliable it was.

The European Space Agency even used a special version of VME/K, called VME/ESA, for their Meteosat satellite data.

In 1981, ICL decided to combine the best parts of VME/B and VME/K into a new version called "VME2900." This helped them improve the system and remove older features.

Later, in 1985, when ICL launched its Series 39 computers, the "2900" part was dropped from the name. Even later, the word "Open" was added, making it "OpenVME." This change meant VME could now run programs originally made for Unix systems, using a part called VME/X.

In 2007, Fujitsu created a version called superNova. This allowed VME to run inside Microsoft Windows or SUSE and Red Hat Enterprise Linux on regular x86-64 computers.

The group of VME users, AXiS, decided to stop meeting in 2012 because fewer people were using VME. Fujitsu planned to support VME on customer computers until 2020. Even in 2020, some UK government applications were moved to Fujitsu's VME hosting platform. By 2021, the Department for Work and Pensions had completely replaced its VME systems with newer technology.

How VME is Built

VME is built like a stack of layers. Each layer has access to different levels of computer resources. Think of it like different security clearances: to use certain resources, a program needs the right "access key." This idea is similar to "rings of protection" in other systems like Multics.

Virtual Machines and Processes

The operating system gives programs access to resources through something called a Virtual Machine. A Virtual Machine can run many "processes." In VME, a Virtual Machine is more like a whole program running, while a "process" is more like a small task within that program.

When a program needs to talk to the operating system, it does so very efficiently by changing its "protection level" without changing its main work area.

How Programs Talk to Each Other

Different Virtual Machines can talk to each other using "Events" (like named communication channels) and shared memory areas. The computer hardware also has special instructions to help programs share resources safely.

The Catalogue: Keeping Track of Everything

Files and other important information are stored in a central place called the Catalogue. This system helps keep track of files no matter where they are stored, whether on a tape or a disk. It also tracks users, devices, and network connections. The Catalogue was one of the first examples of what we now call an entity-relationship database.

When something unexpected happens, like an error, VME has a system to catch it and create a report, which helps programmers find and fix problems.

OMF: How Programs are Stored

When computer code is compiled (turned into instructions the computer can understand), it's saved in a format called OMF (Object Module Format). This is how the computer loads and runs programs. There are also tools to combine different OMF parts into one, or even to fix small bugs in a program without recompiling everything.

SCL: The Command Language

The main language for giving commands to VME is called SCL (System Control Language). It's more like a high-level programming language than a simple command line. You can use it to type commands one by one or create longer scripts that run automatically.

SCL commands follow a clear pattern, like "DELETE_FILE" or "DISPLAY_LIBRARY_DETAILS." You can also use shorter versions, like "XF" for "DELETE_FILE." SCL is structured with "begin/end" blocks, which help organize code and manage resources.

Here's a simple example of SCL code:

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

This example shows how SCL can be used to compile a program written in another language called S3. It includes commands like `DELETE_FILE` to remove files and `S3_COMPILE` to turn S3 code into a working program. The `COLLECT` command combines different parts of a program into one.

Files in VME often have a "generation number" (like `(101)` in the example). This means the system keeps track of different versions of a file, and you can choose which one to use.

Extra Security for VME

Because ICL worked a lot with the UK government, VME was designed to be very secure. It had special features, like hardware-assisted Access Control Registers, to limit what programs could do.

This led to projects like Project Spaceman in the 1980s, which created even more secure versions of VME. These were called High Security Option (HSO) for businesses and Government Security Option (GSO) for the public sector. These versions were among the first operating systems to be officially certified for high security.

Series 39 Computers

The ICL Series 39 computers introduced a new way of working called Nodal Architecture. This system combined features of multiprocessor systems (where one computer has many brains) and clusters (where many computers work together). Each Series 39 computer had several "nodes," and each node had its own processor and memory.

Virtual machines could run on any node and even move between them. Disks and other devices were shared between nodes. The nodes were connected by a super-fast optical bus, which made it seem like they all shared the same memory.

How VME Was Developed

VME was mostly written in S3, a special programming language similar to Algol 68R. Even though it's a high-level language, VME was designed to work very closely with the specific hardware it ran on.

Later, in the 1990s, some new parts of VME were written using the C programming language.

From the very beginning, VME was developed using a special system called CADES. CADES wasn't just for storing code; it managed everything about creating software, from planning to maintenance. It helped developers keep track of different versions of code and other components.

Tools for Making VME Programs

VME offered tools for creating applications, falling into two main groups:

• Traditional third-generation programming languages
• More advanced fourth-generation QuickBuild tools.

Most VME users used the same set of tools, which worked very well together. For many years, most VME applications were written in COBOL, often using the IDMS database and the TPMS system for handling many transactions at once. Other languages like Fortran and Pascal were also available. Later, C compilers were added, especially to help move relational database systems to VME.

The compilers used a common structure, which helped them share parts and work efficiently.

System Programming Languages: S3 and SFL

The main language for building VME itself and other system software was S3. It was designed to match the specific features of the 2900 series computers.

Another language, SFL (System Function Language), was also available. This was an assembly language, which is a very low-level language. It was used for parts of VME/K and the IDMS database.

Neither S3 nor SFL were widely sold to regular users, but they were available to organizations that needed them for special projects.

QuickBuild: Fast Application Development

The QuickBuild system for VME was very successful. It was built around the Data Dictionary System (DDS), which was an early and very good system for managing all the information needed for software development. DDS kept track of database designs, screen layouts, and even the code for 4GL programs.

QuickBuild offered two main tools:

• ApplicationMaster for creating online transaction processing applications.
• ReportMaster for creating reports from data.

Both were high-level languages that made it easier to design applications. ApplicationMaster was special because it handled complex user interactions by making it seem like everything happened in one smooth conversation. Because these tools worked directly with the DDS dictionary, they could reuse information easily, which was a big advantage.