Summary Concepten van programmeertalen

-
ISBN-10 9491465996 ISBN-13 9789491465994
772 Flashcards & Notes
17 Students
  • This summary

  • +380.000 other summaries

  • A unique study tool

  • A rehearsal system for this summary

  • Studycoaching with videos

Remember faster, study better. Scientifically proven.

This is the summary of the book "Concepten van programmeertalen". The author(s) of the book is/are M Witsiers Voglet Arnold van der Leer Maria Wienbröker Kampermann. The ISBN of the book is 9789491465994 or 9491465996. This summary is written by students who study efficient with the Study Tool of Study Smart With Chris.

PREMIUM summaries are quality controlled, selected summaries prepared for you to help you achieve your study goals faster!

Summary - Concepten van programmeertalen

  • 1 Waarden en typen

  • Geef een beschrijving van het begrip waarde
    Een waarde is elke entiteit die tijdens een berekening kan ontstaan
  • Geef een beschrijving van het begrip type
    Een type is een verzameling van waarden met bijbehorende operaties
  • Geef een beschrijving van het begrip statische typering
    Bij statische typering heeft elke variabele en daarmee elke expressie een vast type dat zonder het programma uit te voeren gecontroleerd kan worden (gedeclareerde type)
  • Geef een beschrijving van het begrip samengesteld type
    Een samengesteld type is een type waarvan de waarden samengesteld zijn, zoals bijvoorbeeld tuples, structures, records, arrays, algabraric types, discriminated records, objects, unions, strings, trees, ists, etc.
  • In welke 4 structureringsconcepten kunnen we samengestelde typen onderverdelen?
    - cartesisch product (tupels en records
    - mappings (arrays)
    - disjoint unions (algabraic types, discriminated records en objects)
    - recursive types(trees, lists)
  • Geef een beschrijving van het begrip dynamische typering
    Bij dynamische typering kan het type van de variabele gedurende de uitvoering van het programma veranderen (actuele type). Typecontrole vindt plaats tijdens de verwerking. Bijvoorbeeld in Javascript a="tekst", a=10.
  • Geef een beschrijving van het begrip standaard type
    De types die standaard in een programmeertaal aanwezig zijn
  • Geef en beschrijving van het begrip discreet type
    Bij een discreet primitief type hebben de waarden een 1 op 1 relatie met een bereik van integers
  • Geef een beschrijving van het cartesisch product
    SxT heeft als waardenverzameling tweetallen, met een eerste element van type S en een tweede element van type Y (aanwezig in Haskell in de vorm van tupels , in Java als klassetype)

    In de verzamelingenleer is het cartesisch product of de productverzameling van twee verzamelingen de verzameling van alle koppels of geordende paren (a,b) waarvan a uit de eerste en b uit de tweede verzameling komt. Het cartesisch product van twee verzamelingen A en B wordt genoteerd als  AxB.Voorbeeld A={1,2} en B={3,4,5}, dan is AxB={(1,3),(1,4),(1,5),(2,3),(2,4),(2,5)}
  • Geef een beschrijving van het begrip recursief type
    Een recursief type is een type die gedefinieerd wordt in termen van zichzelf
  • Geef een beschrijving van het begrip disjuncte vereniging
    S+T heeft als waardenverzameling de waarden van S en T, waarbij te onderscheiden is uit welk van de twee verzamelingen de waarden afkomstig is (aanwezig in Haskell als datatype, in Java aanwezig als interfacetype met voor ieder component van de vereniging een klasse die de interface implementeert.
  • Geef een beschrijving van het begrip cartesisch product
    <TODO>
  • Geef een beschrijving van het begrip functieruimte
    S->T heeft als waardenverzameling de funties van S naar T (in Haskell aanwezig als functies, in Java alleen aanwezig in de vorm van arrays)
  • Geef een beschrijving van het begrip  type-equivalentie
    Bij naamequivalentie zijn 2 tpen gelijk als ze dezelfde naam hebben. Bij structuurequivalentie zijn 2 typen gelijk als ze dezelfde structuur(verzameling waarden) hebben. Java maakt gebruik van naamequivalentie.
  • Geef een beschrijving van het begrip type-equivalentie
    <TODO>
  • Geef een beschrijving van het begrip structurele equivalentie
    Bij structuurequivalentie zijn 2 typen gelijk als ze dezelfde structuur(verzameling waarden) hebben
  • Geef een beschrijving van het begrip  naamequivalentie
    Bij naamequivalentie zijn 2 typen gelijk als ze dezelfde naam hebben.
  • Geef een beschrijving van het begrip constructie

    Een constructie is een expressie die een composite waarde van zijn component waarden construeert. Bijvoorbeeld het volgende Java object constructie:
    new Date(today.m, size(today.m)).
    Een Java constructie is een call naar een operatie, die constructor genoemd wordt. het effect van een constructor aanroep is om een nieuw object aan te maken van een bepaalde klasse, de constructor zelf wordt gedefinieerd als deel van de klasse zelf.
  • Geef een beschrijving van het begrip functieaanroep
    Een functieaanroep berekent een resultaat door een functieprocedure toe te passen op 1 of meer argumenten
  • Geef een beschrijving van het begrip conditionele expressie
    Een conditionele expressie berekent een waarde die afhangt van een conditie. Het heeft 2 of meer subexpressie, waarbij er exact 1 uitgekozen wordt om geevalueert te worden
  • Geef van de verschillende soorten typen voorbeelden in de talen Jave en Haskell
    Haskell 
    -  primitieve typen -> Int, Integer, Float, Double, Char
    - andere typen -> Bool, Rational
    samengestelde waarden: lijsten, tupels, dataconstructies
    - Haskell kent geen deelintervaltype
    - Een opsommingstype (enumeration type) is in Haskell geen primitief type, maar kan wel gecreerd worden met behulp van constructiefuncties zonder parameter

    Java
    -  primitieve type -> byte, short, int, long, char, float, double en boolean
    - samengestelde waarden (arrays, objecten) 
    - Java kent geen deelintervaltype, maar kan wel worden gecreerd met behulp van een klasse van type enum
  • Noem de 4 structureringsconcepten met behulp waarvan we samengestelde typen kunnen karakteriseren en herken de verschillende samengestelde typen uit Java en Haskell
    1. cartesische producten: bijvoorbeeld een set van ale paren van (x,y), SxT={(x,y)|xeS,yeT}. Bijvoorbeeld S={u,v} en T={a,b,c} dan is SxT={(u,a),(u,b),(u,c),(v,a),(v,b),(v,c)}. De kardinaliteit is 2x3=6
    2. mappings: S->T staat voor alle mappings van S naar T. De kardinaliteit van S->T is #(S->T)=(#T)^(#S)
    3. disjoint unions: Hierbij wordt een waarde gekozen van 1 of meerdere (meestal verschillende) sets. S+T. #(S+T)=#S+#T
    4. recursieve typen: Is een type die gedefinieerd wordt in termen van zichzelf. 2 Gebruikelijke recurcieve typen zijn lists (een sequence van waarden) en strings (een sequence van karaketers).
  • Geef de formules waarmee de verschillende kardinaliteiten van de verschillende samengestelde typen kunnen worden berekend en pas deze toe

    Cartesisch product: S x T: 
    - Cardinaliteit: #(S x T) = #S x #T 

    Disjuncte vereniging: S + T
    Cardinaliteit: #(S + T) = #S + #T

    Functieruimte: S -> T
    Cardinaliteit: #(S -> T) = #T^#S
  • Geef de manieren waarop in verschillende talen strings zijn gedefinieerd en geef aan welke consequenties een dergelijke keuze heeft voor de manier waarop we operaties op strings aan de taal kunnen toevoegen
    1. Strings als primitieve waarde classificeren: ML gebruikt deze manier. De basis string operatie moet dan ingebouwd zijn; ze kunnen dan niet gedefinieerd worden in de taal zelf
    2. Strings behandelen als een array van karakters: ADA gebruikt deze manier. Hierdoor zijn alle gebruikelijke operaties die gelden voor een array ook toe te passen op strings. Consequentie is dat een sring hierdoor een fixed lenght krijgt
    3. Strings als pointers naar arrays van karakters behandelen: C en C++ gebruiken deze manier
    4. Strings als lijst van karakters behandelen: Haskell en Prolog gebruiken deze manier. Hierdoor komen alle gebruikeleijke list operaties ook toegankleijk voor strings
    5. Strings als objecten te behandelen: Wordt in een objectgeorienteerde taal gebruikt, bijv, Java. Op deze manier kun je strings gebruiken met methoden die alle benodigde operaties heeften niet het nadeel van het behandelen van strings als speciale cases van list of arrays.
  • Leg het verschil uit tussen statisch en dynamisch getypeerde programmeertalen en geef enkele relevante voorbeelden van beide klassen van talen en geef de voor en nadelen van beide benaderingen
    Statisch getypeerd
    - Elke variabele expressie heeft een fixed type. hierdoor kunnen de types gecontroleerd worden gedurende compilatie. De meeste high-level talen zijn statisch getypeerd, bijvoorbeeld C++

    Dynamisch getypeerd
    - Waarden hebben een fixed type, maar variabelen en expressies hebben dit niet. Elke keer dat er een operand berekend wordt, kan het een waarde van een verschillend type zijn. Dus de operand meot gecontroleerd worden op type nadat ze berekend worden, maar voordat de operatie uitgevoerd wordt, dus tijdens run-time. Talen: Smalltalk, Lisp, Prolog, Perl en Python

    Voor en nadelen
    - Static typing is efficienter. Dynamische typing heeft veel run-time type checks nodig, die het programma vertraagd tijdens excecutie. Static typing heeft alleen compile-time checks nodig. Dynamic typing heeft het nodig dat alle waarden getagged worden en dit heeft strage space nodig. Static typing heeft dit niet nodig.
    - Static typing is veiliger. De compiler kan verifieren dat het programma geen type errors heeft. Dynamic typing heeft dit niet. Type errors zorgen voor veel programma fouten.
    - Dynamic typing is flexibeler, dat nodig is voor sommige applicaties, waarbij het type van data niet op voorhand bekend is.
  • Leg het verschil uit tussen structurele equivalentie en naamequivalentie en welk type wordt toegepast in de talen Java en Haskell
    Bij naamequivalentie zijn 2 typen equivalent als ze dezelfde naam hebben. Bij structurele equivalentie zijn 2 typen gelijk als ze dezelfde structuur (verzameling waarden) hebben. Java maakt gebruik van namequivalentie en Haskell maakt gebruik van structurele equivalentie
  • Formuleer het typevolledigheidsprincipe en geef in grote lijnen aan in hoeverre de talen Java en Haskell voldoen aan dit principe
    Het typevolledigheidsprincipe: wat met waarden van 1 type kan, moet - voor zover zinvol - ook met waarden van een ander type kunnen.
    Haskell voldoet aan het volledigheidsprincipe. Haskell kent 3 samengestelde typen: lijsten, tupels en datatypen. In alle gevallen is een constante definitie mogelijk.
    Een functie kan in Haskell argumenten en resultaat zijn van een functie
    Een tupel kan in Haskell zonder problemen een functie bevatten
    Lijst-componenten kunnen lijsten zijn, maar ook tupels of dataconstructies. De componenttypen van tupels moeten gelijk zijn: elk element van een lijst moet immers hetzelfde type hebben
    Java voldoet niet aan het volledigheidprincipe? TODO:klopt dit?>
    In Java kunnen constanten alleen van een primitief type of van het type String zijn: dit laatste is vreemd, want in Java is het type String een klassetype
    Een samengesteld type kan in Java niet worden meegegeven als argument aan een methodeaanroep
    Het resultaat van een methode kan in Java geen methode of samengsteld type zijn, wel een referentie naar een samengesteld type
    In Java kunnen methoden en variabele-referenties wel componeneten zijn van een bject, maar niet van een array
  • Welk onderscheidt zit er tussen de verschillende soorten expressies en welk verschil bestaat er tussen Java en Haskell met betrekking tot het gebruik van expressies
    Verschillende soorten expressies:
    - literal = een vaste waarde van een bepaald type, bijvoorbeeld 35, 3.88, false, "%"
    - constructions = een expressie ie een waarde maakt van zijn componentwaarden
    - functie aanroep = berekent een resultaat door een functie procedure (of methode) aan te roepen op 1 of meer argumenten
    - conditionele expressie  berekent een waarde die afhankelijk is van een conditie. Het heeft  1o f meer expressies waarbij precies 1 gekozen wordt die geevalueerd wordt (bijvoorbeeld if of case)
    - iteratieve expressie = een expressie die een berekening doet over een serie waarden )in Haskell wordt dit gedaan door list comprehension)
    - constante en variabele toegang = een constante access is een referentie naar een constante met naam en geeft de waarde van deze constante terug (in Java luiden de constant en variabele declaratie als volgt: final float pi=3.1416f;  float r;)
Read the full summary
This summary. +380.000 other summaries. A unique study tool. A rehearsal system for this summary. Studycoaching with videos.

Latest added flashcards

Statische typering
Mechanisme waarbij elke variabele of parameter een vast, door de programmeur gekozen type heeft en waarbij de typecontrole op grond van de programmatekst mogelijk is en al tijdens de vertaalfase plaatsvindt.
[T2.5.1]
Waarde
Elke entiteit die tijdens de uitvoering van een programma of berekening kan worden uitgerekend of opgeslagen, opgenomen kan worden in gegevensstructuur, meegegeven kan worden als parameter, resultaat is van een functieaanroep, enzovoort. Anders gezegd: elke entiteit die tijdens een berekening kan bestaan .
Ook: value
[T2.1]
Gegeven is de volgende monitor in (pseudo-)Java voor een begrensde buffer die gebruikmaakt van de conditievariabelen nonfull en nonempty en van synchronized-clausules.public class QueueMonitor {private class MessageBuffer {int size, front, rear; Message[] items; }public int capacity;private MessageBuffer buffer = new MessageBuffer();private Signal nonfull; private Signal nonempty;public QueueMonitor(int capacity) { // we don't use items[0] buffer.items = new Message[capacity + 1];this.capacity = capacity; nonfull = new Signal(); nonempty = new Signal(); } public synchronized void sendmessage(Message newitem) { while (buffer.size == capacity) // buffer full nonfull.sig_wait(); buffer.size = buffer.size + 1; buffer.rear = buffer.rear % capacity + 1; buffer.items[buffer.rear] = newitem; nonempty.sig_signal();}public synchronized Message receivemessage() { while (buffer.size == 0) // buffer empty nonempty.sig_wait();buffer.size = buffer.size - 1;Message olditem = buffer.items[buffer.front]; buffer.front = buffer.front % capacity + 1; nonfull.sig_signal(); return olditem; } { // initialisation of buffer buffer.size = 0; buffer.front = 1; buffer.rear = 0; } }a Waarmee is communicatie geïmplementeerd in QueueMonitor?b Waarmee is wederzijdse uitsluiting geïmplementeerd in QueueMonitor?
a Communicatie is geïmplementeerd met de conditievariabelen nonfull en nonempty.
b Wederzijdse uitsluiting is geïmplementeerd met de synchronizedclausules.
Gegeven zijn de volgende klassen Queue en Box in Java:public class Queue {private char[] elems;private int length, front, rear;public Queue(int capacity) {  elems = new char[capacity];}public void add(char newelem) { // add element to the rear of the queue ... }public int remove() { // remove and return the front element of this queue ... }{ length = 0; front = 0; rear = 0; }}public class Box {private T object;public void save(T object) { this.object = object; }public T getObject() { return object; }public String toString() { return "Box: " + object; }}a In de twee klassen wordt parametrisatie toegepast. Leg uit wat het verschil in parametrisatie is tussen de twee klassen.b Is er in de klasse Box sprake van een vorm van polymorfisme? Verklaar uw antwoord.
 a De klasse Queue is geparametriseerd met betrekking tot de waarde van de variabele capacity. Er is sprake van één klasse, ongeacht de waarde van capacity. De klasse Box is een generieke klasse die geparametriseerd is met betrekking tot het type object dat in een box wordt opgeslagen. Instanties van klasse Box kunnen voor verschillende waarden van de klasseparameter T worden geïnstantieerd.
b Nee, er is geen sprake van polymorfisme. Er kunnen, zoals in a al gezegd, verschillende instanties van type Box worden gemaakt, maar elke keer betreft het een instantie van een monomorf type, bijvoorbeeld Box, Box, enzovoort.
In deze opgave moet u het cartesisch product modelleren in Java en in Haskell en conclusies trekken ten aanzien van de uitbreidbaarheid daarvan in beide talen.Als voorbeeld nemen we personen die in eerste instantie een naam en een leeftijd als eigenschap hebben. Van personen willen we weten of ze meerderjarig (ouder dan 17 jaar) zijn.8a Implementeer in Java het cartesisch product voor de klasse Persoon en geef deze klasse een methode isMeerderjarig.8b Implementeer in Haskell het type Persoon en definieer een functie isMeerderjarig. Geef ook het type van de functie.8c Breid nu zowel in Java als in Haskell het cartesisch product uit door personen ook een adres als eigenschap te geven. Geef aan welke wijzigingen in beide talen moeten plaatsvinden.8d Welke conclusie kunt u uit 8c trekken?

8a Het cartesisch product modelleren we in Java met behulp van een klassetype met voor elke eigenschap een attribuut:
class Persoon {
String naam;
int leeftijd;
boolean isMeerderjarig() {
return leeftijd > 17;
}
}


8b Het cartesisch product modelleren we in Haskell met een typedefinitie voor een tweetupel:
type Persoon = (String, Int)
isMeerderjarig :: Persoon -> Bool
isMeerderjarig (_, leeftijd) | leeftijd > 17 = True
                                               | otherwise = False

8c Om in Java het cartesisch product uit te breiden is het voldoende om een attribuut adres van type String toe te voegen. De methode isMeerderjarig hoeft niet aangepast te worden.
Om in Haskell het cartesisch product uit te breiden moeten we het type Persoon veranderen in een drietupel waarin ook een string voor het adres is opgenomen. Daarnaast moet de definitie van de methode isMeerderjarig veranderd worden. Het patroon dat gebruikt wordt voor de parameter moet drie elementen bevatten in plaats van twee.

8d De conclusie is afhankelijk van de gegeven implementatie voor 8a, 8b en 8c. Belangrijk is dat uw conclusie overeenstemt met het voorgaande. In onze implementatie is uitbreiding makkelijker in Java omdat er slechts een attribuut toegevoegd moet worden. In Haskell moet ook de functie aangepast worden aan de wijziging.
Waarom zijn de meeste scripttalen dynamisch getypeerd?


Scripttalen worden gebruikt om subsystemen, die in verschillende talen zijn geprogrammeerd, met elkaar te laten werken. Als onderdeel daarvan moet allerlei data van verschillende typen verwerkt worden. Scripts kunnen sneller geschreven worden als het type van de variabelen en parameters niet van tevoren gedeclareerd hoeven te worden.
Is er bij Prolog sprake van veranderbare of onveranderbare variabelen?Motiveer kort uw antwoord.

Een variabele in Prolog is een onveranderbare variabele. De variabele, waarvan de
naam begint met een hoofdletter, staat voor een vaste maar onbekende waarde van
een willekeurig type.
We geven hier een voorbeeld uit het tekstboek waar de variabele P staat voor
venus, earth, mars, enzovoort:
?– planet(P).
Wat is het essentiële kenmerk van het logische programmeerparadigma?

Logisch programmeren is gebaseerd op de gedachte dat we programma’s kunnen
ontwerpen door beweringen over een probleem te noteren in logische formules.
Vervolgens zijn die formules zodanig te interpreteren, dat de oplossing voor het
beschreven probleem automatisch kan worden afgeleid.
Alternatief antwoord: Een logisch programma bestaat uit een specificatie van
relaties waarvan bepaald kan worden voor welke waarden van de parameters deze
geldig zijn.
Gegeven is het volgende programmafragment in Java:private int x = 0;public void verhoogX() {for (int i = 0; i < 10000000; i++) {x = x + 1;}}Leg uit waarom in het geval van parallel programmeren er sprake kan zijnvan een race condition bij de uitvoering van de gegeven code.Aanwijzing: Schets voor de uitleg een scenario met daarin twee threads.Verander de Java-code zo dat de race condition opgeheven is.

In de for-lus gebeurt het ophogen van de waarde van x in drie stappen: eerst wordt
de waarde van x uit het geheugen gelezen, dan wordt de waarde verhoogd en
tenslotte wordt de verhoogde waarde teruggeplaatst in het geheugen.
Stel, twee threads voeren de for-lus tegelijk uit. Het volgende scenario is mogelijk:
Thread 1: leest x, waarde x in het geheugen is 7
Thread 1: verhoogd x, waarde is nu 8
Thread 2: leest x, waarde x in het geheugen is 7
Thread 1: schrijft de waarde van x, waarde x in het geheugen is nu 8
Thread 2: verhoogd x, waarde is nu 8
Thread 2: schrijft de waarde van x, waarde x in het geheugen is nu 8.
Voeren de twee threads de for-lus achter elkaar uit, dan is de waarde van x na
afloop 9. Er is dus een verschil in uitkomst.
 Voor de methode verhoogX kunnen we een synchronized-clausule gebruiken:
private int x = 0;
public synchronized void verhoogX() {
for (int i = 0; i < 10000000; i++) {
x = x + 1;
}
}
NB Het is niet mogelijk om een synchronized-opdracht (blok-opdracht) te
gebruiken waarbij we op attribuut x synchroniseren. Het attribuut x is namelijk
geen object maar een primitief type.
Wat is een race condition.

Een race condition treedt op wanneer twee of meer processen of threads in staat
zijn om tegelijk een gemeenschappelijke variabele te veranderen waardoor het
resultaat onverwacht kan zijn.