Systematic Development of Programming Languages
description
Transcript of Systematic Development of Programming Languages
cs7100(Prasad) L1Intro 1
Systematic Development of Programming Languages
cs7100(Prasad) L1Intro 2
Orthogonal Parameters
Conceptual view (Model of Computation)» imperative, functional, relational,...
Level of abstraction (Model of Implementation)» problem domain
» ...
» machine
– Computational Task : I/O relation to be implemented
cs7100(Prasad) L1Intro 3
1. Customized Digital Computer
OjIj
Ik Ok
Task j
Task k
Rig different circuit for each task
cs7100(Prasad) L1Intro 4
von Neumann showed the existence of a Universal Machine (hardware) that can be customized using control inputs to carry out different tasks.
Software is the encoding of the task to control this machine.
2. Stored Program Computing
encoding(Tj)Ij Oj
cs7100(Prasad) L1Intro 5
Imperative Languages
Model of Computation» ALU + Memory + Input + Output
(von Neumann architecture) Levels of Abstraction (“Human Interface”)
– Machine Language » Binary Representation of the task
– Assembly Language» Symbolic Representation of the task
Assembly Language
Use symbols instead of binary digits to describe fields of instructions.
Every aspect of machine visible in program:– One statement per machine instruction.
– Register allocation, call stack, etc. must be managed explicitly.
No structure: everything looks the same.
10101100100000100000000000010101ADDI R4 R2 21
ADDI R4,R2,21
cs7100(Prasad) L1Intro 6
cs7100(Prasad) L1Intro 7
Pros and Cons of Assembly Language
Avoids Absolute Addressing» relocatable, reusable/shareable
Uses Symbolic Names» readable
Low-level programming wastes effort in coding a solution rather than solving a problem.
Difficult to build and maintain large programs.
cs7100(Prasad) L1Intro 8
High-level Language
Provides notation to describe problem solving strategies rather than organize data and instructions at machine-level.
Improves programmer productivity by supporting features to abstract/reuse code, and to improve reliability/robustness of programs.
Requires a compiler.
cs7100(Prasad) L1Intro 9
Levels of Abstraction
Problem Domain (stacks, tables)
Machine (char, int)
C++
(Class Hierarchies) Java/C#/Scala/Python/Scheme/Clojure
Ada
CPascal
Assembly Language
(ADTs) (arrays)
cs7100(Prasad) L1Intro 10
Evolution of Programming Languages
• FORTRAN ( FORmula TRANslator) Goals : Scientific Computations Efficiency of execution Compile-time storage determination Features : Symbolic Expressions Subprograms Absence of Recursion
• COBOL Goal: Business Application Features : Record/Structure; File Handling
cs7100(Prasad) L1Intro 11
Evolution of Programming Languages
• ALGOL - 60 (ALGOrithmic Language)
Goals : Communicating AlgorithmsFeatures : Block Structure (Top-down design) Recursion (Problem-solving strategy) BNF - Specification
• LISP (LISt Processing) Goals : Manipulating symbolic information Features : List Primitives Interpreters / Environment
cs7100(Prasad) L1Intro 12
Problems
Not rugged wrt typographical errorsDo 10 I = 1.20 I5 = I5 + 1
vs vs
Do 10 I = 1,20 I5 = IK + 1
– Remedy: Use spaces to delimit tokens,
Declare before use Unintended Coercion
I > J and false
– Remedy: Type checking
cs7100(Prasad) L1Intro 13
Evolution of Programming Languages
• Pascal Goal : Structured Programming, Type checking, Compiler writing. Features :
• Rich set of data types for efficient algorithm design
• E.g., Records, sets, ...• Variety of “readable” single-entry single-exit control structures
• E.g., for-loop, while-loop,...• Efficient Implementation
• Recursive descent parsing
cs7100(Prasad) L1Intro 14
Programming in the Large
Programs no longer monolithic. Developed by a team of programmers.
Code sharing and reuse very important. Correctness, reliability, and robustness
essential.– Data Abstraction / Encapsulation / Strong
Typing» Ada, CLU, Modula etc.
cs7100(Prasad) L1Intro 15
Other Languages Functional
» Common LISP, Scheme, Clojure» ML, Haskell
Logic » Prolog
Object-oriented» Smalltalk, SIMULA, Modula-3, Oberon» C++, Eiffel, Ada-95, Java, C#
Hybrid» Python, Ruby, Scala
Application specific languages and tools
cs7100(Prasad) L1Intro 16
Scripting vs Systems Programming Languages
Designed for gluing applications : flexibility
Interpreted Dynamic typing and
variable creation Data and code integrated :
meta-programming supported
Examples: PERL, Tcl, Python, Ruby, PHP, Scheme, Visual Basic, etc.
Designed for building applications : efficiency
Compiled Static typing and variable
declaration Data and code separated :
cannot create/run code on the fly
Examples: PL/1, Ada, Java, C, C++, C#, Scala, etc.
cs7100(Prasad) L1Intro 17
(cont’d)
Does application implement complex algorithms and data structures?
Does application process large data sets (>10,000 items)? Are application functions well-defined, fixed?If yes, consider a system programming language.
Is the main task to connect components, legacy apps? Does the application manipulate a variety of things? Does the application have a GUI? Are the application's functions evolving rapidly? Must the application be extensible? Does the application do a lot of string manipulation?If yes, consider a scripting language.
cs7100(Prasad) L1Intro 18
Jython (for convenient access to Java APIs)
I:\tkprasad\cs7100>jython
…
>>> import javax.swing as swing
>>> win = swing.JFrame("Welcome to Jython")
>>> win.size = (200, 200)
>>> win.show()
>>> ^Z
cs7100(Prasad) L1Intro 19
Java vs Jython
map = new HashMap();map.put("one",new Integer(1));map.put("two",new Integer(2));map.put("three",new Integer(3));
System.out.println(map.get("one"));
list = new LinkedList();list.add(new Integer(1));list.add(new Integer(2));list.add(new Integer(3));
map =
{"one":1,"two":2,"three":3}
print map ["one"]
list = [1, 2, 3]
cs7100(Prasad) L1Intro 20
(cont’d)
for i in list:
(* iterator *)
newList = [function(i) for i in oldList]
(* list comprehension *)
for (Iterator i; i.hasNext();) { i.next(); }
List newList = ArrayList()for (Iterator i; i.hasNext();) {
Object obj = i.next(); newList.add(function(obj))
}
cs7100(Prasad) L1Intro 21
Functional Programming in Jython
apply(lambda x,y : x*y, (10, 20))# 200map(lambda x,y: x + y, [[1,2],[“a”]], [[“3”],[“b”]])# [[1, 2, ‘3’], [‘a’, ‘b ’]]reduce(lambda x,y: x + y, [1,2,3], 100)# 106filter(lambda x: x > 0, range(10,-5,-3))# [10, 7 , 4, 1]
cs7100(Prasad) L1Intro 22
Meta-programming in Jython
Dynamic code evaluation
print eval (“[1,3] + range(6,10,3)”)
# [1, ,3, 6, 9]x = 2 + 3jexec “x = 5, x + x”#(5, (4+6j)
cs7100(Prasad) L1Intro 23
import java.lang as langimport javax.swing as swingimport java.awt as awt
names = ["Groucho", "Chico", "Harpo"]quotes = {"Groucho": "Say the secret word", "Chico": "Viaduct?",
"Harpo": "HONK!"}
def buttonPressed(event): field.text = quotes[event.source.text]
def exit(event): lang.System.exit(0) def createButton(name): return swing.JButton(name, preferredSize=(100,20),
actionPerformed=buttonPressed)
Java functionality through Jython
cs7100(Prasad) L1Intro 24
win = swing.JFrame("Welcome to Jython", size=(200, 200),windowClosing=exit)
win.contentPane.layout = awt.FlowLayout( )
field = swing.JTextField(preferredSize=(200,20))win.contentPane.add(field)
buttons = [createButton(each) for each in names]
for eachButton in buttons: win.contentPane.add(eachButton)
win.pack( )win.show( )
Current Trend Multiparadigm languages
– Functional constructs for programming in the small » Focus on conciseness and correctness
– Object-Oriented constructs for programming in the large
» Focus on programmer productivity, robustness and code evolution
Example languages
– Older: Python, Ruby
– Recent: Scala, F#
cs7100(Prasad) L1Intro 25
cs7100(Prasad) L1Intro 26
Scheme (dialect of LISP) Recursive definitions Symbolic computation : List Processing Higher-order functions Dynamic type checking Functional + Imperative features Automatic storage management
– Provides a uniform executable platform for studying, specifying, and comparing languages.
cs7100(Prasad) L1Intro 27
DrRacket (IDE for dialect of LISP)
http://docs.racket-lang.org/quick/
http://docs.racket-lang.org/teachpack/2htdp2htdp.html
http://picturingprograms.com/download/chap03.pdf
cs7100(Prasad) L1Intro 28
Standard ML and Scala
Strongly typed language– static type inference– SML supports polymorphic types
Supports Abstract Data Types and Modules Higher-order functions Pattern matching
– cf. Prolog, list-processing in Scheme
Java vs Scala//Java - what we're used to seeing
public String buildEpochKey(String... keys) {StringBuilder s = new StringBuilder("elem") for(String key:keys) { if(key != null) { s.append(".") s.append(key) } } return s.toString(). toLowerCase()}
cs7100(Prasad) L1Intro 29
Java vs Scala//Scala
def buildEpochKey(keys: String*): String = { ("elem" +: keys) . mkString(".") . toLowerCase}
println(buildEpochKey("aBcDeF"))
cs7100(Prasad) L1Intro 30