# Other Languages We wrap up our examination of programming languages by briefly considering a wide variety we will look at some meaningfully important historic.

## Presentation on theme: "Other Languages We wrap up our examination of programming languages by briefly considering a wide variety we will look at some meaningfully important historic."— Presentation transcript:

Other Languages We wrap up our examination of programming languages by briefly considering a wide variety we will look at some meaningfully important historic languages of note apl to demonstrate an array-based language a stack-based language (because some of the bizarre languages use this approach) bcpl to see more of how C-languages evolved some truly abnormal languages a couple of the newer languages of note bizarre languages esoteric languages languages that were developed for fun, or as a proof of concept, but not meant to be taken as serious languages obfuscated languages languages that are purposefully very difficult to understand and use

APL APL – a programming language (literally) developed in the 1960s
meant to be a language to express mathematical ideas notation consists of a set of symbols and a syntax to describe the processing of data. APL has primitive instructions that can manipulate n-dimensional arrays of data simplifying a program these primitives can be strung together in a single line of code as a combination of array manipulations APL is interactive (interpreted) useful for rapid prototyping APL is one of the most concise, consistent, and powerful programming languages ever devised (according to the author of a website I got this info from)

APL Operations APL programs are typical 1/5 to 1/20 the size of other programs due to the built-in array and math operations sort up (or down) a set of numbers raise any number to any power take any root of a number logarithms and exponentials examine separately the integer and decimal parts of a number convert number bases trigonometric functions random numbers rearrange arrays of numbers into different size and shape arrays, i.e. vectors, matrices, and multi-dimensional "cubes". DIMENSION X(100),Y(100) READ(5,10) N,(X(I),I=1,N) 10 FORMAT (15/(F10.2)) DO 20 I=1,N A=X(I) L=1 DO 15 J=1,N IF(A-X(J))15,15,12 12 A=X(j) L=J 15 CONTINUE Y(I)=A 20 X(L)= WRITE(6,30) (Y(I),I=1,N) 30 FORMAT(E15.2) END APL Array sorting program FORTRAN Array sorting program

Sample APL A  This creates an array, A with the values as specified B  2 4 r This creates a 2x4 array with 1..4 being in the first row and 5..8 being in the second row (r is the Greek letter rho) Once you create arrays, here are some operations to perform on them +/A Computes the sum of the array elements (returns 92 in this case) A + 1 Adds 1 to each element of array A x/A Computes the product of the array elements r B Returns the dimensions of the array (in this case, 2 4) (+/A) r A Computes the sum over the size of the array (average) This final one computes and displays all of the prime numbers ending at 20 See for an explanation (halfway down this page)

BCPL Basic Combined Programming Language, the precursor of C (also B)
block structured like Algol and syntactically somewhat similar to Algol but it introduced the { } for blocks (although since many early keyboards lacked these characters, \$( and \$) was also used, and was typeless had only 1-D arrays was case insensitive for identifiers but all reserved words start with upper case letters had all of C’s control structures but included an Unless-Do and Repeat-Until (which would later be found in Pascal/Modula) loop (infinite loop) more primitive for loop test-then-else rather than if-then-else introduced pass-by-value as the only form of parameter passing, but also had global memory (a 1-D array to store any global values) for variables that should be changed in a subroutine had both functions and procedures

BCPL Examples Manifest – declares constants
GET "LIBHDR" LET START() = VALOF { LET LC, WC, CC = 0, 0, 0 AND SP = TRUE { LET CH = RDCH( ) IF CH=ENDSTREAMCH BREAK IF CH='*N' THEN LC := LC + 1 TEST CH='*T' | CH='*N' | CH='*S' THEN SP := TRUE OR IF SP { WC := WC + 1 SP := FALSE } CC := CC + 1 } REPEAT WRITEF("%N %N %N*N", LC, WC, CC) RESULTIS 0 Manifest – declares constants Let – declares functions, procs GET "LIBHDR" MANIFEST { BOTTLES = 99 } LET START( ) BE { LET BEERS(N, S) BE { TEST N = 0 THEN WRITEF("No more bottles") ELSE WRITEF("%N bottle%S", N, (N = 1) -> "", "s") WRITEF(" of beer%S", S) FOR I = BOTTLES TO 1 BY -1 DO { BEERS(I, " on the wall, ") BEERS(I, ".*NTake one down, pass it around.*N") BEERS(I - 1, " on the wall.*N") FINISH GET "LIBHDR" LET START ( ) BE { LET F(N) = N=0 -> 1, N*F(N-1) FOR I = 1 TO 10 DO WRITEF("F(%N), = %N*N", I, F(I)) FINISH }

Forth An extensible stack-based language from the 1970s
Interpreted language All commands are part of a dictionary defining your own commands adds to the current dictionary (because its interpreted, you can continue to add during the current session) All data interact with a built-in data stack this will require that operations be specified in a postfix notation example: pushes 5, then 4, + pops 5 and 4, adds them, pushes 9 onto the stack, . ends the instruction, 9 popped off the stack and returned Built-in stack operations: DUP – duplicates the top of the stack SWAP – swaps the top 2 elements DROP – drops the top element of stack ROT – Rotate the top 3 numbers

Variables and Words To define a variable use variable name
this allocates storage for the integer variable name in the dictionary When you use the variable name, the address of the variable is placed on the stack ! stores stack values into a variable as in variable year 2005 year ! @ fetches variable and places it on the stack . Arrays and strings are also available where the index precedes the variable name as in 10 array ! To define a dictionary entry (word): :name body; This adds to the dictionary a new routine whose name is name and whose body consists of all characters after the space following name and prior to the ; For example, :square dup *; defines square as a routine that will duplicate the top of the stack and then multiply the top two elements on the top of stack You would execute square by doing variable square . And this would compute variable2 and return that value

Control Statements Conditional operators pop the top two values off the stack, perform the comparison and push -1 (true) or 0 (false) onto the stack A control statement can then use the result If statements: If operator statement(s) then ; If x * ! then ; This means “if top item on stack < second item” then retrieve x and multiply it by top of stack (which is now -1) and push to top of stack – in effect, this does “if top < second x = x * -1” If operator statement(s) then statement(s) else ; Loop statements: Limit Init do var statement(s) loop ; As in 10 0 do i . loop ; -- which prints 0..9 There is also an until and while repeat begin statement(s) condition until . begin condition while statement(s) repeat .

SNOBOL SNOBOL (String-oriented Symbolic Language) dates back to 1962 but its standard version, SNOBOL 4 was implemented in 67 The language contains the following features string manipulation operations - has several of these operations which allow a string to be tested for contents and make replacements in the string pattern matching- involves examining substrings, for the occurrences of specified substrings dynamically typed - no type declarations, variables may take on any type at any time aside from the basic data types, SNOBOL allowed user defined structures like Simula 67 or Algol 68 interpreted language with a compiler SNOBOL statements are of the form label statement :(label) -- the :(…) is a goto statement after this instruction executes and is optional like the label that precedes the statement statements have varying syntax and can look like message passing or imperative statements

Sample SNOBOL Program &TRIM = 1
WORDPAT = BREAK(&LCASE &UCASE) SPAN(&LCASE &UCASE "'-") . WORD COUNT = ARRAY('3:9',0) READ LINE = INPUT :F(DONE) NEXTW LINE WORDPAT = :F(READ) COUNT<SIZE(WORD)> = COUNT<SIZE(WORD)>+ 1 :(NEXTW) DONE OUTPUT = "WORD LENGTH NUMBER OF OCCURRENCES" I = 2 PRINT I = I + 1 OUTPUT = LPAD(I,5) LPAD(COUNT<I>,20) :S(PRINT) END This program inputs a text file and reads each word and counts the number of 3-letter, 4-letter, …, 9-letter words and reports on the number of each found

JCL Job Control Language
IBM Mainframe language to control execution of programs JCL instructions are thought of as cards (since originally each instruction was on its own punch card) instructions specify to submit a job to the operating system to request a resource for the job (input file, output file, printer, etc) to control the system’s processing of the job instructions include: job statement – specifies job name, accounting and billing information, and supplies options to control processing of the job execute statement– instructions the computer which program or procedure to execute data definition statement – identifies data sets that will be used or created by the job comment statement– contains comments delimiter/null statement – signifies end of a job step or end of job procedure/procedure end statement – marks the beginning/end of a procedure and assigns default values to parameters control/end control statement – marks the beginning/end of a program control statement output JCL statement – specifies the processing options that the job entry subsystem uses to print a sysout data set

// STORCLAS=MFI, // SPACE=(TRK,5), // DCB=(RECFM=FB,LRECL=512,BLKSIZE=5120,DSORG=PS) //PDSCRTP3 PROC //PDSCRTS1 EXEC PGM=IEFBR14 //TEMPLIB1 DD DISP=(NEW,CATLG),DSN=&DSNAME, // STORCLAS=MFI, // SPACE=(TRK,(45,15,50)), // DCB=(RECFM=FB,LRECL=80,BLKSIZE=800,DSORG=PO) // PEND //SIMOJOB1 JOB (ACCTINFO),CLASS=A,MSGCLASS=C,NOTIFY=USERID //JOBLIB DD DSN=SIMOTIME.DEVL.LOADLIB1,DISP=SHR //* //STEP0100 EXEC PGM=PROGRAM1 //STEP0200 EXEC PGM=PROGRAM2 //STEP0300 EXEC PGM=PROGRAM3 //STEPLIB DD DSN=SIMOTIME.DEVL.TEMPLIB1,DISP=SHR //STEP0400 EXEC PGM=PROGRAM4 JCL Examples

Mathematica This is a language for performing mathematical calculations and plotting of mathematical functions Mathematica is both a tool and a programming language, it includes features similar to other languages that we have studied Lisp – list manipulation Perl, Prolog – pattern matching on symbolic data APL – structured data manipulation C++ & Smalltalk – OO Pascal/C – procedural programming using modules FORTRAN/C – contains a number of built-in mathematical functions as a tool, the language has an interpreted interface for session work, much like Lisp, Python, Ruby, a 2D and 3D data visualizer to plot mathematical functions built-in solvers for systems of equations, differential equations, recurrence relations multi-variate statistics libraries and other features

Some Examples In[2]:= FindRoot[Exp[x] == x^2 + 2, {x, -1}]
Out[2]= {x -> } In[6]:= l1 = {}; (* initialize as empty list, since we want a list in the end *) Do[l2 = {}; Do[l2 = Append[l2, GCD[i, j]], {j, 1, 5}]; l1 = Append[l1, l2], {i, 1, 5}] Integrate[ a x^2 + b x + c ,{x,0,1}] integration example Clear[uRandomVector,a] uRandomVector[size_,{min_,max_}]:=Table[Random[Integer,{min,max}],{size}] a=uRandomVector[4,{0,1}]; Clear[i,x,y,cnt,ls] cnt=0; ls={}; i=1; While[(i<=Length[a]),x=a[[i]];       While[((i<=Length[a])&&(a[[i]]==x)),cnt+=1;i+=1];       ls=Append[ls,cnt];       cnt=0]

Mouse A language originally intended for microcomputers with a small amount of memory, interpreted and stack-based, using postfix notation the unique aspect of Mouse is that the program is specified as a single stream of symbols so that a program will tend to be very short (in terms of byte length) variables are single characters and commands are also typically single characters Mouse includes conditional branches, loops, pointers, macros, arrays and code tracing Rather than displaying the entire table of symbols for commands, here are some brief examples: X. Y: assign X to Y N. 1 + N: increment N by 1 P. Q. P: Q: swap values of P and Q ? A: input a number and store in A P. ! print variable P 1 N: N = 1 ( N. N. * ! “ ” Print N * N N. 10 – 0 < ^ If N < 10 – 0 then exit N N: N = N + 1 \$ End Program

Groovy This is a new language, an extension to Java
It includes these features == compares data (whether primitive or the values that make up an object) and not references, so for instance if a and b are Strings, a == b compares the two Strings’ values the ; is not needed unless multiple statements are on the same line – the interpreter is able to judge the end of an instruction if it ends with a \n supports operator overloading like C++ includes the tuple type from Python (indexed via arrays) as in list = [“hello”, 5, 3.14] and then list[2] is 3.14 functions can be passed as parameters, like in C++ uses the Java for loop but also has a simpler counting loop as in Python: for(i in 1..10) closures have built-in iterator operations as with Ruby, automatically generated mutators and accessors for all private data members

Lua Lua is a dynamically typed scripting language
Lua is a very small language that is very extendable While not overtly OO (for instance, no built-in support for inheritance) it can be expanded to include inheritance to make it OO and to handle AOP the language also fits the imperative paradigm by having control statements (similar to Modula/Pascal) the functional paradigm borrowing other aspects from Scheme and concurrent programming The basic unit of storage is known as a table, which is a heterogeneous associative array aside from associative arrays, Lua provides local and global (the default) variables with types that include numbers, strings, and booleans traditional arrays, sets, records and lists are implemented using tables

First Class Functions Lua supports first class functions (functions that can be passed as parameters) but also allows functions to be pointed to and functions to be redefined For instance, you can do the following in order to “save” a function while re-implementing it: do local oldprint = print // save the old function function print(s) // redefine the function if s ==“foo” then oldprint(“bar”) // cal the old function else oldprint(s) end

Metatables One of Lua’s greatest strengths is the inclusion of metatables and the ability for the programmer to modify metatables A metatable is attached to every variable that contains data describing the variable including how the variable should be treated under various conditions To add or alter a metatable entry, use name.__entry = where name is the name of the variable and entry is the metatable element We can then use the metatable entry in situations where the variable might not normally be usable For instance, if a variable x is not a string but we still want to know its length, we can obtain it by doing metatable(x).__len Hopefully the len metatable entry is present to either return x’s length or compute x’s length Built in metatable entries exist for a number of useful features such as length, index, concat and eq

Go A systems programming language from Google that combines features of C/C++ and Python For instance, the semicolon is only used to separate elements in the for loop There is a built-in string type where strings are immutable but not objects Assignment copies contents of values, not references (pointers) unless you explicitly request the address Go is strongly typed Go supports OOP, functional programming (functions are first class objects), concurrent programming and procedural programming The language supports the development of ontologies (as used for the semantic web)

Example Code func sum(a []int) int { s := 0
for i := 0; i < len(a); i++ { s += a[i] } return s main .. { include "sys:go/io.gof". include "sys:go/stdlib.gof". main() -> drink(99); stdout.outLine("Time to buy some more beer..."). drink(0) -> {}. drink(i) -> stdout.outLine( bottles(i) <> " on the wall,\n" <> bottles(i) <> ".\n" <> "take one down, pass it around,\n" <> bottles(i) <> " on the wall.\n"); drink(i-1). bottles(0) => "no bottles of beer". bottles(1) => "1 bottle of beer". bottles(i) => i^0 <> " bottles of beer". } func Open(name string, mode int, perm int) (file *File, err os.Error) { r, e := syscall.Open(name, mode, perm) if e != 0 { err = os.Errno(e) } return newFile(r, name), err

Obfuscated/Esoteric Languages
The idea behind these languages is to either (or both) Hide the meaning of the instructions, that is, to make programming as challenging as possible Make languages as simple as possible by reducing the number of operators/operations to a minimum and permit a very small compiler I’m going to break these down into roughly three categories: Spatial languages – languages whose instructions pertain to physical locations among the data Stack languages – languages like Forth where the data are implied to be on one or more stacks Other – languages that are just plain weird

False One of the first obfuscated languages, it uses postfix notation for operations like Lisp uses prefix notation operators include _ for unary minus, =~ for not equal and ~ for not for instance, a;1_=~ means a <> -1 and a;0>a;99>~& means a>0 and a<99 data types are limited to integer and character, which are single quoted like Lisp (e.g., ’a) variable names are limited to single letters assignment is : ; is used to dereference a variable example: 1a: is a = 1; and a;1+b: is b = a + 1; False uses an implied stack (all operations are via stack, that’s why the language uses postfix) functions are defined as lambda functions (unnamed) and placed inside of [ ] where parameters are taken from the stack based on the number of values that precede the function call you can declare a function’s name by placing name: after the function definition

False Instructions Built-in stack operations include \$ to duplicate top of stack, % to delete top of stack, \ to swap top two of to rotate top 3 of stack The only control instruction are if which is denoted using ? after the then or else clause, for instance: a;1=[“hello”]? if a = 1 then print “hello” a;0>[1:b]?a;0=[0:b]?~[-1:b]? if a > 0 then b = 1 else if a = 0 then b = 0 else b = -1 while loop which is denoted with a # after two lambda functions, the condition and the body [a;1=][2f;!]# while (a = 1) f(2) [a;0>][a;a-b:b;b-1:]# while(a>0) { a = a – b; b = b – 1;} output is simply [“literal”] or [var] or [.] (print top of stack as number) or [,] (print top of stack as char) input follows the ^ symbol which means “stdin”

False Examples 2[1+]! – [1+]
is a function that adds 1 to the argument passed, so this code returns 3 [1+]i: defines the function as i, and can be called as valuei! as in 2i! which returns 3 [^\$1_=~][,]# while((c=getchar( )) != -1) putc(c); more literally, push the char on top of stack and then pop it off and print it [\$1=\$[\%1\]?~[\$1-f;!*]?]f: this defines a function f as follows: f(x) = if(top of stack = 1) then return 1 else return f(x – 1)

Brainf*ck Goal: create a language with the smallest compiler ever
Brainf*ck’s original compiler was 240 bytes! supposedly a newer compiler is under 200 bytes The language manipulates an array of 30,000 bytes with a single pointer instructions move the pointer or manipulate what is being pointed at instructions (C equivalents given, assume p is pointer): > is ++p < is --p + is ++*p - is --*p . is putchar(*p) , is *p = getchar( ) [ is while(*p) { that is, while loop while pointer *p = = 0 ] is }, that is, ends the while loop started with [

BF Examples BF Hello World program (creates the integer values for ASCII “Hello World” and outputs these values) [> > >+++>+<<<<-]> ++.> >++.<< > >+.>. This program multiplies the original input value by 10 and stores the value back into the array [>+<-]> ; move num one right ie num2=num >> ; load 10 into fourth element [ <<[<+>>+<-] ; add num2 to first and third element >[<+>-]> ; num2=third element ; loop ten times ] <<[-]< ; clear num2 # Input text and output it backwards: >.+[>.+]<[-.<] Program to compute and output the result: ,>++++++[< >-],,[<+>-],<.>.

Argh! BF/Esoteric language where commands are single letters and control is based on orientation of commands in a 2D grid Execution starts with j at position 0, 0 j indicates “go down 1 position” l means “process commands to the right” p and P are print commands to print the character below or above the letter q means quit (end of program) Programs are limited to a 80x40 grid of Ascii characters Aargh! is an extension to Argh! where programs can be Nx40 where there is no restriction on N (that is, programs can have an unlimited length but no more than 40 columns) j world lppppppPPPPPPq hello, Note: the type is not lined up exactly, each letter of “world” and “hello” shouold appear directly above or below a p/P

Argh Commands h, j, k, l - set execution direction to "left", "down", "up", "right" H, J, K, L - move instruction pointer left/down/up/right to the next cell whose value matches the value on top of the stack, set execution direction to "left", "down", "up", "right" x/X - if value on top of the stack is positive, turn the execution direction 90 degrees to the right/left q - quit: end program execution s/S - store (push) value of the cell below/above the current cell to stack d/D – duplicate/delete top value on stack a/A - add value of cell below/above current cell to the value on top of the stack r/R - reduce the value on top of the stack by the value of the cell below/above f/F - fetch (pop) value from top of stack and store to cell below/above p/P - send value below/above the current cell to stdout g/G - get one byte from stdin and store in cell below/above e/E - insert value of system EOF in cell below/above Argh! and Aargh! allow self-modifying code – instructions can be used to overwrite instructions!

Kipple A BF/esoteric language
the goal is minimalism – a language with very few commands the language is based on stack storage 26 built-in stacks available, called a-z, i and o are reserved for pre-execution input and post-execution output only, no other variables commands are limited to pushing/popping off of stacks 5 > a – pushes 5 onto stack a, a > b pops the top of stack a and pushes the item onto b, a < b does the same adding/subtracting two stack items or one stack item and one numeric operand a + 5 pushes (top of a + 5) onto a, a + b pushes (top of a + top of b) onto a, a + 5 pushes 5 onto a if a is empty clearing a stack (if the top of stack stores 0) a? pops all elements off of a if the top of a is 0 a loop that iterates through the body until a given stack is empty (a instructions) repeats the instructions, one time per element of a until a is empty strings are converted into individual ascii values and pushed/popped as ints “abc” > a pushes 97, 98 and 99 onto a in order (so that the top of stack a is 99) @value > o pushes the value onto the output stack, not its ascii character

Kipple Example 1 # Prints the lyrics to the famous "99 bottles of beer" song 99>n # push 99 onto stack n (n # while n is not empty 10>s # 10 is ascii for “new line”, push new line onto s n+0 (t>s) s<" bottle" n-1 n>a? (a "s">s 0>a?) s<" of beer on the wall" 10>s # output 1 line of this verse to stack s n+0 (t>s) s<" bottle" n-1 n>a? (a "s">s 0>a?) s<" of beer" n-1 10>s<"Take one down and pass it around" 10>s # compute next n (n-1) and output next line of verse with new n # output last line of this verse to stack s n? # clear stack n if top of stack is 0, that is, we have reached the ) # end of the song, and therefore empty stack exits the loop (s>o) # take everything in s and move it to o (output stack)

More Kipple Examples # Prints the 25 first Fibonacci numbers
# push fibonacci numbers onto stack t (n-1 a+0 t<a>b+a c<b>a<c n? ) # output numbers: 32>o # Bubblesort by DeathPing (i d+1 (b>c 0>b? x?) (x? d+0 d>f) ) (c>i) 0>d? (f>o) # Reverse (i>r)(r>o) # Unix cat (i>o)

Chef Like Kipple, Chef is another stack-based programming language
programs in Chef are natural language statements that are supposed to be recipes the natural language-based instructions are converted into stack commands based on the following ingredients represent integer or character values for data dry ingredients are interpreted as numeric values and liquid ingredients are interpreted as characters (they are stored as int ASCII values so the interpretation is important to output the right value) dry vs. liquid is based on the measurement used (e.g., g, kg are dry and ml, l are liquid) ingredients themselves are merely symbols and so can be anything the programmer desires recipe steps represent stack operations see the next slide recipe references to mixing bowls and baking dishes represent different stacks to manipulate other information, which is optional, is merely decorative such as baking time, oven temperature, and the final statement is how many people the recipe serves (required, but does nothing in the program)

Chef Operations Take ingredient from refrigerator. – input statement
Put ingredient into [nth] mixing bowl. – pushes onto stack n Fold ingredient into [nth] mixing bowl. – pops off stack n and places it into variable ingredient Add ingredient [to [nth] mixing bowl].– performs top of stack n + ingredient and pushes onto stack n Remove ingredient [from [nth] mixing bowl]. – same but does subtraction Combine ingredient [into [nth] mixing bowl].– same but multiplies Divide ingredient [into [nth] mixing bowl].– same but divides Add dry ingredients [to [nth] mixing bowl]. – adds all dry ingredients and pushes onto stack n Liquefy | Liquify ingredient. – converts from int to char Liquefy | Liquify contents of the [nth] mixing bowl. – same for top of stack n

Continued Stir [the [nth] mixing bowl] for number minutes. – rotates number of elements on stack n Mix [the [nth] mixing bowl] well. – randomizes order of items on stack n Clean [nth] mixing bowl. – removes all elements from stack n Pour contents of the [nth] mixing bowl into the [pth] baking dish. – copies all elements of stack n onto stack p Verb the ingredient. – this is followed by another statement and executes the next statement based on the numeric value stored in ingredient (a for loop), where the number of ingredient is decremented each time through Verb [the ingredient] until verbed. – ends the loop. The verb used is arbitrary. Serve with auxiliary-recipe. – this invokes the subroutine auxiliary recipe. Refrigerate [for number hours]. – exits the recipe or auxiliary recipe, printing out the number of baking dishes used in the recipe if the recipe contains a number of hours (cooking time)

Example: Compute Fibonacci
Fibonacci Numbers with Caramel Sauce. Ingredients. 100 g flour 250 g butter 1 egg Method. Sift the flour. Put flour into mixing bowl. Serve with caramel sauce. Stir for 2 minutes. Remove egg. Rub the flour until sifted. Stir for 2 minutes. Fold the butter into the mixing bowl. Pour contents of the mixing bowl into the baking dish. Serves 1.

Caramel Sauce. Ingredients
Caramel Sauce. Ingredients. 1 cup white sugar 1 cup brown sugar 1 vanilla bean Method. Fold white sugar into mixing bowl. Put white sugar into mixing bowl. Fold brown sugar into mixing bowl. Clean mixing bowl. Put white sugar into mixing bowl. Remove vanilla bean. Fold white sugar into mixing bowl. Melt white sugar. Put vanilla bean into mixing bowl. Refrigerate. Heat white sugar until melted. Put white sugar into mixing bowl. Remove vanilla bean. Fold white sugar into mixing bowl. Caramelise white sugar. Put vanilla bean into mixing bowl. Refrigerate. Cook white sugar until caramelised. Put white sugar into mixing bowl. Serve with caramel sauce. Fold brown sugar into mixing bowl. Put white sugar into mixing bowl. Add vanilla bean. Serve with caramel sauce. Add brown sugar. Continued

Shakespeare Like Chef but the instructions are coded as if you are writing a play with characters (variables) and scenes (subroutines) The reserved words in this case are based on whether a word is a verb or noun or adjective or a character in the play Characters are declared at the top of the play in a Dramatis Personae section each character represents its own stack The declaration is charactername, description (description is ignored) Characters enter into dialog with each other – the dialog manipulates one or more stacks through push, pop, topmost operations, conditions, and arithmetic operations

Continued Acts and scenes
Each program is broken into procedural units known as acts and scenes Each act and scene is given a roman numeral identifier, these are used as GOTO statement labels Act I: Hamlet’s last battle (the text after the : is a comment) Characters must explicitly enter and exit an act At most, only two characters can be on stage at a time The exeunt statement calls all listed characters to leave at the same time [Enter Juliet] [Enter Romeo and Juliet] Exeunt Romeo and Juliet] Scenes will consist of lines of dialog Lines are the commands and fall into three categories Control statements (see the next slide) I/O statements, which are prefaced with the expression “Open your heart” (input) or “Speak your mind” (output) Assignment statements (see the next slide)

Dialog/Instructions Numbers (literals) are represented using two combining schemes A noun is equal to 1, any adjective that precedes it doubles the value, so for instance, 3 adjectives and a noun is 8 You can combine numbers with such phrases as “the sum of … and …” or “the difference between … and …” “The difference between a small, tired, dirty pony and a big boy is nothing”: this represents 8 – 2 = 6 Assignment statements are dialog between one or two characters and the direction of the assignment (which character) is based on whether the dialog uses first person or second person The dialog “Remember me” means to push the latest value on to that character’s stack whereas “Recall …” means to pop the latest value from the stack

Control Statements There are two forms of control statements:
Go to statements specify particular scenes as is “Let us return to scene III” Selection statements are broken into a question (condition) and actions, possibly spoken by multiple characters Questions ask “is X as good as Y” or “is X better than Y” or “is X worse than Y” example: Am I as horrid as a flirt-gill? This compares the value of the current speaker (their stack’s top value) against a literal computed by “flirt-gill” The action may be a go to statement, assignment statement or input or output Notice that there is no loop, you must construct loops as you would in assembly language, by combining selection statements and go to statements

Example: Reversing an Input String

4DL Another stack-based language, but here, the operators manipulate either the top of stack, or locations of a 4-D array all operations are single ascii characters the instruction pointer (program counter) moves not sequentially but based on the direction that the instruction steers it (much like the change of directions available in Argh!) so the current instruction is at some location (i, j, k, l) in the 4-D array and the instruction might cause us to go to i++, i--, j++, j--, k++, k--, l++ or l-- Instructions are to push items adjacent to the current instruction pointer location (for instance, push i+ means take the character at (i+1, j, k, l) and push it onto the stack) add or subtract top two items of the stack pop off stack and if not zero, skip the next coordinate in the current direction skip the next character in the program change directions in 4-space (change the dimension being incremented or decremented, or change from incr to decr) input to stack, output from stack

Example Hello World program Shows control flow
P – push X+, p push X-, B – push Y+, b – push Y-, D – push Z+, d – push Z-, Q – push T+, q – push T-, X/x – change to X+ or X- direction (similarly for Y/y/Z/z/T/t), , - input to stack, ? – pop and if not zero then skip instr, % - end, 0 – push 0 to stack, . – pop and print

Unlambda A real BF language
the goal is to make a functional language without using lambda functions to define anything this means no variables and no parameters! Unlambda has no tape/array/stack (making it unlike other languages that are based on the Turing machine) local variables or integer processing control constructs (loops, selection statements) literally everything in Unlambda is a function call based on 7 primitive functions and the application operator (like Lisp’s eval) ` – apply function to function k – evaluate two functions returning the result of the first function s – apply first function to third function, second function to third function, and result of first function call to result of second function call i – return argument without evaluation `kFG = F ``sFGH = ``FH`GH .x – outputs x and returns x Other built-in functions are d, c, v, these are much harder to explain so we won’t go over them

Programming Unlambda The basic idea is to write your program as lambda functions And then use abstraction elimination to convert your lambda function into unlambda for instance, lambda# (x) F (where F is the code for your function) is rewritten as ``si`FF Loops are only available through tail recursion Numbers are represented in one of a couple of ways side effects generated by a function by using .* to represent 1 and then nested applications of this 1 is ``s`kski.* and 2 is ``s``s`kski.* and 3 is ``s``s`ksk``s``s`kski

Sample Unlambda Code Hello world program ```s``sii`ki
``s``s`ks ``s``s`ks``s`k`s`kr ``s`k`si``s`k`s`k `d````````````.H.e.l.l.o.,. .w.o.r.l.d.! k `k``s``s`ksk`k.* Print out Fibonacci sequence ```s``s``sii`ki `k.*``s``s`ks ``s`k`s`ks``s``s`ks``s`k`s`kr``s`k`sikk `k``s`ksk # Print integers consecutively (each integer n is printed as a line of n asterisks) ````s``s`ks``s`k`si``s`kk``s`k `s``s`ksk # Increment ``s`k ``s``s``si`k.*`kri # Print n (and return n) i`ki `ki # The number zero (replace by i to start from one) ``s``s`ks``s`k`si``s`kk``s`k # Ditto (other half-loop) `s``s`ksk ``s``s``si`k.*`kri

Whitespace Most languages (and compilers) ignore white space (blanks, tabs, return keys) but Whitespace is a language that uses only these keystrokes as meaningful elements Whitespace uses a stack and a heap for storage and has basic I/O and arithmetic operations, push and pop, pointers, labels for branches, conditional and unconditional branches, and subroutines definitely an obfuscated language arithmetic operations and the stack only operate on integers (currently) a program actually looks like empty space because it is in fact full of spaces, tabs and returns! programming requires fully commenting your code because you can’t actually see the code The author claims that Whitespace is the perfect language for spies since no one can actually see the code to make sense of it!

Whitespace Operations
White Space Parameter Meaning [Space] Number Push the number onto the stack [LF][Space] - Duplicate the top item on the stack [Tab][Space] Number Copy nth item on the stack to the top of the stack [LF][Tab] - Swap the top two items on the stack [LF][LF] - Discard the top item on the stack [Tab][LF] Number Slide n items off the stack, keeping the top item [Space][Space] - Addition [Space][Tab] - Subtraction [Space][LF] - Multiplication [Tab][Space] - Integer Division [Tab][Tab] - Modulo [Space] - Store to Heap [Tab] - Retrieve from Heap [Space][Space] Label Mark a location in the program [Space][Tab] Label Call a subroutine [Space][LF] Label Jump unconditionally to a label [Tab][Space] Label Jump to a label if the top of the stack is zero [Tab][Tab] Label Jump to a label if the top of the stack is negative [Tab][LF] - End subroutine, transfer control back to caller [LF][LF] - End the program [Space][Space] - Output the character at the top of the stack [Space][Tab] - Output the number at the top of the stack [Tab][Space] - Read character, place it in location given by the top of the stack [Tab][Tab] - Read number, place it in location given by the top of the stack Whitespace Operations

Whitespace Example [Space][Space][Space][Tab][LF] Put a 1 on the stack
[LF][Space][Space][Space][Tab][Space][Space] [Space][Space][Tab][Tab][LF] Set a Label at this point [Space][LF][Space] Duplicate the top stack item [Tab][LF][Space][Tab] Output the current value [Space][Space][Space][Tab][Space][Tab][Space][LF] Put 10 (newline) on the stack... [Tab][LF][Space][Space] and output the newline [Space][Space][Space][Tab][LF] Put a 1 on the stack [Tab][Space][Space][Space] Increments our current value. [Space][LF][Space] Duplicate that value so we can test it [Space][Space][Space][Tab][Space][Tab][Tab][LF] Push 11 onto the stack [Tab][Space][Space][Tab] Subtraction, if we reached the end, we have a zero on the stack [LF][Tab][Space][Space][Tab][Space][Space] [Space][Tab][Space][Tab][LF] If we have a zero, jump to the end [LF][Space][LF][Space][Tab][Space] [Space][Space][Space][Tab][Tab][LF] Jump to start [LF][Space][Space][Space][Tab][Space] [Space][Space][Tab][Space][Tab][LF] Set the end label [Space][LF][LF] Discard our accumulator, to be tidy [LF][LF][LF] Finish

Malbolge Designed in 1998 to be the hardest programming language ever!
based on Intercal and Brainf*ck instruction’s effects are based on where it is stored in memory mod 94 instructions are self-modifying both code and pointers are incremented by 1 after being accessed only control statement is an unconditional jump data are stored in trinary (0, 1, 2) rather than binary or decimal no load or store operation, instead memory must be pre-loaded The above Hello World program was the most complex Malbolge program ever written for years, but a version of the 99 Bottles of Beer program has been written it consists of 7773 characters and is about 200 lines long of meaningless characters (see if you are interested) Hello World Program: [the program is supposed to be on one line]

Download ppt "Other Languages We wrap up our examination of programming languages by briefly considering a wide variety we will look at some meaningfully important historic."

Similar presentations