Pythonistaが伝える「ここがヘンだよGo言語」

[VISITS Advent Calendar](https://qiita.com/advent-calendar/2019/visits)も残りついに一週間を切ってしまいました。

見返してみると、とても幅広い分野の記事が書かれていて、社内の人間であっても「この人、こんな技術を持ってたんだ」のように驚かされることが多い毎日でした。

私にとっては2019年Advent Calendarの締めの記事となります！

# TL; DR

弊社のいくつかのプロダクトで **Go言語** でAPIサーバが実装されています。

昔からPythonばかり触ってきた筆者が、Go言語を一ヶ月半ほどですが業務でみっちり書いてわかった **Go言語とPythonの違い**について記事にしてみることにします。

題して、

**Pythonistaが伝える「ここがヘンだよGo言語」**

 とりあえず某番組のタイトルを~~パクt（ry~~ リスペクトしてキャッチーなタイトルにしてみました（何

対象読者は次のように設定しています。

- **Pythonはよく使うけど、Go言語を書いたことがない人**
- **Go言語を趣味で触っているけど、業務では書くor読む機会がない人**

Go言語のことをよく知らなくてもPythonの文法を知っていたら読めるように書いているつもりです。

文法レベルの違いから、業務レベルで効いてくる言語特性までカバーできたらなーと思ってます。

記事全体としては、**Go贔屓**な感じになってしまいましたが、Pythonへの愛があるからこそですよ！

# なんでPythonとGoの比較？全然違うだろうが！

確かにおっしゃる通りで、何から何まで違う言語です。

第一、Pythonは**動的型付け言語かつインタプリタ上で実行される言語**である一方、Goは**静的型付け言語のコンパイル言語**です。

これだけでも比較対象にするのは間違っていそうですね。

**これぐらい違うと対比させると逆に面白いんじゃないか**という筆者の淡い期待もあり、記事にしてみる価値があるかもしれないと思ったのが記事を書こうとした大きな動機です。

全然違う言語ではありますが、PythonとGoの大きな共通点は **どちらの言語も可読性が高くなるように設計されている** ことです。

様々なプログラミング言語がありますが、やっぱり可読性が高く、メンテナンス性の高い言語が（自然淘汰の結果）残っていくんだろうなぁという謎の雑感を持っています。

皆さんもやっぱり読みやすいコードが大好きですよね！

# PythonとGoの違い

## 歴史は全然違う！

### Pythonの歴史
Pythonの誕生は意外に古く、Guido Van Rossumによって**1991年**に最初のリリース(**Python 0.90**)がされました。
「Python」という名前の由来は**空飛ぶモンティ・パイソン（Monty Python’s Flying Circus）**というBBCのテレビ番組であることは有名ですね（なお観たことはない）。

[History of Python](https://www.geeksforgeeks.org/history-of-python/)によると、ヴァンロッサムさんはこの番組の大ファンだったらしく、当時名前のなかった発明した言語に短くてミステリアスな名前を付けたいということでこの名前になったそうです。

なんと、最初は **クリスマスの暇つぶしに行っていた趣味開発だった** らしいです。暇つぶしで作られた言語が世界中で使われるようになるのはなんとも夢があって面白いですね。

2000年に**Python2.0**がリリースされ、一躍メジャー言語として名が知れ渡ることとなりました([Python - Wikipedia](https://ja.wikipedia.org/wiki/Python#%E6%AD%B4%E5%8F%B2)。

Python2.xからPython3.xへの後方互換性を失う大移行も今では少し過去のことに感じてしまいますが、今では、**Python 3.8** がリリースされています([Python3.8の新機能 (まとめ)](https://qiita.com/ksato9700/items/3846e8db573a07c71c33))。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/260547/6b3600a0-fc62-811b-ce51-5ca25a35847f.png)
([History of Python](https://www.geeksforgeeks.org/history-of-python/)から引用)

### Pythonの思想 - Zen of Python

Pythonインタプリタ上で `import this` と打つと**Zen of Python**が英語で出てきます！)

```
$ python
Python 3.8.0 (default, Oct 31 2019, 16:56:00)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
```


英語辛い人は、[プログラマが持つべき心構え (The Zen of Python)](https://qiita.com/IshitaTakeshi/items/e4145921c8dbf7ba57ef)が参考になります。

### Goの歴史

個人の趣味開発から始まったPythonとは異なり、Goは世界的大企業**Google**から誕生しました。
新しいプログラミングを開発するという実験的プロジェクトのなかで、Googleのエンジニアである Robert Griesemer、Rob Pike、Ken Thompsonの三人によって設計されました([Go - en.wikipedia.org](https://en.wikipedia.org/wiki/Go_(programming_language)))。


**2007年から設計が始まり、2012年にGo1.0がオープンリリースされたばかり**という、プログラミング言語界ではまだまだ**新入り**という歴史の浅さですね。

Goはオープンソースなので、誰でもコードを読むことができます。

```sh
$ git clone https://github.com/golang/go.git # （注！） 200MBぐらいあります
$ git log --reverse
```

上記を実行すると、2008年頃のコミットが見れたりします。
（ちなみに最初のコミットは、仕様書でした。）

三人のうちの一人であるロブ・パイクさんが、まだリリースされていない2010年にStanford EE Computer Systems Colloquiumで発表したスライドをPDFで読むことができます([Another Go at Language Design](https://web.stanford.edu/class/ee380/Abstracts/100428-pike-stanford.pdf))。

このPDFを眺めてみるとかなり興味深い内容が書かれているのですが、ざっくりいうと、**JavaやC++が抱える問題（冗長なコード、コンパイルに時間がかかる、バイナリが大きいなどなど）を解決する**ためにGoが考え出されたようです。

> The Target:
Go aims to combine the safety and performance of a
statically typed compiled language with the expressiveness
and convenience of a dynamically typed interpreted
language.

特にここの部分を訳すと、

**Goが目指すのは、次の二つを結びつけること。**

- **静的型付けコンパイル言語の持つ安全性やパフォーマンス**
- **動的型付けインタプリタ言語の持つ表現能力や利便性**


まさにいいとこ取りな話ですが、Goはそれを本気で実現しようとしている言語だと言えます。

また、PDFの中では、Goが**他の言語の課題を解決する特徴**についても挙げられています。

- 高速なコンパイル
- 表現性のある型システム
- 並行性（並行プログラミングに強い）
- ガベージコレクション
- システムプログラミング言語（ハードウェアへの直接アクセスが可能）
- 明瞭であること
- 直交性（パッケージが他のパッケージと十分独立している）


直交性の部分の解釈は[Orthogonality in Go](https://arschles.svbtle.com/orthogonality-in-go)を参考にしています。標準パッケージが充実していて、わかりやすく分割されているのもそのためでしょうか。

### Goの思想 - Go Way
Goのお作法がまとめられており、それらをまとめて `Go Way` と呼びます。

[Effective Go (英語)](https://golang.org/doc/effective_go.html)

「なんだ、お作法って・・・」

と気になる人も多いかもしれませんが、最初は奇妙に思えるお作法を守ることでめちゃくちゃ得することが多いのです。

[「Go言語らしさ」とは何か？　Simplicityの哲学を理解し、Go Wayに沿った開発を進めることの良さ](https://employment.en-japan.com/engineerhub/entry/2018/06/19/110000#Go%E8%A8%80%E8%AA%9E%E3%82%89%E3%81%97%E3%81%95%E3%81%A8%E3%81%AF)

に非常に詳しく**Go Way**の解説が書かれているのでオススメです。


## 文法が全然違う！

PythonもGoもプログラミング言語ですから、コードで見るのが手っ取り早いでしょう。

### Pythonの"Hello, World"

```python:hello.py
print('Hello, World')
```

```sh
$ python hello.py
Hello, World
```

もしくは、

```sh
$ python
Python 3.8.0 (default, Oct 31 2019, 16:56:00)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>print('Hello, World')
Hello, World
```

### Goの"Hello, World"

```golang:main.go
package main

import "fmt"

func main() {
    fmt.Println("Hello, World")
}
```

```sh
$ go run main.go
Hello, World
```

。。。うーん。

さすがにこれだけだと違いがよくわからないので、もうちょっと実用的な実装をしてみましょう。

## PythonとGoで同じ機能を実装してみる

他のプログラマーに好きなプログラミング言語を布教活動するめんどくさいプログラマーをPythonとGoでそれぞれ実装してみましょう。

仕様としては、

- **プログラマーは名前と好きな言語を属性として持てる**
- **他のプログラマーを引数に与えると、そのプログラマーの好きな言語を自分の好きな言語に変える関数を持つ**
- **クラス変数の中で名前はグローバルからは変更できないようにする**

### Python

まずは、Pythonで `Programmer` Classを作ってみます。

まずは、最小限の実装です。

```python:main.py
class Programmer:
    def __init__(self, name, favorite_language):
        self.name = name
        self.favorite_language = favorite_language

    def teach_favorite_language(self, prog):
        prog.favorite_language = self.favorite_language


pythonista = Programmer("zawawahoge", "Python")
go_lover = Programmer("foobar", "Go")

pythonista.teach_favorite_language(go_lover)
```

`@property` デコレータを用いて、getter, setterを設定することができます。
これでプライベート変数（のようなもの）を実装することができますね。

`name` に関して、setterを実装しなかったので、外部からはアクセスできないようになります(できるけど)。

```python:main.py
class Programmer:
    def __init__(self, name, favorite_language):
        self.__name = name
        self.__favorite_language = favorite_language
        
    @property
    def name(self):
        return self.__name
   
    @property
    def favorite_language(self):
        return self.__favorite_language
    
    @favorite_language.setter
    def favorite_language(self, favorite_language):
        self.__favorite_language = favorite_language

    def teach_favorite_language(self, prog):
        prog.favorite_language = self.favorite_language


pythonista = Programmer("zawawahoge", "Python")
go_lover = Programmer("go_lover", "Go")

pythonista.teach_favorite_language(go_lover)
```

Pythonでは、プライベート変数にしたいものには最初に `__` を付けます。

### Goの"struct"

Pythonで実装したものと全く同じ機能をGoでも実装してみました。
業務で書いているようなコードにできるだけ近づけています。


```golang:main.go
package main

type Language string

// Programmer はプログラマーのインターフェイス（グローバル変数）
type Programmer interface {
	TeachFavoriteLanguage(target Programmer) error
	SetFavoriteLanguage(lang Language) error
	FavoriteLanguage() Language
}

// programmer は Programmerインターフェイスの実装(パッケージ内からのみ参照可能)
type programmer struct {
	Programmer
	name             string
	favoriteLanguage Language
}

// NewProgrammer は新しい Programmer を返す
func NewProgrammer(name string, lang Language) Programmer {
	return &programmer{
		name:             name,
		favoriteLanguage: lang,
	}
}

// getter
func (p *programmer) FavoriteLanguage() Language {
	return p.favoriteLanguage
}

// setter
func (p *programmer) SetFavoriteLanguage(lang Language) error {
	p.favoriteLanguage = lang
	return nil
}

// TeachFavoriteLanguage の実装
func (p *programmer) TeachFavoriteLanguage(target Programmer) error {
	err := target.SetFavoriteLanguage(p.FavoriteLanguage())
	if err != nil {
		return err
	}
	return nil
}

// main関数内では、Programmerインターフェイスのみでやりとりができる
func main() {
	pythonista := NewProgrammer("zawawahoge", Language("Python"))
	go_lover := NewProgrammer("go_lover", Language("Go"))

	err := pythonista.TeachFavoriteLanguage(go_lover)

	if err != nil {
		panic("布教活動中にエラーが発生しました")
	}
}
```

一目見ただけでも、コード量がPythonに比べて圧倒的に多くなっていることがわかります。

**何でこんなに増えてんの！？！？！？**

Pythonと異なる特徴を上げると、

- `Language` 型を明示的に定義（ `string` ）
- `Programmer` インターフェイスを定義
- `programmer` structを定義
- コンストラクタの代わりに、グローバルな `NewProgrammer()` を定義し、Programmerを生成する
- インターフェイスを実装する（関数が作られていれば満たしていることになる）
- エラーハンドリングを行う

Goでは、変数の最初の文字が**大文字ならグローバル変数**になり、**小文字ならパッケージ変数(同一パッケージ内のみ参照可能）**になります。

Pythonに比べてコード量自体は多くなってしまいますが、**一つ一つに明確な意味があり、無駄な部分がありません**。

## 可読性はどちらもあるけど、特徴が全然違う！

### Pythonの可読性

インデントが強制されているので、圧縮された `.js` ファイルのような読めないコードにはなり得ない言語仕様になっています。
初めてPythonに触った人がよく「インデントが気持ち悪い」と言うことがありますが、実はこのおかげで**一目でスコープが理解しやすくなっている**のです。

また、コード量が普通のコンパイル言語に比べて圧倒的に少なくすみます。Pythonがここまで科学技術計算で広まっていったのも、わかりやすいインターフェイスで様々なライブラリをラップすることができる特徴があったからでしょう。

ただ、動的型付け言語なので、IDEの補完などを活かしにくい欠点がある上、言語仕様的にはオブジェクトの中身を破壊することを前もって防ぐことが困難であるため、実装者の腕に強く依存した言語とも言えると思います（特にライブラリを作る時など）。

### Goの可読性

Pythonは実はとんでもなく自由度が高いため、人によって実装が大きく違うことが多々起こります。
Goだと、言語の特性上、目的に対して実装手法がある程度定まるため、**書いた人によらず、似たようなコードになります**。

このおかげで、複数の開発者で開発していても、実装が全く理解できない、ということが起こりにくいと言えます。

**楽をしにくい言語ではあるものの、必要十分な実装を自然と求められるため、実装者に依存しないコードになる**のだと思います。

## エラー処理が全然違う！

### Pythonのエラー処理 `try ~ except`

Pythonでは、 `try ~ except` 構文を使いますね。

```python
try:
    do_something()
    res = get_something()
except Exception as e:
    print(f"e={e}, type(e)={type(e)}")
```

`try ~ catch` 系のエラーハンドリングはエラー検出のためのオーバーヘッドが大きく、エラーが起きない時でもパフォーマンスが落ちる可能性があります。
全部に `try` で囲むとオーバーヘッドが大変なので、エラーが起きそうな部分だけ `try` で囲ってエラー処理を書くわけです。
そうすると、 `try` してないところでエラー起きた時どうするの？という話になってきます。

### Goのエラー処理

Goは他の言語と異なり、 `try ~ catch` や `try ~ except` によるエラーハンドリングを行わず、 `error` 型の戻り値によって成功かエラーかを判別します。

Goのコードには次のようなエラー処理が頻繁に出てきます。

見慣れていないと、おそらく **気持ち悪い** かもしれません（初期の筆者）。

```golang
err := DoSomething()
if err != nil {
        return errors.Errorf("failed to do something; err=%#v", err)
}

res, err := GetSomething()
if err != nil {
        return errors.Errorf("failed to get something; err %#v", err)
}
```
Goのように `err` が `nil` (Pythonでいう `None` )であるかどうかだけを調べれば、エラー検出が可能であるため、オーバーヘッドが非常に小さく、エラー検出のためのパフォーマンス低下がほとんどなくてすみます。

欠点としては、ほとんど全てのコードにエラー処理を書くことになるため、慣れないうちは **なんとなくめんどくさい**です。
ただ、慣れてきた頃には、**全コードをエラー処理できていることの安心感の方が上回ってきます！**

# まとめ
**Pythonistaが伝える「ここがヘンだよGo言語」**いかがだったでしょうか？

題名とは違ってむしろ**Go贔屓**ですいません。

記事的には、あとテストの項目も書きたかったですが、力尽きました。

この記事を書くにあたって、PythonとGoのどちらも調べることになったのですが、そのおかげで**とても勉強になった**ので、題材として選んで良かったと思いました。

何か伝わるものがあった人はいいねしてくださると励みになります。

ありがとうございました。


# 参考URL
- [「Go言語らしさ」とは何か？　Simplicityの哲学を理解し、Go Wayに沿った開発を進めることの良さ](https://employment.en-japan.com/engineerhub/entry/2018/06/19/110000#Go%E8%A8%80%E8%AA%9E%E3%82%89%E3%81%97%E3%81%95%E3%81%A8%E3%81%AF)
- [プログラマが持つべき心構え (The Zen of Python)](https://qiita.com/IshitaTakeshi/items/e4145921c8dbf7ba57ef)