stringtranslate.com

Go (lenguaje de programación)

Go es un lenguaje de programación de alto nivel compilado y tipado estáticamente diseñado en Google [12] por Robert Griesemer , Rob Pike y Ken Thompson . [4] Es sintácticamente similar a C , pero también tiene seguridad de memoria , recolección de basura , tipado estructural , [7] y concurrencia de estilo CSP . [13] A menudo se lo conoce como Golang debido a su antiguo nombre de dominio, pero su nombre propio es Go. [14] golang.org

Hay dos implementaciones principales:

Un compilador de código fuente a código fuente de terceros , GopherJS, [20] compila Go a JavaScript para el desarrollo web front-end .

Historia

Go fue diseñado en Google en 2007 para mejorar la productividad de la programación en una era de múltiples núcleos , máquinas en red y grandes bases de código . [21] Los diseñadores querían abordar las críticas a otros lenguajes en uso en Google, pero mantener sus características útiles: [22]

Sus diseñadores estaban motivados principalmente por su aversión compartida hacia C++ . [24] [25] [26]

Go se anunció públicamente en noviembre de 2009, [27] y la versión 1.0 se lanzó en marzo de 2012. [28] [29] Go se usa ampliamente en producción en Google [30] y en muchas otras organizaciones y proyectos de código abierto.

Marca y estilo

La mascota del lenguaje de programación Go es un Gopher que se muestra arriba.

La mascota Gopher se presentó en 2009 para el lanzamiento de código abierto del lenguaje. El diseño, de Renée French , se tomó prestado de una promoción de WFMU de alrededor de 2000. [31]

En noviembre de 2016, los diseñadores tipográficos Charles Bigelow y Kris Holmes lanzaron las fuentes Go y Go Mono específicamente para su uso en el proyecto Go. Go es una sans-serif humanista parecida a Lucida Grande , y Go Mono es monoespaciada . Ambas fuentes se adhieren al conjunto de caracteres WGL4 y fueron diseñadas para ser legibles con una gran altura x y formas de letras distintas . Tanto Go como Go Mono se adhieren al estándar DIN 1450 al tener un cero con barra, minúsculas lcon cola y mayúsculas Icon serifas. [32] [33]

En abril de 2018, el diseñador de la marca Adam Smith rediseñó el logotipo original. El nuevo logotipo es un GO moderno y estilizado, inclinado hacia la derecha con líneas aerodinámicas que lo siguen. (La mascota Gopher se mantuvo igual. [34] )

Genéricos

La falta de soporte para programación genérica en las versiones iniciales de Go generó muchas críticas. [35] Los diseñadores expresaron su apertura a la programación genérica y notaron que las funciones integradas eran de hecho genéricas, pero se las trataba como casos especiales; Pike dijo que esto era una debilidad que podría cambiarse en algún momento. [36] El equipo de Google construyó al menos un compilador para un dialecto experimental de Go con genéricos, pero no lo lanzó. [37]

En agosto de 2018, los principales colaboradores de Go publicaron borradores de diseños para programación genérica y manejo de errores y pidieron a los usuarios que enviaran comentarios. [38] [39] Sin embargo, la propuesta de manejo de errores finalmente fue abandonada. [40]

En junio de 2020, se publicó un nuevo borrador de documento de diseño [41] que agregaría la sintaxis necesaria a Go para declarar funciones y tipos genéricos. Se proporcionó una herramienta de traducción de código, go2go , para permitir que los usuarios prueben la nueva sintaxis, junto con una versión habilitada para genéricos del Go Playground en línea. [42]

Los genéricos finalmente se agregaron a Go en la versión 1.18 el 15 de marzo de 2022. [43]

Control de versiones

Go 1 garantiza compatibilidad [44] para la especificación del lenguaje y las partes principales de la biblioteca estándar. Todas las versiones hasta la versión actual de Go 1.23 [45] han mantenido esta promesa.

Go no sigue SemVer , sino que cada versión principal de Go recibe soporte hasta que haya dos versiones principales más nuevas. A diferencia de la mayoría del software, Go llama al segundo número de una versión "principal", es decir, "in" 1.x xes la versión principal. [46] Esto se debe a que Go planea nunca llegar a la versión 2.0, dado que la compatibilidad es uno de los principales puntos de venta del lenguaje. [47]

Diseño

Go está influenciado por C (especialmente el dialecto Plan 9 [48] [ verificación fallidaver discusión ] ), pero con énfasis en una mayor simplicidad y seguridad. Consiste en:

Sintaxis

La sintaxis de Go incluye cambios con respecto a C que apuntan a mantener el código conciso y legible. Se introdujo un operador combinado de declaración/inicialización que permite al programador escribir o , sin especificar los tipos de variables utilizadas. Esto contrasta con y de C.i := 3s := "Hello, world!"int i = 3;const char *s = "Hello, world!";

Los puntos y coma todavía terminan declaraciones; [b] pero son implícitos cuando ocurre el final de una línea. [c]

Los métodos pueden devolver múltiples valores, y devolver un par es la forma convencional en que un método indica un error a quien lo llama en Go. [d] Go agrega sintaxis literales para inicializar parámetros de estructura por nombre y para inicializar mapas y sectores . Como alternativa al bucle de tres declaraciones de C, las expresiones de Go permiten una iteración concisa sobre matrices, sectores, cadenas, mapas y canales. [56]result, errforrange

Tipos

Go tiene varios tipos integrados, incluidos los numéricos ( byte , int64 , float32 , etc.), los booleanos y las cadenas de bytes ( string ). Las cadenas son inmutables; los operadores integrados y las palabras clave (en lugar de funciones) proporcionan concatenación, comparación y codificación/descodificación UTF-8 . [57] Los tipos de registro se pueden definir con la palabra clave struct . [58]

Para cada tipo T y cada constante entera no negativa n , existe un tipo de matriz denotado [ n ] T ; las matrices de diferentes longitudes son, por lo tanto, de diferentes tipos. Las matrices dinámicas están disponibles como "segmentos", denotados [] T para algún tipo T . Estos tienen una longitud y una capacidad que especifican cuándo se necesita asignar nueva memoria para expandir la matriz. Varias porciones pueden compartir su memoria subyacente. [36] [59] [60]

Los punteros están disponibles para todos los tipos, y el tipopuntero a T se denota * T . La toma de direcciones y la indirección utilizan los operadores & y * , como en C, o ocurren implícitamente a través de la llamada al método o la sintaxis de acceso a atributos. [61] [62] No hay aritmética de punteros, [e] excepto a través del tipo especial unsafe.Pointer en la biblioteca estándar. [63]

Para un par de tipos K , V , el tipo map[ K ] V es el mapeo de tipos de claves de tipo K a valores de tipo V , aunque la especificación del lenguaje de programación Go no ofrece garantías de rendimiento ni requisitos de implementación para los tipos de mapas. Las tablas hash están integradas en el lenguaje, con una sintaxis especial y funciones integradas. chan T es un canal que permite enviar valores de tipo T entre procesos Go concurrentes. [64]

Aparte de su soporte para interfaces, el sistema de tipos de Go es nominal : la palabra clave type se puede utilizar para definir un nuevo tipo nombrado , que es distinto de otros tipos nombrados que tienen el mismo diseño (en el caso de una estructura , los mismos miembros en el mismo orden). Algunas conversiones entre tipos (por ejemplo, entre los diversos tipos de enteros) están predefinidas y agregar un nuevo tipo puede definir conversiones adicionales, pero las conversiones entre tipos nombrados siempre deben invocarse explícitamente. [65] Por ejemplo, la palabra clave type se puede utilizar para definir un tipo para direcciones IPv4 , basado en enteros sin signo de 32 bits de la siguiente manera:

tipo ipv4addr uint32  

Con esta definición de tipo, ipv4addr(x) interpreta el valor uint32 x como una dirección IP. La simple asignación de x a una variable de tipo ipv4addr es un error de tipo. [66]

Las expresiones constantes pueden ser tipificadas o "no tipificadas"; se les asigna un tipo cuando se asignan a una variable tipificada si el valor que representan pasa una verificación en tiempo de compilación. [67]

Los tipos de funciones se indican con la palabra clave func ; toman cero o más parámetros y devuelven cero o más valores, todos los cuales están tipificados. El parámetro y los valores de retorno determinan un tipo de función; por lo tanto, func(string, int32) (int, error) es el tipo de funciones que toman una cadena y un entero con signo de 32 bits, y devuelven un entero con signo (de ancho predeterminado) y un valor del tipo de interfaz incorporado error . [68]

Cualquier tipo con nombre tiene un conjunto de métodos asociado. El ejemplo de dirección IP anterior se puede ampliar con un método para verificar si su valor es un estándar conocido:

// ZeroBroadcast informa si la dirección es 255.255.255.255. func ( addr ipv4addr ) ZeroBroadcast () bool { return addr == 0xFFFFFFFF }         

Debido a la tipificación nominal, esta definición de método agrega un método a ipv4addr , pero no a uint32 . Si bien los métodos tienen una definición y una sintaxis de llamada especiales, no existe un tipo de método distinto. [69]

Sistema de interfaz

Go proporciona dos funciones que reemplazan la herencia de clases . [ cita requerida ]

La primera es la incrustación , que puede considerarse como una forma automatizada de composición . [70]

El segundo son sus interfaces , que proporcionan polimorfismo en tiempo de ejecución . [71] : 266  Las interfaces son una clase de tipos y proporcionan una forma limitada de tipado estructural en el sistema de tipos nominal de Go. Un objeto que es de un tipo de interfaz también es de otro tipo, de forma muy similar a los objetos de C++ que son simultáneamente de una clase base y derivada. Las interfaces de Go se diseñaron a partir de protocolos del lenguaje de programación Smalltalk. [72] Varias fuentes utilizan el término tipado de pato al describir las interfaces de Go. [73] [74] Aunque el término tipado de pato no está definido con precisión y, por lo tanto, no es incorrecto, generalmente implica que la conformidad con el tipo no se verifica estáticamente. Debido a que la conformidad con una interfaz de Go se verifica estáticamente por el compilador de Go (excepto cuando se realiza una aserción de tipo), los autores de Go prefieren el término tipado estructural . [75]

La definición de un tipo de interfaz enumera los métodos requeridos por nombre y tipo. Cualquier objeto de tipo T para el cual existan funciones que coincidan con todos los métodos requeridos del tipo de interfaz I también es un objeto de tipo I. La definición de tipo T no necesita (y no puede) identificar el tipo I. Por ejemplo, si Shape , Square y Circle se definen como

importar "matemáticas" tipo Forma interfaz { Área () float64 }     tipo Square struct { // Nota: no hay declaración "implementa" lado float64 }      func ( sq Cuadrado ) Area () float64 { return sq . lado * sq . lado }          tipo Círculo struct { // Aquí tampoco hay declaración de "implementos" radio float64 }      func ( c Círculo ) Área () float64 { return math . Pi * math . Pow ( c . radio , 2 ) }           

Entonces, tanto un cuadrado como un círculo son implícitamente una forma y se pueden asignar a una variable de tipo forma . [71] : 263–268  En lenguaje formal, el sistema de interfaz de Go proporciona tipado estructural en lugar de nominal . Las interfaces pueden incorporar otras interfaces con el efecto de crear una interfaz combinada que se satisface exactamente con los tipos que implementan la interfaz incorporada y cualquier método que agregue la interfaz recién definida. [71] : 270 

La biblioteca estándar de Go utiliza interfaces para proporcionar genericidad en varios lugares, incluido el sistema de entrada/salida que se basa en los conceptos de Reader y Writer . [71] : 282–283 

Además de llamar a métodos a través de interfaces, Go permite convertir valores de interfaz a otros tipos con una verificación de tipo en tiempo de ejecución. Las construcciones del lenguaje para hacerlo son la aserción de tipo , [76] que verifica contra un único tipo potencial:

var shp Shape = Square { 5 } square , ok := shp .( Square ) // Afirma el tipo Square en shp, debería funcionar si ok { fmt . Printf ( "%#v\n" , square ) } else { fmt . Println ( "No se puede imprimir la forma como Square" ) ​​}             

y el cambio de tipo , [77] que verifica múltiples tipos: [ cita requerida ]

func ( sq Cuadrado ) Diagonal () float64 { return sq . lado * math . Sqrt2 } func ( c Círculo ) Diámetro () float64 { return 2 * c . radio }                    func LongestContainedLine ( shp Shape ) float64 { switch v := shp .( type ) { case Square : return v.Diagonal ( ) // O, con afirmación de tipo, shp.(Square).Diagonal() case Circle : return v.Diámetro () // O , con afirmación de tipo, shp.(Círculo).Diametro() default : return 0 // En la práctica, esto debería manejarse con errores } }                

La interfaz vacía es un caso base importante porque puede hacer referencia a un elemento de cualquier tipo concreto. Es similar a la clase Object en Java o C# y se satisface con cualquier tipo, incluidos los tipos integrados como int . [71] : 284  El código que utiliza la interfaz vacía no puede simplemente llamar a métodos (u operadores integrados) en el objeto al que se hace referencia, pero puede almacenar el valor, intentar convertirlo a un tipo más útil a través de una aserción de tipo o un cambio de tipo, o inspeccionarlo con el paquete de Go. [78] Debido a que puede hacer referencia a cualquier valor, es una forma limitada de escapar de las restricciones de tipado estático, como en C pero con comprobaciones de tipo adicionales en tiempo de ejecución. [ cita requerida ]interface{}interface{}reflectinterface{}void*

El tipo se puede utilizar para modelar datos estructurados de cualquier esquema arbitrario en Go, como datos JSON o YAML , representándolos como un (mapa de cadena a interfaz vacía). Esto describe de forma recursiva los datos en forma de un diccionario con claves y valores de cadena de cualquier tipo. [79]interface{}map[string]interface{}

Los valores de interfaz se implementan utilizando un puntero a datos y un segundo puntero a información de tipo en tiempo de ejecución. [80] Al igual que otros tipos implementados utilizando punteros en Go, los valores de interfaz son nilsi no están inicializados. [81]

Código genérico que utiliza tipos parametrizados

Desde la versión 1.18, Go admite código genérico que utiliza tipos parametrizados. [82]

Las funciones y los tipos ahora tienen la capacidad de ser genéricos mediante el uso de parámetros de tipo. Estos parámetros de tipo se especifican entre corchetes, justo después del nombre de la función o el tipo. [83] El compilador transforma la función o el tipo genérico en no genérico sustituyendo los parámetros de tipo proporcionados por argumentos de tipo, ya sea explícitamente por el usuario o por inferencia de tipo por parte del compilador. [84] Este proceso de transformación se conoce como instanciación de tipo. [85]

Las interfaces ahora pueden definir un conjunto de tipos (conocido como conjunto de tipos) utilizando |el operador (Unión), así como un conjunto de métodos. Estos cambios se realizaron para admitir restricciones de tipo en el código genérico. Para una función o tipo genérico, una restricción puede considerarse como el tipo del argumento de tipo: un metatipo. Esta nueva ~Tsintaxis será el primer uso de ~como token en Go. ~Tsignifica el conjunto de todos los tipos cuyo tipo subyacente es T. [86]

tipo Número interfaz { ~ int | ~ float64 | ~ float32 | ~ int32 | ~ int64 }           func Agregar [ T Número ]( nums ... T ) T { var suma T para _ , v := rango nums { suma += v } devolver suma }                func main () { add := Add [ int ] // Instanciación de tipo println ( add ( 1 , 2 , 3 , 4 , 5 )) // 15          res := Add ( 1.1 , 2.2 , 3.3 , 4.4 , 5.5 ) // Inferencia de tipo println ( res ) // +1.650000e+001 }        

Tipos enumerados

Go utiliza la iotapalabra clave para crear constantes enumeradas. [87]

tipo ByteSize float64  const ( _ = iota // ignora el primer valor asignándolo al identificador en blanco KB ByteSize = 1 << ( 10 * iota ) MB GB )               

Sistema de paquetes

En el sistema de paquetes de Go, cada paquete tiene una ruta (por ejemplo, "compress/bzip2"o "golang.org/x/net/html") y un nombre (por ejemplo, bzip2o html). Las referencias a las definiciones de otros paquetes siempre deben tener como prefijo el nombre del otro paquete, y solo los nombres en mayúsculas de otros paquetes son accesibles: io.Readeres público pero bzip2.readerno lo es. [88] El go getcomando puede recuperar paquetes almacenados en un repositorio remoto [89] y se recomienda a los desarrolladores que desarrollen paquetes dentro de una ruta base correspondiente a un repositorio de origen (como ejemplo.com/nombre_usuario/nombre_paquete) para reducir la probabilidad de colisión de nombres con futuras incorporaciones a la biblioteca estándar u otras bibliotecas externas. [90]

Concurrencia: gorutinas y canales

El lenguaje Go tiene funciones integradas, así como soporte de bibliotecas, para escribir programas concurrentes . La concurrencia no solo se refiere al paralelismo de la CPU, sino también a la asincronía : permitir que operaciones lentas como una lectura de la base de datos o de la red se ejecuten mientras el programa realiza otro trabajo, como es común en los servidores basados ​​en eventos. [91]

La construcción de concurrencia primaria es la goroutine , un tipo de hilo verde . [92] : 280–281  Una llamada de función prefijada con la gopalabra clave inicia una función en una nueva goroutine. La especificación del lenguaje no especifica cómo se deben implementar las goroutines, pero las implementaciones actuales multiplexan las goroutines de un proceso Go en un conjunto más pequeño de hilos del sistema operativo , de manera similar a la programación realizada en Erlang . [93] : 10 

Si bien está disponible un paquete de biblioteca estándar que incluye la mayoría de las estructuras clásicas de control de concurrencia (bloqueos mutex , etc.), [93] : 151–152  los programas concurrentes idiomáticos prefieren canales , que envían mensajes entre goroutines. [94] Los buffers opcionales almacenan mensajes en orden FIFO [95] : 43  y permiten que el envío de goroutines continúe antes de que se reciban sus mensajes. [92] : 233 

Los canales están tipificados, de modo que un canal de tipo chan T sólo se puede utilizar para transferir mensajes de tipo T . Se utiliza una sintaxis especial para operar en ellos; <-ch es una expresión que hace que la goroutine en ejecución se bloquee hasta que llegue un valor por el canal ch , mientras que ch <- x envía el valor x (posiblemente bloqueando hasta que otra goroutine reciba el valor). La sentencia select integrada similar a switch se puede utilizar para implementar una comunicación sin bloqueo en varios canales; consulte a continuación un ejemplo. Go tiene un modelo de memoria que describe cómo las goroutines deben utilizar canales u otras operaciones para compartir datos de forma segura. [96]

La existencia de canales no distingue por sí misma a Go de los lenguajes concurrentes de estilo actor -modelo como Erlang, donde los mensajes se dirigen directamente a los actores (correspondientes a las gorutinas). En el modelo actor, los canales son en sí mismos actores, por lo tanto, dirigirse a un canal solo significa dirigirse a un actor. El estilo actor se puede simular en Go manteniendo una correspondencia uno a uno entre las gorutinas y los canales, pero el lenguaje permite que varias gorutinas compartan un canal o que una sola gorutina envíe y reciba en varios canales. [93] : 147 

A partir de estas herramientas se pueden construir construcciones concurrentes como grupos de trabajadores, tuberías (en las que, por ejemplo, se descomprime y analiza un archivo a medida que se descarga), llamadas en segundo plano con tiempo de espera, llamadas paralelas "en abanico" a un conjunto de servicios y otras. [97] Los canales también han encontrado usos más allá de la noción habitual de comunicación entre procesos, como servir como una lista segura de concurrencia de búferes reciclados, [98] implementar corrutinas (que ayudaron a inspirar el nombre goroutine ), [99] e implementar iteradores . [100]

Las convenciones estructurales relacionadas con la concurrencia de Go ( canales y entradas de canal alternativas) se derivan del modelo de procesos secuenciales comunicantes de Tony Hoare . A diferencia de los lenguajes de programación concurrente anteriores, como Occam o Limbo (un lenguaje en el que trabajó el codiseñador de Go, Rob Pike), [101] Go no proporciona ninguna noción incorporada de concurrencia segura o verificable. [102] Si bien el modelo de procesos comunicantes es el preferido en Go, no es el único: todas las goroutines de un programa comparten un único espacio de direcciones. Esto significa que los objetos mutables y los punteros se pueden compartir entre goroutines; consulte § Falta de seguridad en la carrera de datos, a continuación.

Adecuación para programación paralela

Aunque las características de concurrencia de Go no están dirigidas principalmente al procesamiento paralelo , [91] se pueden usar para programar máquinas multiprocesador con memoria compartida . Se han realizado varios estudios sobre la efectividad de este enfoque. [103] Uno de estos estudios comparó el tamaño (en líneas de código ) y la velocidad de los programas escritos por un programador experimentado que no estaba familiarizado con el lenguaje y las correcciones a estos programas por parte de un experto en Go (del equipo de desarrollo de Google), haciendo lo mismo para Chapel , Cilk e Intel TBB . El estudio encontró que el no experto tendía a escribir algoritmos de divide y vencerás con una declaración go por recursión, mientras que el experto escribía programas de distribución-trabajo-sincronización usando una goroutine por núcleo de procesador. Los programas del experto eran generalmente más rápidos, pero también más largos. [104]

Falta de datos sobre seguridad en las carreras

El enfoque de Go para la concurrencia se puede resumir como "no comunicarse compartiendo memoria; compartir memoria comunicándose". [105] No hay restricciones sobre cómo las gorutinas acceden a los datos compartidos, lo que hace posible las carreras de datos . Específicamente, a menos que un programa se sincronice explícitamente a través de canales u otros medios, las escrituras de una gorutina pueden ser parcialmente, completamente o no visibles para otra, a menudo sin garantías sobre el orden de las escrituras. [102] Además, las estructuras de datos internas de Go como valores de interfaz, encabezados de segmento, tablas hash y encabezados de cadena no son inmunes a las carreras de datos, por lo que la seguridad de tipo y memoria puede ser violada en programas multiproceso que modifican instancias compartidas de esos tipos sin sincronización. [106] [107] En lugar de soporte de lenguaje, la programación concurrente segura se basa en convenciones; por ejemplo, Chisnall recomienda un modismo llamado "alias xor mutable", lo que significa que pasar un valor mutable (o puntero) sobre un canal indica una transferencia de propiedad sobre el valor a su receptor. [93] : 155  La cadena de herramientas gc tiene un detector de carrera de datos opcional que puede verificar el acceso no sincronizado a la memoria compartida durante el tiempo de ejecución desde la versión 1.1, [108] además, un detector de carrera de máximo esfuerzo también se incluye de manera predeterminada desde la versión 1.6 del tiempo de ejecución gc para el acceso al maptipo de datos. [109]

Binarios

El enlazador en la cadena de herramientas gc crea binarios enlazados estáticamente de manera predeterminada; por lo tanto, todos los binarios de Go incluyen el entorno de ejecución de Go. [110] [111]

Omisiones

Go omite deliberadamente ciertas características comunes en otros lenguajes, incluyendo (implementación) herencia , aserciones , [f] aritmética de punteros , [e] conversiones de tipos implícitas , uniones sin etiquetar , [g] y uniones etiquetadas . [h] Los diseñadores agregaron solo aquellas facilidades en las que los tres estuvieron de acuerdo. [114]

De las características del lenguaje omitidas, los diseñadores argumentan explícitamente en contra de las aserciones y la aritmética de punteros, al tiempo que defienden la elección de omitir la herencia de tipos como una forma de obtener un lenguaje más útil, fomentando en su lugar el uso de interfaces para lograr un envío dinámico [i] y la composición para reutilizar el código. De hecho, la composición y la delegación están en gran medida automatizadas por la incrustación de estructuras ; según los investigadores Schmager et al. , esta característica "tiene muchos de los inconvenientes de la herencia: afecta a la interfaz pública de los objetos, no es de grano fino (es decir, no hay control a nivel de método sobre la incrustación), los métodos de los objetos incrustados no se pueden ocultar y es estática", lo que hace que "no sea obvio" si los programadores la usarán en exceso hasta el punto en que se dice que los programadores de otros lenguajes abusan de la herencia. [70]

El manejo de excepciones fue omitido inicialmente en Go debido a la falta de un "diseño que dé valor proporcional a la complejidad". [115] Se propuso un mecanismo de pánico / recuperación similar a una excepción que evita la estructura de control habitual [116] y se publicó en la instantánea del 30 de marzo de 2010. [117] Los autores de Go recomiendan usarlo para errores irrecuperables como aquellos que deberían detener un programa completo o una solicitud de servidor, o como un atajo para propagar errores por la pila dentro de un paquete. [118] [119] Más allá de los límites de los paquetes, Go incluye un tipo de error canónico, y los retornos de múltiples valores que usan este tipo son el idioma estándar. [4]try-catch

Estilo

Los autores de Go hicieron un esfuerzo considerable para influir en el estilo de los programas de Go:

Herramientas

La distribución principal de Go incluye herramientas para crear , probar y analizar código:

También incluye soporte para creación de perfiles y depuración , capacidades de fuzzing para detectar errores, instrumentación en tiempo de ejecución (por ejemplo, para rastrear pausas en la recolección de basura ) y un detector de carrera de datos .

Otra herramienta mantenida por el equipo de Go pero que no está incluida en las distribuciones de Go es gopls, un servidor de lenguaje que proporciona funciones IDE como finalización de código inteligente a editores compatibles con el Protocolo de servidor de lenguaje . [128]

Un ecosistema de herramientas de terceros se suma a la distribución estándar, como gocode, que permite el autocompletado de código en muchos editores de texto, goimports, que agrega o elimina automáticamente las importaciones de paquetes según sea necesario, y errcheck, que detecta código que podría ignorar errores involuntariamente.

Ejemplos

Hola Mundo

paquete principal importar "fmt" func main () { fmt.Println ( " hola mundo " ) }   

donde "fmt" es el paquete para E/S formateada , similar a la entrada/salida de archivos de C. [129]

Concurrencia

El siguiente programa simple demuestra las características de concurrencia de Go para implementar un programa asincrónico. Lanza dos hilos livianos ("goroutines"): uno espera a que el usuario escriba algún texto, mientras que el otro implementa un tiempo de espera. La instrucción select espera a que cualquiera de estas goroutines envíe un mensaje a la rutina principal y actúa sobre el primer mensaje que llega (ejemplo adaptado del libro de David Chisnall). [93] : 152 

paquete principal importar ( "fmt" "tiempo" )   func readword ( ch chan string ) { fmt.Println ( " Escribe una palabra y pulsa Enter." ) var word string fmt.Scanf ( " %s " , & word ) ch < - word }             func timeout ( t chan bool ) { tiempo.Sleep ( 5 * tiempo.Segundo ) t < -falso }          func main () { t := make ( chan bool ) ir tiempo de espera ( t )         ch := make ( chan cadena ) ir leerpalabra ( ch )      seleccionar { caso palabra := <- ch : fmt . Println ( "Recibido" , palabra ) caso <- t : fmt . Println ( "Tiempo de espera." ) } }           

Pruebas

El paquete de prueba proporciona soporte para pruebas automatizadas de paquetes go. [130] Ejemplo de función de destino:

func ExtractUsername ( correo electrónico cadena ) cadena { at := cadenas . Index ( correo electrónico , "@" ) return correo electrónico [: at ] }        

Código de prueba (tenga en cuenta que la palabra clave assert falta en Go; las pruebas se encuentran en <filename>_test.go en el mismo paquete):

importar ( "prueba" )  func TestExtractUsername ( t * testing.T ) { t.Run ( " withoutDot" , func ( t * testing.T ) { nombredeusuario : = ExtractUsername ( " [email protected]" ) si nombredeusuario != "r" { t.Fatalf ( " Obtuve : % v\n" , nombredeusuario ) } } )             t . Run ( "withDot" , func ( t * testing . T ) { nombre de usuario := ExtractUsername ( "[email protected]" ) si nombre de usuario != "jonh.smith" { t . Fatalf ( "Obtuve: %v\n" , nombre de usuario ) } }) }          

Es posible ejecutar pruebas en paralelo.

Aplicación web

El paquete net/http proporciona soporte para la creación de aplicaciones web.

Este ejemplo mostraría "¡Hola mundo!" cuando se visite localhost:8080.

paquete principal importar ( "fmt" "log" "net/http" )    func helloFunc ( w http.ResponseWriter , r * http.Request ) { fmt.Fprintf ( w , " ¡ Hola mundo ! " ) }       func main ( ) { http.HandleFunc ( " /" , helloFunc ) log.Fatal ( http.ListenAndServe ( " : 8080 " , nil ) ) }      

Aplicaciones

Go ha sido ampliamente adoptado en varios dominios debido a su sólida biblioteca estándar y facilidad de uso. [131]

Las aplicaciones populares incluyen: Caddy , un servidor web que automatiza el proceso de configuración de HTTPS, [132] Docker , que proporciona una plataforma para la contenerización, con el objetivo de facilitar las complejidades del desarrollo e implementación de software, [133] Kubernetes , que automatiza la implementación, el escalado y la gestión de aplicaciones en contenedores, [134] CockroachDB , una base de datos SQL distribuida diseñada para escalabilidad y una fuerte consistencia, [135] y Hugo , un generador de sitios estáticos que prioriza la velocidad y la flexibilidad, lo que permite a los desarrolladores crear sitios web de manera eficiente. [136]

Recepción

El sistema de interfaz y la omisión deliberada de la herencia fueron elogiados por Michele Simionato, quien comparó estas características con las de ML estándar y calificó de "vergüenza que ningún lenguaje popular haya seguido [esta] ruta particular". [137]

Dave Astels de Engine Yard escribió en 2009: [138]

Es muy fácil adentrarse en Go. Hay una cantidad mínima de conceptos fundamentales del lenguaje y la sintaxis es clara y está diseñada para ser inequívoca. Go todavía es experimental y todavía tiene algunos detalles preliminares.

Go fue nombrado Lenguaje de Programación del Año por el Índice de la Comunidad de Programación TIOBE en su primer año, 2009, por tener un mayor aumento de popularidad en 12 meses (en solo 2 meses, después de su introducción en noviembre) que cualquier otro lenguaje ese año, y alcanzó el puesto 13 en enero de 2010, [139] superando a lenguajes establecidos como Pascal . Para junio de 2015, su clasificación había caído por debajo del puesto 50 en el índice, ubicándose más abajo que COBOL y Fortran . [140] Pero a partir de enero de 2017, su clasificación había subido al puesto 13, lo que indica un crecimiento significativo en popularidad y adopción. Go fue nuevamente galardonado como Lenguaje de Programación TIOBE del Año en 2016. [141]

Bruce Eckel ha declarado: [142]

La complejidad de C++ (se ha añadido aún más complejidad en el nuevo C++) y el impacto resultante en la productividad ya no se justifican. Todos los obstáculos que el programador de C++ tuvo que superar para utilizar un lenguaje compatible con C ya no tienen sentido: son solo una pérdida de tiempo y esfuerzo. Go tiene mucho más sentido para la clase de problemas que C++ originalmente se pretendía resolver.

Una evaluación de 2011 del lenguaje y su implementación de gc en comparación con C++ ( GCC ), Java y Scala realizada por un ingeniero de Google encontró lo siguiente:

Go ofrece interesantes características del lenguaje, que además permiten una notación concisa y estandarizada. Los compiladores para este lenguaje aún son inmaduros, lo que se refleja tanto en el rendimiento como en el tamaño de los binarios.

—  R. Hundt [143]

La evaluación recibió una refutación del equipo de desarrollo de Go. Ian Lance Taylor, que había mejorado el código de Go para el artículo de Hundt, no había estado al tanto de la intención de publicar su código, y dice que su versión "nunca tuvo la intención de ser un ejemplo de Go idiomático o eficiente"; Russ Cox luego optimizó el código de Go, así como el código de C++, y logró que el código de Go se ejecutara casi tan rápido como la versión de C++ y más de un orden de magnitud más rápido que el código del artículo. [144]

Disputa por el nombre

El 10 de noviembre de 2009, el día del lanzamiento general del lenguaje, Francis McCabe, desarrollador del lenguaje de programación Go! (nótese el signo de exclamación), solicitó un cambio de nombre del lenguaje de Google para evitar confusiones con su lenguaje, que había pasado 10 años desarrollando. [151] McCabe expresó su preocupación de que "el 'gran tipo' terminará arrollándolo", y esta preocupación resonó entre los más de 120 desarrolladores que comentaron en el hilo de problemas oficiales de Google diciendo que deberían cambiar el nombre, y algunos [152] incluso dijeron que el problema contradice el lema de Google de: No seas malvado . [153]

El 12 de octubre de 2010, el ticket de problema público presentado fue cerrado por el desarrollador de Google Russ Cox (@rsc) con el estado personalizado "Desafortunado" acompañado del siguiente comentario:

"Hay muchos productos y servicios informáticos que se llaman Go. En los 11 meses transcurridos desde su lanzamiento, ha habido una mínima confusión entre ambos lenguajes". [153]

Véase también

Notas

  1. ^ El uso de backends alternativos reduce la velocidad de compilación y el control de Go sobre la recolección de basura, pero proporciona una mejor optimización del código de máquina. [19]
  2. ^ Pero "Para permitir que declaraciones complejas ocupen una sola línea, se puede omitir un punto y coma antes de un ) o } de cierre". [54]
  3. ^ "Si la nueva línea viene después de un token que podría finalizar una declaración, [el analizador léxico] insertará un punto y coma". [55]
  4. ^ Por lo general, exactamente uno de los valores de resultado y error tiene un valor distinto del valor cero del tipo; a veces ambos lo tienen, como cuando una lectura o escritura solo se puede completar parcialmente, y a veces ninguno, como cuando una lectura devuelve 0 bytes. Consulte Problema de semipredicado: retorno multivalor .
  5. ^ ab Preguntas frecuentes sobre el lenguaje "¿Por qué no existe la aritmética de punteros? Seguridad... nunca se deriva una dirección ilegal que tiene éxito de forma incorrecta... el uso de índices de matriz puede ser tan eficiente como... la aritmética de punteros... simplifica la implementación del recolector de basura..." [4]
  6. ^ Preguntas frecuentes sobre el lenguaje "¿Por qué Go no tiene aserciones? ...nuestra experiencia ha sido que los programadores las usan como una muleta para evitar pensar en el manejo y reporte de errores adecuados..." [4]
  7. ^ Preguntas frecuentes sobre el lenguaje "¿Por qué no hay uniones sin etiquetar...? [Estas] violarían las garantías de seguridad de memoria de Go". [4]
  8. ^ Preguntas frecuentes sobre el lenguaje "¿Por qué Go no tiene tipos variantes? ... Los consideramos, pero se superponen de manera confusa con las interfaces... [A]lgunos de los aspectos que abordan los tipos variantes ya están cubiertos, ... aunque no de manera tan elegante". [4] (Se accede a la etiqueta de un tipo de interfaz [112] con una afirmación de tipo [113] ).
  9. ^ Preguntas "¿Cómo obtengo el envío dinámico de métodos?" y "¿Por qué no hay herencia de tipos?" en las preguntas frecuentes del lenguaje. [4]

Referencias

  1. ^ "Codewalk: Funciones de primera clase en Go". Go admite funciones de primera clase, funciones de orden superior, tipos de funciones definidos por el usuario, literales de función, cierres y múltiples valores de retorno. Este amplio conjunto de características admite un estilo de programación funcional en un lenguaje fuertemente tipado.
  2. ^ "¿Go es un lenguaje orientado a objetos?" . Consultado el 13 de abril de 2019. Aunque Go tiene tipos y métodos y permite un estilo de programación orientado a objetos, no existe una jerarquía de tipos.
  3. ^ "Go: código que crece con gracia" . Consultado el 24 de junio de 2018. Go está orientado a objetos, pero no de la forma habitual.
  4. ^ abcdefgh "Preguntas frecuentes sobre diseño de lenguaje". El lenguaje de programación Go . 16 de enero de 2010. Consultado el 27 de febrero de 2010 .
  5. ^ ab "Archivo de texto LICENCIA". El lenguaje de programación Go . Consultado el 5 de octubre de 2012 .
  6. ^ "La especificación del lenguaje de programación Go - el lenguaje de programación Go".
  7. ^ ab "¿Por qué Go no tiene declaraciones de "implementos"?". El lenguaje de programación Go . Consultado el 1 de octubre de 2015 .
  8. ^ Pike, Rob (22 de diciembre de 2014). "Rob Pike en Twitter". Archivado desde el original el 7 de abril de 2022. Consultado el 13 de marzo de 2016. Go tiene tipado estructural, no tipado de pato. Se comprueba y exige la plena satisfacción de la interfaz.
  9. ^ "lang/go: go-1.4". Puertos OpenBSD . 23 de diciembre de 2014 . Consultado el 19 de enero de 2015 .
  10. ^ "Esfuerzos de portabilidad de Go". Recursos del lenguaje Go . cat-v. 12 de enero de 2010 . Consultado el 18 de enero de 2010 .
  11. ^ "Concesión de derechos de propiedad intelectual adicionales". El lenguaje de programación Go . Consultado el 5 de octubre de 2012 .
  12. ^ Kincaid, Jason (10 de noviembre de 2009). "Google's Go: A New Programming Language That's Python Meets C++" (Go de Google: un nuevo lenguaje de programación que combina Python con C++). TechCrunch . Consultado el 18 de enero de 2010 .
  13. ^ Metz, Cade (5 de mayo de 2011). "Google Go se atreve a ir donde ningún código ha ido antes". The Register .
  14. ^ "¿El lenguaje se llama Go o Golang?" . Consultado el 16 de marzo de 2022 . El lenguaje se llama Go.
  15. ^ "Notas de la versión de Go 1.5" . Consultado el 28 de enero de 2016 . El compilador y el entorno de ejecución ahora están implementados en Go y ensamblador, sin C.
  16. ^ "Go 1.11 ya está disponible". 24 de agosto de 2018. Consultado el 1 de enero de 2019 .
  17. ^ "Instalación de GCC: configuración" . Consultado el 3 de diciembre de 2011 . Ada, Go y Objective-C++ no son lenguajes predeterminados
  18. ^ "Preguntas frecuentes: Implementación". El lenguaje de programación Go . 2 de agosto de 2021 . Consultado el 2 de agosto de 2021 .
  19. ^ "gollvm § ¿gollvm es un reemplazo para el compilador principal de Go? (gc)". Git en Google .
  20. ^ "Un compilador de Go a JavaScript para ejecutar código Go en un navegador: Gopherjs/Gopherjs". GitHub . Archivado desde el original el 12 de diciembre de 2023.
  21. ^ "Go at Google: Language Design in the Service of Software Engineering" (Ve a Google: Diseño de lenguaje al servicio de la ingeniería de software) . Consultado el 8 de octubre de 2018 .
  22. ^ Pike, Rob (28 de abril de 2010). "Otra oportunidad en el diseño de lenguajes". Stanford EE Computer Systems Colloquium . Universidad de Stanford .Vídeo disponible.
  23. ^ "Preguntas frecuentes (FAQ) - El lenguaje de programación Go". El lenguaje de programación Go . Consultado el 26 de febrero de 2016 .
  24. ^ Binstock, Andrew (18 de mayo de 2011). "Dr. Dobb's: Entrevista con Ken Thompson". Archivado desde el original el 5 de enero de 2013. Consultado el 7 de febrero de 2014 .
  25. ^ Pike, Rob (2012). "Menos es exponencialmente más".
  26. ^ Griesemer, Robert (2015). "La evolución del Go".
  27. ^ Griesemer, Robert; Pike, Rob; Thompson, Ken; Taylor, Ian; Cox, Russ; Kim, Jini; Langley, Adam. "¡Hey! ¡Ho! ¡Vamos!". Google Open Source . Consultado el 17 de mayo de 2018 .
  28. ^ Shankland, Stephen (30 de marzo de 2012). "El lenguaje Go de Google cumple un año y gana un lugar en YouTube: el lenguaje de programación de nivel inferior ha madurado lo suficiente como para ostentar el número de versión 1.0. Y se está utilizando para el trabajo real en Google". Noticias. CNet . CBS Interactive Inc . Consultado el 6 de agosto de 2017 . Google ha lanzado la versión 1 de su lenguaje de programación Go, un ambicioso intento de mejorar a los gigantes del mundo de la programación de nivel inferior como C y C++.
  29. ^ "Historial de versiones". El lenguaje de programación Go .
  30. ^ "Preguntas frecuentes sobre Go: ¿Google utiliza Go internamente?" . Consultado el 9 de marzo de 2013 .
  31. ^ "The Go Gopher - El lenguaje de programación Go". go.dev . Consultado el 9 de febrero de 2023 .
  32. ^ "Go fonts". Go. 16 de noviembre de 2016. Consultado el 12 de marzo de 2019 .
  33. ^ "Go Font TTFs". GitHub . Consultado el 2 de abril de 2019 .
  34. ^ "La nueva marca de Go". The Go Blog . Consultado el 9 de noviembre de 2018 .
  35. ^ Merrick, Alice (9 de marzo de 2021). "Go Developer Survey 2020 Results". Lenguaje de programación Go . Consultado el 16 de marzo de 2022 .
  36. ^ ab Pike, Rob (26 de septiembre de 2013). "Matrices, porciones (y cadenas): la mecánica de 'append'". The Go Blog . Consultado el 7 de marzo de 2015 .
  37. ^ "E2E: Erik Meijer y Robert Griesemer". Canal 9 . Microsoft. 7 de mayo de 2012.
  38. ^ "Go 2 Draft Designs" . Consultado el 12 de septiembre de 2018 .
  39. ^ "El blog de Go: diseños preliminares de Go 2". 28 de agosto de 2018.
  40. ^ "Propuesta: una función de comprobación de errores de Go integrada, "try"". Repositorio de Go en GitHub . Consultado el 16 de marzo de 2022 .
  41. ^ "Parámetros de tipo: borrador de diseño". go.googlesource.com .
  42. ^ "Medicamentos genéricos en Go". bitfieldconsulting.com . 17 de diciembre de 2021.
  43. ^ "¡Ya se lanzó Go 1.18!". Lenguaje de programación Go . 15 de marzo de 2022. Consultado el 16 de marzo de 2022 .
  44. ^ "Go 1 y el futuro de los programas Go". El lenguaje de programación Go .
  45. ^ "Notas de la versión 1.23 de Go". El lenguaje de programación Go .
  46. ^ "Historial de versiones". El lenguaje de programación Go .
  47. ^ "Compatibilidad con versiones anteriores, Go 1.21 y Go 2". El lenguaje de programación Go .
  48. ^ "Una guía rápida del ensamblador de Go". go.dev . Consultado el 31 de diciembre de 2021 .
  49. ^ Pike, Rob. "El lenguaje de programación Go". YouTube . Consultado el 1 de julio de 2011 .
  50. ^ Pike, Rob (10 de noviembre de 2009). El lenguaje de programación Go (flv) (charla técnica). Google. El evento ocurre a las 8:53.
  51. ^ "Descargar e instalar paquetes y dependencias".Consulte godoc.org para obtener direcciones y documentación de algunos paquetes.
  52. ^ "GoDoc". godoc.org .
  53. ^ Pike, Rob. "The Changelog" (Podcast). Archivado desde el original el 20 de octubre de 2013. Consultado el 7 de octubre de 2013 .
  54. ^ "Especificación del lenguaje de programación Go, §Puntos y coma". El lenguaje de programación Go .
  55. ^ "Go eficaz, §Puntos y coma". El lenguaje de programación Go .
  56. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  57. ^ Pike, Rob (23 de octubre de 2013). "Cadenas, bytes, runas y caracteres en Go".
  58. ^ Doxsey, Caleb. "Estructuras e interfaces: una introducción a la programación en Go". www.golang-book.com . Consultado el 15 de octubre de 2018 .
  59. ^ Gerrand, Andrew. "Go Slices: uso y funcionamiento interno".
  60. ^ Los autores de Go. "Go eficaz: porciones".
  61. ^ Los autores de Go. "Selectores".
  62. ^ Los autores de Go. "Llamadas".
  63. ^ "Especificación del lenguaje de programación Go, §Paquete no seguro". El lenguaje de programación Go .
  64. ^ "La especificación del lenguaje de programación Go". go.dev . Consultado el 31 de diciembre de 2021 .
  65. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  66. ^ "Un recorrido por go". go.dev .
  67. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  68. ^ "La especificación del lenguaje de programación Go". go.dev . Consultado el 31 de diciembre de 2021 .
  69. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  70. ^ ab Schmager, Frank; Cameron, Nicholas; Noble, James (2010). GoHotDraw: evaluación del lenguaje de programación Go con patrones de diseño . Evaluación y usabilidad de lenguajes y herramientas de programación. ACM.
  71. ^ abcde Balbaert, Ivo (2012). El camino a seguir: una introducción completa al lenguaje de programación Go . iUniverse.
  72. ^ "La evolución del Go". talks.golang.org . Consultado el 13 de marzo de 2016 .
  73. ^ Diggins, Christopher (24 de noviembre de 2009). "Duck Typing and the Go Programming Language". Dr. Dobb's, El mundo del desarrollo de software . Consultado el 10 de marzo de 2016 .
  74. ^ Ryer, Mat (1 de diciembre de 2015). «Duck writing in Go» (Pato escribiendo en Go) . Consultado el 10 de marzo de 2016 .
  75. ^ "Preguntas frecuentes (FAQ) - El lenguaje de programación Go". El lenguaje de programación Go .
  76. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  77. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  78. ^ "paquete reflect". pkg.go.dev .
  79. ^ "map[string]interface{} en Go". bitfieldconsulting.com . 6 de junio de 2020.
  80. ^ "Estructuras de datos Go: Interfaces" . Consultado el 15 de noviembre de 2012 .
  81. ^ "La especificación del lenguaje de programación Go". El lenguaje de programación Go .
  82. ^ "Notas de la versión 1.18 de Go: genéricos". Lenguaje de programación Go . 15 de marzo de 2022 . Consultado el 16 de marzo de 2022 .
  83. ^ "Propuesta de parámetros de tipo". go.googlesource.com . Consultado el 25 de junio de 2023 .
  84. ^ "La especificación del lenguaje de programación Go - El lenguaje de programación Go". go.dev . Consultado el 25 de junio de 2023 .
  85. ^ "Introducción a los genéricos: el lenguaje de programación Go". go.dev . Consultado el 25 de junio de 2023 .
  86. ^ "Propuesta de parámetros de tipo". go.googlesource.com . Consultado el 25 de junio de 2023 .
  87. ^ "Go eficaz". golang.org . Los autores de Go . Consultado el 13 de mayo de 2014 .
  88. ^ "Un tutorial para el lenguaje de programación Go". El lenguaje de programación Go . Consultado el 10 de marzo de 2013. En Go , la regla sobre la visibilidad de la información es simple: si un nombre (de un tipo, función, método, constante o variable de nivel superior, o de un campo o método de estructura) está en mayúsculas, los usuarios del paquete pueden verlo. De lo contrario, el nombre y, por lo tanto, la cosa que se nombra solo es visible dentro del paquete en el que se declara.
  89. ^ "go". El lenguaje de programación Go .
  90. ^ "Cómo escribir código Go". El lenguaje de programación Go . Los paquetes de la biblioteca estándar reciben rutas de importación cortas, como "fmt" y "net/http". Para sus propios paquetes, debe elegir una ruta base que no tenga muchas probabilidades de colisionar con futuras incorporaciones a la biblioteca estándar u otras bibliotecas externas. Si mantiene su código en un repositorio de código fuente en algún lugar, entonces debe usar la raíz de ese repositorio de código fuente como su ruta base. Por ejemplo, si tiene una cuenta de Example en example.com/user, esa debería ser su ruta base
  91. ^ ab Pike, Rob (18 de septiembre de 2012). "La concurrencia no es paralelismo".
  92. ^ ab Donovan, Alan AA; Kernighan, Brian W. (2016). El lenguaje de programación Go . Serie informática profesional de Addison-Wesley. Nueva York, Múnich: Addison-Wesley. ISBN 978-0-13-419044-0.
  93. ^ abcde Chisnall, David (2012). Manual de frases del lenguaje de programación Go. Addison-Wesley. ISBN 9780132919005.
  94. ^ "Go eficaz". El lenguaje de programación Go .
  95. ^ Summerfield, Mark (2012). Programación en Go: creación de aplicaciones para el siglo XXI . Addison-Wesley.
  96. ^ "El modelo de memoria de Go" . Consultado el 10 de abril de 2017 .
  97. ^ "Patrones de concurrencia en Go". El lenguaje de programación Go .
  98. ^ Graham-Cumming, John (24 de agosto de 2013). "Reciclaje de búferes de memoria en Go".
  99. ^ "árbol.go".
  100. ^ Cheslack-Postava, Ewen. "Iteradores en Go".
  101. ^ Kernighan, Brian W. "Un descenso al limbo".
  102. ^ ab "El modelo de memoria de Go" . Consultado el 5 de enero de 2011 .
  103. ^ Tang, Peiyi (2010). Programación paralela multinúcleo en Go (PDF) . Proc. Primera Conferencia Internacional sobre Computación y Comunicaciones Avanzadas. Archivado desde el original (PDF) el 9 de septiembre de 2016. Consultado el 14 de mayo de 2015 .
  104. ^ Nanz, Sebastian; West, Scott; Soares Da Silveira, Kaue. Examinando la brecha de expertos en programación paralela (PDF) . Euro-Par 2013. CiteSeerX 10.1.1.368.6137 . 
  105. ^ Go Authors. "Compartir la memoria mediante la comunicación".
  106. ^ Cox, Russ . "A las carreras".
  107. ^ Pike, Rob (25 de octubre de 2012). "Go at Google: Diseño de lenguaje al servicio de la ingeniería de software". Google, Inc."Hay una salvedad importante: Go no es puramente seguro para la memoria en presencia de concurrencia".
  108. ^ "Presentación del detector de carreras Go". The Go Blog . Consultado el 26 de junio de 2013 .
  109. ^ "Notas de la versión de Go 1.6: el lenguaje de programación Go". go.dev . Consultado el 17 de noviembre de 2023 .
  110. ^ "Preguntas frecuentes (FAQ) - el lenguaje de programación Go".
  111. ^ "La historia de un binario gordo". 21 de septiembre de 2018.
  112. ^ "Especificación del lenguaje de programación Go, §Tipos de interfaz". El lenguaje de programación Go .
  113. ^ "Especificación del lenguaje de programación Go, §Afirmaciones de tipo". El lenguaje de programación Go .
  114. ^ "Todos los sistemas están listos". informIT (Entrevista). 17 de agosto de 2010. Consultado el 21 de junio de 2018 .
  115. ^ "Preguntas frecuentes sobre diseño de lenguaje". 13 de noviembre de 2009. Archivado desde el original el 13 de noviembre de 2009.
  116. ^ "Propuesta de un mecanismo de tipo excepcional". golang-nuts . 25 de marzo de 2010 . Consultado el 25 de marzo de 2010 .
  117. ^ "Historial de instantáneas semanales". El lenguaje de programación Go .
  118. ^ "Entrar en pánico y recuperarse". Ir a wiki.
  119. ^ "Go eficaz". El lenguaje de programación Go .
  120. ^ "gofmt". El lenguaje de programación Go . Consultado el 5 de febrero de 2021 .
  121. ^ "Archivo público de golang/lint". github.com . 30 de noviembre de 2022.
  122. ^ ab "Go efectivo". El lenguaje de programación Go .
  123. ^ "Variables locales no utilizadas". yourbasic.org . Consultado el 11 de febrero de 2021 .
  124. ^ "Importaciones de paquetes no utilizados". yourbasic.org . Consultado el 11 de febrero de 2021 .
  125. ^ "Comentarios de revisión de código". GitHub . Consultado el 3 de julio de 2018 .
  126. ^ "Charlas" . Consultado el 3 de julio de 2018 .
  127. ^ "Los errores son valores" . Consultado el 3 de julio de 2018 .
  128. ^ "tools/gopls/README.md at master · golang/tools". GitHub . Consultado el 17 de noviembre de 2023 .
  129. ^ "fmt". El lenguaje de programación Go . Consultado el 8 de abril de 2019 .
  130. ^ "prueba". El lenguaje de programación Go . Consultado el 27 de diciembre de 2020 .
  131. ^ Lee, Wei-Meng (24 de noviembre de 2022). «Introducción al lenguaje de programación Go». Revista Component Developer . Archivado desde el original el 5 de junio de 2023. Consultado el 8 de septiembre de 2023 .
  132. ^ Hoffmann, Frank; Neumeyer, Mandy (agosto de 2018). «Simply Secure». Linux Magazine . N.º 213. Archivado desde el original el 28 de mayo de 2023. Consultado el 8 de septiembre de 2023 .
  133. ^ Lee, Wei-Meng (31 de agosto de 2022). «Introducción a la contenedorización con Docker». Revista CODE . Archivado desde el original el 30 de mayo de 2023. Consultado el 8 de septiembre de 2023 .
  134. ^ Pirker, Alexander (24 de febrero de 2023). «Seguridad de Kubernetes para principiantes». Revista CODE . Archivado desde el original el 1 de abril de 2023. Consultado el 8 de septiembre de 2023 .
  135. ^ Taft, Rebecca; Sharif, Irfan; Matei, Andrei; Van Benschoten, Nathan; Lewis, Jordan; Grieger, Tobias; Niemi, Kai; Woods, Andy; Birzin, Anne; Poss, Raphael; Bardea, Paul; Ranade, Amruta; Darnell, Ben; Gruneir, Bram; Jaffray, Justin; Zhang, Lucy; Mattis, Peter (11 de junio de 2020). "CockroachDB: la base de datos SQL geodistribuida resiliente". Actas de la Conferencia internacional ACM SIGMOD 2020 sobre gestión de datos . SIGMOD '20. págs. 1493–1509. doi : 10.1145/3318464.3386134 . ISBN . 978-1-4503-6735-6.
  136. ^ Hopkins, Brandon (13 de septiembre de 2022). «Generación de sitios estáticos con Hugo». Linux Journal . Archivado desde el original el 8 de abril de 2023. Consultado el 8 de septiembre de 2023 .
  137. ^ Simionato, Michele (15 de noviembre de 2009). "Interfaces vs. Herencia (o, ¡cuidado con Go!)". artima . Consultado el 15 de noviembre de 2009 .
  138. ^ Astels, Dave (9 de noviembre de 2009). "Ready, Set, Go!". Engineyard. Archivado desde el original el 19 de octubre de 2018. Consultado el 9 de noviembre de 2009 .
  139. ^ jt (11 de enero de 2010). «Go de Google gana el premio al lenguaje de programación del año». jaxenter . Consultado el 5 de diciembre de 2012 .
  140. ^ "Índice de la comunidad de programación TIOBE para junio de 2015". Software TIOBE. Junio ​​de 2015. Consultado el 5 de julio de 2015 .
  141. ^ "Índice TIOBE". TIOBE . Consultado el 15 de julio de 2024 .
  142. ^ Eckel, Bruce (27 de agosto de 2011). "Llamar a Go desde Python mediante JSON-RPC" . Consultado el 29 de agosto de 2011 .
  143. ^ Hundt, Robert (2011). Reconocimiento de bucles en C++/Java/Go/Scala (PDF) . Scala Days.
  144. ^ Metz, Cade (1 de julio de 2011). "Google Go contraataca con un concurso de C++". The Register .
  145. ^ Yager, Will. "Por qué Go no es bueno" . Consultado el 4 de noviembre de 2018 .
  146. ^ Dobronszki, Janos. "Everyday Hassles in Go" (Los problemas cotidianos en Go) . Consultado el 4 de noviembre de 2018 .
  147. ^ "¿Por qué hay llaves pero no punto y coma? ¿Y por qué no puedo poner la llave de apertura en la siguiente línea?" . Consultado el 26 de marzo de 2020. Las ventajas de un formato único, exigido por programación para todos los programas Go, superan ampliamente cualquier desventaja percibida del estilo en particular.
  148. ^ "Quiero bajarme del viaje salvaje del señor Golang". 28 de febrero de 2020. Consultado el 17 de noviembre de 2020 .
  149. ^ "Propuesta: sistema operativo: Create/Open/OpenFile() establece FILE_SHARE_DELETE en Windows #32088". GitHub . 16 de mayo de 2019 . Consultado el 17 de noviembre de 2020 .
  150. ^ Tu, Tengfei (2019). "Understanding Real-World Concurrency Bugs in Go" (PDF) . Por ejemplo, alrededor del 58% de los errores de bloqueo son causados ​​por el paso de mensajes. Además de la violación de las reglas de uso del canal de Go (por ejemplo, esperar en un canal al que nadie envía datos o cerrarlo), muchos errores de concurrencia son causados ​​por el uso mixto del paso de mensajes y otras semánticas y bibliotecas nuevas en Go, que pueden pasarse por alto fácilmente pero son difíciles de detectar.
  151. ^ Brownlee, John (13 de noviembre de 2009). «Google no buscó «Go» antes de nombrar su lenguaje de programación». Archivado desde el original el 8 de diciembre de 2015. Consultado el 26 de mayo de 2016 .
  152. ^ Claburn, Thomas (11 de noviembre de 2009). «El nombre 'Go' de Google genera acusaciones de maldad». InformationWeek. Archivado desde el original el 22 de julio de 2010. Consultado el 18 de enero de 2010 .
  153. ^ ab "Número 9 - Go - Ya he usado el nombre para *MI* lenguaje de programación". Github . Google Inc. Consultado el 12 de octubre de 2010 .

Lectura adicional

Enlaces externos