Goを試してみた①(環境構築〜Hello Worldまで) 

# 背景・目的
最近、Goに触れる機会が増えてきたので、今後、本格的に学んでいこうと思います。
本ページではGoの特徴など基本的なところを整理します。

# まとめ
下記に特徴を整理します。

|特徴|説明|
|:--|:--|
|概要|・Google がサポートするオープンソースプログラミング言語<BR>・学びやすく、チームに最適<BR>・組み込みの同時実行性と堅牢な標準ライブラリ<BR>・パートナー、コミュニティ、ツールによる大規模なエコシステム|
|Goのユースケース|・Cloud & Network Services<BR>・CLI開発<BR>・Web Development<BR>・
Development Operations & Site Reliability Engineering|
|Cloud & Network ServicesでGoを利用するメリット|・開発サイクル時間の短縮<BR>・サーバパフォーマンスの向上<BR>・サービス開発をサポートする強力なエコシステム<BR>・サービス用のGo APIと、一般的なOSSライブラリを提供している|
|CLI開発でGoを利用するメリット|高速なコンパイル時間を活用して、迅速にどのシステムでも実行できるプログラムを構築する|
|Web DevelopmentでGoを利用するメリット|・使いやすく、セキュア、パフォーマンスの高いWebサーバ、独自のWebテンプレートが含まれている<BR>最新で優れたサポートを備えている<BR>Goの優れた移植性|
|Site Reliability EngineeringでGoを利用するメリット|・Goの堅牢な標準ライブラリと静的型付けを使用して小さなスクリプトを簡単に構築<BR>・Goはビルドと起動時間が早い|

# 概要
下記を基に整理します。

https://go.dev/

> Build simple, secure, scalable systems with Go
> - An open-source programming language supported by Google
> - Easy to learn and great for teams
> - Built-in concurrency and a robust standard library
> - Large ecosystem of partners, communities, and tools

- Goでシンプルで、セキュア、スケーラブルなシステムをつくる
    - Google がサポートするオープンソースプログラミング言語
    - 学びやすく、チームに最適
    - 組み込みの同時実行性と堅牢な標準ライブラリ
    - パートナー、コミュニティ、ツールによる大規模なエコシステム

## Why go
### Using Go at Google
https://go.dev/solutions/google/

> Go started in September 2007 when Robert Griesemer, Ken Thompson, and I began discussing a new language to address the engineering challenges we and our colleagues at Google were facing in our daily work.

- Goは、2007年9月に始まった
- Robert Griesemer、 Ken Thompson、Rob Pike、Googleの同僚が日常業務で直面しているエンジニアリングの課題に対処するための新しい言語について話し始めた

> When we first released Go to the public in November 2009, we didn’t know if the language would be widely adopted or if it might influence future languages. Looking back from 2020, Go has succeeded in both ways: it is widely used both inside and outside Google, and its approaches to network concurrency and software engineering have had a noticeable effect on other languages and their tools.

- 最初の公開は、2009年11月
- 2020年時点では
    - Googleの内外の両方で広く使用されている
    - NWの同時実行性と、SWエンジニアリングに対するそのアプローチは、他の言語とそのツールに影響を与えてきた

> Go has turned out to have a much broader reach than we had ever expected. Its growth in the industry has been phenomenal, and it has powered many projects at Google.

- Go は予想していたよりもはるかに広範囲で影響を与えた
- 業界の成長は驚異的でGoogleの多くのプロジェクトを推進してきた

### Use case 
https://go.dev/solutions/use-cases

#### Go for Cloud & Network Services
下記を基に整理します。

https://go.dev/solutions/cloud

##### Overview
> Go helps enterprises build and scale cloud computing systems

- Goは、企業のクラウドの構築と拡張を支援する

> As applications and processing move to the cloud, concurrency becomes a very big issue. Cloud computing systems, by their very nature, share and scale resources. Coordinating access to shared resources is an issue that impacts every application processing in the cloud, and requires programming languages “explicitly geared to develop highly reliable concurrent applications.”

- アプリケーションと処理は、クラウドに移行すると、同時実行性が大きな問題になる
- クラウドコンピューティングはその性質上、リソースを共有し拡張する
- 共有されたリソースに対して協調してアクセスするには、クラウド内のすべてのアプリケーション処理に影響を与える問題
- 信頼性の高い同時実行アプリケーションの開発に適合したプログラミング言語が必要

##### Key Benefits
> Address tradeoff between development cycle time and server performance

開発サイクル時間とサーバパフォーマンスのトレードオフへの対処

> Go was created to address exactly these concurrency needs for scaled applications, microservices, and cloud development. In fact, over 75 percent of projects in the Cloud Native Computing Foundation are written in Go.

- Goは、大規模なアプリケーション、マイクロサービス、クラウド開発における同時実行のニーズへ対処するために開発された
- Cloud Native Computing Foundationの75%以上はGoで書かれている

> Go helps reduce the need to make this tradeoff, with its fast build times that enable iterative development, lower memory and CPU utilization. Servers built with Go experience instant start up times and are cheaper to run in pay-as-you-go and serverless deployments.

- Goは反復開発を可能にする高速ビルド時間、低いメモリとCPU使用率の削減により、トレードオフの必要性を軽減する
- Goで構築されたサーバは、起動時間が短く、従量課金、サーバレスデプロイメントの実行が安価

> Address challenges with the modern cloud, delivering standard idiomatic APIs
モダンなクラウドで課題に対処し、標準的で慣用的なAPIを提供

> Go addresses many challenges developers face with the modern cloud, delivering standard idiomatic APIs, and built in concurrency to take advantage of multicore processors. Go’s low-latency and “no knob” tuning make Go a great balance between performance and productivity - granting engineering teams the power to choose and the power to move.

- Goは、開発者が最新のクラウドで直面する多くの課題に対処する
    - 標準的で慣用的なAPIの提供
    - マルチコアプロセサを活用するための同時実行機能あ組み込まれている
- Goは、低レイテンシーと「ノブなし」チューニングにより、Goはパフォーマンスと生産性のバランスが優れており、エンジニアリングチームに選択する力と行動する力を与える

##### Use Case
> Use Go for Cloud Computing

CloudコンピューティングでGoを使う

> Go’s strengths shine when it comes to building services. Its speed and built-in support for concurrency results in fast and efficient services, while static typing, robust tooling, and emphasis on simplicity and readability help build reliable and maintainable code.

- Goの強みは、サービスの構築
- 迅速で、同時実行のサポートが組み込まれているので、高速で効率的なサービスが実現できる
- 静的型付け、堅牢なツール、シンプルで読みやすさを重視し、信頼性が高くメンテしやすいコードを構築できる

> Go has a strong ecosystem supporting service development. The standard library includes packages for common needs like HTTP servers and clients, JSON/XML parsing, SQL databases, and a range of security/encryption functionality, while the Go runtime includes tools for race detection, benchmarking/profiling, code generation, and static code analysis.

- Goには、サービス開発をサポートする強力なエコシステムがある
- 標準ライブラリには、下記が含まれている
    - HTTP サーバーとクライアント
    - JSON/XML 解析
    - SQL データベース
    - さまざまなセキュリティ/暗号化機能などの一般的なニーズに対応するパッケージ
- Go ランタイムとツールには下記が含まれている
    - 競合検出
    - ベンチマーク/プロファイリング
    - コード生成
    - 静的コード分析


> The major Cloud providers (GCP, AWS, Azure) have Go APIs for their services, and popular open source libraries provide support for API tooling (Swagger), transport (protocol buffers, gRPC), monitoring (OpenCensus), Object-Relational Mapping (gORM), and authentication (JWT). The open source community has also provided several service frameworks, including Go Kit, Go Micro, and Gizmo, which can be a great way to get started quickly.

- 主要なクラウドプロバイダーは、下記のサービス用のGo APIと、一般的なOSSライブラリをサポートしている
    - APIツール（Swagger）
    - トランスポート（プロトコルバッファ、gRPC）
    - 監視（OpenCensus）
    - オブジェクトリレーションマッピング（gORM）
    - JWT
- オープンソースコミュニティは、下記を提供しているので、すぐに使い始めるには最適
    - several service frameworks
    - including Go Kit
    - Go Micro
    - Gizmo

#### Command-line Interfaces (CLIs)
下記を基に整理します。

https://go.dev/solutions/clis

##### Overview
> CLI developers prefer Go for portability, performance, and ease of creation

CLI開発者は、移行性、パフォーマンス、作成の簡単さからGoを好む

> Command line interfaces (CLIs), unlike graphical user interfaces (GUIs), are text-only. Cloud and infrastructure applications are primarily CLI-based due to their easy automation and remote capabilities.

- CLIは、GUIとは異なりテキストのみ
- クラウドとインフラアプリケーションは、簡単な自動化とリモート機能により、主にCLIベース


##### Key benefits
> Leverage fast compile times to build programs that start quickly and run on any system

- 高速なコンパイル時間を活用して、迅速に自動詞どのシステムでも実行できるプログラムを構築する

> Developers of CLIs find Go to be ideal for designing their applications. Go compiles very quickly into a single binary, works across platforms with a consistent style, and brings a strong development community. From a single Windows or Mac laptop, developers can build a Go program for every one of the dozens of architectures and operating systems Go supports in a matter of seconds, no complicated build farms are needed. No other compiled language can be built as portably or quickly. Go applications are built into a single self contained binary making installing Go applications trivial.

- CLI の開発者は、Go がアプリケーションの設計に最適であると考える
- Goは、単一のバイナリに、高速にコンパイルされる
- 一貫したスタイルで複数プラットフォームで動作する
- 強力な開発コミュニティをもたらす
- 開発者は、ラップトップから、数十のアーキテクチャ、GoがサポートするOSの全てに対応するGoプログラムを数秒で構築できる
- 複雑なビルドファームは不要
- Goアプリケーションは、単一の自己完結型バイナリに組み込まれているので、インストールは簡単


> Specifically, programs written in Go run on any system without requiring any existing libraries, runtimes, or dependencies. And programs written in Go have an immediate startup time—similar to C or C++ but unobtainable with other programming languages.


##### Use Case
> Use Go for building elegant CLIs

> When developing CLIs in Go, two tools are widely used: Cobra & Viper.

- GoでCLIを開発する場合、下記の2つのツールが広く使用されている
    - Cobra
    - Viper

> Cobra is both a library for creating powerful modern CLI applications and a program to generate applications and CLI applications in Go. Cobra powers most of the popular Go applications including CoreOS, Delve, Docker, Dropbox, Git Lfs, Hugo, Kubernetes, and many more. With integrated command help, autocomplete and documentation “[it] makes documenting each command really simple,” says Alex Ellis, founder of OpenFaaS.

- Cobraは、強力な最新のCLIアプリケーションを開発するのと同時に、GoでアプリケーションとCLIアプリを生成するプログラムでもある
- Corbaは、下記の人気のあるアプリケーション等で使用されている
    - CoreOS
    - Delve
    - Docker
    - Dropbox
    - Git Lfs
    - Hugo
    - Kubernetes
- 下記により、各コマンドのドキュメント作成が非常に簡単
    - 統合されたコマンドヘルプ
    - オートコンプリート
    - ドキュメント

> Viper is a complete configuration solution for Go applications, designed to work within an app to handle configuration needs and formats. Cobra and Viper are designed to work together.

- Viperは、Goアプリケーション向けの完全な構成ソリューション
- アプリ内で動作し構成のニーズと形式を処理するように設計されている
- CobraとViperは互いに連携して動作するように設計されている

> Viper supports nested structures in the configuration, allowing CLI developers to manage the configuration for multiple parts of a large application. Viper also provides all of the tooling need to easily build twelve factor apps.

- ViperはConfig内でネストされた構造をサポートしている
- CLI開発者は、大規模アプリケーションの複数の部分の構成を管理できる
- Twelve factor appsを簡単に構築するために必要なすべてのツールを提供する

> “If you don’t want to pollute your command line, or if you’re working with sensitive data which you don’t want to show up in the history, it’s a good idea to work with environment variables. To do this, you can use Viper,” suggests Geudens.

- 機密情報は、環境変数を使用することを推奨。Viperを使用できる

#### Go for Web Development
下記を基に整理します。

https://go.dev/solutions/webdev

##### Overview
> Go delivers speed, security, and developer-friendly tools for Web Applications

- Goは、Webアプリケーションのためにスピード、セキュリティ、デベロッパーフレンドなツールを提供する

> Go is designed to enable developers to rapidly develop scalable and secure web applications. Go ships with an easy to use, secure and performant web server and includes it own web templating library. Go has excellent support for all of the latest technologies from HTTP/2, to databases like MySQL, MongoDB and Elasticsearch, to the latest encryption standards including TLS 1.3. Go web applications run natively on Google App Engine and Google Cloud Run (for easy scaling) or on any environment, cloud, or operating system thanks to Go’s extreme portability.

- Goは、下記の設計により開発者のために設計されている
    - 大規模かつ高速な開発
    - セキュアなWebアプリケーション
- Goには、使いやすく、セキュア、パフォーマンスの高いWebサーバ、独自のWebテンプレートが含まれている
- Goは、下記の最新で優れたサポートを備えている
    - HTTP/2
    - MySQL、MongoDB、ElasticSearchなどのDB
    - TLS1.3 を含む最新の暗号化標準
- Go Webアプリケーションは、Goの優れた移植性により下記でネイティブに実行される
    - Google App Engine
    - Google Cloud Run
    - その他の環境
    - クラウド
    - OS

##### Key Benefits
> Deploy across platforms in record speed
> For enterprises, Go is preferred for providing rapid cross-latform deployment. With its goroutines, native compilation, and the URI-based package namespacing, Go code compiles to a single, small binary—with zero dependencies—making it very fast.

- 記録的なスピードでPF全体にデプロイ
    - 企業の場合、迅速なクロスプラットフォームデプロイを実現するためにGoが好まれる
    - Goルーチン、ネイティブコンパイル、UIRIベースのパッケージ名前空間により、Goは依存ゼロで単一の小さなバイナリにコンパイルされ、非常に高速

> Leverage Go’s out-of-the-box performance to scale with ease
Tigran Bayburtsyan, Co-Founder and CTO at Hexact Inc., summarizes five key reasons his company switched to Go:

> - Compiles into a single binary — “Using static linking, Go actually combining all dependency libraries and modules into one single binary file based on OS type and architecture.”
> - Static type system — “Type system is really important for large scale applications.”
> - Performance — “Go performed better because of its concurrency model and CPU scalability. Whenever we need to process some internal request, we are doing it with separate Goroutines which are 10x cheaper in resources than Python Threads.”
> - No need for a web framework — “In most of the cases you really don’t need any third-party library.”
> - Great IDE support and debugging — “After rewriting all projects to Go, we got 64 percent less code than we had earlier.”

- Go のすぐに使えるパフォーマンスを活用して、簡単に拡張
    - Goに切り替えた5つの主な理由
        - 単一のバイナリにコンパイル
            - Goは静的リンキングを利用して、OSの種類、アーキテクチャに基づき、すべての依存関係ライブラリとモジュールを1つのバイナリに結合する
        - 静的型付け
        - パフォーマンス
            - Goは同時実行モデルと、CPUスケーラビリティによりパフォーマンスが向上
            - 内部リクエストを処理する場合、Pythonスレッドよりもリソースが10倍やすい別のCoroutinesを使用している
        - Webフレームワークが不要
        - 優れたIDEのサポートとデバッグ


#### Development Operations & Site Reliability Engineering
##### Overview
> Go helps enterprises automate and scale
Development Operations (DevOps) teams help engineering organizations automate tasks and improve their continuous integration and continuous delivery and deployment (CI/CD) process. DevOps can topple developmental silos and implement tooling and automation to enhance software development, deployment, and support.

- 企業の自動化に役立つ
    - DevOpsチームは、エンジニアリング組織の自動化タスクとCI/CDの改善を支援する
    - DevOpsは、開発サイロを打破し、ツールと自動化を実装し、SWエンジニアリング開発、デプロイ、サポートを強化できる

> Site Reliability Engineering (SRE) was born at Google to make the company’s “large-scale sites more reliable, efficient, and scalable,” writes Silvia Fressard, an independent DevOps consultant. “And the practices they developed responded so well to Google’s needs that other big tech companies, such as Amazon and Netflix, also adopted them.” SRE requires a mix of development and operations skills, and “empowers software developers to own the ongoing daily operation of their applications in production.”

- SREには、開発と運用の組み合わせが必要

> Go serves both siblings, DevOps and SRE, from its fast build times and lean syntax to its security and reliability support. Go’s concurrency and networking features also make it ideal for tools that manage cloud deployment—readily supporting automation while scaling for speed and code maintainability as development infrastructure grows over time.

- Goは、高速なビルドとセキュリティ、信頼性サポートまでDevOpsとSREの両方として機能する
- Goの同時実行性とネットワーク機能は、クラウドデプロイメントを管理するツールにも最適
- 開発インフラが時間の経過とともに拡大にするにつれて、速度とコードの保守性のためにスケーリングしながら自動化を容易にサポートできる

> DevOps/SRE teams write software ranging from small scripts, to command-line interfaces (CLI), to complex automation and services, and Go’s feature set has benefits for every situation.

- DevOps/SREチームは、小さなスクリプトからCLI、複雑な自動化やサービスに至るまでのソフトウェアを作成しており、Goの機能セットはあらゆる状況にメリットをもたらす


##### Key Benefits
> Easily build small scripts with Go’s robust standard library and static typing

> Go’s fast build and startup times. Go’s extensive standard library—including packages for common needs like HTTP, file I/O, time, regular expressions, exec, and JSON/CSV formats—lets DevOps/SREs get right into their business logic. Plus, Go’s static type system and explicit error handling make even small scripts more robust.


- Goの堅牢な標準ライブラリと静的型付けを使用して小さなスクリプトを簡単に構築
    - Goはビルドと起動時間が早い
    - Goの広範囲な標準ライブラリによりDevOps/SREはビジネスロジックに直接取り込める
        - HTTP
        - file I/O
        - time
        - regular expressions
        - exec
        - JSON/CSV formats
    - Goの静的型付けと明示的なエラーハンドリングにより小さなスクリプトでもより堅牢になる

> Quickly deploy CLIs with Go’s fast build times

> Every site reliability engineer has written “one-time use” scripts that turned into CLIs used by dozens of other engineers every day. And small deployment automation scripts turn into rollout management services. With Go, DevOps/SREs are in a great position to be successful when software scope inevitably creeps. Starting with Go puts you in a great position to be successful when that happens.

- Go の高速ビルド時間で CLI を迅速にデプロイ
    - Goを使用するとソフトウェアスコープが必然的に増大する場合でも、DevOps/SREは成功するために優れている

> Scale and maintain larger applications with Go’s low memory footprint and doc generator

> Go’s garbage collector means DevOps/SRE teams don’t have to worry about memory management. And Go’s automatic documentation generator (godoc) makes code self-documenting–lowering maintenance overhead and establishing best practices from the get-go.

- Goの低メモリフットプリントとドキュメントジェネレーターにより、大規模アプリケーションを拡張、メンテナンスする
    - GoのGCは、DevOps/SREチームがメモリ管理について心配不要
    - Goの自動ドキュメントジェネレーター（godoc）は、自己ドキュメント化し、メンテナンスのオーバヘッドを削減、最初からベストプラクティスを確立する

## Goモジュールについて
- コードが、他のモジュールに含まれるパッケージをインポートする場合、コード独自のモジュールを通じてその依存関係を管理する。それらのパッケージはモジュールにより追跡するgo.modで定義される
- go.modファイルは、ソースコードリポジトリを含めてコードに残る
- go.modファイルを作成し、コードの依存関係を追跡を有効にするには、コードが含まれるモジュール名を指定して[go mod init](https://go.dev/ref/mod#go-mod-init) コマンドを実行する
    - 通常の開発では、モジュールのパスは通常ソースコードが保存されるリポジトリの場所になる
        - 例）github.com/mymodule
    - 他の人が使用できるようにモジュールを公開する場合、モジュールパスは、Goツールがモジュールをダウンロードできる場所である必要がある
    - モジュールの命名の詳細は、[Managing dependencies](https://go.dev/doc/modules/managing-dependencies#naming_module)を参照


# 実践
下記を下に進めます

https://go.dev/doc/tutorial/getting-started


## 前提
下記を使用しています。
- MacOS
- VSCode

## Installing Go
下記を基に試します。

https://go.dev/doc/install

1. Downloadをクリックします
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/560f5d23-967c-1ae6-1393-9832ccc3cb31.png)

1. Stable versionsでインストーラーを選択し、ダウンロードします
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/96ff8d23-ba5b-6149-3d48-6c9e987e48cf.png)

1. ダウンロードしたインストーラーを起動します
    <img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/f5c71c70-ba16-fcd4-d6e7-a66217a53936.png" width=400 />

1. インストーラーに従い進めます
    <img src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/49f2ff81-e91e-1a5b-9861-7a93e735c80e.png" width=400 />

1. CLIでバージョンを確認します。インストールできたようです
    ```bash
    $ which go
    /usr/local/go/bin/go
    $ go version
    go version go1.23.0 darwin/amd64
    $ 
    ```

## Write some code
ここでは、定番のHello Worldを表示します。

1. ディレクトリを作成し、移動します
    ```bash
    $ mkdir -p go-tutrial/hello-world
    $ cd go-tutrial/hello-world     
    ```
1. コードの依存関係の追跡を有効にします
    ```bash
    $ go mod init example/hello
    go: creating new go.mod: module example/hello
    $ ls
    go.mod
    $ cat go.mod 
    module example/hello
    
    go 1.23.0
    $ 
    ```
1. VSCodeのワークスペースに`go-tutrial`フォルダを追加します
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/de4ac820-0708-cd1a-98ef-6a762098193e.png)

1. hello.goファイルを追加します
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/55b221c5-7d2a-25b6-450b-a914c30b5473.png)

1. 下記のコードを書きます
    - mainパッケージの宣言
        - パッケージは、関数をグループ化する方法
        - 同じディレクトリ内のすべてのファイルで構成される
    - コンソールへの出力を含むテキストの書式設定関数が含まれるfmtパッケージをインポート
    ```go
    package main
    
    import "fmt"
    
    func main() {
    	fmt.Println("Hello, World!")
    }
    ```
1. 下記のコマンドで実行します
    ```bash
    hello-world $ go run .
    Hello, World!
    $
    ```

## Call code in an external package
ここでは、外部パッケージ内のコードを呼び出します。
他の人が実装したコードを実行する場合、使用できる関数が含まれるパッケージを探すことができます。

- `pkg.go.dev`を使用すると公開されたモジュールを見つけることができる
- パッケージは、`rsc.io/quote`などのモジュールで公開され、他のユーザが使用できる

1. [pkg.go.dev](https://pkg.go.dev/)を開きます
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/a4820216-d7bd-18ab-462a-2982b587d94b.png)

1. `quote`を入力し、「Search」をクリックします。表示されました
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/6ca7df34-e579-64cc-08b7-67249140e048.png)

1. `rsc.io/quote`をクリックすると、下記が表示されます。Index配下に関数が記載されています
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/1d7fdb1e-6557-ddc0-0c2e-d2404ad8ef5b.png)

1. ファイルを新たに作成します(hello_v2.goを作成します)
    ![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/206276/faa34c2c-5cc2-8a9d-ebca-08868c13e638.png)
1. 下記のコードを書きます
    ```go
    package main
    
    import "fmt"
    
    import "rsc.io/quote"
    
    func main() {
    	fmt.Println(quote.Go())
    }
    ```
1. 新しいモジュールのrequirementsとsumsを追加します。ここではv1.5.2がダウンロードされました
    ```bash
    hello-world $ go mod tidy
    go: finding module for package rsc.io/quote
    go: downloading rsc.io/quote v1.5.2
    go: found rsc.io/quote in rsc.io/quote v1.5.2
    go: downloading rsc.io/sampler v1.3.0
    go: downloading golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c
    hello-world $ ls     
    go.mod          go.sum          hello.go        hello_v2.go
    hello-world $ cat go.mod 
    module example/hello
    
    go 1.23.0
    
    require rsc.io/quote v1.5.2
    
    require (
            golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c // indirect
            rsc.io/sampler v1.3.0 // indirect
    )
    ```
1. 実行します
    ```bash
    hello-world $ go run hello_v2.go 
    Don't communicate by sharing memory, share memory by communicating.
    $
    ```


# 考察
今回は、Goの特徴について整理し、環境構築〜Hello World，モジュールを使用するところまで試しました。
今後も継続して理解を深めていきます

# 参考
https://go.dev/

https://qiita.com/tenntenn/items/0e33a4959250d1a55045

https://docs.google.com/presentation/d/1RVx8oeIMAWxbB7ZP2IcgZXnbZokjCmTUca-AbIpORGk/edit#slide=id.g4f417182ce_0_0


https://go.dev/ref/mod#go-mod-init