Essay
Concepten van programmeertalen
- Course
- Institution
Verslag voor het vak Concepten van Programmeertalen. De taal Go is gekozen. Dient als voorbeeld voor het eigen verslag.
[Show more]
4 reviews
By: dannyvantol • 3 year ago
By: moutalib • 4 year ago
By: tcaspers • 4 year ago
By: rorygroen • 7 year ago
Seller
Followantonsteenvoorden
Reviews received
Content preview
CONCEPTEN VAN GOAnton Steenvoorden (s1087187) – Informatica Hogeschool Leiden
Versie 1.0 – 23 Januari 2016
,Hogeschool Leiden ICP – Januari 2017 – Versie 1.0 – s1087187 – Anton Steenvoorden
Samenvatting
Go(golang) is een vrij nieuwe taal geschreven door programmeurs van Google (Rob Pike,
Ken Thompson en Robert Griesemer). Go is een gecompileerde statically typed (met
type inference) taal met garbage collection. Als je een variabele van type wilt wisselen
moet je dit, indien mogelijk, parsen.
In Go maak je gebruik van Structs om eigen typen te ontwerpen. Go maakt vooral
gebruik van interfaces als het gaat om polymorphisme en om gedragspatronen te
maken.
In Go geef je eerst de naam van de variabele aan en vervolgens het type. Je kunt ook
meerdere return waarden (en return types) hebben. Sommige concepten uit andere
talen zijn standaard niet opgenomen in Go, maar kun je wel zelf bouwen zoals
bijvoorbeeld functioneel programmeren.
Go maakt voor concurrency gebruik van een aangepaste versie van de “coroutine” die zij
uiteraard: “Goroutines” noemen. Wanneer verschillende goroutines de aandacht van de
processor krijgt wordt door de compiler bepaald in plaats van door het OS. Voor
message-passing wordt er gebruik gemaakt van zogenaamde channels. Met behulp van
deze channels kun je ook concepten zoals semaphores en monitors bouwen.
In Go kun je ook specificeren of je gebruik wilt maken van pointers, references of een
kopie wilt maken. Het is niet mogelijk om standaard operatoren te overloaden.
Go maakt gebruik van short-circuit evaluation. Subprogramma’s kun je ook meegeven
als parameter aan andere subprogramma’s. Ook het concept closures wordt
ondersteund in Go. Om abstractie te ondersteunen kun je ook op een bepaalde manier
gebruik maken van overerving, maar dit is niet de conventionele manier. Je nest als het
ware de parent in de child.
Error Handling in Go werkt ook anders dan gebruikelijk, vaak returnt een functie die
mogelijk een error tegenkomt meerdere waarden, als de error dan gevuld is is het
blijkbaar mis gegaan. Er is wel een andere manier om een exception op te roepen en dit
af te handelen, panic en recover.
In Go kun je nagenoeg alle ideeen van object georienteerd programmeren uitoefenen.
Er is de mogelijkheid om functioneel programmeren uit te oefenen (als je zelf een hoop
van de first class functies schrijft). Het is niet mogelijk om logisch te programmeren in
Go.
Go heeft een goede dependency management waarbij je direct kunt importeren van
versiebeheersystemen zoals Github.
De mascotte van Go is de Go Gopher, een cartoon editie van de Noord-Amerikaanse
grond eekhoorn.
1
,Hogeschool Leiden ICP – Januari 2017 – Versie 1.0 – s1087187 – Anton Steenvoorden
Inleiding
Voor het vak “Concepten van programmeertalen” heb ik de opdracht gekregen om een
nieuwe taal te onderzoeken en voor die taal de concepten van programmeren te
beschrijven. Voor dit onderzoek heb ik de taal Go gekozen dat is ontwikkeld door
Google. In dit verslag beschrijf ik allerlei aspecten van de taal Go vanaf de geschiedenis
tot de implementatie van verschillende programmeer paradigma’s binnen deze taal. Dit
verslag is voornamelijk gebaseerd op literatuur die ik gevonden heb op het internet en
heeft een grote inspiratie gevonden in het boek “Concepts of Programming languages”
de tiende editie van Robert W. Sebesta. Het doel van dit verslag is om de lezer bekend te
maken met de structuur van Go en daarnaast de verschillende concepten uit de
programmeertalen uit te leggen en relateren aan Go. Het verslag is gericht op lezers die
zelf al bezig zijn met programmeertalen. Er zijn een aantal woorden gebruikt zonder
daarbij de definitie te vermelden, hierbij wordt ervan uit gegaan dat deze woorden in
het vocabulaire van de lezer passen. Het achterliggende doel is voor mij om uit te
zoeken hoe deze taal werkt en terwijl ik dat doe begrijpen wat de concepten inhouden.
Dat gezegd te hebben wens ik jou, de lezer, veel leesplezier en hopelijk ben je hierna zelf
net zo enthousiast geworden over de taal Go als ik dat werd tijdens het onderzoeken
ervan.
2
,Hogeschool Leiden ICP – Januari 2017 – Versie 1.0 – s1087187 – Anton Steenvoorden
Inhoud
Samenvatting ....................................................................................................................... 1
Inleiding................................................................................................................................ 2
Historie ................................................................................................................................. 7
Ontstaan van de taal ........................................................................................................ 7
Waarvoor is Go geschikt .................................................................................................. 8
Google gebruikt zelf ook Go ............................................................................................ 8
Go’s Gopher .................................................................................................................... 8
Taalopbouw en parsing ........................................................................................................ 9
Describing Syntax and Semantics .................................................................................... 9
Formal Methods of Describing Syntax ......................................................................... 9
EBNF ...........................................................................................................................10
Attribute Grammars ...................................................................................................10
Describing the Meanings of Programs: Dynamic Semantics .....................................11
Lexical and Syntax Analysis ............................................................................................12
Lexical Analysis...........................................................................................................12
Syntax analyzer ..........................................................................................................13
Top-down parsing (recursive-descent parsing) .........................................................13
Bottom-up parsing .....................................................................................................14
Parsing Problem .........................................................................................................14
Basic Concepts ...................................................................................................................15
Names Bindings and Scopes ..........................................................................................15
Names ........................................................................................................................15
Binding .......................................................................................................................15
Scope and lifetime .....................................................................................................16
Referencing environments ........................................................................................17
Named constants .......................................................................................................18
Dependency Management ............................................................................................18
Data Types......................................................................................................................19
Primitive .....................................................................................................................19
Character/String.........................................................................................................19
User-Defined ..............................................................................................................20
Array ...........................................................................................................................20
Associative Array........................................................................................................21
List (Growing Slice).....................................................................................................21
Record ........................................................................................................................21
3
, Hogeschool Leiden ICP – Januari 2017 – Versie 1.0 – s1087187 – Anton Steenvoorden
Tupel ..........................................................................................................................21
Union ..........................................................................................................................22
Function .....................................................................................................................22
Deze kan dus worden aangeroepen met een variabel aantal strings. Deze strings
zullen worden gestopt in een lijst. .............................................................................22
Goroutine ...................................................................................................................23
Channel ......................................................................................................................23
Pointer and Reference Types .....................................................................................24
Type Checking & Strong Typing .................................................................................24
Type equivalence .......................................................................................................24
Expressions and Assignment Statements ......................................................................25
Operators voor de expressies ....................................................................................25
Arithmetic expressions ..............................................................................................25
Overloaded Operators ...............................................................................................26
Type Conversions ...........................................................................................................26
Relational Expressions ...............................................................................................26
Boolean Expressions ..................................................................................................27
Short-Circuit evaluation .............................................................................................28
Statement-Level Control Structures ..............................................................................29
Selection Statements .................................................................................................29
Iterative Statements ..................................................................................................30
Unconditional Branching ...........................................................................................31
Guarded Commands ..................................................................................................31
Advanced Concepts ...........................................................................................................32
Subprograms & Implementing subprograms ................................................................32
Fundamentals of Subprograms ......................................................................................32
Parameter-Passing Methods .........................................................................................33
Parameters That Are Subprograms ...............................................................................34
Calling Subprograms Indirectly ......................................................................................35
Overloaded Subprograms ..............................................................................................35
Generic Subprograms ....................................................................................................35
Design issues for Functions ............................................................................................36
User-Defined Overloaded Operators .............................................................................36
Nested Subprograms .....................................................................................................36
Block ...............................................................................................................................36
Abstract Data Types and Encapsulation Constructs ......................................................37
4
The benefits of buying summaries with Stuvia:
Guaranteed quality through customer reviews
Stuvia customers have reviewed more than 700,000 summaries. This how you know that you are buying the best documents.
Quick and easy check-out
You can quickly pay through credit card or Stuvia-credit for the summaries. There is no membership needed.
Focus on what matters
Your fellow students write the study notes themselves, which is why the documents are always reliable and up-to-date. This ensures you quickly get to the core!
Frequently asked questions
What do I get when I buy this document?
You get a PDF, available immediately after your purchase. The purchased document is accessible anytime, anywhere and indefinitely through your profile.
Satisfaction guarantee: how does it work?
Our satisfaction guarantee ensures that you always find a study document that suits you well. You fill out a form, and our customer service team takes care of the rest.
Who am I buying these notes from?
Stuvia is a marketplace, so you are not buying this document from us, but from seller antonsteenvoorden. Stuvia facilitates payment to the seller.
Will I be stuck with a subscription?
No, you only buy these notes for $5.88. You're not tied to anything after your purchase.
Can Stuvia be trusted?
4.6 stars on Google & Trustpilot (+1000 reviews)
71498 documents were sold in the last 30 days
Founded in 2010, the go-to place to buy study notes for 14 years now