CONCEPTEN VAN GO
Anton 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
Anton 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
