Simplified Instructional Computer

By: Kirby Paul E. Fabro

The Simplified Instructional Computer

• (also abbreviated SIC) is a hypothetical computer system introduced in System Software: An Introduction to Systems Programming, by Leland Beck. Due to the fact that most modern microprocessors include subtle, complex functions for the purposes of efficiency, it can be difficult to learn systems programming using a real-world system. The Simplified Instructional Computer solves this by abstracting away these complex behaviors in favor of an architecture that is clear and accessible for those wanting to learn systems programming.

SIC Architecture

• The SIC machine has basic addressing, storing most memory addresses hexadecimal integer format. Similar to most modern computing systems, the SIC architecture stores all data in binary and uses the two's complement to represent negative values at the machine level. Memory storage in SIC consists of 8-bit bytes, and all memory addresses in SIC are byte addresses. Any three consecutive bytes form a 24-bit 'word' value, addressed by the location of the lowest numbered byte in the word value. Numeric values are stored as word values, and character values use the 8-bit ASCII system. The SIC machine does not support floating-point hardware and have at most 32,768 bytes of memory. There is also a more complicated machine built on top of SIC called the Simplified Instruction Computer with Extra Equipment (SIC/XE). The XE expansion of SIC adds a 48-bit floating point data type, an additional memory addressing mode, and extra memory (1 megabyte instead of 32,768 bytes) to the original machine. All SIC assembly code is upwards compatible with SIC/XE.

• SIC machines have several registers, each 24 bits long and having both a numeric and character representation:

• A (0): Used for basic arithmetic operations; known as the accumulator register.

• X (1): Stores and calculates addresses; known as the index register.

• L (2): Used for jumping to specific memory addresses and storing return addresses; known as the linkage register.

• PC (8): Contains the address of the next instruction to execute; known as the program counter register.

• SW (9): Contains a variety of information, such as carry or overflow flags; known as the status word register.

• In addition to the standard SIC registers, there are also four additional general-purpose registers specific to the SIC/XE machine:

• B (3): Used for addressing; know as the base register.

• S (4): No special use, general purpose register.

• T (5): No special use, general purpose register.

• F (6): Floating point accumulator register (This register is 48-bits instead of 24).

• These five/nine registers allow the SIC or SIC/XE machine to perform most simple tasks in a customized assembly language. In the System Software book, this is used with a theoretical series of operation codes to aid in the understanding of assemblers and linker-loaders required for the execution of assembly language code.

Addressing Modes for SIC and SIC/XE

• The Simplified Instruction Computer has three instruction formats, and the Extra Equipment add-on includes a fourth. The instruction formats provide a model for memory and data management. Each format has a different representation in memory:

• Format 1: Consists of 8 bits of allocated memory to store instructions.

• Format 2: Consists of 16 bits of allocated memory to store 8 bits of instructions and two 4-bits segments to store operands.

• Format 3: Consists of 6 bits to store an instruction, 6 bits of flag values, and 12 bits of displacement.

• Format 4: Only valid on SIC/XE machines, consists of the same elements as format 3, but instead of a 12-bit displacement, stores a 20-bit address.

• Both format 3 and format 4 have six-bit flag values in them, consisting of the following flag bits:

• n: Indirect addressing flag

• i: Immediate addressing flag

• x: Indexed addressing flag

• b: Base address-relative flag

• p: Program counter-relative flag

• e: Format 4 instruction flag

SIC Assembly Syntax

• SIC uses a special assembly language with its own operation codes that hold the hex values needed to assemble and execute programs. A sample program is provided below to get an idea of what a SIC program might look like. In the code below, there are three columns. The first column represents a forwarded symbol that will store its location in memory. The second column denotes either a SIC instruction (opcode) or a constant value (BYTE or WORD). The third column takes the symbol value obtained by going through the first column and uses it to run the operation specified in the second column. This process creates an object code, and all the object codes are put into an object file to be ran by the SIC machine.

• COPY START 1000FIRST STL RETADRCLOOP JSUB RDRECLDA LENGTHCOMP ZEROJEQ ENDFILJSUB WRRECJ CLOOPENDFIL LDA EOFSTA BUFFERLDA THREESTA LENGTHJSUB WRRECLDL RETADRRSUBEOF BYTE C'EOF'THREE WORD 3ZERO WORD 0RETADR RESW 1LENGTH RESW 1BUFFER RESB 4096.. SUBROUTINE TO READ RECORD INTO BUFFER.

• RDREC LDX ZEROLDA ZERORLOOP TD INPUTJEQ RLOOPRD INPUTCOMP ZEROJEQ EXITSTCH BUFFER,XTIX MAXLENJLT RLOOPEXIT STX LENGTHRSUBINPUT BYTE X'F1'MAXLEN WORD 4096.. SUBROUTINE TO WRITE RECORD FROM BUFFER.

• WRREC LDX ZEROWLOOP TD OUTPUTJEQ WLOOPLDCH BUFFER,XWD OUTPUTTIX LENGTHJLT WLOOPRSUBOUTPUT BYTE X'06'END FIRST

• If you were to assemble this program, you would get the object code depicted below. The beginning of each line consists of a record type and hex values for memory locations. For example, the top line is an 'H' record, the first 6 hex digits signify its relative starting location, and the last 6 hex digits represent the program's size. The lines throughout are similar, with each 'T' record consisting of 6 hex digits to signify that line's starting location, 2 hex digits to indicate the size (in bytes) of the line, and the object codes that were created during the assembly process.

• HCOPY 00100000107A T0010001E1410334820390010362810303010154820613C100300102A0C103900102D T00101E150C10364820610810334C0000454F46000003000000 T0020391E041030001030E0205D30203FD8205D2810303020575490392C205E38203F T0020571C1010364C0000F1001000041030E02079302064509039DC20792C1036 T002073073820644C000006 E001000

Emulating the SIC System

• Since the SIC and SIC/XE machines are not real machines, the task of actually constructing a SIC emulator is often part of coursework in a systems programming class. The purpose of SIC is to teach introductory-level systems programmers or collegiate students how to write and assemble code below higher-level languages like C and C++. With that being said, there are some sources of SIC-emulating programs across the web, however infrequent they may be.

• An assembler and a simulator written by the author, Leland in Pascal is available on his educational home page at ftp://rohan.sdsu.edu/faculty/beck

• SIC/XE Simulator And Assembler downloadable at https://sites.google.com/site/sarimohsultan/Projects/sic-xe-simulator-and-assembler

• SIC Emulator, Assembler and some example programs written for SIC downloadable at http://sicvm.sourceforge.net/home.php

Comparison of programming languages

• is a common topic of discussion among software engineers. Basic instructions of severalprogramming languages are compared here.

• Conventions of this article

• The bold is the literal code. The non-bold is interpreted by the reader. Statements in guillemets (« … ») are optional. Tab↹indicates a necessary indent (with whitespace).

Type identifiers• 8 bit (byte)16 bit (short integer)32 bit64 bit (long integer)Word sizeArbitrarily precise (bignum)SignedUnsignedSignedUnsignedSignedUnsignedSignedUnsignedSignedUnsignedAda[1]range

-2**7 .. 2**7 - 1[j]range 0 .. 2**8 - 1[j] ormod 2**8[k]range -2**15 .. 2**15 - 1[j]range 0 .. 2**16 - 1[j] ormod 2**16[k]range -2**31 .. 2**31 - 1[j]range 0 .. 2**32 - 1[j] ormod 2**32[k]range -2**63 .. 2**63 - 1[j]mod 2**64[k]Integer[j]range 0 .. 2**Integer'Size - 1[j] ormod Integer'Size[k]N/AALGOL 68(variable-width)short short int[c]N/Ashort int[c]N/Aint[c]N/Along int[c]N/Aint[c]N/Along long int [a][g]bytes & bitsC (C99fixed-width)int8_tuint8_tint16_tuint16_tint32_tuint32_tint64_tuint64_tintunsigned intN/AC++ (C++11fixed-width)C (C99variable-width)signed charunsigned charshort[c]unsigned short[c]long[c]unsigned long[c]long long[c]unsigned long long[c]C++ (C++11variable-width)Objective-Csigned charunsignedcharshort[c]unsigned short[c]long[c]unsigned long[c]long long[c]unsigned long long[c]intorNSIntegerunsigned intorNSUIntegerC#sbytebyteshortushortintuintlongulongIntPtrUIntPtrSystem.Numerics.BigInteger(.NET 4.0)JavabyteN/Achar[b]N/AN/AN/AN/Ajava.math.BigIntegerGoint8uint8 orbyteint16uint16int32uint32int64uint64intuintbig.IntSwiftInt8UInt8Int16UInt16Int32UInt32Int64UInt64IntUIntDbyteubyteshortushortintuintlongulongN/AN/ABigIntCommonLisp[2]bignumSchemeISLISP[3]bignumPascal(FPC)shortintbytesmallintwordlongintlongwordint64qwordintegercardinalN/AVisual BasicN/AByteIntegerN/ALongN/AN/AN/AN/AVisual Basic .NETSByteShortUShortIntegerUIntegerLongULongSystem.Numerics.BigInteger(.NET 4.0)FreeBasicByte orInteger<8>UByte orUInteger<8>Short orInteger<16>UShort orUInteger<16>Long orInteger<32>ULong orUInteger<32>LongInt orInteger<64>ULongInt orUInteger<64>IntegerUIntegerN/APython 2.xN/AN/AN/AN/AintN/AlongPython 3.xN/AN/AN/AN/AN/AintS-LangN/AN/AN/AN/AN/AN/AFortranINTEGER(KIND = n)[f]N/AINTEGER(KIND = n)[f]N/AINTEGER(KIND = n)[f]N/AINTEGER(KIND = n)[f]N/APHPN/AN/Aint [m]N/Aint [m]N/AN/A[e]Perl 5N/A[d]N/A[d]N/A[d]N/A[d]N/A[d]Math::BigIntPerl6int8uint8int16uint16int32uint32int64uint64IntN/ARubyN/AN/AN/AN/AFixnumN/ABignumErlang[n]N/AN/AN/AN/Ainteger()N/Ainteger()[o]ScalaByteN/AShortChar[l]IntN/ALongN/AN/AN/Ascala.math.BigIntSeed7N/AN/AN/AN/AN/AN/AintegerN/AN/AN/AbigIntegerSmalltalkN/AN/AN/AN/ASmallInteger[i]N/ALargeInteger[i]Windows PowerShellN/AN/AN/AN/AN/AN/AOCamlN/AN/Aint32N/Aint64N/Aintornativeintopen Big_int;;big_intF#sbytebyteint16uint16int32 or intuint32uint64nativeintunativeintbigintStandard MLN/AWord8.wordN/AInt32.intWord32.wordInt64.intWord64.wordintwordLargeInt.int orIntInf.intHaskell(GHC)«import Int»Int8«import Word»Word8«import Int»Int16«import Word»Word16«import Int»Int32«import Word»Word32«import Int»Int64«import Word»Word64Int«import Word»WordIntegerEiffelINTEGER_8NATURAL_8INTEGER_16NATURAL_16INTEGER_32NATURAL_32INTEGER_64NATURAL_64INTEGERNATURALN/ACOBOL[h]BINARY-CHAR «SIGNED»BINARY-CHAR UNSIGNEDBINARY-SHORT «SIGNED»BINARY-SHORT UNSIGNEDBINARY-LONG «SIGNED»BINARY-LONG UNSIGNEDBINARY-DOUBLE «SIGNED»BINARY-DOUBLE UNSIGNEDN/AN/AN/AMathematicaN/AN/AN/AN/AN/AInteger

• ^a The standard constants int shorts and int lengths can be used to determine how many 'short's and 'long's can be usefully prefixed to 'short int' and 'long int'. The actually size of the 'short int', 'int' and 'long int' is available as constants short max int, max int and long max int etc.^b Commonly used for characters.^c The ALGOL 68, C and C++ languages do not specify the exact width of the integer types short, int, long, and (C99, C++11) long long, so they are implementation-dependent. In C and C++ short, long, and long long types are required to be at least 16, 32, and 64 bits wide, respectively, but can be more. The int type is required to be at least as wide as short and at most as wide as long, and is typically the width of the word size on the processor of the machine (i.e. on a 32-bit machine it is often 32 bits wide; on 64-bit machines it is often 64 bits wide). C99 and C++11[citation needed] also define the [u]intN_t exact-width types in the stdint.h header. SeeC syntax#Integral types for more information.^d Perl 5 does not have distinct types. Integers, floating point numbers, strings, etc. are all considered "scalars".^e PHP has two arbitrary-precision libraries. The BCMath library just uses strings as datatype. The GMP library uses an internal "resource" type.

• ^f The value of "n" is provided by the SELECTED_INT_KIND[4] intrinsic function.^g ALGOL 68G's run time option --precision "number" can set precision for long long ints to the required "number" significant digits. The standard constants long long int widthand long long max int can be used to determine actual precision.^h COBOL allows the specification of a required precision and will automatically select an available type capable of representing the specified precision. "PIC S9999", for example, would required a signed variable of four decimal digits precision. If specified as a binary field, this would select a 16 bit signed type on most platforms.^i Smalltalk automatically chooses an appropriate representation for integral numbers. Typically, two representations are present, one for integers fitting the native word size minus any tag bit (SmallInteger) and one supporting arbitrary sized integers (LargeInteger). Arithmetic operations support polymorphic arguments and return the result in the most appropriate compact representation.

• ^j Ada range types are checked for boundary violations at run-time (as well as at compile-time for static expressions). Run time boundary violations raise a "constraint error" exception. Ranges are not restricted to powers of two. Commonly predefined Integer subtypes are: Positive (range 1 .. Integer'Last) and Natural (range 0 .. Integer'Last).Short_Short_Integer (8 bit), Short_Integer (16 bit) and Long_Integer (64 bit) are also commonly predefined, but not required by the Ada standard. Run time checks can be disabled if performance is more important than integrity checks.^k Ada modulo types implement modulo arithmetic in all operations, i.e. no range violations are possible. Modulos are not restricted to powers of two.^l Commonly used for characters like Java's char.^m int in PHP has the same width as long type in C has on that system [c].^n Erlang is dynamically typed. The type identifiers are usually used to specify types of record fields and the argument and return types of functions.[5]

^o When it exceeds 1 word.[6]

• Floating point[edit]

• Single precisionDouble precisionProcessordependentAda[1]FloatLong_FloatN/AALGOL 68real[a]long real[a]short real, long long real, etc.[d]Cfloat[b]doublelong double[f]Objective-CC++ (STL)C#floatN/AJavaGofloat32float64SwiftFloatDoubleDfloatdoublereal

• Common LispSchemeISLISPPascal (Free Pascal)singledoublerealVisualBasicSingleDoubleN/AVisual Basic .NETXojoPythonN/AfloatJavaScriptNumber[7]N/A

• S-LangFortranREAL(KIND = n)[c]PHPfloatPerlPerl6num32num64NumRubyN/AFloatN/AScalaFloatDoubleSeed7N/AfloatSmalltalkFloatDouble

• Windows PowerShellOCamlN/AfloatN/AF#float32Standard MLN/ArealHaskell(GHC)FloatDoubleEiffelREAL_32REAL_64COBOLFLOAT-BINARY-7[e]FLOAT-BINARY-34[e]FLOAT-SHORT, FLOAT-LONG, FLOAT-EXTENDEDMathematicaN/AN/AReal

BASIC

• BASIC (an acronym for Beginner's All-purpose Symbolic Instruction Code) is a family of general-purpose, high-level programming languages whose design philosophy emphasizes ease of use.

• In 1964, John G. Kemeny and Thomas E. Kurtz designed the original BASIC language at Dartmouth College in New Hampshire. They wanted to enable students in fields other than science and mathematics to use computers. At the time, nearly all use of computers required writing custom software, which was something only scientists and mathematicians tended to learn.

• Versions of BASIC became widespread on microcomputers in the mid-1970s and 1980s. Microcomputers usually shipped with BASIC, often in the machine's firmware. Having an easy-to-learn language on these early personal computers allowed small business owners, professionals, hobbyists, and consultants to develop custom software on computers they could afford.

• BASIC remains popular in many dialects and in new languages influenced by BASIC, such as Microsoft's Visual Basic. In 2006, 59% of developers for the .NET Framework used Visual Basic .NET as their only programming language.

History

• Before the mid-1960s, computers were extremely expensive mainframe machines, usually requiring a dedicated computer room and air-conditioning, used by large organizations for scientific and commercial tasks. Users submitted jobs, on punched cards or similar media, to computer operators, and usually collected the output later. A simple batch processing arrangement ran only a single "job" at a time, one after another. During the 1960s faster and more affordable computers, still mainframes, became available, and time-sharing—a technique which allows multiple users or processes to share use of the CPU and memory—was developed. In such a system the operating system gives each of several processes time on the CPU, then pauses it and switches to another; each process behaves as if it had full use of the computer, although the time to complete its operation increases. Time-sharing was initially used to allow several batched processes to execute simultaneously.

• Time-sharing also allowed several independent users to interact with a computer, working on terminals with keyboards and teletype printers, and later display screens. Computers were fast enough to respond quickly to each user.

• The need to optimize interactive time-sharing, using command line interpreters and programming languages, was an area of intense research during the 1960s and 1970s.

Origin

• The original BASIC language was designed on May 1, 1964 by John Kemeny and Thomas Kurtz[2] and implemented by a team of Dartmouth students under their direction. The acronymBASIC comes from the name of an unpublished paper by Thomas Kurtz.[3] BASIC was designed to allow students to write mainframe computer programs for the Dartmouth Time-Sharing System. It was intended specifically for less technical users who did not have or want the mathematical background previously expected. Being able to use a computer to support teaching and research was quite novel at the time.

• The language was based on FORTRAN II, with some influences from ALGOL 60 and with additions to make it suitable for timesharing. Initially, BASIC concentrated on supporting straightforward mathematical work, with matrix arithmetic support from its initial implementation as a batch language, and character string functionality being added by 1965.

• The designers of the language decided to make the compiler available free of charge so that the language would become widespread. (In the 1960s software became a chargeable commodity; until then it was provided without charge as a service with the very expensive computers, usually available only to lease.) They also made it available to high schools in theHanover area, and put a considerable amount of effort into promoting the language. In the following years, as other dialects of BASIC appeared, Kemeny and Kurtz's original BASIC dialect became known as Dartmouth BASIC.

Spread on minicomputers

• Knowledge of the relatively simple BASIC became widespread for a computer language, and it was implemented by a number of manufacturers, becoming fairly popular on newer minicomputers such as the DEC PDP series and the Data General Nova. The BASIC language was also central to the HP Time-Shared BASIC system in the late 1960s and early 1970s, where the language was implemented as an interpreter. Also at this time it was ported into the Pick operating system where a compiler renders it into bytecode, able to be interpreted by a virtual machine.

• During this period a number of simple computer games were written in BASIC, most notably Mike Mayfield's Star Trek. A number of these were collected by DEC employee David H. Ahl and published in a newsletter he compiled. He later collected a number of these into book form, "101 BASIC Computer Games", which was first published in 1973.[4][5] During the same period, Ahl was involved in the creation of a small computer for education use, an early personal computer. When management refused to support the concept, Ahl left DEC in 1974 to found the seminal computer magazine,Creative Computing. The book remained popular, and was re-published on several occasions.

Explosive growth: the home computer era

• he introduction of the first microcomputers in the mid-1970s was the start of explosive growth for BASIC. It had the advantage that it was fairly well known to the young designers and computer hobbyists who took an interest in microcomputers.

• One of the first to appear was Tiny BASIC, a simple BASIC variant designed by Dennis Allison at the urging of Bob Albrecht of the Homebrew Computer Club. He had seen BASIC on minicomputers and felt it would be the perfect match for new machines like the MITS Altair 8800. How to design and implement a stripped-down version of an interpreter for the BASIC language was covered in articles by Allison in the first three quarterly issues of thePeople's Computer Company newsletter published in 1975 and implementations with source code published in Dr. Dobb's Journal of Tiny BASIC Calisthenics & Orthodontia: Running Light Without Overbyte. Versions were written by Li-Chen Wang and Tom Pittman.[7]

• In 1975 MITS released Altair BASIC, developed by Bill Gates and Paul Allen as the company Micro-Soft,[8] which eventually grew into corporate giantMicrosoft. The first Altair version was co-written by Gates, Allen, and Monte Davidoff.

IBM PC, and compatibles

• When IBM was designing the IBM PC they followed the paradigm of existing home-computers in wanting to have a built-in BASIC. They sourced this from Microsoft -IBM Cassette BASIC - but Microsoft also produced several other versions of BASIC

for MS-DOS/PC DOS including IBM Disk BASIC(BASIC D), IBM BASICA (BASIC A), GW-BASIC (a BASICA-compatible version that did not need IBM's ROM) and QuickBASIC, all typically bundled with the machine. In addition they produced the Microsoft BASIC Compiler aimed at professional programmers.

• Turbo Pascal-publisher Borland published Turbo Basic 1.0 in 1985 (successor versions are still being marketed by the original author under the namePowerBASIC). Microsoft wrote the windowing-based AmigaBASIC that was supplied with version 1.1 of the pre-emptive multitasking GUI Amiga computers (late 1985 / early 1986), although the product unusually did not bear any Microsoft marks.

• These languages introduced many extensions to the original home-computer BASIC, such as improved string manipulation and graphics support, access to the file system and additional data types. More important were the facilities for structured programming, including additional control structures and proper subroutines supportinglocal variables.

Visual Basic

• BASIC's fortunes reversed once again with the introduction in 1991 of Visual Basic ("VB"), by Microsoft. This was an evolutionary development of QuickBasic, and included constructs from other languages such as block structured control statements including With and For Each, parameterized subroutines, optional static typing, and more recentlyTemplate:2001 a full object oriented language. But the language retains considerable links to its past, such as the Dim statement for declarations, Gosub/Return statements, and even line numbers which are still needed to report errors properly.

• An important driver for the development of Visual Basic was as the new macro language for Excel.• Ironically, given the origin of BASIC as a "beginner's" language, and apparently even to the surprise

of many at Microsoft who still initially marketed it as a language for hobbyists, the language had come into widespread use for small custom business applications shortly after the release of VB version 3.0, which is widely considered the first relatively stable version. While many advanced programmers still scoffed at its use, VB met the needs of small businesses efficiently wherever processing speed was less of a concern than ease of development. By that time, computers running Windows 3.1 had become fast enough that many business-related processes could be completed "in the blink of an eye" even using a "slow" language, as long as large amounts of data were not involved. Many small business owners found they could create their own small, yet useful applications in a few evenings to meet their own specialized needs. Eventually, during the lengthy lifetime of VB3, knowledge of Visual Basic had become a marketable job skill.

• Microsoft also produced VBScript in 1996 and Visual Basic .NET in 2001. The latter has essentially the same power as C# and Java but with syntax that reflects the original Basic language.

Recent versions

• Many other BASIC dialects have also sprung up since 1990, including the open source QB64, Bywater BASIC, Gambas and FreeBASIC - and the commercial PureBasic, PowerBASIC, RealBasic, and True BASIC (the direct successor to Dartmouth BASIC from a company controlled by Kurtz).

• Several web-based simple BASIC interpreters also now exist, including Quite BASIC and Microsoft's Small Basic (educational software).

• Versions of BASIC have been showing up for use on smart phones and tablets. Apple App Store contains such implementations of BASIC programming language as smart BASIC, Basic!, HotPaw Basic, BASIC-II, techBASIC and others. Android devices feature such implementations of BASIC as RFO BASIC and Mintoris Basic.

• Applications for some mobile computers with proprietary OS (CipherLab) can be built with programming environment based on BASIC.

• An application for the Nintendo 3DS and Nintendo DSi called Petit Computer allows for programming in a slightly modified version of BASIC with DS button support. A 3DS sequel was released in Japan in November 2014.

Windows Command Line

• QBasic, a version of Microsoft QuickBasic without the linker to make EXE files, is present in the Windows NT and Dos-Windows 95 streams of operating systems and can be obtained for more recent releases like Windows 7 which do not have them. Prior to Dos 5, the Basic interpreter was GW-Basic. QuickBasic is part of a series of three languages issued by Microsoft for the home and office power user and small scale professional development; QuickC and QuickPascal are the other two.

• For Windows 95 and 98, which do not have QBasic installed by default, they can be copied from the installation disc which will have a set of directories for old and optional software; other missing commands like Exe2Bin and others are in these same directories.

• Many Linux distributions include Chipmunk Basic.

Nostalgia

• he ubiquity of BASIC interpreters on personal computers was such that textbooks once included simple "Try It In BASIC" exercises that encouraged students to experiment with mathematical and computational concepts on classroom or home computers. Popular computer magazines of the day typically included type-in programs. Futurist and sci-fi writer David Brin mourned the loss of ubiquitous BASIC in a 2006 Salon article[18] as have others who first used computers during this era. In turn, the article prompted Microsoft to develop and release Small Basic.

• References: http://en.wikipedia.org/wiki/Simplified_Instructional_Computer

• http://en.wikipedia.org/wiki/Comparison_of_programming_languages

• http://en.wikipedia.org/wiki/BASIC