Other languages
This presentation is the property of its rightful owner.
Sponsored Links
1 / 52

Other Languages PowerPoint PPT Presentation


  • 81 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

Other Languages

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Other languages

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


Other languages

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 Operations

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)=100000.

WRITE(6,30) (Y(I),I=1,N)

30 FORMAT(E15.2)

END

  • 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".

APL Array

sorting program

FORTRAN

Array sorting

program


Sample apl

Sample APL

  • A  15 23 8 19 21 6

    • This creates an array, A with the values as specified

  • B  2 4 r 1 2 3 4 5 6 7 8

    • 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

    • rB 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 http://www.users.cloud9.net/~bradmcc/APL.html

for an explanation (halfway down this page)


Other languages

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

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

}

BCPL Examples

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

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: 5 4 + .

        • 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

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

      • year @ .

    • 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

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

  • 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

Sample SNOBOL Program

&TRIM =1

WORDPAT = BREAK(&LCASE &UCASE) SPAN(&LCASE &UCASE "'-") .

WORD

COUNT = ARRAY('3:9',0)

READLINE = INPUT :F(DONE)

NEXTWLINE WORDPAT = :F(READ)

COUNT<SIZE(WORD)> = COUNT<SIZE(WORD)>+ 1 :(NEXTW)

DONEOUTPUT= "WORD LENGTH NUMBER OF OCCURRENCES"

I = 2

PRINTI = 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


Other languages

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


Jcl examples

//SQADB512 DD DSN=SIMOTIME.DATA.SQADB512,DISP=(NEW,CATLG,DELETE),

// 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

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

Some Examples

In[2]:= FindRoot[Exp[x] == x^2 + 2, {x, -1}]

Out[2]= {x -> 1.3190736768573652}

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

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. 1 + N: N = N + 1

$ End Program


Groovy

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


Other languages

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

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

end

end


Metatables

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 lenmetatable 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


Other languages

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

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

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

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

False Instructions

  • Built-in stack operations include $ to duplicate top of stack, % to delete top of stack, \ to swap top two of stack, @ 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

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

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 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 4 + 3 and output the result:

,>++++++[<-------->-],,[<+>-],<.>.


Other languages

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

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

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

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 n>@ (@>t) (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 n>@ (@>t) (t>s) s<" bottle" n-1 n>a? (a "s">s 0>a?) s<" of beer"

# output 1 line of this verse to stack s

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

n+0 n>@ (@>t) (t>s) s<" bottle" n-1 n>a? (a "s">s 0>a?) s<" of beer on the wall" 10>s

# 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

More Kipple Examples

# Prints the 25 first Fibonacci numbers

24>n

0>t

1>a

# push fibonacci numbers onto stack t

(n-1

a+0

t<a>b+a

c<b>a<c

n?

)

# output numbers:

(t>@

(@>o)

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)


Other languages

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

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

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 throughVerb [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

Example: Compute Fibonacci

Fibonacci Numbers with Caramel Sauce.Ingredients.100 g flour250 g butter1 eggMethod.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.


Continued1

Caramel Sauce.Ingredients.1 cup white sugar1 cup brown sugar1 vanilla beanMethod.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

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


Continued2

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

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 statements1

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

Example: Reversing an Input String

Othello, a stacky man.

Lady Macbeth, who pushes him around till he pops.

Act I: The one and only.

Scene I: In the beginning, there was nothing.

[Enter Othello and Lady Macbeth]

Othello: You are nothing!

Scene II: Pushing to the very end.

Lady Macbeth: Open your mind! Remember yourself.

Othello: You are as hard as the sum of yourself and a stone wall.

Am I as horrid as a flirt-gill?

Lady Macbeth: If not, let us return to scene II. Recall your imminent death!

Othello: You are as small as the difference between yourself and a hair!

Scene III: Once you pop, you can't stop!

Lady Macbeth: Recall your unhappy childhood. Speak your mind!

Othello: You are as vile as the sum of yourself and a toad! Are you better than nothing?

Lady Macbeth: If so, let us return to scene III.

Scene IV: The end.

[Exeunt]


Other languages

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

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

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

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

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

`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`k

``s``s``si`k.*`kri

i`ki


Whitespace

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

WhitespaceOperations

White SpaceParameterMeaning

[Space]NumberPush the number onto the stack

[LF][Space]-Duplicate the top item on the stack

[Tab][Space]NumberCopy 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]NumberSlide 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]LabelMark a location in the program

[Space][Tab]LabelCall a subroutine

[Space][LF]LabelJump unconditionally to a label

[Tab][Space]LabelJump to a label if the top of the stack is zero

[Tab][Tab]LabelJump 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 example

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

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 http://www.99-bottles-of-beer.net/language-malbolge-375.html if you are interested)

Hello World Program:

(=<`$9]7<5YXz7wT.3,+O/o'K%$H"[email protected]=`{^Lx8%$Xmrkpohm-kNi;gsedcba`_^]

\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543s+O<oLm

[the program is supposed to be on one line]


  • Login