Southampton BASIC System
From Seo Wiki  Search Engine Optimization and Programming Languages
Southampton BASIC System (SOBS} was a dialect of the BASIC programming language developed for and used on ICT 1900 series computers in the late 60s and early 70s; it was implemented under the MINIMOP operating system at the University of Southampton.^{[1]}
It was operated from a teletype terminal.
Contents 
Language characteristics
In common with many early implementations of BASIC, SOBS needed lines to have line numbers, both to allow a user to add new lines to the program in the desired place and also as targets for GOTO
and GOSUB
statements. A RENUMBER
facility was available to allow for sections of the code to be renumbered, by default in increments of 10, to allow more space in the middle of a program.
Other than line numbers, all numeric values were represented internally as floating point.
Statements
The language had relatively few statements by comparison with modern programming languages:
Statement  Purpose 

DATA
 Stored data for READ ing into variables at runtime

DIM var(size)...
 Dimension an array. One, two and threedimensional arrays were supported. 
END
 Halt execution of the program. 
FOR var=start TO end [STEP incr]
 Perform a set of statements repeatedly for varying values of var 
GOSUB line
 Call a subroutine at a given line number; flow would return to the next statement when a RETURN was executed.

GOTO line
 Unconditional branch to a given line number. 
IF expr THEN line [ELSE line]
 Conditionally branch. The THEN and ELSE parts could only give line numbers to go to.

INPUT var
 Prompt the user for input data 
LET var=expr
 Assign a value to a variable. Unlike many modern dialects of BASIC, LET was not an optional word.

NEXT var
 Perform the next iteration of a FOR loop.

PRINT
 Output to the teletype 
READ var...
 Read data from DATA statements into variables

REM
 Short for REM ark, this allowed for a comment to be placed on a line

RESTORE [line]
 Reset the READ pointer in order to reread DATA

RETURN
 Return to the line following a GOSUB .

Note in particular the lack of a WHILE
like statement; FOR
was the only looping construct available to programmers.
Variables
Variable names for numeric values were either a single letter, or a single letter followed by a single numeric digit, thus allowing for 286 discreet variables in total. Strings were supported; variable names for them had the same restriction but were followed by a pound (£
) symbol.
Functions
A limited number of numeric functions were provided, all of which took one numeric parameter:
Function  Function(<math>x</math>) returned 

SIN
 <math>\sin x</math> 
COS
 <math>\cos x</math> 
ATN
 <math>\arctan x</math> 
SQR
 <math>\sqrt{x}</math> 
LOG
 <math>\log x</math> 
EXP
 <math>e^x</math> 
INT
 The largest integer not greater than <math>x</math> 
SGN
 −1, 0, or 1, depending on whether <math>x</math> was less than, equal to, or greater than zero 
ABS
 <math>x</math> if <math>x</math> was negative, otherwise <math>x</math> 
Support for strings was more limited, with only one function, LEN
, which returned the length of the string parameter. Substrings were supported with square brackets, so A£[2,3]
referred to the substring of the string A£
from the 2nd character to the 3rd character inclusive, so
10 LET A£ = "FOO" 20 PRINT A£[2,3]
would print OO
This syntax was also supported on the lefthand side of an assignment, so
10 LET A£ = "FOO" 20 LET A£[2,2] = "BAR" 30 PRINT A£
would print FBARO
Arrays
Support for handling arrays of data was relatively strong, with MAT
statements able to read an entire array from DATA
statements, and perform useful matrix operations such as matrix addition, matrix subtraction, matrix multiplication, and finding the inverse matrix for a square matrix.
Example:
10 DIM A(3,3) 20 MAT READ A 30 DATA 1,1,2,1,0,2,0,2,1 40 DIM B(3,3) 50 MAT READ B 60 DATA 0,0,1,0,1,0,1,0,0 70 DIM C(3,3),D(3,3) 80 MAT C=A*B 90 MAT D=INV(C) 100 MAT PRINT D,
A is read from the first DATA statement
 <math>\begin{pmatrix}
1 & 1 & 2 \\ 1 & 0 & 2 \\ 0 & 2 & 1 \end{pmatrix}</math> 
B is read from the second DATA statement
 <math>\begin{pmatrix}
0 & 0 & 1 \\ 0 & 1 & 0 \\ 1 & 0 & 0 \end{pmatrix}</math> 
C is calculated by multiplying A and B
 <math>\begin{pmatrix}
2 & 1 & 1 \\ 2 & 0 & 1 \\ 1 & 2 & 0 \end{pmatrix}</math> 
D is calculated as the inverse of C
 <math>\begin{pmatrix}
2 & 2 & 1 \\ 1 & 1 & 0 \\ 4 & 3 & 2 \end{pmatrix}</math> 
The output would be
2 2 1 1 1 0 4 3 2
Debugging
File:Wiki letter w.svg  This section requires expansion. 
SOBS had primitive debugging capabilities, limited mostly to the TRACE
statement. TRACE ON
would cause the interpreter to print each line number as it was executed.
References
 ↑ Rees, M.J.; Oppenheimer, A.W. (21 January 1977). "SOBS  an incremental BASIC system". Software. Wiley InterScience. doi:. http://www3.interscience.wiley.com/journal/113444749/abstract?CRETRY=1&SRETRY=0. Retrieved 18 May 2009.