Go – Bases, culture et pédagogie

Quelques lectures « essentielles » sur le langage Go.

Apprendre Go

Quelques pistes pour apprendre Go :

• http://www.golang-book.com/, un livre en ligne par Caleb Doxsey
• Un petit livre sur Go, par Karl Seguin : http://openmymind.net/The-Little-Go-Book/
• Apprendre Go en dix minutes : http://learnxinyminutes.com/docs/go/
• Apprendre Go en tant que premier langage, par Siddhartha Singh en 2013 : http://www.informit.com/articles/article.aspx?p=2153658
• Apprendre Go par l'exemple : https://gobyexample.com/
• Bonnes pratiques avec Go dans un environnement de production, selon Peter Bourgon en 2014 : http://peter.bourgon.org/go-in-production/
• Survol de Go, par Russ Cox en 2012 : http://research.swtch.com/gotour
• Le site Effective Go : http://golang.org/doc/effective_go.html
• La syntaxe déclarative de Go : http://blog.golang.org/gos-declaration-syntax
• L'environnement d'exécution de Go : http://code.google.com/intl/en/appengine/docs/go/
• Distinguer les fonctions make et new : https://groups.google.com/group/golang-nuts/browse_thread/thread/9165d853de57374e?pli=1
• La réfléxivité sous Go : http://blog.golang.org/2011/09/laws-of-reflection.html
• Apprendre Go par les exemples, texte de Mark McGranaghan en 2012 : http://mmcgrana.github.com/2012/10/introducing-go-by-example.html
• Fonctions autoréférentielles, par Rob Pike en 2014 : http://commandcenter.blogspot.nl/2014/01/self-referential-functions-and-design.html
• Enseigner les systèmes répartis avec Go, un texte de David Andersen en 2013 : http://da-data.blogspot.ca/2013/02/teaching-distributed-systems-in-go.html
• Pourquoi la pile d'exécution d'un programme Go est « infinie », par Dave Cheney en 2013 : http://dave.cheney.net/2013/06/02/why-is-a-goroutines-stack-infinite
• Texte de Francesc Campoy, en 2015, qui présente les cinq étapes de l'apprentissage de Go, avec exemples de code dans chaque cas : https://sourcegraph.com/blog/live/gopherconindia/112025389257
• Série d'articles par Sergey Matyukevich en 2015, décrivant Go à l'interne :
  • structure d'un projet et fonctionnement du compilateur : http://blog.altoros.com/golang-part-1-main-concepts-and-project-structure.html
  • fonctionnement du compilateur et petits programmes de base : http://blog.altoros.com/golang-internals-part-2-diving-into-the-go-compiler.html
  • édition des liens et code objet : http://blog.altoros.com/golang-internals-part-3-the-linker-and-object-files.html
  • format du code objet et métadonnées des fonctions : http://blog.altoros.com/golang-part-4-object-files-and-function-metadata.html
  • démarrage de l'exécution d'un programme : http://blog.altoros.com/golang-internals-part-5-runtime-bootstrap-process.html
• Des exemples « testables » en Go, par Andrew Gerrand en 2015 : http://blog.golang.org/examples
• Quelques pièges du langage Go, répertoriés par Daniel Smith en 2016 : https://gist.github.com/lavalamp/4bd23295a9f32706a48f
• Apprendre Go en manipulant du texte, par Leah Hanson en 2016 : http://blog.leahhanson.us/post/recursecenter2016/recipeparser.html

Go expliqué aux programmeurs d'autres cultures :

• Go pour programmeurs C++ : http://golang.org/doc/go_for_cpp_programmers.html
• Faire interagir C et Go :
  • L'outil CGO : http://blog.golang.org/2011/03/c-go-cgo.html
  • Selon Dennis Forbes en 2013, la plus grande force de Go est que ce langage interagit bien avec C : http://dennisforbes.ca/index.php/2013/07/23/the-most-powerful-feature-of-go-is-the-least-sexy/
  • Faire interagir Go avec des bibliothèques à liens dynamiques écrites en C, par William Kennedy en 2013 : http://www.goinggo.net/2013/08/using-c-dynamic-libraries-in-go-programs.html
  • Le faire sans utiliser CGO, un texte de Shane M Hansen en 2014 : http://skullcountry.com/c-and-go-without-cgo
• Développer avec Go pour Android :
  • texte de David Cranshaw en 2014 : https://docs.google.com/document/d/1N3XyVkAP8nmWjASz8L_OjjnjVKxgeVBjIsTr5qIUcA4/preview?sle=true
  • texte de Dennis Forbes en 2014 : http://dennisforbes.ca/index.php/2014/03/19/go-golang-and-android/
• Compiler Go pour plusieurs plateformes, par Dave Cheney en 2012 : http://dave.cheney.net/2012/09/08/an-introduction-to-cross-compilation-with-go
• Utiliser du langage d'assemblage avec Go, texte de Caleb Doxsey en 2013 : http://www.doxsey.net/blog/go-and-assembly
• Faire interagir Go et Python à travers JSON : http://www.artima.com/weblogs/viewpost.jsp?thread=333589
• Programmation orientée objet avec Go : ../../Liens/Paradigmes-programmation--Liens.html#poo_langage_Go

Histoires de vitesse d'exécution qu'on raconte sur Go, relatées par Jason Moiron en 2013 : http://jmoiron.net/blog/go-performance-tales/

Idées et opinions

Réflexions sur le langage :

• Réflexion de Bram Cohen en 2009 : http://bramcohen.livejournal.com/71760.html
• Premières impressions de Daniel Lyons en 2009 : http://bitbucket.org/fusiongyro/dupfinder/wiki/notes_about_Go
• Le monde avait-il besoin d'un autre langage? Entretien de James Turner avec Rob Pike en 2010 : http://radar.oreilly.com/2010/06/does-the-world-need-yet-anothe.html
• Sur l'expressivité de Go (un diaporama par Rob Pike) : http://go.googlecode.com/hg/doc/ExpressivenessOfGo.pdf
• Apprendre Go, selon Andrew Gerrand en 2010 : http://nf.id.au/posts/2010/12/on-learning-go.html
• Penser en Go pour résoudre des problèmes : http://groups.google.com/group/golang-nuts/msg/7030eaf21d3a0b16?pli=1
• Réflexion a posteriori sur les quatre premières années de Go, par Andrew Gerrand en 2014 : http://blog.golang.org/4years
• Pensées sur Go, par Adam Smith en 2013 : http://www.not-the-economist.com/post/a-few-thoughts-on-go
• En 2013, Tahir Hashmi explique pourquoi il programme en Go : http://tech.t9i.in/2013/01/why-program-in-go/
• Design orienté objet avec Go, par Nathan Youngman en 2013 : http://nathany.com/good/
• En 2014, Aldo Cortesi relate son amour de Go : http://corte.si/posts/code/go/golang-practicaly-beats-purity/index.html/
• Quelques « abstractions brisées » avec Go, un article plutôt élogieux par Russ Cox en 2010 : http://research.swtch.com/goabstract
• Programmer avec Go inciterait aux saines pratiques de gestion du temps et de l'espace mémoire, selon Jason Moiron en 2013 : http://jmoiron.net/blog/whats-going-on/
• Le langage Go pour les administrateurs de systèmes, point de vue de John E. Vincent en 2013 : http://blog.lusis.org/blog/2013/08/11/go-for-system-administrators/
• Selon Elazar Leibovich en 2014, la principale force de Go a trait aux comportements émergents : http://www.onebigfluke.com/2014/04/gos-power-is-in-emergent-behavior.html
• Le futur de Go, tel que perçu par Brad Fitzpatrick en 2014 : http://dotgo.sourcegraph.com/post/99652962343/brad-fitzpatrick-on-the-future-of-the-go-programming
• Pour aimer Go, il faut faire face à de gros problèmes, du moins si on en croit Tzvetan Mikov en 2015 : http://tmikov.blogspot.ca/2015/02/you-dont-like-googles-go-because-you.html
• La relation entre Go et la communauté de programmation à code ouvert, texte d'une présentation donnée en 2015 par Russ Cox : http://blog.golang.org/open-source
• Ce que l' histoire retiendra de Go, de l' avis de Dave Cheney en 2015 : http://dave.cheney.net/2015/11/15/the-legacy-of-go
• Selon Matt Farina en 2016, Go a un problème de gestion de paquetages. Dans cet article, il propose une approche pour corriger ce problème : http://engineeredweb.com/blog/2016/path-go-pkg-mgmt/
• Go et les tests unitaires, texte de 2016 par Shekkar Gulati : https://github.com/shekhargulati/52-technologies-in-2016/blob/master/29-go-unit-testing/README.md
• Ce que Go est, et ce qu'il n'est pas, selon Dan Mullineux en 2016 : http://danmux.com/posts/what_golang_isnt/
• Présentation par Francesc Campoy en 2017, portant sur l'état de Go (où en est son développement, quelles sont les directions et les avenues envisagées pour le futur) : https://talks.golang.org/2017/state-of-go.slide#1

Technique

Divers sujets techniques à propos du langage Go.

• Multiprogrammation avec Go : ../../Liens/Multiprogrammation--Liens.html#langage_Go
• Gestion de la mémoire avec Go : ../../Liens/Gestion-memoire--Liens.html#langage_Go
• Go et le temps : ../../Liens/Temps--Liens.html#langage_Go

Saines pratiques de programmation avec Go :

• Par Francesc Campoy Flores en 2013 : http://talks.golang.org/2013/bestpractices.slide#1
• Par Peter Bourgon en 2016 : https://peter.bourgon.org/go-best-practices-2016/

Go est un langage facile à compiler, la grammaire étant pensée pour faciliter le travail des compilateurs, mais les binaires de Go tendent à être massifs. En 2016, Filippo Valsorda propose un truc pour réduire drastiquement leur taille : https://blog.filippo.io/shrink-your-go-binaries-with-this-one-weird-trick/

Utiliser Go pour :

• Des calculs géométriques, texte de Reinder Nijhoff en 2010 : http://www.infi.nl/blog/view/id/47/Rendering_distance_fields_using_the_Go_language
• Résoudre un Sudoku, textes d'Andrew Gerrand en 2010 :
  • http://nf.id.au/posts/2010/07/expressive-concurrency-a-go-sudoku-solver-pt.html
  • http://nf.id.au/posts/2010/07/expresive-concurrency-a-go-sudoku-solver-pt-2.html
• Manipuler des images :
  • images et Websockets, par Felix Palmer en 2013 : http://www.pheelicks.com/2013/11/intro-to-images-in-go-websockets/
  • fractals, texte de Felix Palmer en 2013 : hhttp://www.pheelicks.com/2013/11/intro-to-images-in-go-fractals/
• Générer des nombres uniques, par Andrew Gerrand en 2010 : http://nf.id.au/posts/2010/08/concurrency-patterns-a-source-of-unique-numbe.html
• Écrire un serveur de clés de chiffrement, par Kyle Isom en 2014 : http://kyleisom.net/blog/2014/01/23/building-a-key-server/
• De la programmation de nature scientifique : http://soniacodes.files.wordpress.com/2010/11/p098.png
• Créer un schéma de BD : http://msnyder.info/posts/2010/12/golang-database-schemas/
• Sérialiser des objets : http://www.jmcneil.net/2011/02/learning-go-and-serializing-objects-with-it-too/
• Développer des applications Web :
  • générer une (petite) application Web du début à la fin avec Go, par Jeff Wendling en 2012 : http://shadynasty.biz/blog/2012/07/30/quick-and-clean-in-go/
  • utiliser Go pour écrire des applications Web, une expérience constructive selon Krzyzstov Kowalczyk en 2012 : http://blog.kowalczyk.info/article/uvw2/Thoughts-on-Go-after-writing-3-websites.html
  • l'outil Web.go, pour faciliter la génération applications Web avec Go : http://webgo.io/
  • écrire un serveur Web avec Go, par Austin G. Walters en 2014 : http://austingwalters.com/building-a-web-server-in-go-handling-page-requests/
  • le livre en ligne Building Web Apps with Go, par Jeremy Saenz en 2014 : http://codegangsta.gitbooks.io/building-web-apps-with-go/
• De la robotique :
  • le paquetage Gobot : http://gobot.io/
• Résoudre le défi Instagram, par Jon Cooper en 2011 : http://blog.carbonfive.com/2011/11/17/explorations-in-go-solving-the-instagram-engineering-challenge/
• Consommer de volumineux documents XML, par David Singleton en 2012 : http://blog.davidsingleton.org/parsing-huge-xml-files-with-go/
• Générer des chaînes de Markov : http://golang.org/doc/codewalk/markov/
• Utiliser Go... pour compiler Go, par Dave Cheney en 2013 : http://dave.cheney.net/2013/06/04/how-go-uses-go-to-build-itself
• Écrire un émulateur de Gameboy : http://djhworld.github.io/gomeboycolor/
• Go n'offre pas de types génériques, mais on peut s'en rapprocher, selon Bouke van der Bijl en 2014 : http://bouk.co/blog/idiomatic-generics-in-go/
• Compilation croisée, article de Dave Cheney en 2015 : http://dave.cheney.net/2015/03/03/cross-compilation-just-got-a-whole-lot-better-in-go-1-5
• Faire du Monkeypatching, ou faire des passe-passe pas toujours propres, par Bouke van der Bijl en 2015 : http://bouk.co/blog/monkey-patching-in-go/
• Dix trucs de programmation utiles avec Go, par Fatih Arslan en 2015 : http://arslan.io/ten-useful-techniques-in-go
• Livre en ligne pour le développement Web avec Go : https://astaxie.gitbooks.io/build-web-application-with-golang/content/en/preface.html
• Écrire un service ntpd avec Go, les bons côtés et les petits irritants (expérience globalement positive, cela dit), texte de 2017 : https://blog.ntpsec.org/2017/02/07/grappling-with-go.html

Chaînes de caractères

Comprendre et manipuler les chaînes de caractères avec Go.

• Les strings, les bytes, les runes et les caractères : http://blog.golang.org/strings
• Normalisation du texte : http://blog.golang.org/normalization

Gestion des erreurs

L'un des aspects sur la base desquels Go se distingue d'autres langages contemporains est sa gestion des erreurs. En effet, plutôt que de lever des exceptions, Go permet de retourner plusieurs valeurs d'une même fonction, et une fonction Go idiomatique retournera souvent un résultat et un code d'erreur.

• http://blog.golang.org/2011/07/error-handling-and-go.html
• http://www.artima.com/weblogs/viewpost.jsp?thread=331407
• Selon Dave Cheney en 2012, Go a « réussi » son implémentation des exceptions... en n'en ayant pas! http://dave.cheney.net/why-go-gets-exceptions-right
• Les erreurs sont des valeurs, comme le rappelle Rob Pike dans ce texte de 2015 sur les saines pratiques de traitement d'erreurs, même dans le cas où l'erreur est nil : https://blog.golang.org/errors-are-values
• En 2016, Dave Cheney discute de l'évolution de ses pratiques de gestion d'erreurs avec Go : http://dave.cheney.net/2016/06/12/stack-traces-and-the-errors-package
• La philosophie de la gestion des erreurs avec Go, selon Dave Cheney en 2016 : http://dave.cheney.net/paste/gocon-spring-2016.pdf

Les goroutines

Ce qui tient lieu de thread (de microthread, en fait) avec Go est une goroutine. Une goroutine est une fonction lancée avec l'instruction go, et s'exécute concurremment avec la fonction l'ayant lancée.

Pour un exemple simple utilisant des goroutines, voir ../Client-Serveur/TiPointsGo.html

Quelques textes d'autres sources :

• Lancer 100000 goroutines? Texte de 2009 : http://dalkescientific.com/writings/diary/archive/2009/11/15/100000_tasklets.html (un comparatif avec une implémentation de Python)
• Gérer les timeouts, texte de 2010 par Andrew Gerrand : http://blog.golang.org/go-concurrency-patterns-timing-out-and
• Analyse de l'ordonnanceur de Go, proposée par Neil Deshpande, Erica Sponsler et Nathaniel Weiss en 2012 : http://www.cs.columbia.edu/~aho/cs6998/reports/12-12-11_DeshpandeSponslerWeiss_GO.pdf
• Les map de Go sont-elles assujetties aux conditions de course? Pas vraiment, selon Dave Cheney en 2015, quoique selon l'usage qu'on en fait... http://dave.cheney.net/2015/12/07/are-go-maps-sensitive-to-data-races
• Article animé plutôt intéressant sur la visualisation de la concurrence dans un programme Go, par Ivan Daniluk en 2016 : https://divan.github.io/posts/go_concurrency_visualize/

Interfaces

Les interfaces avec Go sont un concept du langage.

• En 2011, Rob Pike donne un aperçu des interfaces avec Go : https://groups.google.com/group/golang-nuts/msg/8de71de10ea48f96
• Utiliser les interfaces en Go, un texte de Jordan Orelli en 2012 : http://jordanorelli.tumblr.com/post/32665860244/how-to-use-interfaces-in-go
• Les interfaces implicites de Go, par Rod Salazar en 2013 : http://www.swageroo.com/wordpress/googles-go-and-implicit-interface-declaration/
• En quoi les interfaces de Go facilitent la rédaction de tests, selon John Graham-Cumming en 2014 : http://blog.cloudflare.com/go-interfaces-make-test-stubbing-easy

Structures de données

Les itérateurs avec Go, par Ewen Cheslack-Postava en 2013 : http://ewencp.org/blog/golang-iterators/

Les range et les slice :

• http://blog.golang.org/slices
• Les range et les slice avec Go, par Peter Armitage en 2013 : http://www.funcmain.com/for_range
• Les slice avec Go, texte de William Kennedy en 2013 : http://www.goinggo.net/2013/08/understanding-slices-in-go-programming.html
• Un usage imprudent des slice avec Go peut causer des surprises, comme l'indique Shannon Behrens en 2015 : http://www.jjinux.com/2015/05/go-surprising-edge-case-concerning.html

En 2016, Eli Bendersky discute des tableaux de suffixes (pour faciliter la recherche de sous-chaînes dans une chaîne de caractères) dans la bibliothèque standard de Go : http://eli.thegreenplace.net/2016/suffix-arrays-in-the-go-standard-library/

Structures de contrôle

Texte de 2016 par Elliot Chance, expliquant en quoi Go rend la structure de contrôle switch pertinente : http://elliot.land/making-switch-cool-again

Tests

Explications d'Elliot Chance en 2016 sur le fonctionnement des tests standardisés avec Go :

• http://elliot.land/go-subtests-and-sub-benchmarks 
• http://elliot.land/go-data-driven-parameterized-tests

Entrées/ sorties

• Sorte de déclaration d'amour de Jason Moiron envers io.Reader, en 2014 : https://www.datadoghq.com/2014/07/crossing-streams-love-letter-gos-io-reader/
• Les canaux, si chouettes soient-ils, ne suffisent pas vraiment à eux seuls. Texte d'Alexey Kachayev en 2014 : https://gist.github.com/kachayev/21e7fe149bc5ae0bd878
• Critique des canaux, du moins sous leur forme de 2016, par JT Olds : http://www.jtolds.com/writing/2016/03/go-channels-are-bad-and-you-should-feel-bad/

Généricité

De prime abord, Go ne supporte pas la généricité, et c'est un aspect qui lui a attiré des critiques, mais des travaux sont en cours pour changer cet état de fait :

• Proposition d'Ian Lance Taylor : https://github.com/golang/proposal/blob/master/design/15292-generics.md

Cas vécus

Plusieurs gens et plusieurs entreprises ont écrit pour décrire leur expérience, souvent positive, avec Go. Quelques cas vécus suivent.

• En 2009, Dustin Sallings relate son expérience d'écriture d'un serveur memcached avec Go : http://dustin.github.com/2009/11/12/gomemcached.html
• Écrire un client BitTorrent en Go : http://grammerjack.blogspot.com/2010/01/writing-bittorrent-client-in-go.html
• Écrire un langage basé sur une machine virtuelle en Go, présentation d'Eleanor McHugh en 2010 : http://www.slideshare.net/feyeleanor/golightly-building-vmbased-language-runtimes-in-go
• En 2011, Andrew Gerrand explique comment il a appris Go dans un contexte de production : http://blog.golang.org/2011/12/from-zero-to-go-launching-on-google.html
• En 2012, Dhaivat Pandya fait part d'une expérience très positive avec Go : http://poincare101.blogspot.ca/2012/03/experiences-in-go-ing.html
• En 2012, Ian Davis relate cinq semaines d'expérimentation avec Go : http://blog.iandavis.com/2012/05/23/5-weeks-of-go/
• En 2012, Peter Bourgon relate l'expérience de son entreprise avec Go : http://backstage.soundcloud.com/2012/07/go-at-soundcloud/
• Comment est utilisé Go chez Google :
  • une présentation de Rob Pike en 2012 : http://talks.golang.org/2012/splash.slide#1
  • une adaptation « texte » de cette présentation, en 2012 : http://talks.golang.org/2012/splash.article
• En 2013, Andrew W. Deane parle de la fiabilité de Go : http://andrewwdeane.blogspot.ca/2013/05/the-reliability-of-go.html
• Texte de 2013 par Nathan Youngman expliquant pourquoi il a choisi Go : http://nathany.com/why-go
• Texte de Ben Sigelman en 2013, qui tire une impression somme tout positive de son expérience : http://blog.bensigelman.org/post/56158760736/golang-impressions
• En 2013, Herman Schaaf raconte pourquoi il a réécrit son moteur de blogue en Go, comment il s'y est pris, et ce que cela lui a rapporté : http://www.ironzebra.com/code/103/i-rewrote-my-blog-in-go
• La vie après deux ans d'utilisation de Go pour du développement réel, par Travis Reeder en 2013 : http://blog.iron.io/2013/08/go-after-2-years-in-production.html
• Une première application en Go, par Aleksandar Diklić en 2013 : http://renderedtext.com/blog/2013/08/28/building-our-first-app-in-go/
• Cas vécu de programmation système, relaté par David Andersen en 2013 : http://da-data.blogspot.ca/2013/10/experience-with-epaxos-systems-research.html
• :Le développement d'applications avec Go, expliqué par Jason Roelofs en 2013 : http://jasonroelofs.com/2013/08/01/application-development-in-go/
• Ce que John Graham-Cumming et son équipe font avec Go, relaté en 2013 : http://blog.cloudflare.com/what-weve-been-doing-with-go
• Expérience plutôt négative relatée par Srinivas Jonnalagadda en 2014 : http://oneofmanyworlds.blogspot.ca/2014/01/another-go-at-go-failed.html
• En 2014, JT Olds relate son expérience (positive) de migration de Python vers Go : https://www.spacemonkey.com/blog/posts/go-space-monkey
• En 2014, Russ Cox relate la migration automatisée du compilateur Go de C vers... Go : http://gophercon.sourcegraph.com/post/83820197495/russ-cox-porting-the-go-compiler-from-c-to-go
• Comme le relate Danny Gratzer en 2014, Code & Co a choisi de laisser Go de côté : http://jozefg.bitbucket.org/posts/2013-08-23-leaving-go.html
• Ce qui fait de Go un bon choix, côté serveur du moins, un texte de 2014 : http://togototo.wordpress.com/2014/07/04/why-go-is-great-for-servers/
• Réécrire le compilateur Go... en Go, selon Russ Cox en 2013 : https://docs.google.com/document/d/1P3BLR31VA8cvLJLfMibSuTdwTuF7WWLux71CYD0eeD8/preview?sle=true&pli=1
• En 2015, l'auteur de ce texte relate son expérience de réécriture d'un serveur aux performances non-critiques de C++ à Go. Il met en valeur les plus et les moins de l'expérience, ce qui rend son texte particulièrement instructif : https://togototo.wordpress.com/2015/03/07/fulfilling-a-pikedream-the-ups-of-downs-of-porting-50k-lines-of-c-to-go/ Sa conclusion, à savoir que « Go is a double-edged sword: it forbids complex abstraction, both bad and good. The worse the abstraction that you and your colleagues are likely to use, the better a language is Go, and vice-verse (ultimately depending on what is considered ‘good’ and ‘bad’ abstraction) », est signifiante
• Evan Miller relate, par ce texte de 2015, sa première expérience de développement d'un éditeur hexadécimal avec Go : http://www.evanmiller.org/four-days-of-go.html
• Pourquoi une entreprise utiliserait un langage aussi « imparfait », selon Tyler Treat en 2015 : http://bravenewgeek.com/go-is-unapologetically-flawed-heres-why-we-use-it/
• Après un an d'utilisation de Go, Andrew Thompson a décidé de le retirer de son code de production, estimant qu'il n'est pas suffisamment utile pour lui. Il critique en particulier la qualité des outils qui accompagnent le langage : http://vagabond.github.io/rants/2015/06/05/a-year-with-go/
• Texte de 2015 par Philip O'Toole, qui pose un regard sur 400 jours d'utilisation de Go : http://www.philipotoole.com/400-days-of-go/

Critiques

Nul n'est parfait.

• En 2010, Robert Nystrom explique ce qui, selon lui., manque à Go : http://journal.stuffwithstuff.com/2010/10/21/the-language-i-wish-go-was/
• http://seanerussell.blogspot.com/2011/06/now-we-get-to-annoying-aspects-of-go.html
• Une critique intéressante sur le fait que Go tienne compte (ou non) des progrès en théorie des langages : http://acooke.org/cute/GoRocksHow0.html
• Une critique plutôt positive dans l'ensemble des bons et des moins bons aspects de Go, par Graham King en 2012 : http://www.darkcoding.net/software/go-lang-after-four-months/
• Pourquoi Shaneal Manek ne souhaite pas utiliser Go, un texte de 2012 : http://arantaday.com/why-i-dont-want-to-learn-go
• Selon Abtin Forouzandeh, en 2012, mieux vaut ne pas utiliser Go sur une machine 32 bits : http://www.abtinforouzandeh.com/2012/04/08/Do-Not-Use-Go-For-32bit-Development.html
• Critique très positive de Go par John Graham-Cumming en 2012 : http://blog.jgc.org/2012/07/things-i-like-about-programming-in-go.html
• En 2012, Dave Cheney émet l'opinion à l'effet que Go sera le prochain « gros » langage à succès : http://dave.cheney.net/2012/09/03/another-go-at-the-next-big-language
• Autre critique très positive de Go, par Marco Peereboom en 2012 : https://www.cyphertite.com/blog.php?/archives/7-Go-at-Conformal.html
• En 2012, Yuval Greenfield explique pourquoi il ne compte pas abandonner Python pour utiliser Go : http://uberpython.wordpress.com/2012/09/23/why-im-not-leaving-python-for-go/ (une partie importante de sa critique repose sur l'absence d'exceptions en Go)
  • réplique de Russ Cox, qui explique les choix faits par Go, en 2012 : https://plus.google.com/116810148281701144465/posts/iqAiKAwP6Ce
• Critique relativement détaillée de bons et de moins bons aspects de Go, en 2012 : http://ridiculousfish.com/blog/posts/go_bloviations.html
• Texte de 2013 par Aldo Cortesi, décrivant Go comme un langage charmant, mais avec une personnalité agaçante : http://corte.si/posts/code/go/go-rant.html
• En 2013, un auteur dont le nom m'échappe explique pourquoi il aime Go : https://gist.github.com/freeformz/4746274
• Texte de 2013 où l'auteur indique ce qui, selon lui, est le bon, le moins bon et le « meh... » de Go : http://blog.carlsensei.com/post/42828735125
• Texte de Lionel Barrow en 2013, relatant des irritant dans le développement Web avec Go : https://www.braintreepayments.com/braintrust/gotchas-irritants-and-warts-in-go-web-development
• Selon Tim Penhey, en 2013, certains éléments de la bibliothèque standard de Go brisent le principe de moindre surprise : http://how-bazaar.blogspot.co.nz/2013/07/stunned-by-go.html
• En 2013, Jesse Donat signale que la taille des binaires générés par la compilation de programmes Go est devenue démesurée : https://donatstudios.com/Golang-Binary-Sizes
• Critique sévère du système de types de Go, par Tamas Czinege en 2014 : https://functionwhatwhat.com/go%E2%80%99s-type-system-is-an-embarrassment/
• Selon Will Yager en 2014, Go a ses forces mais n'est tout simplement pas un bon langage : http://yager.io/programming/go.html
• Il semble clair de ce texte de 2014 que l'auteur n'a pas apprécié. son expérience avec Go (pas tant le langage que les outils qui l'appuient) : http://dtrace.org/blogs/wesolows/2014/12/29/golang-is-trash
• Quitter Node.js pour Go, le cas de Bowery relaté par Steve Kaliski en 2015 : http://bowery.io/posts/Nodejs-to-Golang-Bowery/
• Dands ce texte de 2015, Gary Willoughby se dit d'avis que le design de Go nuit aux programmeuses et aux programmeurs intelligents : http://nomad.so/2015/03/why-gos-design-is-a-disservice-to-intelligent-programmers/
• De l' avis d'Ilya Kowalewski en 2015, le langage Go a été mal conçu (mais il l' adore quand même) : https://medium.com/@tucnak/why-go-is-a-poorly-designed-language-1cc04e5daf2
  • réplique de Jason Moiron en 2015 : http://jmoiron.net/blog/for-better-or-for-worse/
  • en 2015, Ian Byrd formule une critique semblable à cette d'Ilya Kowalewski mais avec un argumentaire différent : http://byrd.im/go-is-poor/
• « Go is not Good », titre quelque peu provocateur en 2015 par Will Yager, qui dit bien aimer Go mais soumet une critique de son design, avec exemples: http://yager.io/programming/go.html
• Texte de Gregg Thomason en 2016 qui met de l'avant que Go n'est pas une panacée, malgré ses qualités : https://neurobashing.com/2016/04/14/come-and-go/
• Maksim Kochkin collige des articles critiques à propos de Go sur https://github.com/ksimka/go-is-not-good
• En 2016, Adam Leventhal explique pourquoi il aime Go, et ... pourquoi il n'aime pas Go : http://dtrace.org/blogs/ahl/2016/08/02/i-love-go-i-hate-go/
• Texte de 2016 par Jack Lindamood qui met en relief un irritant relié au fait que Go est un produit, et appartient à Google : https://hackernoon.com/gos-alias-proposal-and-all-my-concerns-of-google-controlling-go-a39f6c6046aa