Top Banner
TDDA69 Data and Program Structure Introduction Cyrille Berger 2 / 73 Lecture content Course Introduction Introduction to the different Programming Paradigm The different programming paradigms Why different paradigms? Introduction to Functional Programming Expressions Functions Control Recursion Advantages and inconvenients of functional programming Course Introduction 4 Course goals Describe aspects of evaluation and execution in different language models Explain and demonstrate how design choices affect the expressiveness and efficacy of a programming language Analyze and value programming languages based on their evaluation and compilation strategies Implement programming languages in the form of an interpreter and a compiler
19

Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

Jul 15, 2020

Download

Documents

dariahiddleston
Welcome message from author
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
Page 1: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

TDDA69DataandProgramStructureIntroductionCyrilleBerger

2/73

LecturecontentCourseIntroductionIntroductiontothedifferentProgrammingParadigmThedifferentprogrammingparadigmsWhydifferentparadigms?IntroductiontoFunctionalProgrammingExpressionsFunctionsControlRecursionAdvantagesandinconvenientsoffunctionalprogramming

CourseIntroduction

4

CoursegoalsDescribeaspectsofevaluationandexecutionindifferentlanguagemodelsExplainanddemonstratehowdesignchoicesaffecttheexpressivenessandefficacyofaprogramminglanguageAnalyzeandvalueprogramminglanguagesbasedontheirevaluationandcompilationstrategiesImplementprogramminglanguagesintheformofaninterpreterandacompiler

Page 2: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

5

Whydoyouneedtoknowhowprogramareinterpreted?

ItwillhelpyouunderstandwhyprogramminglanguageworksacertainwayandwhatarethelimitsNewprogramminglanguagesandinterpretersareconstantlybeingdevelopedExistinginterpretersareconstantlybeingdevelopedtoimproveperformance,security,addnewfeatures...

6

ProgramminglanguagesGeneralpurposes:C,C++,Java,Python...Specialpurposes:Prolog,Matlab,R,Agent0...Scripting:JavaScript,VBA...Historical:Fortran,Lisp...

7

Evolutionofprogramminglanguages

8

Howisaprograminterpreted?Sourcecode Parser

Parser

AbstractSyntaxTree Treevisitor

Generator Sourcecode ...

Bytecode VirtualMachine

Assembler Assembly OperatingSystem CPU

Page 3: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

9

Facebook'sworkonthePHPintepreter

FacebookstartedwithPHPin2004Backatthetime,PHPwasthegoldstandardforwebsiteprogrammingandprototypingButthisiscausingproblemsandforpracticalreasonstheycannotchangeprogramminglanguage

10

WhydidFacebookneedtodeveloptheirownPHPinterpreter?

www.govote.at493985start

11

WhatdidFacebookdo?ThestandardPHPinterpreterisusingavirtualmachine(Zend)TheydevelopedatooltoconvertPHPtoC++ThentheydevelopedanewinterpreterthatdoJust-In-Time(JIT)compilation,calledHHVMTheyintroducedHack,avariantofPHPwithatypingsystem

12

Andotherexamples...GooglewithJava,Dalvik,PythonwithCPythonvsQt'sJavaScript,switchingfromASTInterpretationtoJITandtoamixofJITandASTInterpretation...

Page 4: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

13

Listoflectures1IntroductionandFunctionalProgramming2ImperativeProgrammingandDataStructures3Parsing4Evaluation5ObjectOrientedProgrammingandtypessystem6Macrosand7VirtualMachinesandBytecode8GarbageCollectionandNativeCode9ConcurrentComputing10DeclarativeProgramming11Logic12Summary

14

Book(s)StructureandInterpretationofComputerProgramsinPythonbyHalAbelson,JerrySussman,JulieSussmanandJohnDeneroStructureandInterpretationofComputerProgramsbyHalAbelson,JerrySussmanandJulieSussman

15

Listoflabs1FunctionalProgramming2Supportingclassforaninterpreter3ECMAScriptInterpreter4Macros5Bytecode6Garbagecollector7SQpy

16

Divisionoftime24hlectures(in12sessions)40hlabs(in20sessions)8htutorials(in488hhomework

Page 5: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

17

Lastyearevaluationandimprovments

Toomuchboilerplatting,LabsandlecturesarenotwellconnectedTwonewlabsQuizzesarenicebutteacherwaitfortoolongIntroduceatimeoutTeacherisshy,slidesaremostlyusedbytheteachertoknowwhattosayIntroducemoreinterractivityTheexamisworthmorethantwocredits

IntroductiontothedifferentProgrammingParadigm

Thedifferentprogrammingparadigms

20

Page 6: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

21

ProgrammingParadigm(2/2)declarative

functional

Imperative

Object-Oriented

LogicSymbolic

22

DeclarativeExpresseslogicofcomputationwithoutcontrolflow:Whatshouldbecomputedandnothowitshouldbecomputed.Examples:XML/HTML,antlr4/yacc/regularexpressions,make/ants,SQL,...

23

Declarative-Examples<b>Helloworld!</b>SELECTnameFROMstudentWHEREcourseeq'TDDA69'grammarHello;r:'hello'ID;ID:[a-z]+;WS:[''\t\r\n]+->skip;

24

FunctionalComputationaretreatedasmathematicalfunctionwithoutchanginganyinternalstateExamples:Lisp,Scheme,

Page 7: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

25

Functional-Examples(print"HelloWorld")(take25(squares-of->(1491625364964...576625)

26

ImperativeExpresshowcomputationareexecutedDescribescomputationintermofstatementsthatchangetheinternalstateExamples:C/C++,Pascal,Java,Python,JavaScript...

27

Imperative-Examplesfor(vari=1;i<26;++i){varsq=i*i;console.log(sq)}#include<stdio.h>intmain(){charch;printf("Enteracharacter\n");scanf("%c",&ch);if(ch=='a'||ch=='A'||ch=='e'||ch=='E'||ch=='i'||ch=='I'||ch=='o'||ch=='O'||ch=='u'||ch=='U')printf("%cisavowel.\n",ch);elseprintf("%cisnotavowel.\n",ch);return0;}

28

Object-OrientedBasedontheconceptofobjects,whicharedatastructurescontainingfieldsandmethodsProgramsaredesignedbymakingobjectsinteractwitheachothersExamples:C++,Java,C#,Python,Ruby,JavaScript...

Page 8: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

29

Object-Oriented-Programming#include<iostream>classCharacter:publicSymbol{public:Character(char_c):m_c(_c){}boolisVowel()const{returnch=='a'||ch=='A'||ch=='e'||ch=='E'||ch=='i'||ch=='I'||ch=='o'||ch=='O'||ch=='u'||ch=='U';}private:charm_c;};intmain(){charc;std::cout<<"Enteracharacter:\n";std::cin>>c;Characterch(c);if(ch.isVowel()){std::cout<<c<<"isavowel.\n";}else{std::cout<<c<<"isnotavowel.\n";}}

30

OthersparadigmlanguagesLogicBasedonFormallogic:expressingfactsandrulesSymbolicAprogramcanmanipulateitsownformulasandcomponentsasiftheyaredataExample:prolog

31

Logicprogramminglikes(mary,food).likes(mary,wine).likes(john,wine).likes(john,mary).|?-likes(mary,food).yes.|?-likes(john,wine).yes.|?-likes(john,food).no.

32

Symbolicprogrammingd(X,X,1):-!./*d(X)w.r.t.Xis1*/d(C,X,0):-atomic(C)./*IfCisaconstant*//*thend(C)/dXis0*/d(U+V,X,R):-/*d(U+V)/dX=A+Bwhere*/d(U,X,A),/*A=d(U)/dXand*/d(V,X,B),R=A+B....d(sin(W),X,Z*cos(W)):-/*d(sin(W))/dX=Z*cos(W)*/d(W,X,Z)./*whereZ=d(W)/dX*/d(exp(W),X,Z*exp(W)):-/*d(exp(W))/dX=Z*exp(W)*/d(W,X,Z)./*whereZ=d(W)/dX*/...?-d(cos(2*X+1),X,what=2*sin(2*X

Page 9: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

Whydifferentparadigms?

34

Canyoudoeverythinginimperativeprogramming?

www.govote.at394839start

35

Isthereaparadigmtorulethemall?

IntheoryyoucanprogrameverythinginC/C++andimperativeprogramming,orfunctionalprogramming...ButisthatAndisthat

36

FunctionalvsImperativeDoubleallthenumbersinanarrayvarnumbers=Imperative:vardoubled=[]for(vari=0;i<numbers.length;i++){varnewNumber=numbers[i]*2doubled.push(newNumber)}Functional:vardoubled=numbers.map(function(n){returnn*2})

Page 10: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

37

DeclarativevsImperativeSelectallthedogsthatbelongstoaspecificDeclarative:SELECT*fromdogsINNERJOINownersWHEREdogs.owner_id=owners.idImperative:vardogsWithOwners=[]vardog,ownerfor(vardogindogs){for(varownerinowners){if(owner&&dog.owner_id==owner.id){dogsWithOwners.push({dog:dog,owner:owner})}}}

38

FunctionalvsImperativeImperativelanguage(C/C++,Java...)BasicconstructsareimperativestatementsChangeexistingvalues,statesx=x+y=while(x>0)...FunctionalBasicconstructsaredeclarativeDeclarenewvaluesfunctionf(x){returnx+1;ComputationsareprimarilydonebyevaluatingexpressionsPureifallconstructsaredeclarative

IntroductiontoFunctionalProgramming Expressions

Page 11: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

41

Expressions(1/2)Primitiveexpressionstocapturethesimplestelementswewanttodescribenumbers,arithmeticexpressions...2 plus 'hello'

number operator stringCallexpressions:max ( 2 , 3 )

operator operand operand42

Expressions(2/2)Meansofcombiningsimpleelementsintocoumpoundonesmax(min(pow(3,5),-4),min(1,-2)*2)+6

43

NamesMeansofabstractingelementsbynamingandmanipulatingthem2 plus 'hello'

namea plus b

name name namemax ( 2 , 3 )name

44

AssignmentBindsnamestoa := 2

Nowahasthevalue2a plus 2

evaluatesto4

Page 12: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

Functions

46

Whatisafunction?Assignmentisasimplemeansofabstraction:bindsnamestovaluesFunctiondefinitionisamorepowerfulmeansofabstraction:bindsnamestoexpressions

47

FunctiondefinitionAfunctiondefinitioncontains:AsignaturewhichdefineshowmanyargumentsafunctiontakesAbodywhichdefinesthecomputationperformedwhenthefunctioniscalledfunction <name> ( parameterslist )

return <returnexpression> ;

48

Pureandnon-purefunctionPurefunctions:justreturnvalues:Math.abs(-2)->Math.pow(2,100)->1267650600228229401496703205376Non-purefunctions:havesideeffects:print(-2)->Butprint'-2'intheAsideeffectisnotavalue,itisanythingthathappensasaconsequenceofcallinga

Page 13: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

49

Whatisalambda?www.govote.at956729start

50

ClosureandlambdaAlambdaisafunctionwithnonamevardoubled=numbers.map(function(n){returnn*2})AclosureisafunctionwithcapturedvariablesThisseemsimple,butthisisactuallyratherpowerful!functioncreate_function_multiplication(number){returnfunction(x){returnx*number;}}vardoubled=numbers.map(create_function_multiplication(2))

51

ClosureinPythonPythonhaslimitedsupportforlamdas:singlestatement:numbers.map(lambdav:v*2)Butsupportnestedfunctions(andclosure):defcreate_function_multiplication(number):deffunction_multiplication(x):returnx*numberreturnfunction_multiplicationdoubled=numbers.map(create_function_multiplication(2))

Control

Page 14: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

53

Controlflow(1/2)Inimperativeprogramming,acontrolflowstatementexecutionresultinachoicebetweentwopathsExemple:if,while...Infunctionalprogramming,itisdoneusingaspecialfunction.Forinstance,inLisp:(COND(condition1result1)(condition2result2)...(TresultN))

54

Controlflow(2/2)Thefunctionalwayinimperativelanguages:InJavaScript,C++,Java,Ruby...:condition?result1:result2;InPython:conditionifresult1elseresult2

55

Whataboutloops?LoopconstructsisimperativeHowwouldyouimplementtheequivalentofaloopinfunctional?functionfactorial(n){varr=1;for(vari=2;i<=n;++i){r*=i;}returnr;}

Recursion

Page 15: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

57

Whatisrecursion?Afunctioniscalledrecursiveifthebodyofthatfunctioncallsitself,eitherdirectlyorindirectly.

58

Factorial:theclassicalexample(1/2)

Factorialinfactorial::Integral->Integralfactorial0=1factorialn=n*factorial(n-1)FactorialinCommonLISP:(define(factorialn)(cond((=n0)1)(t(*n(factorial(-n1))))))

59

Factorial:theclassicalexample(1/2)

Withaloop:functionfactorial(n){varr=1;for(vari=2;i<=n;++i){r*=i;}returnr;}Witharecursivefunctionfactorial(n){return(n===0)?1:n*factorial(n-1)}

60

Recursionvsloopswhile(expression){do_something();}functionloop_something(args...){if(expression)return;else{do_something();loop_something(args...);}}(define(loop_somethingargs...)(cond(expression)value)(t(do_something)(loop_somethingargs...))

Page 16: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

61

Whentouserecursionratherthaniteration?(1/4)

deffactorial(n):if(n==0):return1else:returnn*factorial(n-1)Letstry:factorial(10)factorial(1000)

62

Whentouserecursionratherthaniteration?(2/4)

Inmostprogramminglanguage,thenumberoffunctioncallislimitedbythesizeofthestacksys.getrecursionlimit()sys.setrecursionlimit(1003)factorial(1000)Tail-calloptimisation

63

Whentouserecursionratherthaniteration?(3/4)

Callingafunctionisusuallymoreexpensivethanaloopdeffactorial2(n):r=1foriinrange(1,n+1):r=r*ireturnrtimeit.timeit("factorial(30)","from__main__importfactorial")timeit.timeit("factorial2(30)","from__main__importfactorial2")

64

Whentouserecursionratherthaniteration?(4/4)

ItisamatterofRecursionisabitmoregeneralthanloopsWhenwalkingthroughatree

Page 17: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

Advantagesandinconvenientsoffunctionalprogramming

66

Noside-effectspurefunctionalInpurefunctional,callingafunctiononlyreturnavalueTheimplicationisthatcallingafunctionwiththesameargumentswillalwaysreturnthesamevalueIsthewithdrawfunctionpure(definebalance100)(define(withdrawamount)(if(>=balanceamount)(begin(set!balance(-balanceamount))balance)"Insufficientfunds"))www.govote.atentercode5445start

67

VerificationandprovingToproveaprogramcorrect,wemustconsidereverythingaprogramdependsonInpurefunctionalprograms,dependenceonanydatastructureisexplicit

68

Provingpropertiesinfunctionalprogramming

(define(powerbn)(cond((=n0)1)(t(*(powerb(-n1))))))Claim:foranyintegern≥0andanynumberb,(powerbn)=bⁿProof:1)Verifythebasecase:(powerb2)Assumethat(powerb(-n1))iscorrect3)Verifythat(powerbn)iscorrectassumingthat(powerb(-n1))iscorrect

Page 18: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

69

Provingpropertiesinimperativeprogramming

functionpower(b,n){intresult=1;for(inti=0;i<n;++i){result*=b;}returnresult;}Devisealoopinvariant:(n≥i)⋀(result=bⁱ)ProvethatitistrueforthefirstloopiterationProvethateachloopiterationpreservesitAssumethat(n≥i)⋀(result=bⁱ)Provethat(n≥j)⋀(result=bʲ)withj=i+

70

ConcurencyConcurencyisoneofthecurrenthottopicinprogrammingThemainchallengeisdata-raceImperativeprogramsareverysensibletodata-racebecauseofstatesThereisnodata-raceinpurefunctionallanguagesalldataisimmutableallfunctionsarepure,withoutside-effects

71

Summaryontheupsideoffunctionalprogramming

Themainadvantageisnoside-effectsVerificationandprovingConcurencyProductivity?Ericssonclaimsanincreaseinproductivitybetween9and25timeswhenusingtheirhome-grownversionofErlang

72

Thedownsideoffunctionalprogramming

Inpractice,thereisverylimitedneedforprovingaprogramMostlyincriticalapplications:rocketcontrol,hospital...Andhowdoyouprovehardware?Performanceissues(rememberfunctioncallareexpensive)VerylimitedsupportMostprogrammingtasksrequirestates

Page 19: Lecture content - IDATDDA69/lectures/2016/01_introduction.pdf · Closure in Python Python has limited support for lamdas: single statement: numbers.map(lambda v: v * 2) But support

73

MyKeymessageaboutprogrammingparadigms

Bepragmatic,thereisnooneanswer!