Lenguaje de Programación Go

<p><span><span style="font-weight:bold;"><br /></span></span></p><p><span><span style="font-weight:bold;"><br /></span></span></p><p><span><span style="font-weight:bold;">Go</span> es un nuevo lenguaje de programación para sistemas lanzado por  </span><span><span>G</span><span>o</span><span>o</span><span>g</span><span>l</span><span>e</span></span><span> en Noviembre del 2009. Aunque empezó a ser desarrollado en Septiembre del 2007 por Robert Griesemer, Rob Pike y Ken Thompson.</span><br /></p><p><span>Go es un lenguaje de programación </span><strong>compilado</strong><span>, </span><strong>concurrente</strong><span>, </span><strong>imperativo</strong><span>, </span><strong>estructurado</strong><span>, </span>no orientado a objetos —de una manera bastante especial— y con <strong>recolector de basura</strong> que de momento está soportado en diferentes tipos de sistemas <span class="caps">UNIX</span>, incluidos Linux, FreeBSD y Mac OS X. También está disponible en Plan 9 puesto que parte del compilador está basado en un trabajo previo sobre el sistema operativo Inferno. Las arquitecturas soportadas son i386, amd64 y ARM<span>[<a href="http://www.genbetadev.com/herramientas/introduccion-al-lenguaje-de-programacion-go#nota_1" rel="nofollow">1</a>]</span>. Existe un port no oficial a Microsoft Windows pero es bastante inestable. Actualmente se está trabajando para llevarlo al sistema operativo de Microsoft.<span><br /></span></p><p></p><h2 style="text-align:center;font-weight:bold;">:::::: Introducción :::::::</h2><div><br /></div><div><p>Desde que Go fue anunciado, se generó un inmenso <strong>hype</strong> a su alrededor. No faltaron los que se apresuraron a bautizarlo como el <em>próximo C</em> —ha habido muchos próximos C que se quedaron en promesas— la diferencia principal al probar Go en serio es que te deja una sensación muy placentera que indica que realmente esta vez si podría haber <strong>algo de cierto</strong> detrás de esa afirmación.</p><p>Después de programar con él algo más complejo que un “<em>Hello World!</em>“ deja una <strong>agradable sensación</strong> y rápidamente se detectan los siguientes elementos en el lenguaje que revelan que detrás de toda la espantajería de fanboyismo y hype <strong>hay sustancia</strong>:</p><ul><li>Go usa una sintaxis parecida a C por lo que los programadores que hayan usado dicho lenguaje se sienten <strong>muy cómodos</strong> con él</li><li>Go usa <strong>tipado estático</strong> (estatically typed) y es tan eficiente como C</li><li>Go tiene muchas de las <strong>características y facilidad</strong> de lenguajes dinámicos como Python</li><li>Aún siendo un lenguaje diseñado para la programación de sistemas, provee de un recolector de basura, reflexión y otras capacidades de alto nivel que lo convierten en un lenguaje muy potente</li><li>Go no está orientado a objetos por que no existe jerarquía de tipos pero implementa <strong>interfaces.</strong></li></ul><div><span style="font-weight:bold;"><br /></span></div></div><p></p><h2 style="text-align:center;font-weight:bold;">:::::: Características :::::::</h2><div><br /></div><div><ul><li>Go usa una sintaxis parecida a C por lo que los programadores que hayan usado dicho lenguaje se sienten muy cómodos con él.</li><li>Go usa tipado estatico (statically typed) y es tan eficiente como C.</li><li>Go tiene muchas de las características y facilidad de lenguajes dinámicos como Python</li><li>Aún siendo un lenguaje diseñado para la programación de sistemas, provee de un recolector de basura, reflexión y otras capacidades de alto nivel que lo convierten en un lenguaje muy potente.</li><li>Go admite el paradigma de programación orientada a objetos, pero a diferencia de los lenguajes de programación más populares no dispone de herencia de tipos y tampoco de palabras clave que denoten claramente que soporta este paradigma. Otro detalle que puede resultar confuso es que la definición de un tipo ("clase") se realiza por medio de declaraciones separadas (interfaces, structs, embedded values). Go permite el uso de delegación (a través de embedded values) y polimorfismo (por medio de interfaces).</li></ul><div><span><br /></span></div></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">:::::: Simplicidad :::::::</h2></div><div><br /></div><div><span>Los lenguajes más utilizados como C++, Java o C# son más </span><strong>pesados y voluminosos</strong><span>. La sencillez es la característica principal de Go, su sintaxis es </span><strong>clara y concisa</strong><span>. Mientras que C es tristemente célebre por la complejidad de la sintaxis de sus declaraciones, Go utiliza </span><strong>inferencia implícita</strong><span> de tipos pudiéndose de esta manera evitar la declaración explícita de variables. La declaración de variables es simple y conveniente, y difiere de la de C.</span><br /></div><div><span><br /></span></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">::::::Tipificación Dinámica:::::::</h2></div><div><br /></div><div><span>Go admite la </span><strong>tipificación dinámica</strong><span> de datos también conocida como </span><em><strong>duck Typing</strong></em><span> presente en multitud de lenguajes dinámicos como por ejemplo JavaScript, Ruby o Python. Un </span><code>struct</code><span> puede implementar una interfaz de forma</span><strong> automática</strong><span>, lo cual es una característica potente y novedosa.</span></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">::::::Goroutines:::::::</h2></div><div><span><br /></span></div><div><span>No son ni threads, ni co-rutinas ni procesos. La comunicación entre </span><code>goroutines</code><span> se realiza a través de una característica del lenguaje llamada </span><strong>canales</strong><span> —basada en CSP—, que es mcho más seguro y fácil de usar que los sistemas predominantes basados en bloqueos de </span><code>pthreads</code><span> o características modernas de Java.</span><span><br /></span></div><div><span><br /></span></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">::::::Excepciones:::::::</h2></div><div><br /></div><div><span>Go </span><strong>no tiene excepciones</strong><span>. Los creadores del lenguaje dan varios motivos para que esto sea así. Uno de ellos es que añadir una capa de excepciones añade una complejidad innecesaria al lenguaje y al entorno de ejecución. Por definición deberían de ser </span><strong><em>excepcionales</em></strong><span> pero al final se acaban usando como controladores del flujo de la aplicación y dejan de tener nada de excepcional. Según los creadores, las excepciones tienen que ser realmente excepcionales y el uso que se le da mayoritariamente </span><strong>no justifica</strong><span> su existencia.</span><br /></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">::::::Diferencias:::::::</h2></div><div><br /></div><div><p>En Go las declaraciones se realizan <strong>al revés</strong> desde la perspectiva de C (o C++ o Java). La idea principal en C es que se declara una variable como una expresión que denota su tipo. Según los creadores, aunque la idea detrás de la declaración de tipos en C <strong>es buena</strong>, los tipos y las expresiones gramaticales no se mezclan demasiado bien y el resultado puede ser confuso. Go sin embargo, separa la expresión y la sintaxis de tipo lo cual simplifica las cosas (el prefijo para los punteros es la excepción que confirma la regla). Una declaración típica en C sería:<br /></p><pre class="prettyprint lang-c prettyprinted"><code><span class="typ">int</span><span class="pun"></span><span class="pln"> i</span><span class="pun">,</span><span class="pln"> j</span><span class="pun">;</span></code></pre><br /><span>Declara que </span><code>i</code><span> es un puntero, pero no </span><code>j</code><span>. En Go:</span><br /><pre class="prettyprint lang-go prettyprinted"><code><span class="kwd" style="font-weight:bold;">var</span><span class="pln"> i</span><span class="pun">,</span><span class="pln"> j </span><span class="pun">*</span><span class="kwd" style="font-weight:bold;">int</span></code></pre><br /><span>Se declaran las dos variables como punteros. Es más claro y natural.</span><br /></div><div><span><br /></span></div><div><span><br /></span></div><div><h2 style="text-align:center;font-weight:bold;">::::::Ejemplos:::::::</h2></div><div><br /></div><div><p> Ejemplo más simple posible a escribir con Go:<br /></p><pre class="prettyprint lang-go prettyprinted"><code><span class="kwd" style="font-weight:bold;">package</span><span class="pln"> main </span><span class="kwd" style="font-weight:bold;">import</span><span class="pln"> </span><span class="str">"fmt"</span><span class="pln"> func main</span><span class="pun">()</span><span class="pln"> </span><span class="pun">{</span><span class="pln"> fmt</span><span class="pun">.</span><span class="typ">Printf</span><span class="pun">(</span><span class="str">"Hola, mundo!\n"</span><span class="pun">)</span><span class="pln"> </span><span class="pun">}</span></code></pre><p></p><p>Todos los archivos Go deben <strong>declarar el paquete</strong> al que pertenecen a través de una sentencia<code>package</code>. También pueden importar módulos y funciones externas de otros paquetes, en este caso usamos las funciones del paquete “<code>fmt</code>“ que nos da acceso a la función <code>Printf</code>. Todos los archivos en Go son UTF-8. Para compilar el código anterior usaríamos el compilador Gc o el back-end de gcc.</p><div><br /></div><div><br /></div><p></p></div>

lenguaje google lenguaje programación google go