One place for hosting & domains

      Local

      Cómo instalar Go y configurar un entorno de programación local en Ubuntu 18.04


      Introducción

      Go es un lenguaje de programación que se creó a partir de la frustración en Google. Continuamente, los desarrolladores tenían que elegir entre un lenguaje que se ejecutaba de forma eficiente, pero tardaba mucho en realizar compilaciones, y uno que ofrecía programación sencilla, pero se ejecutaba de forma ineficiente en la producción. Go se diseñó para tener las tres características disponibles al mismo tiempo: compilación rápida, facilidad de programación y ejecución eficiente en producción.

      Si bien Go es un lenguaje de programación versátil que puede utilizarse para muchos proyectos de programación distintos, es especialmente adecuado para los programas de redes o de sistemas distribuidos y se ha ganado la reputación de “lenguaje de la nube”. Se centra en ayudar al programador moderno a ampliar sus capacidades con un conjunto sólido de herramientas, eliminar debates sobre el formato al incorporarlo en las especificaciones del lenguaje y permitir una implementación sencilla al realizar compilaciones en un único binario. Aprender a usar Go es sencillo, ya que cuenta con un conjunto de palabras claves muy reducido, por lo que es una excelente elección tanto para desarrolladores principiantes como experimentados.

      Este tutorial le servirá como guía en la instalación y configuración de un espacio de trabajo de programación con Go a través de la línea de comandos. En él, se abarcará de forma explícita el procedimiento de instalación para Ubuntu 18.04, pero los principios generales pueden aplicarse a otras distribuciones de Debian Linux.

      Requisitos previos

      Necesitará una computadora o una máquina virtual con Ubuntu 18.04 instalado, acceso de administrador a esa máquina y conexión a Internet. Puede descargar este sistema operativo de la página de versiones de Ubuntu 18.04.

      Paso 1: Configurar Go

      En este paso, instalará Go tras descargar la versión actual de la página oficial de descargas de Go.

      Para hacerlo, deberá encontrar la URL del tarball para la versión binaria actual. También le convendrá tomar nota del hash SHA256 enumerado junto a ella, dado que lo usará para verificar el archivo descargado.

      Completará la mayor parte de la instalación y configuración en la línea de comandos, una alternativa para interactuar con la computadora sin gráficos. Es decir que, en lugar de hacer clic en botones, escribirá texto y recibirá retroalimentación de la computadora, también en texto.

      La línea de comandos, también conocida como shell o terminal, puede ayudar a modificar y automatizar muchas de las tareas que se realizan en una computadora a diario, y es una herramienta esencial para los desarrolladores de software. Hay muchos comandos del terminal que puede aprender para realizar tareas que tengan efectos más potentes. Para obtener más información sobre la línea de comandos, consulte el tutorial Introducción al terminal de Linux.

      En Ubuntu 18.04, puede encontrar la aplicación del terminal haciendo clic en el ícono de Ubuntu ubicado en la esquina superior izquierda de la pantalla y escribir terminal en la barra de búsqueda. Haga clic en el ícono de la aplicación del terminal para abrirla. Como alternativa, puede pulsar las teclas CTRL, ALT y T del teclado al mismo tiempo para abrir la aplicación del terminal de forma automática.

      Terminal de Ubuntu

      Una vez que el terminal esté abierto, instalará manualmente los binarios de Go. Si bien podría usar un gestor de paquetes, como apt-get, repasar los pasos de la instalación manual lo ayudará a comprender cualquier cambio de configuración que se requiera en su sistema para tener un espacio de trabajo válido de Go.

      Antes de descargar Go, asegúrese de encontrarse en el directorio principal (~):

      Utilice curl para obtener la URL del tarball que copió de la página oficial de descargas de Go:

      • curl -O https://dl.google.com/go/go1.12.1.linux-amd64.tar.gz

      Luego, utilice sha256sum para verificar el tarball:

      • sha256sum go1.12.1.linux-amd64.tar.gz

      El hash que se muestra al ejecutar el comando anterior debería coincidir con el de la página de descargas. Si no lo hace, no es un archivo válido, por lo que deberá volver a descargar el archivo.

      Output

      2a3fdabf665496a0db5f41ec6af7a9b15a49fbe71a85a50ca38b1f13a103aeec go1.12.1.linux-amd64.tar.gz

      A continuación, extraiga el archivo descargado e instálelo en la ubicación del sistema que desee. Se recomienda mantenerlo en /usr/local:

      • sudo tar -xvf go1.12.1.linux-amd64.tar.gz -C /usr/local

      Con esto, dispondrá de un directorio llamado go en el directorio /usr/local. A continuación, cambie de forma recursiva el propietario y el grupo de este directorio por root:

      • sudo chown -R root:root /usr/local/go

      Esto protegerá todos los archivos y garantizará que solo el usuario root pueda ejecutar los binarios de Go.

      Nota: Aunque /usr/local/go es la ubicación que se recomienda oficialmente, algunos usuarios pueden preferir o requerir diferentes rutas.

      Siguiendo este paso, descargó e instaló Go en su máquina con Ubuntu 18.04. A través del siguiente paso, configurará su espacio de trabajo de Go.

      Paso 2: Crear su espacio de trabajo de Go

      Ahora que Go está instalado, puede crear su espacio de trabajo de programación. El espacio de trabajo de Go contendrá dos directorios en su root:

      • src: directorio que contiene los archivos de origen de Go. Un archivo de origen es un archivo que se escribe con el lenguaje de programación Go. El compilador de Go utiliza los archivos de origen para crear un archivo binario ejecutable.
      • bin: directorio que contiene ejecutables creados e instalados con las herramientas de Go. Los ejecutables son archivos binarios que se ejecutan en su sistema y realizan tareas. Suelen ser programas compilados con su código fuente u otro código fuente de Go descargado.

      El subdirectorio src puede contener varios repositorios de control de versiones (como Git, Mercurial y Bazar). Esto permite una importación canónica de código en su proyecto. Las importaciones canónicas son las que hacen referencia a un paquete completo, como github.com/digitalocean/godo.

      Verá directorios como github.com, golang.org u otros cuando su programa importe bibliotecas de terceros. Si usa un repositorio de códigos como github.com, también dispondrá sus proyectos y archivos de origen en ese directorio. Analizaremos este concepto más adelante en este paso.

      Un espacio de trabajo típico puede tener el siguiente aspecto:

      .
      ├── bin
      │   ├── buffalo                                      # command executable
      │   ├── dlv                                          # command executable
      │   └── packr                                        # command executable
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # Git repository metadata
                      ├── account.go                      # package source
                      ├── account_test.go                 # test source
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      El directorio predeterminado para el espacio de trabajo de Go a partir de la versión 1.8 es su directorio principal de usuario con un subdirectorio go o $HOME/go. Si usa una versión de Go anterior a la 1.8, de todos modos, es recomendable utilizar la ubicación $HOME/go para su espacio de trabajo.

      Emita el siguiente comando para crear la estructura de directorios para su espacio de trabajo de Go:

      • mkdir -p $HOME/go/{bin,src}

      La opción -p indica a mkdir que cree todos los parents en el directorio, incluso si todavía no existen. Con {bin,src}, se crea un conjunto de argumentos en mkdir y se indica a este que cree los directorios bin y src.

      Esto garantizará la creación de la siguiente estructura de directorios:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes de la versión 1.8 de Go, se debía establecer una variable de entorno local llamada $GOPATH. $GOPATH le indicó al compilador dónde encontrar el código fuente de terceros importado, así como cualquier código fuente local que usted haya escrito. Si bien ya no se requiere explícitamente, sigue siendo recomendable hacerlo, ya que muchas herramientas de terceros aún dependen de que esta variable esté configurada.

      Puede configurar su $GOPATH añadiendo variables globales a su ~/.profile. Es recomendable añadir esto en el archivo .zshrc o .bashrc, según la configuración de su shell.

      Primero, abra ~/.profile con nano o el editor de texto de su elección:

      Establezca su $GOPATH agregando lo siguiente al archivo:

      ~/.profile

      export GOPATH=$HOME/go
      

      Cuando Go compile e instale herramientas, las dispondrá en el directorio $GOPATH/bin. Para mayor comodidad, es común añadir el subdirectorio /bin del espacio de trabajo al PATH en ~/.profile:

      ~/.profile

      export PATH=$PATH:$GOPATH/bin
      

      Esto le permitirá ejecutar cualquier programa que realice compilaciones o descargas con las herramientas de Go en cualquier lugar de su sistema.

      Por último, deberá añadir el binario go a su PATH. Puede hacerlo agregando /usr/local/go/bin al final de la línea:

      ~/.profile

      export PATH=$PATH:$GOPATH/bin:/usr/local/go/bin
      

      Al añadir /usr/local/go/bin a su $PATH, todas las herramientas de Go estarán disponibles en cualquier lugar de su sistema.

      Para actualizar su shell, emita el siguiente comando a fin de cargar las variables globales:

      Puede verificar que $PATH esté actualizado usando el comando echo e inspeccionando el resultado:

      Debería ver su $GOPATH/bin, que aparecerá en el directorio principal. Si inició sesión como root, verá /root/go/bin en la ruta.

      Output

      /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

      También verá la ruta a las herramientas de Go para /usr/local/go/bin:

      Output

      /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/root/go/bin:/usr/local/go/bin

      Verifique la instalación revisando la versión actual de Go:

      El resultado debería ser similar a este:

      Output

      go version go1.12.1 linux/amd64

      Ahora que creó el root del espacio de trabajo y estableció la variable de entorno $GOPATH, creará sus futuros proyectos con la estructura de directorios siguiente. En este ejemplo, se supone que usa github.com como repositorio:

      $GOPATH/src/github.com/username/project
      

      Por lo tanto, a modo de ejemplo, si estuviera trabajando en el proyecto https://github.com/digitalocean/godo, se almacenaría en el siguiente directorio:

      $GOPATH/src/github.com/digitalocean/godo
      

      Esta estructura de proyecto hará que los proyectos estén disponibles con la herramienta go get. También facilitará la lectura más adelante. Puede verificar esto usando el comando go get para buscar la biblioteca godo:

      • go get github.com/digitalocean/godo

      Esto descargará el contenido de la biblioteca godo y creará el directorio $GOPATH/src/github.com/digitalocean/godo en su máquina.

      Puede verificar si descargó correctamente el paquete godo haciendo un listado del directorio:

      • ll $GOPATH/src/github.com/digitalocean/godo

      El resultado deberá ser similar a este:

      Output

      drwxr-xr-x 4 root root 4096 Apr 5 00:43 ./ drwxr-xr-x 3 root root 4096 Apr 5 00:43 ../ drwxr-xr-x 8 root root 4096 Apr 5 00:43 .git/ -rwxr-xr-x 1 root root 8 Apr 5 00:43 .gitignore* -rw-r--r-- 1 root root 61 Apr 5 00:43 .travis.yml -rw-r--r-- 1 root root 2808 Apr 5 00:43 CHANGELOG.md -rw-r--r-- 1 root root 1851 Apr 5 00:43 CONTRIBUTING.md . . . -rw-r--r-- 1 root root 4893 Apr 5 00:43 vpcs.go -rw-r--r-- 1 root root 4091 Apr 5 00:43 vpcs_test.go

      A través de este paso, creó un espacio de trabajo de Go y configuró las variables de entorno necesarias. En el siguiente paso, probaremos el espacio de trabajo con código.

      Paso 3: Crear un programa simple

      Ahora que configuró el espacio de trabajo de Go, cree un programa “Hello, World! “. Esto asegurará que su espacio de trabajo funcione y le brindará la oportunidad de familiarizarse más con Go. Debido a que creará un único archivo de origen de Go, no un proyecto real, no es necesario que se encuentre en su espacio de trabajo para hacerlo.

      Desde el directorio principal, abra un editor de texto de línea de comandos, como nano y cree un archivo nuevo:

      Escriba su programa en el archivo nuevo:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Este código usará el paquete fmt e invocará la función Println con Hello, World! como argumento. Esto hará que se imprima la frase Hello, World! en el terminal cuando se ejecute el programa.

      Cierre nano presionando las teclas CTRL y X. Cuando se le pregunte si desea guardar el archivo, presione Y y luego INTRO.

      Una vez que cierre nano y regrese a su shell, ejecute el programa:

      go run hello.go
      

      El programa hello.go hará que el terminal genere el siguiente resultado:

      Output

      Hello, World!

      Siguiendo este paso, utilizó un programa básico para verificar que su espacio de trabajo de Go se configure de forma correcta.

      Conclusión

      ¡Felicitaciones! En este punto, contará con un espacio de trabajo de programación de Go configurado en su máquina con Ubuntu y podrá iniciar un proyecto de codificación.



      Source link

      12 Marketing Strategies to Promote Your Local Business


      Capturing new customers in your local market can be a challenge. Not only can people be set in their ways and routines, but local marketing channels can also be expensive and scarce. This means that creativity is a must when developing a strategy to promote your local business.

      The good news is that there are lots of ways business owners can maximize both high-tech and low-tech options to promote their business.

      What’s more, local promotion doesn’t have to break the bank! Understanding where you’re most likely to find success with your customers will be the key to success in this area.

      In this article, we’ll provide a comprehensive list of ways to promote your local business. We’ll also take a quick look at what the statistics say about marketing locally. Let’s get started!

      Shared Hosting That Powers Your Purpose

      We make sure your website is fast, secure, and always up so your visitors trust you. Plans start at $2.59/mo.

      Why Your Local Business Needs a Marketing Strategy

      Succeeding in the local business market can be tough, so having a solid marketing strategy is vital for building up your revenue and clientele. When small businesses succeed, it’s good for everyone.

      In fact, small and local businesses have a huge impact on the national economy and employment rates. In that regard, it’s important to understand the local business landscape when it comes to online search and customer habits.

      For example, it’s useful to know that online reviews definitely matter in this business category. In a recent survey, 82% of consumers said they read online reviews before visiting a local business.

      This means you’ll want to focus on tools that will help with your Search Engine Optimization (SEO). Additionally, it’s smart to encourage customers to leave positive reviews for others to see.

      Of course, this is just one digital marketing strategy. Throughout the rest of this post, we’ll look at others marketing ideas — such as leveraging tools like online listings, getting involved in your local community, improving customer care, leveraging social media platforms, creating blog content, and more.

      How to Promote Your Local Business With These 12 Marketing Tactics

      Promoting your local business effectively can require a multifaceted approach. This list of 12 marketing ideas will give you a place to start.

      1. Tidy Up Your Online Listings for Greater Visibility

      Creating a free online listing for your local business can be the most effective way to get its information out there. An online listing is essentially any place you can list your business and its relevant information for potential customers to see.

      With options such as Yelp and Google My Business, you can make sure the right information about your business is on the web.

      The Google My Business login page.

      Getting started with the latter platform simply requires you to search for and claim your business. Your account is free and enables you to manage all of your information on Google. Therefore, it’s vital to keep these details up to date.

      2. Revamp Your Website or Start a Blog to Engage Customers

      If you’re looking for new ways to engage with customers online, revamping your website and starting a blog are both worthwhile approaches. WordPress is an ideal platform for doing this, as it is both beginner-friendly and flexible. If you’re looking to make over your site or begin blogging about your business, we can’t recommend WordPress enough.

      To help you customize your site, you’ll find themes and plugins for all niches. Of course, to get started with a website for your business, you’ll also need a reliable web host and some interesting content to promote your shop!

      3. Work on Your Local SEO Tactics to Boost Search Visibility

      It’s been shown that local search has the highest conversion rates of all local advertising channels. This means that it’s important to fine-tune your site so it ranks well on every major search engine.

      We mentioned Google My Business previously, but it comes into play here as well. Some of your local SEO work can be done through that platform. You’ll want to aim for becoming a listing in the “3-pack.” This is the list of three businesses that appear under the Google map in a search with local intent.

      Three search results under a Google Map.

      Another way to boost your local SEO is to build up as many local citations as you can. A citation is anywhere online that your business’ name, address, phone number, and website URL appears.

      4. Launch a Mobile App to Boost User Engagement

      Mobile internet usage accounted for nearly half of all web traffic early in 2019, and researchers predict that it will continue to rise. With that being said, it makes sense to create a way to engage with your customers on their mobile devices.

      If you have the resources to hire a programmer, that’s the simplest solution. However, there are other ways to create an app that don’t require too much technical know-how. Apps can include handy features such as loyalty rewards, coupons, business news, and more.

      5. Run a Contest to Keep Users Engaged and Interested

      Everyone loves to win stuff. That’s why running a contest can help you draw in customers. Whether you run your contest online (via social media or your website) or directly in your store, it’s something your audience is highly likely to share.

      What’s more, online, users are 99% more likely to share a contest with others if it improves their chances of winning. You could invite your customers to help you design a new logo or a piece of branded gear.

      An example of a design contest.

      Running a contest in your physical store can be as simple as collecting business cards for a monthly drawing or highlighting a customer of the month. Either way, this is a fun and popular option that’s great for any kind of local business.

      6. Form Local Partnerships With Influential People

      Collaboration can be the key to success in many business situations. If your community has a need that your business can help meet, why not partner up? Joining forces with organizations or even other businesses will show customers that you’re community-minded and trustworthy.

      Just as influencers make an impact on social media marketing, you can use your local influencers in the same way, whether they are online or in-person. This might include inviting them to host an event at your business, or asking them to endorse your product. Word-of-mouth marketing works!

      7. Host an Event to Benefit the Area

      Local company owners have the unique opportunity to use their businesses for the good of the community. Not only can you add to the local economy, but you can leverage your brand to help raise funds or otherwise benefit your area.

      When implementing this strategy, you’ll want to choose a cause that aligns with your brand practices and values. If you can partner with a local organization, that’s even better! In fact, hosting an event in your shop or organizing a volunteer day to help out in your community are all ways you can be philanthropic while also promoting your business.

      8. Get Involved in the Community by Joining Chamber Groups

      Almost every community has a local chamber of commerce. These groups are designed to help support the growth of local businesses and joining them is a highly-recommended practice to build brand awareness. Checking your local chamber benefits is a good first step.

      Local chamber of commerce benefits.

      As a member of your chamber of commerce, your community will see you as a trusted member of the local economy. Second, most local chambers offer a number of discounts to helpful resources for local businesses (such as printing and marketing services). Additionally, you can offer discounts to chamber members to encourage support of your business.

      9. Build Up a Newsletter and Subscriber List for Enhanced Communication

      An email list is a valuable tool for keeping your customers updated and engaged. You don’t want to overdo it, but regular communication with your customers can lead to valuable word-of-mouth recommendations.

      You can use both online and in-store techniques to attract subscribers. There are many tools available for building your newsletter and email lists. If you don’t have a branded, custom email for your business, that’s also a smart step to take before you start sending out messages.

      10. Encourage Loyal Customers with a Rewards Program

      Loyalty programs are a common option for many small and local businesses. It builds good connections with customers when you’re able to offer rewards for their loyalty.

      There are plenty of examples out there to work from, such as Dunkin’s “DDPerks” program.

      Dunkin’ Donuts reward perks.

      Whether you create an app for loyalty rewards or simply print punch cards, your customers should appreciate the gesture.

      In fact, 69% of consumers report that their choice of retailer is impacted by where they can get the best rewards. Businesses also report that even a 5% increase in customer loyalty can have a big impact on their annual profits.

      11. Maintain Regulars With Improved Customer Service

      When you are a frequent patron of a business, it’s likely due in part to the way you’re treated. If you employ staff at your local business, it might be worthwhile to tackle your overall customer service as a group and establish some goals and norms.

      Holding a training session and providing professional development materials for your employees are two ways you can start building a culture of customer care. Additionally, you can involve your customers in the process by asking them for feedback or creating a recognition program for your employees.

      12. Offer Seasonal or Themed Discounts to Boost Sales

      Shoppers tend to be creatures of habit. So you can take advantage of many holiday-related and seasonal opportunities throughout the year. This might mean getting creative and hosting a Christmas in July sale or latching onto fun, quirky occasions such as “Pi Day.”

      Newegg’s Pi Day sale.

      This enables you to promote your business outside of run-of-the-mill shopping holidays. You can appeal to bargain shoppers, and keep sales up during the times of year when you might otherwise see a dip in profits.

      Small Business Marketing Made Simple

      Mastering the skills needed to effectively promote your local business can take effort. However, there are many ways small business owners can get creative and engage with regional customers. Mixing and matching the items on this list can help you build the perfect toolbox of local promotion techniques.

      Above all, remember to tidy up your online listings and create a Google My Business account, brush up on your customer service, and connect with your community through events and partnerships. All of these strategies can help boost those vital online customer reviews for your brand.

      If you’re looking for more ways to grow your business, we’ve got you covered! Check out these helpful posts for tips and tricks to get your local business on the map.

      Are you ready for a big rush on your local business? Implementing these promotional techniques and showcasing your hard work with a professionally-hosted website should have customers lining up down the street!



      Source link

      Como Instalar o Go e Configurar um Ambiente de Programação Local no macOS


      Introdução

      Go é uma linguagem de programação que nasceu da frustração no Google. Os desenvolvedores precisavam escolher continuamente uma linguagem que fosse executada com eficiência, mas demoravam muito tempo para compilar ou escolher uma linguagem fácil de programar, mas que era executada de forma ineficiente em produção. O Go foi projetado para ter todas as três características disponíveis ao mesmo tempo: compilação rápida, facilidade de programação e execução eficiente em produção.

      Embora o Go seja uma linguagem de programação versátil que pode ser usada para muitos projetos de programação diferentes, ela é particularmente adequada para programas de rede/sistemas distribuídos e ganhou a reputação de ser “a linguagem da nuvem”. Ela se concentra em ajudar o programador moderno a fazer mais com um conjunto forte de ferramentas, removendo debates sobre formatação ao tornar o formato parte da especificação da linguagem, bem como ao facilitar o deploy ao compilar para um único binário. O Go é fácil de aprender, com um conjunto muito pequeno de palavras-chave, o que o torna uma ótima opção para iniciantes e igualmente para desenvolvedores experientes.

      Este tutorial irá guiá-lo pela instalação do Go em sua máquina local com macOS e da configuração de um workspace de programação através da linha de comando.

      Pré-requisitos

      Você precisará de um computador com macOS com acesso administrativo e que esteja conectado à Internet.

      Passo 1 — Abrindo o Terminal

      Você estará concluindo a instalação e a configuração na linha de comando, que é uma maneira não gráfica de interagir com seu computador. Ou seja, em vez de clicar nos botões, você digitará texto e receberá retornos do seu computador por meio de texto também. A linha de comando, também conhecida como shell, pode ajudá-lo a modificar e automatizar muitas das tarefas que você faz em um computador todos os dias, e é uma ferramenta essencial para desenvolvedores de software.

      O Terminal do macOS é um aplicativo que você pode usar para acessar a interface da linha de comando. Como qualquer outro aplicativo, você pode encontrá-lo indo até o Finder, navegando até a pasta Aplicativos e, em seguida, na pasta Utilitários. A partir daqui, dê um clique duplo no Terminal como qualquer outro aplicativo para abri-lo. Alternativamente, você pode usar o Spotlight mantendo pressionadas as teclas CMD e SPACE para localizar o Terminal digitando-o na caixa que aparece.

      macOS Terminal

      Existem muitos outros comandos do Terminal para aprender que podem permitir que você faça coisas mais poderosas. O artigo “An Introduction to the Linux Terminal” pode te orientar melhor com o terminal do Linux, que é semelhante ao teminal do macOS.

      Agora que você abriu o Terminal, pode fazer o download e instalar o Xcode, um pacote de ferramentas de desenvolvedor que você precisará para instalar o Go.

      Passo 2 — Instalando o Xcode

      O Xcode é um integrated development environment ou ambiente de desenvolvimento integrado (IDE) composto de ferramentas de desenvolvimento de software para macOS. Você pode verificar se o Xcode já está instalado, digitando o seguinte na janela do Terminal:

      A saída a seguir significa que o Xcode está instalado:

      Output

      /Library/Developer/CommandLineTools

      Se você recebeu um erro em seu navegador web, instale o Xcode a partir da App Store e aceite as opções padrão.

      Quando o Xcode estiver instalado, retorne à janela do Terminal. Em seguida, você precisará instalar o app separado de Ferramentas de Linha de Comando do Xcode, que pode ser feito digitando:

      Neste ponto, o Xcode e seu app de Ferramentas de Linha de Comando estão totalmente instalados e estamos prontos para instalar o gerenciador de pacotes Homebrew.

      Passo 3 — Instalando e Configurando o Homebrew

      Embora o Terminal do macOS tenha muitas das funcionalidades dos Terminais Linux e de outros sistemas Unix, ele não é fornecido com um gerenciador de pacotes que acomoda as melhores práticas. Um gerenciador de pacotes é uma coleção de ferramentas de software que trabalham para automatizar processos de instalação que incluem instalação inicial de software, atualização e configuração de software, e remoção de software conforme necessário. Eles mantêm instalações em um local central e podem manter todos os pacotes de software no sistema em formatos comumente usados. Homebrew fornece ao macOS um sistema gerenciador de pacotes de software livre e de código aberto que simplifica a instalação de software no macOS.

      Para instalar o Homebrew, digite isso na sua janela de Terminal:

      • /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

      O Homebrew é feito em Ruby, assim ele irá modificar o caminho do Ruby do seu computador. O comando curl baixa um script da URL especificada. Este script explicará o que ele fará e, em seguida, fará uma pausa no processo para solicitar sua confirmação. Isso lhe fornece uma série de comentários sobre o que o script vai fazer no seu sistema e dá a você a oportunidade de verificar o processo.

      Se você precisar digitar sua senha, observe que suas teclas não serão exibidas na janela do Terminal, mas serão gravadas. Basta pressionar a tecla return ou enter depois de inserir sua senha. Caso contrário, pressione a letra y para “sim” quando você for solicitado a confirmar a instalação.

      Vamos dar uma olhada nas flags associadas ao comando curl:

      • A flag -f ou --fail informa à janela do Terminal para não dar saída de documento HTML nos erros de servidor.
      • A flag -s ou --silent silencia o curl para que ele não mostre o medidor de progresso, e combinada com a flag -S ou --show-error ela irá assegurar que curl mostre uma mensagem de erro se falhar.
      • A flag -L ou --location informará ao curl para refazer a solicitação para um novo local se o servidor informar que a página solicitada foi movida para um local diferente.

      Quando o processo de instalação estiver concluído, colocaremos o diretório Homebrew no começo da variável de ambiente PATH. Isso garantirá que as instalações do Homebrew serão chamadas antes das ferramentas que o macOS possa selecionar automaticamente e que podem ser executadas em contraposição ao ambiente de desenvolvimento que estamos criando.

      Você deve criar ou abrir o arquivo ~/.bash_profile com o editor de texto de linha de comando nano usando o comando nano:

      Quando o arquivo abrir na janela do Terminal, escreva o seguinte:

      export PATH=/usr/local/bin:$PATH
      

      Para salvar suas alterações, mantenha pressionada a tecla CTRL e a letra o e, quando solicitado, pressione a tecla RETURN. Agora você pode sair do nano segurando a tecla CTRL e a letra x.

      Ative essas alterações executando o seguinte no Terminal:

      Depois de fazer isso, as alterações feitas na variável de ambiente PATH entrarão em vigor.

      Você pode ter certeza de que o Homebrew foi instalado com sucesso digitando:

      Se nenhuma atualização for necessária neste momento, a saída do Terminal mostrará:

      Output

      Your system is ready to brew.

      Caso contrário, você pode receber um aviso para executar outro comando, como brew update, para garantir que sua instalação do Homebrew esteja atualizada.

      Uma vez que o Homebrew está pronto, você pode instalar o Go.

      Passo 4 — Instalando o Go

      Você pode usar o Homebrew para procurar por todos os pacotes disponíveis com o comando brew search. Para o propósito deste tutorial, você irá procurar por pacotes ou módulos relacionados ao Go:

      Nota: Este tutorial não usa brew search go, pois isso retorna muitos resultados. Como go é uma palavra muito pequena e combinaria com muitos pacotes, tornou-se comum usar golang como termo de busca. Essa é uma prática comum quando se pesquisa na Internet por artigos relacionados ao Go também. O termo Golang nasceu a partir do domínio para o Go, que é golang.org.

      O Terminal mostrará uma lista do que você pode instalar:

      Output

      golang golang-migrate

      O Go estará entre os itens da lista. Vá em frente e instale-o:

      A janela do Terminal lhe dará feedback sobre o processo de instalação do Go. Pode demorar alguns minutos antes da conclusão da instalação.

      Para verificar a versão do Go que você instalou, digite o seguinte:

      Isso mostrará a versão específica do Go que está atualmente instalada, que por padrão será a versão mais atualizada e estável do Go disponível.

      No futuro, para atualizar o Go, você pode executar os seguintes comandos para atualizar o Homebrew e depois atualizar o Go. Você não precisa fazer isso agora, pois acabou de instalar a versão mais recente:

      • brew update
      • brew upgrade golang

      brew update atualizará as fórmulas para o próprio Homebrew, garantindo que você tenha as informações mais recentes sobre os pacotes que deseja instalar. brew upgrade golang atualizará o pacote golang para a sua última versão.

      É uma boa prática garantir que sua versão do Go esteja atualizada.

      Com o Go instalado no seu computador, você está pronto para criar um workspace para seus projetos de Go.

      Passo 5 — Criando o seu Workspace Go

      Agora que você tem o Xcode, Homebrew e Go instalados, você pode criar seu workspace de programação.

      O workspace do Go conterá dois diretórios em sua raiz:

      • src: O diretório que contém os arquivos-fonte do Go. Um arquivo-fonte é um arquivo que você escreve usando a linguagem de programação Go. Arquivos-fonte são usados pelo compilador Go para criar um arquivo binário executável.
      • bin: O diretório que contém executáveis compilados e instalados pelas ferramentas Go. Executáveis são arquivos binários que são executados em seu sistema e executam tarefas. Estes são normalmente os programas compilados a partir do seu código-fonte ou outro código-fonte Go baixado.

      O subdiretório src pode conter vários repositórios de controle de versão (tais como o Git, o Mercurial, e o Bazaar). Você verá diretórios como github.com, golang.org ou outros quando seu programa importar bibliotecas de terceiros. Se você estiver usando um repositório de código como o github.com, você também colocará seus projetos e arquivos-fonte nesse diretório. Isso permite uma importação canônica de código em seu projeto. As importações Canônicas são importações que fazem referência a um pacote completo, como o github.com/digitalocean/godo.

      Aqui está como pode se parecer um workspace típico:

      .
      ├── bin
      │   ├── buffalo                                      # comando executável
      │   ├── dlv                                          # comando executável
      │   └── packr                                        # comando executável
      └── src
          └── github.com
              └── digitalocean
                  └── godo
                      ├── .git                            # metadados do repositório do Git
                      ├── account.go                      # fonte do pacote
                      ├── account_test.go                 # fonte do teste
                      ├── ...
                      ├── timestamp.go
                      ├── timestamp_test.go
                      └── util
                          ├── droplet.go
                          └── droplet_test.go
      

      O diretório padrão para o workspace Go a partir da versão 1.8 é o diretório home do usuário com um subdiretório go ou $HOME/go. Se você estiver usando uma versão anterior à 1.8 do Go, ainda é considerado uma boa prática usar o local $HOME/go para o seu workspace.

      Execute o seguinte comando para criar a estrutura de diretórios para o seu workspace Go:

      • mkdir -p $HOME/go/{bin,src}

      A opção -p diz ao mkdir para criar todos os subdiretórios no diretório, mesmo que eles não existam atualmente. A utilização do {bin, src} cria um conjunto de argumentos para mkdir e diz para ele criar tanto o diretóriobin quanto o diretório src.

      Isso garantirá que a seguinte estrutura de diretórios esteja em vigor:

      └── $HOME
          └── go
              ├── bin
              └── src
      

      Antes do Go 1.8, era necessário definir uma variável de ambiente local chamada $GOPATH. Embora não seja mais explicitamente exigido fazer isso, ainda é considerada uma boa prática, pois muitas ferramentas de terceiros ainda dependem da configuração dessa variável.

      Você pode definir seu $GOPATH adicionando-o ao seu ~/.bash_profile.

      Primeiro, abra ~/.bash_profile com o nano ou seu editor de texto preferido:

      Defina seu $GOPATH adicionando o seguinte ao arquivo:

      ~/.bash_profile

      export GOPATH=$HOME/go
      

      Quando o Go compila e instala ferramentas, ele as coloca no diretório $GOPATH/bin. Por conveniência, é comum adicionar o subdiretório /bin do workspace ao seu PATH no seu arquivo ~/.bash_profile:

      ~/.bash_profile

      export PATH=$PATH:$GOPATH/bin
      

      Agora você deve ter as seguintes entradas no seu ~/.bash_profile:

      ~/.bash_profile

      export GOPATH=$HOME/go
      export PATH=$PATH:$GOPATH/bin
      

      Agora, isso permitirá que você execute todos os programas compilados ou baixados por meio das ferramentas Go em qualquer parte do seu sistema.

      Para atualizar seu shell, execute o seguinte comando para carregar as variáveis globais que você acabou de criar:

      Você pode verificar que seu $PATH está atualizado usando o comando echo e inspecionando a saída:

      Você deve ver seu $GOPATH/bin, que aparecerá no seu diretório home. Se você estivesse logado como sammy, você veria /Users/sammy/go/bin no caminho.

      Output

      /Users/sammy/go/bin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin

      Agora que você tem a raiz do workspace criada e sua variável de ambiente $GOPATH definida, você pode criar seus projetos futuros com a seguinte estrutura de diretórios. Este exemplo assume que você está usando o github.com como seu repositório:

      $GOPATH/src/github.com/username/project
      

      Se você estivesse trabalhando no projeto https://github.com/digitalocean/godo, você iria colocá-lo no seguinte diretório:

      $GOPATH/src/github.com/digitalocean/godo
      

      Estruturar seus projetos dessa maneira tornará os projetos disponíveis com a ferramenta go get. Isso também ajudará a legibilidade mais tarde.

      Você pode verificar isso usando o comando go get para buscar a biblioteca godo:

      • go get github.com/digitalocean/godo

      Você pode ver se baixou com sucesso o pacote godo listando o diretório:

      • ls -l $GOPATH/src/github.com/digitalocean/godo

      Você deve ver uma saída semelhante a esta:

      Output

      -rw-r--r-- 1 sammy staff 2892 Apr 5 15:56 CHANGELOG.md -rw-r--r-- 1 sammy staff 1851 Apr 5 15:56 CONTRIBUTING.md . . . -rw-r--r-- 1 sammy staff 4893 Apr 5 15:56 vpcs.go -rw-r--r-- 1 sammy staff 4091 Apr 5 15:56 vpcs_test.go

      Neste passo, você criou um workspace Go e configurou as variáveis de ambiente necessárias. No próximo passo, você testará o workspace com algum código.

      Passo 6 — Criando um Programa Simples

      Agora que você tem o workspace Go configurado, é hora de criar um simples programa “Hello, World!”. Isso garantirá que o workspace esteja configurado corretamente e também lhe dará a oportunidade de se familiarizar com o Go.

      Como estamos criando um único arquivo-fonte Go, e não um projeto real, não precisamos estar em nosso workspace para fazer isso.

      A partir do seu diretório home, abra um editor de texto de linha de comando, como o nano, e crie um novo arquivo:

      Quando o arquivo de texto abrir no Terminal, digite seu programa:

      package main
      
      import "fmt"
      
      func main() {
          fmt.Println("Hello, World!")
      }
      

      Saia do nano pressionando as teclas control e x, e quando solicitado a salvar o arquivo, pressione y.

      Este código usará o pacote fmt e chamará a função Println com Hello, World! como argumento. Isso fará com que a frase Hello, World! seja impressa no terminal quando o programa for executado.

      Ao sair do nano e retornar ao seu shell, execute o programa:

      O programa hello.go que você acabou de criar fará com que o Terminal produza a seguinte saída:

      Output

      Hello, World!

      Neste passo, você usou um programa básico para verificar se seu workspace Go está configurado corretamente.

      Conclusão

      Parabéns! Neste ponto, você tem um workspace de programação Go configurado em sua máquina local com macOS e pode começar um projeto de codificação!



      Source link