Change XP password via command line

I submitted this quick tip to Lifehacker in the past. If you feel the need to change your Windows password, you don’t need to go through any Control Panel menus and whatnot. You can change any user’s password via the command line, as long as you have administrative access. A good example of when to use this tip would be after a fresh install of XP. One of the first things you should do is lo into the default Administrator account and set a password. That requires booting into Safe Mode as Administrator, setting a password, then booting back into Normal mode as your own user. Instead, go to Start > Run > “cmd” [Enter], then enter:

net user

This will set the password you supplied as the password for the user you entered. You can also do:

net user *

This will prompt you for a password, then have you confirm it.
NOTE: you need administrator access to change the password via this command. However, if you are an administrator, you can change the password for any account on the machine. As you can see, this is a very powerful command, but it can also pose as a security threat.

PHP Exception Handling

Exceptions are used to change the normal flow of a script if a specified error occurs

What is an Exception?

With PHP 5 came a new object oriented way of dealing with errors.

Exception handling is used to change the normal flow of the code execution if a specified error (exceptional) condition occurs. This condition is called an exception.

This is what normally happens when an exception is triggered:

• The current code state is saved
  
• The code execution will switch to a predefined (custom) exception handler function
  
• Depending on the situation, the handler may then resume the execution from the saved code state, terminate the script execution or continue the script from a different location in the code

We will show different error handling methods:

• Basic use of Exceptions
  
• Creating a custom exception handler
  
• Multiple exceptions
  
• Re-throwing an exception
  
• Setting a top level exception handler

Note: Exceptions should only be used with error conditions, and should not be used to jump to another place in the code at a specified point. 

Basic Use of Exceptions

When an exception is thrown, the code following it will not be executed, and PHP will try to find the matching "catch" block.

If an exception is not caught, a fatal error will be issued with an "Uncaught Exception" message.

Lets try to throw an exception without catching it:

//create function with an exception
function checkNum($number)
  {
  if($number>1)
    {
    throw new Exception("Value must be 1 or below");
    }
  return true;
  }

//trigger exception
checkNum(2);
?>

The code above will get an error like this:

Fatal error: Uncaught exception 'Exception'
with message 'Value must be 1 or below' in C:\webfolder\test.php:6

Stack trace: #0 C:\webfolder\test.php(12):
checkNum(28) #1 {main} thrown in C:\webfolder\test.php on line 6

Try, throw and catch

To avoid the error from the example above, we need to create the proper code to handle an exception.
Proper exception code should include:

1. Try - A function using an exception should be in a "try" block. If the exception does not trigger, the code will continue as normal. However if the exception triggers, an exception is "thrown"
2. Throw - This is how you trigger an exception. Each "throw" must have at least one "catch"
3. Catch - A "catch" block retrieves an exception and creates an object containing the exception information

Lets try to trigger an exception with valid code:

//create function with an exception
function checkNum($number)
  {
  if($number>1)
    {
    throw new Exception("Value must be 1 or below");
    }
  return true;
  }

//trigger exception in a "try" block
try
  {
  checkNum(2);
  //If the exception is thrown, this text will not be shown
  echo 'If you see this, the number is 1 or below';
  }

//catch exception
catch(Exception $e)
  {
  echo 'Message: ' .$e->getMessage();
  }
?>

The code above will get an error like this:

Message: Value must be 1 or below

Example explained:

The code above throws an exception and catches it:

1. The checkNum() function is created. It checks if a number is greater than 1. If it is, an exception is thrown
2. The checkNum() function is called in a "try" block
3. The exception within the checkNum() function is thrown
4. The "catch" block retrives the exception and creates an object ($e) containing the exception information
5. The error message from the exception is echoed by calling $e->getMessage() from the exception object

However, one way to get around the "every throw must have a catch" rule is to set a top level exception handler to handle errors that slip through.

Creating a Custom Exception Class

Creating a custom exception handler is quite simple. We simply create a special class with functions that can be called when an exception occurs in PHP. The class must be an extension of the exception class.
The custom exception class inherits the properties from PHP's exception class and you can add custom functions to it.

Lets create an exception class:

class customException extends Exception
  {
  public function errorMessage()
    {
    //error message
    $errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile()
    .': '.$this->getMessage().' is not a valid E-Mail address';
    return $errorMsg;     }
  } 

$email = "someone@example...com";

try
  {
  //check if
  if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
    {
    //throw exception if email is not valid
    throw new customException($email);
    }
  }

catch (customException $e)
  {
  //display custom message

echo $e->errorMessage();
  }
?>

The new class is a copy of the old exception class with an addition of the errorMessage() function. Since it is a copy of the old class, and it inherits the properties and methods from the old class, we can use the exception class methods like getLine() and getFile() and getMessage(). 

Example explained:

The code above throws an exception and catches it with a custom exception class:

1. The customException() class is created as an extension of the old exception class. This way it inherits all methods and properties from the old exception class
2. The errorMessage() function is created. This function returns an error message if an e-mail address is invalid
3. The $email variable is set to a string that is not a valid e-mail address
4. The "try" block is executed and an exception is thrown since the e-mail address is invalid
5. The "catch" block catches the exception and displays the error message
   Multiple Exceptions
   
   It is possible for a script to use multiple exceptions to check for multiple conditions.
   
   It is possible to use several if..else blocks, a switch, or nest multiple exceptions. These exceptions can use different exception classes and return different error messages:
   
   
   class customException extends Exception
   {
   public function errorMessage()
   {
   //error message
   $errorMsg = 'Error on line '.$this->getLine().' in '.$this->getFile()
   .': '.$this->getMessage().' is not a valid E-Mail address';
   return $errorMsg;
   }
   }
   
   $email = "someone@example.com";
   
   try
     {
     //check if
     if(filter_var($email, FILTER_VALIDATE_EMAIL) === FALSE)
       {
       //throw exception if email is not valid
       throw new customException($email);
       }
     //check for "example" in mail address
     if(strpos($email, "example") !== FALSE)
       {
       throw new Exception("$email is an example e-mail");
       }
     }
   
   catch (customException $e)
     {
     echo $e->errorMessage();  }

}

catch(Exception $e)
  {
  echo $e->getMessage();
  }
?>

Example explained:

The code above tests two conditions and throws an exception if any of the conditions are not met:

1. The customException() class is created as an extension of the old exception class. This way it inherits all methods and properties from the old exception class
2. The errorMessage() function is created. This function returns an error message if an e-mail address is invalid
3. The $email variable is set to a string that is a valid e-mail address, but contains the string "example"
4. The "try" block is executed and an exception is not thrown on the first condition
5. The second condition triggers an exception since the e-mail contains the string "example"
6. The "catch" block catches the exception and displays the correct error message

If there was no customException catch, only the base exception catch, the exception would be handled there

Re-throwing Exceptions

Sometimes, when an exception is thrown, you may wish to handle it differently than the standard way. It is possible to throw an exception a second time within a "catch" block.
A script should hide system errors from users. System errors may be important for the coder, but is of no interest to the user. To make things easier for the user you can re-throw the exception with a user friendly message:

class customException extends Exception
  {
  public function errorMessage()
    {
    //error message
    $errorMsg = $this->getMessage().' is not a valid E-Mail address.';
    return $errorMsg;
    }
  }

$email = "someone@example.com";

try
  {
  try
    {
    //check for "example" in mail address
    if(strpos($email, "example") !== FALSE)
      {  

//throw exception if email is not valid
      throw new Exception($email);
      }
    }
  catch(Exception $e)
    {
    //re-throw exception
    throw new customException($email);
    }
  }

catch (customException $e)
  {
  //display custom message
  echo $e->errorMessage();
  }
?> 

Example explained:

The code above tests if the email-address contains the string "example" in it, if it does, the exception is re-thrown:

1. The customException() class is created as an extension of the old exception class. This way it inherits all methods and properties from the old exception class
2. The errorMessage() function is created. This function returns an error message if an e-mail address is invalid
3. The $email variable is set to a string that is a valid e-mail address, but contains the string "example"
4. The "try" block contains another "try" block to make it possible to re-throw the exception
5. The exception is triggered since the e-mail contains the string "example"
6. The "catch" block catches the exception and re-throws a "customException"
7. The "customException" is caught and displays an error message

If the exception is not caught in its current "try" block, it will search for a catch block on "higher levels".

Set a Top Level Exception Handler

The set_exception_handler() function sets a user-defined function to handle all uncaught exceptions.

function myException($exception)
{
echo "Exception: " , $exception->getMessage();
}

set_exception_handler('myException');

throw new Exception('Uncaught Exception occurred');
?>

The output of the code above should be something like this:

Exception: Uncaught Exception occurred In the code above there was no "catch" block. Instead, the top level exception handler triggered. This function should be used to catch uncaught exceptions. 

Rules for exceptions

• Code may be surrounded in a try block, to help catch potential exceptions
• Each try block or "throw" must have at least one corresponding catch block
• Multiple catch blocks can be used to catch different classes of exceptions
• Exceptions can be thrown (or re-thrown) in a catch block within a try block

A simple rule: If you throw something, you have to catch it.

Ingres OpenROAD

OpenROAD stands for "Open Rapid Object Application Development".

Ingres OpenROAD is a rapid application development and flexible deployment solution. With Ingres OpenROAD, developers can quickly build and deploy sophisticated high performance and high availability business applications on a variety of platforms, accessing a broad range of data sources. As a result, you can react to business changes faster and protect your investment in existing mainframe and client server data and applications.

• Rapidly and cost effectively build applications that meet today's high performance and availability needs
• Quickly deploy those applications across a variety of platforms
• Protect existing system and database investments by integrating them with new applications
• Re-use existing and third-party components, speeding development further
• Decouple business logic from presentation and database functions increasing performance and availability incrementally and inexpensively
• Re-deploy applications to other platforms without changing code
• Easily expose business logic as a web service

It is a 4GL development language which include a suite of development tools, with built in IDE (Written in OpenROAD), Code Repository, allowing applications to be developed and deployed on Microsoft and UNIX/LINUX platforms.

OpenROAD started out life in the early nineties as a product called Windows 4GL. When Ingres was re-badged as OpenIngres, the new name of OpenROAD was born. Since that time it has been through a number of major developments; the current version is OpenROAD 2006.

OpenROAD 4.1 introduced an interface to ActiveX controls, providing access to ActiveX control attributes and methods within the language for the brave. This mechanism often requires 'Wrapper' DLLs to be written to handle data type issues, one of which being a 2000 character limit on strings of text.

Ingres (database)

Ingres  is a commercially supported, open-source SQL relational database management system intended to support large commercial and government applications. Ingres is fully open source with a growing global community of contributors, but Ingres Corporation controls the development of Ingres and makes certified binaries available for download, as well as providing worldwide support.

Ingres was first created as a research project at the University of California, Berkeley, starting in the early 1970s and ending in the early 1980s. The original code, like that from other projects at Berkeley, was available at minimal cost under a version of the BSD license. Since the mid-1980s, Ingres has spawned a number of commercial database applications, including Sybase, Microsoft SQL Server, NonStop SQL and a number of others. Postgres (Post Ingres), a project which started in the mid-1980s, later evolved into PostgreSQL.

Ingres is ACID and is fully transactional (including all DDL statements).

Ingres 9.3 was released on October 7, 2009,it is a limited release targeted at new application development on Linux and Windows only. Ingres 9.3 is not an upgrade path for existing Ingres installations or applications.


Ingres 10 was released on October 12, 2010, which is a full release, supporting upgrade from earlier versions of the product. Currently available on 32- and 64-bit Linux, 32-bit Windows and Solaris Sparc.

Language structure

The syntax of OpenROAD is very closely linked to that of the Ingres database, with direct support for embedded SQL. In a similar way to other event based programming languages, code can be placed in groups for related windows/system events.
The syntax is similar to Microsoft Visual Basic, allowing OpenROAD users to quickly adapt to Visual Basic with the help of Intellisense.
Intellisense is still not available (Q2 of 2008) in the OpenROAD IDE, however editors like TextPAD have syntax files that allow colour coding of source files using key word recognition.
OpenROAD comes with system classes with following functionality:

• application source (allows to dynamically fetch, create, modify source artifacts)
• database access
• data types (scalar and complex)
• runtime control
• visual forms (incl. common widgets and controls)

Features

• object oriented language: class, simple inheritance (no interfaces, currently no constructor/destructor but planned for version 5.0)
• Cross platform support
• Integrated Debugger/IDE
• Integrated Application Server
• Support for Windows CE development (V5.0)
• Support for VB.Net/Java Integration

Platforms

OpenROAD application can be deployed on the following clients :- Thin Client (Web), Windows, and various flavours of Linux/Unix.
It has support for n-tier systems by using the OpenROAD Application Server. The Application Server can be deployed on Windows or Linux/Unix platforms.
It has built in support for the Ingres database, or one of the following using a product called Enterprise Access: Oracle, SQL Server or DB2, which allows the client to use the same SQL syntax for all target databases.

Mainframe

Introduction

We all know a PC, probably heard of supercomputers. But mainframes are not so known.

When you watch television and see a movie with a big machine, or hear people talking to each other (at college) about a mainframe do you sometimes wonder what that is? What they are talking about? Then this page is intended for you.

This page is the first in a future series to explain what a mainframe is and how it evolved in history. Who were the pioneers and what companies were, and still are, involved.

How did and how do they look like? On this page are a few pictures of the earliest mainframes.

Mark I mainframe (1950's)

When you think of a mainframe do you think of a large computer? Right!

But how large is it and what does it do, and what is its place in the family of computers we know.

	Quantum computers
	Grid computers
	Supercomputers
	Mainframes
	Mini computers
	Microcomputers
	Terminals
	Embedded computers

The ranking of a mainframe is as you can see almost at the top. (quantum computers are hardly out of the laboratories)

A mainframe is simply a very large computer. And totally different from what you have on your desk. Don't say: what seems to be a mainframe today is on your desktop tomorrow. Apart from the CPU's (processors) that is far from true.

Eniac (1946)

Mainframe is an industry term for a large computer. The name comes from the way the machine is build up: all units (processing, communication etc.) were hung into a frame. Thus the maincomputer is build into a frame, therefore: Mainframe

And because of the sheer development costs, mainframes are typically manufactured by large companies such as IBM, Amdahl, Hitachi.
Their main purpose is to run commercial applications of Fortune 1000 businesses and other large-scale computing purposes.
Think here of banking and insurance businesses where enormous amounts of data are processed, typically (at least) millions of records, each day.

BINAC(1960's)

But what classifies a computer as a mainframe?

• A mainframe has 1 to 16 CPU's (modern machines more)
• Memory ranges from 128 Mb over 8 Gigabyte on line RAM
• Its processing power ranges from 80 over 550 Mips
• It has often different cabinets for
  • Storage
  • I/O
  • RAM
• Separate processes (program) for
  • task management
  • program management
  • job management
  • serialization
  • catalogs
  • inter address space
  • communication

Historically, a mainframe is associated with centralized computing opposite from distributed computing. Meaning all computing takes (physically) place on the mainframe itself: the processor section.

(3)
IBM 4381 mainframe processor from 1985

Refer to mainframe.in for lots of links to other mainframe related sites.

Chronology

Building mainframes started with the MarkI soon to be followed by tens of other types and manufacturers. But as said earlier, because of the development costs only governments and large firms could pay for the development of such behemoths.
Have a look at some early mainframes:

Mainframe	Year
ENIAC	1942
MarkI	1944
BINAC	1949
Whirlwind	1960
UNIVAC	1952
IBM 701	1953
IBM 360	1963

1939

Atanasoff-Berry Computer created at Iowa State.

1940

Konrad Zuse's -Z2 uses telephone relays instead of mechanical logical circuits

1942

1943

Colossus - British vacuum tube computer

1944

Eniac (electronic numerical integrator and calculator ) in operation at the Moore School. Te NIAC has thirty separate units, plus power supply and forced-air cooling, weighed over thirty tons. Its 19,000 vacuum tubes, 1,500 relays, and hundreds of thousands of resistors, capacitors, and inductors consumed almost 200 kilowatts of electrical power.

Manchester Mark1

1945

John von Neumann writes "First Draft of a Report on the EDVAC" in which he outlines the architecture of a stored-program computer. This report changed the direction of computer development away from punched paper tape.

1946

J. Presper Eckert & John Mauchly, ACM, AEEI

1947

Harvard Mark II (Magnetic Drum Storage)

1948

whirlwind
Whirlwind at MIT
Manchester Mark I (1st stored-program digital computer.
Remington engineers complete the Model 3, a one of a kind concept computer.
GE Electronics Laboratory in Syracuse wins an order for a USAF tube computer, named OARAC.

1950

Univac I
Univac I first deliverey to the US Census Bureau

1951

The first UNIVAC I mainframe computer was delivered to the Census Bureau. Unlike the ENIAC, the UNIVAC processed each digit serially. But its much higher design speed permitted it to add two ten-digit numbers at a rate of almost 100,000 additions per second. Internally. It was the first mass-produced computer. The central complex of the UNIVAC was about the size of a one-car garage: 14 feet by 8 feet by 8.5 feet high. It was a walk-in computer. The vacuum tubes generated an enormous amount of heat, so a high capacity chilled water and blower air conditioning system was required to cool the unit. The complete system had 5200 vacuum tubes, weighed 29,000 pounds, and consumed 125 kilowatts of electrical power.

 
 
1955
IBM 704 announced. It was the first large-scale commercially available computer system to employ fully automatic floating point arithmetic commands. It was a large-scale, electronic digital computer used for solving complex scientific, engineering and business problems and was the first IBM machine to use FORTRAN. The 704 and the 705 were the first commercial machines with core memories.
IBM 705 announced. Developed primarily to handle business data, it could multiply numbers as large as one billion at a rate of over 400 per second. In a 1954 IBM publication, the 705 was credited with "Forty thousand or twenty thousand characters of high-speed magnetic core storage; Any one of the characters in magnetic core storage can be located or transferred in 17 millionths of a second; Any one of these characters is individually addressable."
Honeywell computer business was originated from the Datamatic Corporation, founded in Newton MA, as a joint-venture by Raytheon and Honeywell, to produce large-scale computer systems. Raytheon sells its 40% interest to Honeywell in 1957

1952

Illiac I, Univac I at Livermore predicts 1952 election,
AVIDAC built at Argonne
The Remington (later SperryRand) Model 409 is delivered to the Internal Revenue Service facility in Baltimore.
MANIAC (mathematical analyzer, numerical integrator and computer) built at Los Alamos by Metropolis. It is responsible for the calculations of Mike, the first hydrogen bomb. This machine is followed by MANIAC II,
IBM-builds the STRETCH supercomputer and a series of commercial super computers that have made the Laboratory the world's largest scientific computing center.

IBM 701
The IBM 701 Electronic Data Processing Machine announced by IBM President Thomas J. Watson, Jr. was IBM's first commercially available scientific computer and the first IBM machine in which programs were stored in an internal, addressable electronic memory. It was the first of the pioneering line of IBM 700 series mainframe computers, including the 702, 704, 705 and 709. The computer consisted of two tape units (each with two tape drives), a magnetic drum memory unit, a cathode-ray tube storage unit, an L-shaped arithmetic and control unit with an operator's panel, a card reader, a printer, a card punch and three power units. The 701 could perform more than 16,000 addition or subtraction operations a second, read 12,500 digits a second from tape, print 180 letters or numbers a second, and output 400 digits a second from punched-cards.

1953

Edvac
IBM's drum memory 650 computer, announced. It sells for $200,000 to $400,000 and is a great success: more than 1800 will be sold or leased. The basic IBM 650 has 2000 words of memory and 60 words of core memory. It will be the first computer on which IBM makes a meaningful profit.

First IBM 701 delivered.


IBM 701

1954

IBM 650 (first mass-produced computer) o the market.
FORTRAN developed by John Backus.
ORACLE-Oak Ridge Automated Computer And Logical Engine.
Texas Instruments introduces the silicon transistor.
Univac II introduced.

1956

IBM 704

1956

MANIAC 2, DEUCE (fixed head drum memory), clone of IAS
The Air Force accepts the first UNIVAC Solid State Computer. The machine was one of the first to use solid state components in its central processing unit. Remington Rand was not able to market a commercial version for three years. The UNIVAC Solid State Computer came in two versions: the Solid State 80 handled IBM-style 80 column cards, while the Solid State 90 was adapted for Remington Rand's 90 column cards. A Solid State system consisted of the CPU and drum memory, card reader, card punch, and printer. There was the option of adding a tape controller and up to ten UNISERVO II tape drives. The drives could read both mylar tape and the old UNIVAC metallic tape: the mode was selected by a switch on the front of the drive. Actually a hybrid, the CPU had twenty vacuum tubes, 700 transistors, and 3000 FERRACTOR amplifiers.

1957
Installation of the first Honeywell Datamatic D-1000 to Blue Cross/Blue Shield of Michigan.

1958
Nippon Telegraph & Telephone Musasino-1: 1st parametron computer, Jack Kilby-First integrated circuit prototype; Robert Noyce works separately on IC's, NEC 1101 & 1102


Introduction of Honeywell H-800 first shipped in 1960.
Delivery of first GE ERMA system. Two years later it is renamed GE-210. It was also sold by NCR as NCR-204.

1959

The fully transistorized IBM 7090 computer system delivered. The system had computing speeds up to five times faster than those of its predecessor, the IBM 709. It was both a scientific and business machine. It was finally withdrawn from production in 1969

The IBM 1401 is called the Model T of the computer business, because it is the first mass-produced digital, all-transistorized, business computer that can be afforded by many businesses worldwide. The basic 1401 is about 5 feet high and 3 feet across. It comes with 4,096 characters of memory. The memory is 6-bit (plus 1 parity bit) CORE memory, made out of little metal donuts strung on a wire mesh at IBM factories. The 1401 has an optional Storage Expansion Unit which expanded the core storage to an amazing 16K. The 1401 processing unit can perform 193,300 additions of eight-digit numbers in one minute. The monthly rental for a 1401 is $2,500 and up, depending on the configuration. By the end of 1961, the number of 1401s installed in the United States alone will reach 2,000 -- representing about one out every four electronic stored-program computers installed by all manufacturers at this time. The number of installed 1401s will peak at more than 10,000 in the mid-1960s, the system will be withdrawn from marketing in February 1971.(5)

1960

Paul Baran at Rand develops packet-switching, NEAC 2201,
Whirlwind-air traffic control,
Livermore Advanced Research Computer (LARC),
Control Data Corporation CDC 1604,
First major international computer conference


Stretch
UNIVAC announces the 1107 (completed in 1962) with the EXEC I operating system which occupied about 8K of the 1107's 32K of memory. The machine is intended to support true multiprogramming: sharing CPU time among several batch runs.
Introduction of Honeywell 400
Decision to launch the GE Mosaic line, a family of four 24-bits computers. The lower models will be announced as GE-415, GE-425 and GE-435. They will be known as Compatible GE-400 series.

1961

IBM Stretch-Multiprogramming

IBM709

IBM 7040 and 7044 computer systems announced.

1962

First use of virtual memory in a mainframe computer.⁽⁴⁾
Control Data Corporation opens lab in Chippewa Falls headed by Seymour Cray,
Telestar launched,
Atlas-virtual memory and pipelined operations.

IBM 7090 console

Timesharing-IBM 709 and 7090
Introduction of Honeywell 1800 (first shipps in 1964).
IBM's 1440 Data Processing System is a low-cost compact electronic computer designed specifically for small and medium-size business firms.
IBM 7094 computer announced. With a memory reference speed of two microseconds (millionth of a second), the 7094 could in one second perform 500,000 logical decisions, 250,000 additions or subtractions, 100,000 multiplications or 62,500 divisions. The 7094 internally performed mathematical computations 1.4 to 2.4 times faster than the IBM 7090, A typical 7094 sold for $3,134,500. IBM provided customers with a complete package of 7090/7094 programs, including FORTRAN and COBOL programming languages, input-output control system and sorting, without charge. The 7094 was withdrawn from marketing in 1969.(5)

1963

Introduction of Honeywell H-200, a machine targeting the IBM 1401, with a similar architecture and a "Liberator" program translator.

1964

IBM 360
IBM 360-third generation computer family.
Burroughs B5000 mainframe introduced. The system can be considered the first of the "third generation" of computer systems. The most remarked-upon aspects are its use of a hardware-managed stack for calculation, and the extensive use of descriptors for data access. It includes virtual memory -- perhaps the first commercial computer to do so -- as well as support for multiprogramming and multiprocessing.(5)
CDC (Computer Data Corp.) 6600 shipped; 100 nsec cycle time.
First GE Time-sharing operation at Dartmouth College of the DTSS Dartmouth time-sharing system on a GE-265 (GE-225 + Datanet-30)
The Burroughs B5500 has multiprogramming and virtual memory capabilities, and is three times faster than the B5000.

1965

The Sage System,
IBM ships the midrange 360 model 40 computer which had COBOL and FORTRAN programming languages available as well as the stock Basic Assembly Language (BAL) assembler.
Introduction of GECOS-II, a multi-programming operating system for the GE-600

1966

The Burroughs B6500, an improved version of the B5500.

1967

First IBM 360/Model 91 shipped to NASA GSFC.

1969

First shipment of the CDC 7600 computer system.
First shipment of IBM 360 Model 85. The 360 family was intended to have 3 operating systems:

* DOS/360 operating system for the small machines. It could run two "real-time" sessions and one batch session.
* OS/360 operating system for the midrange and high end.
* TSS/360 operating system for Time-sharing Multi-user system

Introduction of Honeywell model 115 in the H-200 product line. The line is renamed H-2000 after models 115/2, 1015 and 2015 introduced in January 1971, and model 2020 and 2030 in December 1972 after the GE merger. The line is eventually merged into Series6 0 NPL through a H-200 mode (emulator) on level 64. Introduction of GE-655 that is better known as H-6000 after 1970.

1970

Burroughs announces the 700 series. The first B6700 computer systems were installed during 1971. It was the first Burroughs machine with dynamic linking of programs at runtime. The B6700 line started out with one CPU and one i/o processor and could be expanded up to a maximum of three CPUs and two i/o processors.
Formal acquisition of Bull-General Electric by Honeywell. BGE takes the name of Honeywell-Bull.
IBM announces a family of machines with an enhanced instruction set, called System/370. The 370s proved so popular that there was a two-year waiting list of customers who had ordered a systems.
A giant dies: Announcement of the cession of the world-wide GE computer business, except time-sharing to Honeywell.

1971

US Air Force orders several Honeywell H-6000 WWMCCS (World Wide Military Command and Control System), a $3.5M contract.
First shipments of IBM S/370 Models 155 and 165 as well as the S/360 Model 195.

1973

Introduction of virtual memory on IBM S/370 Models 158 and 168.

1975

Amdahl 470 V/6 computer system delivered to NASA.

1977

The Burroughs Scientific Processor was developed, and announced.
IBM 3033 computer system announced

1979

The Burroughs 900-level systems are introduced.

1985

The most powerful IBM computer system of its time, the 3090 high-end processor of the IBM 308X computer series incorporated one-million-bit memory chips, Thermal Conduction Modules to provide the shortest average chip-to-chip communication time of any large general purpose computer. The Model 200 (entry-level with two central processors) and Model 400 (with four central processors) IBM 3090 had 64 and 128 megabytes of central storage, respectively. At the time of announcement, the purchase price of a Model 200 was $5 million. A later six-processor IBM 3090 Model 600E, using vector processors, could perform computations up to 14 times faster than the earlier four-processor IBM 3084.(5)

1990

The ES/9000 models came out with fiber-optical I/O channels (ESCON), and IBM began using the name System/390. The ES/9000s exploited new technologies, such as high-speed fiber optic channels with IBM's new ESCON architecture, ultra-dense circuits and circuit packaging that provided higher performance, extended supercomputing capabilities and twice the processor memory previously available. The line spanned a 100-fold performance range increase from the smallest (model 120) to the most powerful (model 900 six-way multiprocessor). Basic purchase prices for the air-cooled processors of ES/9000 ranged from approximately $70,500 to $3.12 million. Basic purchase prices for the water-cooled models ranged from $2.45 million to $22.8 million.(5)

1999

IBM releases a new generation of S/390.

From the late 1990's mainframe manufacturers start to leave the mainframe market, thinking mainframe business to be less profitable. And then there is virtually only one manufacturer of major importance left: IBM. And as the single (most important) manufacturer IBM can dictate its own prices and sales goes up as well as profits. Not surprisingly IBM's innovations in new mainframe architecture leaves the rest far behind. In due time this is observed by other computer manufacturers and since 2001 competition gets stronger again.

2002

The IBM S/390 G5/G6 enterprise server family has up to 256 channels, from 2 to 8 Cryptographic Coprocessors, from 8 to 32 Gigabytes of memory, and can run under OS/390, MVS, VM, VSE, or TPF operating systems. It can also host an unbelievable amount of hard drive storage.

2004

The 3/4 ton IBM eServer zSeries 890, dubbed the "Baby Shark" can host up to 32 GBytes of memory.

The four PCIX Crypto Coprocessor (and optional PCI Crypto Accelerators) on the z890 have seven engine levels, giving a total of 28 capacity settings overall.
With it's advanced virtualization technology the 64-bit z890 can run several operating systems at the same time including z/OS, OS/390®, z/VM®, VM/ESA®, VSE/ESA, TPF and Linux for zSeries and Linux for S/390®.
The z890 is upgradeable within z890 family and can also upgrade to z990 from select z890 configurations.
Configured with the new Enterprise Storage Server Model 750 which handles from 1.1TB up to 4.6TB of data, the x890 makes an awesome server.

 

Construction

In the early days output came via a paper tape.

Later by an array of burning lamps and when the vacuumtube technology became sophisticated enough to build a CRT output came by means of spots on the screen (see williams tube).

Operating systems

At first there was no operating system. Most machines were hard wired. Programming it meant rewiring panels and setting hundreds of switches to have the machine calculate a table.
The next years when programming languages became available and memory was no longer a problem programmers created operating systems. You no longer had to be an electrical engineer to program a machine like that.
That made it possible for scientists and other users to quickly make a program and get the results.
To take care of all this a mainframe needs a sophisticated Operating System.
And as you look at it closely also quite different from what you find on your desktops machine. Almost always text based terminals (no graphics) are connected to it. Also PC's can be connected to a mainframe with a special interface program - often called 3270 emulation.
But a mainframe does have some particular properties:

• It manages a large number of users
• Distributes the sheer workload that can be handled by the machine over different processors and in/output devices.
• All processes are running on the host and not on your terminal.
• Output is sent to your terminal through a program running (in background) on the host(mainframe). Nothing else goes over the line. It is like you are connected to a large computer by long wires. That is also the reason why it seems that your keyboard typing sometimes appears slower on your monitor then you actually type

Operating systems for mainframes are few in number: UNIX, Linux, VMS, Z/OS, Z/VM, VSE/ESA. The latter three are of IBM origin and all three: VMS, Linux and Unix also run on IBM mainframes(2)
However there are some dialects of VMS, Linux, and Unix running on different machines.

Programming mainframes

When the first programming languages like Cobol, Fortran and Algol were created every large company and institution could hire people to do the programming of administration or complicated scientific calculations. The atomic bomb project in Los Alamos was a prime example of doing calculations using computers, without it the project never had succeeded in time.

Pioneers

Many scientists have contributed to the mainframe computer as it is now. Things did not go as smooth and fast as it goes nowadays. Sometimes many items, mechanisms, or materials still had to be invented before things really got on their way. On line memory was a crucial phase in developing large computers. Also when timesharing was invented in the late 60's mainframe use exploded.

Companies

To create a mainframe one needed at least a few hundred thousand dollars to build the first types.
Later types of the 60' and 70's required a few million dollars and now depending on what capacities you need mainframes range between two three hundred to several tens of millions
It is reasonable to say that small companies can not afford to spent that kind of money to develop one machine or prototype.

Firms like:
Ahmdal (Hitachi)
Bull
Comparex (Hitachi)
DEC (Compaq)
Fujitsu
Hitatchi
IBM
ICL (Hitachi)
NEC
Siemens
Unisys
Sun

and the like were the only ones financially capable of developing mainframe machines.
As mainframe markets shrunk some companies were assimilated by their peers and other congregated into even larger firms.

Conclusion

A (modern) mainframe is still a very large machine, sometimes tens of square meters. Has usually more than one processor and loads of memory: often running between a few mega- to several hundreds Gb of RAM.
It has tons of disk space and other storage facilities in large size and quantities that are not normally found with mini or micro computers. And although it looks like hundreds of users are using the machine simultaneously it is all governed by a sophisticated time sharing system, hence: serialization. (per processor)

IBM 701 (1952)