diff --git a/.gitignore b/.gitignore
index a190a5f2c..34f22cc19 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,4 +2,14 @@
pkg/*
*.html
*.exe
+_book
+*.epub
+*.pdf
+.DS_Store
+.gitignore
+.vscode
+.git
+/fa/working
+# Folders
+.idea/
\ No newline at end of file
diff --git a/LANGS.md b/LANGS.md
new file mode 100644
index 000000000..a7a4b0e62
--- /dev/null
+++ b/LANGS.md
@@ -0,0 +1,11 @@
+* [Deutsch](de/)
+* [English](en/)
+* [Español](es/)
+* [Français](fr/)
+* [Português - Brasil](pt-br/)
+* [Русский](ru/)
+* [Türkçe](tr/)
+* [বাংলা](bn/)
+* [日本語](ja/)
+* [中文](zh/)
+* [پارسی](fa/)
diff --git a/README.md b/README.md
index d3a290c0f..f7903b67f 100644
--- a/README.md
+++ b/README.md
@@ -1,35 +1,36 @@
-# 《Go Web 编程》
-这本书目前有多个版本:
+# Multiple Language Versions
+
+* [(HTML - PDF) on GitBook](https://astaxie.gitbooks.io/build-web-application-with-golang)
+* [Deutsch](de/preface.md)
+* [English](en/preface.md)
+* [Español](es/preface.md)
+* [Français](fr/preface.md)
+* [Português - Brasil](pt-br/preface.md)
+* [Русский](ru/preface.md)
+* [Türkçe](tr/preface.md)
+* [বাংলা](bn/preface.md)
+* [日本語](ja/preface.md)
+* [简体中文](zh/preface.md)
+* [正體中文](zh-tw/preface.md)
+* [پارسی](fa/preface.md)
+* [ภาษาไทย](th/preface.md)
+
+# Donate
+
+AliPay: 
-[中文开始阅读]()
-
-[日文开始阅读]()
-
-[English Version]()
-
-目前这本书已经出版，如果你觉得内容还可以，你可以通过下面几个途径购买，谢谢支持：
-
-- [chinapub](http://product.china-pub.com/3767290)
-- [当当网](http://product.dangdang.com/product.aspx?product_id=23231404)
-- [京东](http://book.jd.com/11224644.html)
-- [Amazon](http://www.amazon.cn/Go-Web%E7%BC%96%E7%A8%8B-%E8%B0%A2%E5%AD%9F%E5%86%9B/dp/B00CHWVAHQ/ref=sr_1_1?s=books&ie=UTF8&qid=1369323453&sr=1-1)
-
-
-
-# 通过捐款支持本书
-如果你喜欢这本《Go Web编程》的话， 可以通过捐款的方式， 支持作者继续更新本书或者做出其他更多好玩好用的开源应用： 比如为本书修补漏洞、添加更多有趣的章节， 或者发行有更多更棒内容的下一版，或者改善beego等等。
+English Donate:[donate](http://beego.me/donate)
-支付宝扫描捐款: 
+## Community
+QQ群：148647580
-English Donate:[donate](http://beego.me/donate)
+BBS：[http://gocn.io/](http://gocn.io/)
-## 交流
-欢迎大家加入QQ群：386056972 《Go Web编程》专用交流群
+## Contributors
-论坛交流：[http://bbs.go-china.org/](http://bbs.go-china.org/)
+- See [contributors page](https://github.com/astaxie/build-web-application-with-golang/graphs/contributors) for full list of contributors.
-## 致谢
-首先要感谢Golang-China的QQ群102319854(已满)，请加2群(384414723),里面的每一个人都很热心，同时要特别感谢几个人
+## Acknowledgments
- [四月份平民](https://plus.google.com/110445767383269817959) (review代码)
- [Hong Ruiqi](https://github.com/hongruiqi) (review代码)
@@ -39,11 +40,7 @@ English Donate:[donate](http://beego.me/donate)
- [polaris](https://github.com/polaris1119)(review书)
- [雨痕](https://github.com/qyuhen)(review第二章)
-## 授权许可
-除特别声明外，本书中的内容使用[CC BY-SA 3.0 License](http://creativecommons.org/licenses/by-sa/3.0/)（创作共用 署名-相同方式共享3.0许可协议）授权，代码遵循[BSD 3-Clause License]()（3项条款的BSD许可协议）。
-
-## 开始阅读
-[开始阅读]()
-
+## License
+Book License: [CC BY-SA 3.0 License](http://creativecommons.org/licenses/by-sa/3.0/)
-[](http://githalytics.com/astaxie/build-web-application-with-golang)
+Code License: [BSD 3-Clause License]()
diff --git a/bn/01.0.md b/bn/01.0.md
new file mode 100644
index 000000000..4b26df95b
--- /dev/null
+++ b/bn/01.0.md
@@ -0,0 +1,23 @@
+# ১ গো এনভায়রনমেন্ট কনফিগারেশন
+
+গো এর ভুবনে আপনাকে স্বাগতম! পরম করুণাময় সৃষ্টিকর্তার নামে শুরু করছি।
+
+গো একটি ওপেনসোর্স, কম্পাইল প্রোগ্রামিং ল্যাঙ্গুয়েজ যেটি ২০০৭ সালে রব পাইক, কেন থমসন এবং রবার্ট গ্রিসমার মিলে ডিজাইন করেন। এটি স্ট্যাটিক টাইপ ল্যাঙ্গুয়েজ এবং এর সিনট্যাক্স অনেকটা সি প্রোগ্রামিং ল্যাঙ্গুয়েজ এর মত। গো এর সুবিধাসমূহ নিম্নে দেয়া হলঃ
+
+- অনেক বড় প্রজেক্ট কয়েক সেকন্ডের মধ্যে কম্পাইল করতে পারে
+- গারবেজ কালেকশন সুবিধা
+- এমন একটা সফটওয়্যার ডেভেলপমেন্ট মডেল প্রদান করে যেটা সি-স্টাইল হেডারের সমস্যা দূর করে
+- স্ট্যাটিক ল্যাঙ্গুয়েজ যার টাইপ সিস্টেম এর সীমা নেই। এটা অনেকটা অবজেক্ট-ওরিয়েণ্টেড প্রোগ্রামিং ল্যাঙ্গুয়েজের মত
+- গো ল্যাঙ্গুয়েজ লেভেলে কনকারেন্সি এবং কমিউনিকেশন সাপোর্ট করে
+- মাল্টি-কোর প্রসেসরের জন্য ডিজাইন করা
+- স্ট্রিং এবং ম্যাপ ল্যাঙ্গুয়েজে বিল্টইন দেয়া আছে
+
+গো একটি কম্পাইল ল্যাঙ্গুয়েজ। এটা একই সাথে স্ট্যাটিক ল্যাঙ্গুয়েজের সিকিউরিটি এবং ইন্টারপ্রেটেড ও ডায়নামিক ল্যাঙ্গুয়েজের ডেভেলপমেন্ট সুবিধা প্রদান করে। গো একটি আধুনিক প্রোগ্রামিং ল্যাঙ্গুয়েজ যা নেটওয়ার্কিং ও মাল্টি-কোর সাপোর্ট করে।
+
+
+পরবর্তী ধাপে আমরা দেখব কিভাবে গো ইনস্টল ও ইনভাইরনমেন্ট কনফিগারেশন করতে হয়।
+
+## লিঙ্ক
+
+- [ডিরেক্টরি](preface.md)
+- পরিবর্তী ধাপ: [ইনস্টলেশন](01.1.md)
diff --git a/bn/01.1.md b/bn/01.1.md
new file mode 100644
index 000000000..e0ee70461
--- /dev/null
+++ b/bn/01.1.md
@@ -0,0 +1,149 @@
+# ইনস্টলেশন ১.১
+
+## ইনস্টলেশন ১.১
+আপনার কম্পিউটারে গো এর পরিবেশ কনফিগার করার অনেক উপায় আছে এবং আপনি আপনার পছন্দ মত যে কোনটি চয়ন করতে পারেন। নিম্নরূপ তিনটি সর্বাধিক প্রচলিত উপায়।
+
+- অফিসিয়াল ইনস্টলেশন প্যাকেজ।
+ - গো টিম উইন্ডোজ, লিনাক্স, ম্যাক এবং অন্যান্য অপারেটিং সিস্টেমে সুবিধাজনক ইনস্টলেশন প্যাকেজগুলি প্রদান করে। এটি সম্ভবত শুরু করার সবচেয়ে সহজ উপায়। আপনি গোল্যাং ডাউনলোড পেজ থেকে ইনস্টলার পেতে পারেন।
+
+- সোর্স কোড থেকে এটি ইনস্টল করতে পারেন
+
+ - এটি ডেভেলপারদের সাথে পরিচিত যারা ইউনিক্স-মত সিস্টেমের সাথে পরিচিত।
+- তৃতীয় পক্ষের সরঞ্জাম ব্যবহার করে
+ - গো ইনস্টল করার জন্য অনেক তৃতীয় পক্ষের সরঞ্জাম এবং প্যাকেজ ম্যানেজার রয়েছে, যেমন উবুন্টুতে FT- প্রফিট এবং ম্যাকে হোমব্রো ।
+আপনি যদি কম্পিউটারে একাধিক সংস্করণ ইনস্টল করতে চান, তাহলে আপনাকে [GVM](https://github.com/moovweb/gvm) নামক একটি প্যাকেজ ম্যানেজার ইনস্টল করতে হবে। এই কাজের জন্য এটি সবচেয়ে ভালো , অন্যথায় আপনাকে নিজে এটি পরিচালনা করতে হবে।
+
+## সোর্স কোড থেকে ইনস্টল করুন
+
+গো ১.৫ এবং ঊর্ধ্বগামী কম্পাইল করার জন্য, শুধুমাত্র আপনার গো এর আগের সংস্করণটি দরকার, যেমনটি বুটস্ট্র্যাপিং অর্জন করেছে। আপনার শুধুমাত্র Go কম্পাইল প্রয়োজন
+
+go ১.৪ নীচের দিকে কম্পাইল করতে,আপনাকে সি সি-কম্পাইলার প্রয়োজন হবে কারণ গো এর কিছু অংশ এখনও প্ল্যান 9 সি এবং এটি এন্ড টি এসেম্বারের মধ্যে লেখা আছে।
+
+ম্যাক এ যদি আপনি Xcode ইনস্টল করেন তবে আপনার ইতিমধ্যেই কম্পাইলার আছে।
+
+ইউনিক্স-মত সিস্টেমগুলিতে, আপনি gcc বা অনুরূপ কম্পাইলার ইনস্টল করতে হবে। উদাহরণস্বরূপ, প্যাকেজ ম্যানেজার apt-get (উবুন্টুতে অন্তর্ভুক্ত) ব্যবহার করে, প্রয়োজন অনুসারে প্রয়োজনীয় কম্পাইলার ইনস্টল করতে পারেন:
+
+```sh
+sudo apt-get install gcc libc6-dev
+```
+
+উইন্ডোজে, আপনার জি.সি.সি. ইনস্টল করার জন্য আপনাকে মিনিগড ইনস্টল করতে হবে। ইনস্টলেশনের পরে আপনার এনভেরিয়েবলগুলি কনফিগার করতে ভুলবেন না। (*** এটির মত দেখায় যে এটি একটি অনুবাদক দ্বারা মন্তব্য করা হয়েছে: যদি আপনি 64-বিট উইন্ডোজ ব্যবহার করছেন তবে আপনাকে 64-বিট সংস্করণটি ইনস্টল করতে হবে MinGW ***)
+
+এই মুহুর্তে, Go সোর্স কোড ক্লোন করতে এবং এটি কম্পাইল করার জন্য নিম্নোক্ত কমান্ডগুলি চালনা করুন (*** এটি আপনার বর্তমান ডিরেক্টরীতে সোর্স কোড ক্লোন করবে। আপনি চালিয়ে যাওয়ার আগে আপনার কাজের পাথ পরিবর্তন করুন। এটি কিছু সময় নিতে পারে। *** )
+
+ git clone https://go.googlesource.com/go
+ cd go/src
+ ./all.bash
+
+ একটি সফল ইনস্টলেশন "সমস্ত পরীক্ষা পাস" বার্তার সঙ্গে শেষ হবে।
+
+উইন্ডোজে, আপনি 'all.bat` চালানোর মাধ্যমে এটি অর্জন করতে পারেন।
+
+আপনি যদি উইন্ডোজ ব্যবহার করেন, তাহলে ইনস্টলেশনের প্যাকেজটি আপনার ওয়্যারলেস ভেরিয়েবল স্বয়ংক্রিয়ভাবে সেট করবে। ইউনিক্স-মত সিস্টেমগুলিতে, আপনাকে এই ভেরিয়েবলগুলিকে ম্যানুয়ালি সেট করতে হবে। (*** আপনার Go সংস্করণটি 1.0 এর চেয়ে বড় হলে আপনার $ GOBIN সেট করতে হবে না এবং এটি স্বয়ংক্রিয়ভাবে আপনার $ GOROOT / bin এর সাথে সম্পর্কিত হবে, যা আমরা পরবর্তী অংশে আলোচনা করব ***)।
+
+ export GOROOT=$HOME/go
+ export GOBIN=$GOROOT/bin
+ export PATH=$PATH:$GOROOT/bin
+
+আপনি যদি আপনার পর্দায় নিম্নলিখিত তথ্য দেখতে পান, আপনি সব সেট হয়।
+
+
+
+চিত্র 1.1 সূত্র কোড থেকে ইনস্টল করার পরে তথ্য
+
+একবার আপনি Go এর ব্যবহারের তথ্য দেখেন, এর মানে হল আপনি সফলভাবে ইনস্টল করেছেন আপনার কম্পিউটারে । যদি এটি " কমান্ডের মতো না বলে", তবে পরীক্ষা করুন যে আপনার $ PATH এনভায়রনমেন্ট ভেরিয়েবল Go- এর ইনস্টলেশন পাথ রয়েছে কিনা।
+
+## স্ট্যান্ডার্ড ইনস্টলেশন প্যাকেজ ব্যবহার করে
+
+গো আর প্রতিটি সমর্থিত অপারেটিং সিস্টেমের জন্য এক ক্লিকে ইনস্টলেশনের প্যাকেজ রয়েছে । এই প্যাকেজটি ডিফল্টভাবে `/ usr / local / go` (` c: \ Go` উইন্ডোজে) চালু হবে। অবশ্যই এই পরিবর্তন করা যেতে পারে, কিন্তু উপরে দেখানো হিসাবে আপনাকে সব পরিবেশের ভেরিয়েবলগুলি পরিবর্তন করতে হবে।
+
+### আপনার অপারেটিং সিস্টেম 32-বিট বা 64-বিট কিভাবে পরীক্ষা করবেন ?
+
+আমাদের পরবর্তী পদক্ষেপটি আপনার অপারেটিং সিস্টেমের প্রকারের উপর নির্ভর করে, তাই আমাদের স্ট্যান্ডার্ড ইনস্টলেশন প্যাকেজগুলি ডাউনলোড করার আগে এটি পরীক্ষা করতে হবে।
+
+আপনি যদি উইন্ডোজ ব্যবহার করছেন, তাহলে `win + আর` টিপুন এবং কমান্ড টুলটি রান করুন। `Systeminfo` কমান্ডটি টাইপ করুন এবং এটি আপনাকে কিছু দরকারী সিস্টেম তথ্য দেখাবে। "সিস্টেম type" বলে লাইন খুঁজুন - যদি আপনি "x64- ভিত্তিক পিসি" দেখতে পান যা আপনার অপারেটিং সিস্টেম 64-বিট, 32-বিট নয়।
+
+আমি ম্যাক ওএসএক্সে 32-বিট প্রসেসরকে আর সমর্থন করি না কেননা আমি ম্যাক ইউজার হিসাবে 64-বিট প্যাকেজটি ডাউনলোড করার জন্য দৃঢ়ভাবে সুপারিশ করছি।
+
+লিনাক্স ব্যবহারকারীরা সিস্টেমের তথ্য দেখতে টার্মিনালে `uname -a` টাইপ করতে পারেন।
+একটি 64 বিট অপারেটিং সিস্টেম নিম্নলিখিত দেখাবে:
+
+ x86_64 x86_64 x86_64 GNU / Linux
+ // কিছু মেশিন যেমন উবুন্টু 10.04 নিম্নলিখিত হিসাবে প্রদর্শন করা হবে
+ x86_64 GNU / লিনাক্স
+
+32-বিট অপারেটিং সিস্টেম পরিবর্তে দেখান:
+
+ i686 i686 i386 GNU / লিনাক্স
+
+### ম্যাক
+
+[ডাউনলোড পেজ ] (https://golang.org/dl/) এ যান, 32 বিট সিস্টেমের জন্য `go1.4.2.darwin-386.pkg` (পরবর্তী সংস্করণে 32-বিট ডাউনলোড নেই।) নির্বাচন করুন এবং `go1.8.3.darwin-amd64.pkg` 64 বিট সিস্টেমের জন্য। "পরবর্তী" ক্লিক করে শেষ পর্যন্ত সব পথ ধরে, আপনার সিস্টেমের $ PATH- এ যোগ করার পরে `~ / go / bin 'যোগ করা হবে। এখন টার্মিনাল খুলুন এবং `go` টাইপ করুন। আপনি চিত্র 1.1 এ প্রদর্শিত একই আউটপুট দেখতে হবে।
+
+### লিনাক্স
+
+[ডাউনলোড পেজ] (https://golang.org/dl/) এ যান, 32-বিট সিস্টেমের জন্য `go1.8.3.linux-386.tar.gz` এবং` go1.8.3.linux-amd64.tar নির্বাচন করুন 64-বিট সিস্টেমের জন্য .gz`। ধরুন আপনি '$ GO_INSTALL_DIR' পথে গিয়ে ইনস্টল করতে চান। `Tar zxvf go1.8.3.linux-amd64.tar.gz -C $ GO_INSTALL_DIR` কমান্ডের সাহায্যে আপনার নির্বাচিত পাথে` tar.gz` আনকম্প্রেস করুন। তারপরে আপনার $ PATH সেট করুন: 'রপ্তানি PATH = $ PATH: $ GO_INSTALL_DIR / go / bin' এখন শুধু টার্মিনাল খুলুন এবং `go` টাইপ করুন আপনি এখন চিত্র 1.1 এ প্রদর্শিত একই আউটপুট দেখতে হবে।
+
+### উইন্ডোজ
+
+[ডাউনলোড পেজ] (https://golang.org/dl/) এ যান, 32 বিট সিস্টেমের জন্য `go1.8.3.windows-386.msi` এবং` go1.8.3.windows-amd64.msi` নির্বাচন করুন 64-বিট সিস্টেম "পরবর্তী" ক্লিক করে শেষ পর্যন্ত সমস্ত পথ ধরে, `c: / go / bin '` পাথ' এ যোগ করা হবে। এখন শুধু একটি কমান্ড লাইন উইন্ডো খুলুন এবং `go` টাইপ করুন আপনি এখন চিত্র 1.1 এ প্রদর্শিত একই আউটপুট দেখতে হবে।
+
+## তৃতীয় পক্ষের সরঞ্জামগুলি ব্যবহার করুন
+
+### জিএমএম
+
+GVM একটি গৌণ সংস্করণ নিয়ন্ত্রণ সরঞ্জাম যা তৃতীয় পক্ষের দ্বারা তৈরি হয়, যেমন রুবি জন্য rvm। এটি ব্যবহার করতে বেশ সহজ। আপনার টার্মিনালে নিম্নোক্ত কমান্ডগুলি লিখে gvm ইনস্টল করুন:
+
+ bash < <(curl -s -S -L https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
+
+তারপর আমরা নিম্নলিখিত কমান্ড ব্যবহার করে ইনস্টল করবো :
+
+ gvm install go1.8.3
+ gvm use go1.8.3
+
+এই প্রক্রিয়াটি সম্পূর্ণ হওয়ার পরে, আপনার সব সেট আছে।
+
+### Apt-get
+
+উবুন্টু লিনাক্সের সবচেয়ে জনপ্রিয় ডেস্কটপ রিলিজ সংস্করণ। এটি প্যাকেটগুলি পরিচালনার জন্য `apt-get` ব্যবহার করে। আমরা নিম্নলিখিত কমান্ড ব্যবহার করে Go ইনস্টল করতে পারি
+
+ sudo add-apt-repository ppa:gophers/go
+ sudo apt-get update
+ sudo apt-get install golang-go
+
+### wget
+```sh
+
+wget https://storage.googleapis.com/golang/go1.8.3.linux-amd64.tar.gz
+sudo tar -xzf go1.8.3.linux-amd64.tar.gz -C /usr/local
+
+# Go environment
+export GOROOT=/usr/local/go
+export GOBIN=$GOROOT/bin
+export PATH=$PATH:$GOBIN
+export GOPATH=$HOME/gopath
+```
+
+1.8 থেকে শুরু করে, GOPATH এনভায়রনমেন্ট ভেরিয়েবলটি এখন যদি সেট না থাকে তবে একটি ডিফল্ট মান থাকে। এটা ইউনিক্সে `$ HOME / go` এবং Windows এ`% USERPROFILE% / go` এ ডিফল্ট।
+### Homebrew
+
+Homebrew একটি সফটওয়্যার ম্যানেজমেন্ট টুল যা সাধারণত প্যাকেজগুলি পরিচালনার জন্য ম্যাকে ব্যবহৃত হয়। Go ইনস্টল করার জন্য নিম্নোক্ত কমান্ডগুলি টাইপ করুন।
+
+১. হোমব্রু ইনস্টল করুন
+
+```sh
+ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+```
+
+২. গো ইনস্টল করুন
+
+```sh
+ brew update && brew upgrade
+ brew install go
+```
+## লিঙ্ক
+
+- [ডিরেক্টরি](preface.md)
+- আগের অধ্যায়: [গো এনভায়রনমেন্ট কনফিগারেশন](01.0.md)
+- পরিবর্তী ধাপ: [$GOPATH and workspace](01.2.md)
+
diff --git a/bn/preface.md b/bn/preface.md
new file mode 100644
index 000000000..b99eca120
--- /dev/null
+++ b/bn/preface.md
@@ -0,0 +1,96 @@
+- ১.[গো এনভায়রনমেন্ট কনফিগারেশন](01.0.md)
+ - ১.১. [ইনস্টলেশন](01.1.md)
+ - ১.২. [গো-পাথ এবং ওয়ার্কস্পেস](01.2.md)
+ - ১.৩. [গো কমান্ড](01.3.md)
+ - ১.৪. [গো ডেভেলপমেন্ট টুলস](01.4.md)
+ - ১.৫. [সারমর্ম](01.5.md)
+- ২.[গো প্রাথমিক জ্ঞান](02.0.md)
+ - ২.১. ["হ্যালো, গো"](02.1.md)
+ - ২.২. [গো পটভূমি](02.2.md)
+ - ২.৩. [কন্ট্রোল স্টেটমেন্ট এবং ফাংশন](02.3.md)
+ - ২.৪. [স্ট্রাক্ট](02.4.md)
+ - ২.৫. [অবজেক্ট-ওরিয়েন্টেড](02.5.md)
+ - ২.৬. [ইন্টারফেস](02.6.md)
+ - ২.৭. [কনকারেন্সি](02.7.md)
+ - ২.৮. [সারমর্ম](02.8.md)
+- ৩.[ওয়েব ফাউন্ডেশন](03.0.md)
+ - ৩.১. [ওয়েবে কাজ করার ভিত্তি](03.1.md)
+ - ৩.২. [একটি সাধারণ ওয়েব সার্ভার তৈরি করা](03.2.md)
+ - ৩.৩. [গো কিভাবে ওয়েবে কাজ করে](03.3.md)
+ - ৩.৪. [http প্যাকেজ সম্পর্কে জানা](03.4.md)
+ - ৩.৫. [সারমর্ম](03.5.md)
+- ৪.[ইউজার ফর্ম](04.0.md)
+ - ৪.১. [ফর্ম ইনপুট প্রকিয়াকরন](04.1.md)
+ - ৪.২. [ইনপুট ভেরিফাই করা](04.2.md)
+ - ৪.৩. [ক্রস সাইট স্ক্রিপটিং](04.3.md)
+ - ৪.৪. [ডুপ্লিকেট সাবমিশন](04.4.md)
+ - ৪.৫. [ফাইল আপলোড](04.5.md)
+ - ৪.৬. [সারমর্ম](04.6.md)
+- ৫.[ডেটাবেস](05.0.md)
+ - ৫.১. [ডেটাবেস/এসকিউএল ইন্টারফেস](05.1.md)
+ - ৫.২. [মাইসিক্যুয়েল](05.2.md)
+ - ৫.৩. [সিক্যুয়েলাইট](05.3.md)
+ - ৫.৪. [পোস্টগ্রেস](05.4.md)
+ - ৫.৫. [beedb এর উপর ভিত্তি করে ওআরএম তৈরি করা](05.5.md)
+ - ৫.৬. [নো-সিক্যুয়েল ডেটাবেস](05.6.md)
+ - ৫.৭. [সারমর্ম](05.7.md)
+- ৬.[ডেটা ষ্টোরেজ](06.0.md)
+ - ৬.১. [সেশন এবং কুকি](06.1.md)
+ - ৬.২. [কিভাবে গোতে সেশন ব্যবহার করতে হয়](06.2.md)
+ - ৬.৩. [সেশন ষ্টোরেজ](06.3.md)
+ - ৬.৪. [সেশন হাইজ্যাক প্রতিরোধ](06.4.md)
+ - ৬.৫. [সারমর্ম](06.5.md)
+- ৭.[টেক্সট ফাইল](07.0.md)
+ - ৭.১. [এক্সএমএল](07.1.md)
+ - ৭.২. [জেসন](07.2.md)
+ - ৭.৩. [রেগুলার এক্সপ্রেশন](07.3.md)
+ - ৭.৪. [টেমপ্লেট](07.4.md)
+ - ৭.৫. [ফাইল](07.5.md)
+ - ৭.৬. [স্ট্রিং](07.6.md)
+ - ৭.৭. [সারমর্ম](07.7.md)
+- ৮.[ওয়েব সার্ভিস](08.0.md)
+ - ৮.১. [সকেট](08.1.md)
+ - ৮.২. [ওয়েবসকেট](08.2.md)
+ - ৮.৩. [রেস্ট](08.3.md)
+ - ৮.৪. [আরপিসি](08.4.md)
+ - 8.৫. [সারমর্ম](08.5.md)
+- ৯.[সিকিউরেটি এবং এনক্রিপশন](09.0.md)
+ - ৯.১. [সিএসআরএফ অ্যাটাক](09.1.md)
+ - ৯.২. [ইনপুট ফিল্টার](09.2.md)
+ - ৯.৩. [এক্সএসএস অ্যাটাক](09.3.md)
+ - ৯.৪. [এসকিউএল ইনজেকশন](09.4.md)
+ - ৯.৫. [পাসওয়ার্ড ষ্টোরেজ](09.5.md)
+ - ৯.৬. [ডাটা এনক্রিপ্ট](09.6.md)
+ - ৯.৭. [সারমর্ম](09.7.md)
+- ১০.[লোকালাইজেশন](10.0.md)
+ - ১০.১ [টাইম জোন](10.1.md)
+ - ১০.২ [রিসোর্স লোকালাইজেশন](10.2.md)
+ - ১০.৩ [আন্তজাতিক ওয়েব সাইট](10.3.md)
+ - ১০.৪ [সারমর্ম](10.4.md)
+- ১১.[এরর হ্যান্ডেলিং, ডিবাগ এবং টেস্টিং](11.0.md)
+ - ১১.১. [এরর হ্যান্ডেলিং](11.1.md)
+ - ১১.২. [GDB ব্যবহার করে ডিবাগ করা](11.2.md)
+ - ১১.৩. [টেস্ট কেইস লেখা](11.3.md)
+ - ১১.৪. [সারমর্ম](11.4.md)
+- ১২.[ডেপলয় এবং মেন্টেনেস](12.0.md)
+ - ১২.১. [লগ](12.1.md)
+ - ১২.২. [এরর এবং ক্রাশ](12.2.md)
+ - ১২.৩. [ডেপলয়](12.3.md)
+ - ১২.৪. [ব্যাকআপ এবং রিকভারী](12.4.md)
+ - ১২.৫. [সারমর্ম](12.5.md)
+- ১৩.[ওয়েব ফ্রামওয়ার্ক তৈরি করা](13.0.md)
+ - ১৩.১. [প্রজেক্ট প্রোগ্রাম](13.1.md)
+ - ১২.২. [কাস্টম রাউটার](13.2.md)
+ - ১২.৩. [কনট্রলার ডিজাইন](13.3.md)
+ - ১২.৪. [লগ এবং কনফিগারেশন](13.4.md)
+ - ১২.৫. [ব্লগ তৈরি, আপডেট এবং ডিলিট](13.5.md)
+ - ১২.৬. [সারমর্ম](13.6.md)
+- ১৪.[ওয়েব ফ্রামওয়ার্ক উন্নতি করা](14.0.md)
+ - ১৪.১. [স্ট্যাটিক ফাইল](14.1.md)
+ - ১৪.২. [সেশন](14.2.md)
+ - ১৪.৩. [ফর্ম](14.3.md)
+ - ১৪.৪. [ইউজার ভ্যালিডেশন](14.4.md)
+ - ১৪.৫. [একাধিক ভাষা](14.5.md)
+ - ১৪.৬. [পিপ্রফ](14.6.md)
+ - ১৪.৭. [সারমর্ম](14.7.md)
+- অ্যাপেন্ডিক্স [রেফারেন্স](ref.md)
diff --git a/bn/ref.md b/bn/ref.md
new file mode 100644
index 000000000..e3000bdd4
--- /dev/null
+++ b/bn/ref.md
@@ -0,0 +1,13 @@
+# Appendix A References
+
+This book is a summary of my Go experience, some content are from other Gophers' either blogs or sites. Thanks to them!
+
+1. [golang blog](http://blog.golang.org)
+2. [Russ Cox's blog](http://research.swtch.com/)
+3. [go book](http://go-book.appsp0t.com/)
+4. [golangtutorials](http://golangtutorials.blogspot.com)
+5. [轩脉刃de刀光剑影](http://www.cnblogs.com/yjf512/)
+6. [Go Programming Language](http://golang.org/doc/)
+7. [Network programming with Go](http://jan.newmarch.name/go/)
+8. [setup-the-rails-application-for-internationalization](http://guides.rubyonrails.org/i18n.html#setup-the-rails-application-for-internationalization)
+9. [The Cross-Site Scripting (XSS) FAQ](http://www.cgisecurity.com/xss-faq.html)
diff --git a/ebook/images/ebook.jpg b/cover.jpg
similarity index 100%
rename from ebook/images/ebook.jpg
rename to cover.jpg
diff --git a/de/01.0.md b/de/01.0.md
new file mode 100644
index 000000000..7e7903fc2
--- /dev/null
+++ b/de/01.0.md
@@ -0,0 +1,21 @@
+# 1 Einrichtung der Go Entwicklungsumgebung
+
+Willkommen in der Welt von Go. Lass sie uns erforschen.
+
+Go ist eine schnell kompilierte, automatisch speicherbereinigte, multitaskingfähige Programmiersprache. Sie hat folgende Vorteile:
+
+- Kompiliert große Projekte binnen Sekunden
+- Bietet ein einfaches Model zur Softwareentwicklung, welches die meisten Probleme um C-ähnliche Probleme mit Header-Dateien vermeidet
+- Sie ist eine statische Sprache ohne vielschichte Ebenen im Datentypensystem, sodass Benutzer nicht viel Zeit damit verschwenden, Verbindungen zwischen Datentypen herauszufinden. Es ist mehr wie eine leichtgewichtige, objekt-orientierte Programmiersprache.
+- Führt eine automatische Speicherbereinigung (Garbage Collection) durch. Sie bietet grundlegende Unterstützung für das parallele Ausführen von Aufgaben und die Kommunikation zwischen diesen.
+- Entworfen für Computer mit mehreren Rechnenkernen.
+
+
+Go ist eine kompilierte Sprache. Sie vereint während der Entwicklung die Effizienz von dynamischen Programmiersprachen mit der Sicherheit von statischen Sprachen. Sie ist die erste Wahl für moderne, mit Mehrkernprozessoren ausgestatten Computern, welche für die Netzwerkprogrammierung genutzt werden. Um diesen Anforderungen gerecht zu werden, müssen grundsätzliche Probleme in einer solchen Sprache gelöst werden. Dazu zählen ein ausdruckstarkes und zugleich leichtgewichtiges Datentypensystem, native Unterstützung zum simultanen Ausführen von Aufgaben und eine stark regulierte, automatische Speicherbereinigung. Eine lange Zeit gab es keine Packages oder andere Werkzeuge, mit dem Ziel, die genannten Probleme elegant zu lösen. Dies war letztendlich die Motivation, um Go zu entwicklen.
+
+In diesem Kapitel werde ich Dir zeigen, wie Du Deine eigene Go-Entwicklungsumgebung installierst und einrichtest.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Nächster Abschnitt: [Installation](01.1.md)
diff --git a/de/01.1.md b/de/01.1.md
new file mode 100644
index 000000000..f8ff2fbfd
--- /dev/null
+++ b/de/01.1.md
@@ -0,0 +1,125 @@
+# 1.1 Installation
+
+## Drei Wege Go zu installieren
+
+Es gibt viele Wege, um eine Go-Entwicklungsumgebung auf Deinem Computer einzurichten und Du kannst die auswählen, welche Dir gefällt. Die Folgenden sind die drei Häufigsten:
+
+- Offizielle Installationspakete.
+ - Das Team um Go stellt praktische Installationspakete für Windows, Linux, Mac und andere Betriebssysteme zur Verfügung. Dies ist wahrscheinlich der einfachste Weg, um zu starten.
+- Eigenhändige Kompilierung des Quellcodes.
+ - Beliebt untern Entwicklern, die mit UNIX-ähnlichen Systemen vertraut sind.
+- Nutze Programme von Dritten.
+ - Da Draußen gibt es eine Menge Werkzeuge von Drittanbietern und Paketmanager, um Go zu installieren, wie apt-get in Ubuntu oder homebrew für Mac.
+
+
+Im Fall, dass Du mehr als eine Version von Go auf Deinem Computer installieren möchtest, dann empfehle ich Dir, einen Blick auf [GVM](https://github.com/moovweb/gvm) zu werfen. Es ist die bisher beste Möglichkeit, die ich soweit gesehen habe, um dies zu tun. Andernfalls musst Du diese Aufgabe selbst bewältigen.
+
+
+## Eigenhändige Kompilierung des Quellcodes
+
+Da einige Bestandteile von Go in Plan 9 C und AT&T Assembler geschrieben sind, musst Du einen C-Compiler installieren, bevor Du den nächsten Schritt durchführst.
+
+Auf dem Mac, sofern Du Xcode installiert hast, ist bereits ein entsprechender Compiler vorhanden.
+
+
+Auf UNIX-ähnlichen Systemen musst Du gcc oder einen vergleichbaren Compiler installieren. Zum Beispiel mit dem Paketmanager apt-get (welcher in Ubuntu integriert ist), kannst Du die benötigten Compiler wie folgt installieren:
+
+`sudo apt-get install gcc libc6-dev`
+
+
+In Windows wird MinGW vorrausgesetzt, um folglich gcc zu installieren. Vergiss nicht, die Umgebungsvariablen nach der Installation zu konfigurieren. ( ***Alles was so aussieht wie dies, ist eine Anmerkung von den Übersetzern: Wenn Du eine 64-Bit Version von Windows nutzt, solltest Du auch eine 64-Bit Variante von MinGW installieren.*** )
+
+Zu diesem Zeitpunkt, führe die folgenden Befehle aus, um Gos Quellcode zu "klonen" und zu kompilieren. ( ***Der Quellcode wird in Dein aktuelles Arbeitsverzeichnis "geklont". Wechsle dieses, bevor Du fortfährst. Es könnte eine Weile dauern.***)
+
+ git clone https://go.googlesource.com/go
+ cd go/src
+ ./all.bash
+
+
+Eine erfolgreiche Installation wird mit der Nachricht "ALL TESTS PASSED." beendet.
+
+In Windows kannst Du das Selbe erreichen, indem Du `all.bat` ausführst.
+
+Wenn Du Windows nutzt, richtet die Installationsroutine die Umgebungsvariablen automatisch ein. Auf UNIX-ähnlichen Systemen musst Du diese wie folgt manuell setzen. ( ***Nutzt Du Go 1.0 oder höher, dann brauchst Du $GOBIN nicht zu definieren, da diese Umgebungsvariable relativ zu $GOROOT/bin gesetzt wird, welche wir im nächsten Abschnitt behandeln werden.*** )
+
+ export GOROOT=$HOME/go
+ export GOBIN=$GOROOT/bin
+ export PATH=$PATH:$GOROOT/bin
+
+Wenn Du die folgenden Informationen auf Deinem Bildschirm siehst, ist alles erfolgreich verlaufen.
+
+
+
+Abbildung 1.1 Informationen nach der manuellen Installation vom Quellcode
+
+Sobald Du Informationen zur Nutzung von Go siehst, bedeutet dies, dass Du Go erfolgreich auf Deinem Computer installiert hast. Steht dort jedoch "no such command", überprüfe die $PATH Umgebungsvariable und schaue, ob Sie den Installationspfad von Go beinhaltet.
+
+## Nutze die offiziellen Installationspakete
+
+Go bietet auch Ein-Klick-Installationspakete für jedes unterstützte Betriebssystem. Dieser Vorgang wird Go standardmäßig unter `/usr/local/go` (oder `C:\Go` unter Windows) installieren. Natürlich kannst Du dies nach belieben anpassen, jedoch musst Du die Umgebungsvariablen wie oben gezeigt von Hand ändern.
+
+### Wie überprüfe ich, ob mein Betriebssystem eine 32-Bit oder 64-Bit Variante ist?
+
+Der nächste Schritt hängt von der Art Deines Betriebssystems ab. Deshalb müssen wir diese erst herausfinden, bevor wir mit der Installation beginnen.
+
+Unter Windows, drücke `Win+R` und öffne die Kommandozeile, indem du `cmd` eingibst und `Enter` drückst. Tippe nun `systeminfo` ein und Du wirst ein paar nützliche Informationen vorfinden. Suche nach der Zeile "Systemtyp", welche die benötigten Informationen beinhaltet. Wenn Du "x64-based PC" liest, besitzt Du ein 64-Bit System, andernfalls ist es eine 32-Bit Version.
+
+Ich empfehle Dir dringlichst die 64-Bit Version von Go herunterzuladen, solltest Du ein Mac-Benutzer sein, da Go keine reinen 32-Bit-Prozessoren mehr unter Mac OSX unterstützt.
+
+Linux-Benutzer können `uname -a` im Terminal eintippen, um die Systeminformationen einzusehen. Ein 64-Bit Betriebssystem wird folgendes anzeigen:
+
+ x86_64 x86_64 x86_64 GNU/Linux
+ // Einige Computer mit Ubuntu 10.04 werden folgendes ausgeben
+ x86_64 GNU/Linux
+
+Ein 32-Bit System sieht dagegen folgendermaßen aus:
+
+ i686 i686 i386 GNU/Linux
+
+### Mac
+
+Rufe die Seite zum [Herunterladen](https://golang.org/dl/) auf und wähle `go1.4.2.darwin-386.pkg` für 32-Bit Systeme und `go1.4.2.darwin-amd64.pkg` für 64-Bit Systeme. Installiere Go, indem Du immer auf "weiter" klickst. `~/go/bin` wird automatisch zur Umgebungsvariable $PATH Deines Systems am Ende der Installation hinzugefügt. Öffne nun ein Terminal und tippe `go` ein. Du solltest die selben Ausgaben wie in Abbildung 1.1 sehen.
+
+### Linux
+
+
+Rufe die Seite zum [Herunterladen](https://golang.org/dl/) auf und wähle `go1.4.2.linux-386.tar.gz` für 32-Bit Systeme und `go1.4.2.linux-amd64.tar.gz` für 64-Bit Systeme. Angenommen, Du willst Go im `$GO_INSTALL_DIR` Pfad installieren: entpacke das `tar.gz` Archiv und wähle Deinen Pfad mit dem Befehl `tar zxvf go1.4.2.linux-amd64.tar.gz -C $GO_INSTALL_DIR`. Dann setze die Umgebungsvariable $PATH mit `export PATH=$PATH:$GO_INSTALL_DIR/go/bin`. Öffne nun ein Terminal und gib `go` ein. Du solltest die selben Ausgaben wie in Abbildung 1.1 sehen.
+
+### Windows
+
+Rufe die Seite zum [Herunterladen](https://golang.org/dl/) auf und wähle `go1.4.2.windows-386.msi` für 32-Bit Systeme und `go1.4.2.windows-amd64.msi` für 64-Bit Systeme. Installiere Go, indem Du immer auf "weiter" klickst. `c:/go/bin` wird zu `path` hinzugefügt. Öffne nun ein Terminal und tippe `go` ein. Du solltest die selben Ausgaben wie in Abbildung 1.1 sehen.
+
+## Nutze Programme von Dritten
+
+### GVM
+
+GVM ist ein Multi-Versions-Kontroll-Werkzeug'für Go und wurde von einem unabhängigen Programmier entwickelt, wie rvm für Ruby. Es ist ziemlich einfach zu nutzen. Installiere gvm indem Du folgendes in ein Terminal eingibst:
+
+ bash < <(curl -s -S -L https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
+
+Dann installieren wir Go wie folgt:
+
+ gvm install go1.4.2
+ gvm use go1.4.2
+
+Ist die Installation abgeschlossen, sind wir auch schon fertig.
+
+### apt-get
+
+Ubuntu ist die beliebteste Desktopvariante für Linux. Es nutzt `apt-get`, um Pakete zu verwalten. Wir können Go mit den unten stehenden Befehlen installieren:
+
+ sudo add-apt-repository ppa:gophers/go
+ sudo apt-get update
+ sudo apt-get install golang-stable
+
+### Homebrew
+
+Homebrew ist ein oftmals auf dem Mac genutztes Programm, um Pakete zu verwalten. Gib einfach folgendes ein, um Go zu installieren:
+
+ brew install go
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Einrichtung der Go Entwicklungsumgebung](01.0.md)
+- Nächster Abschnitt: [$GOPATH und Workspaces](01.2.md)
diff --git a/de/01.2.md b/de/01.2.md
new file mode 100644
index 000000000..dc0285888
--- /dev/null
+++ b/de/01.2.md
@@ -0,0 +1,153 @@
+# 1.2 $GOPATH und Workspaces
+
+## $GOPATH
+
+Alle Go-Befehle bauen auf einer wichtigen Umgebungsvariable mit dem Namen $GOPATH. Bedenke, dass es sich nicht um $GOROOT, also den Installationspfad von Go, handelt. Diese Variable verweist vielmehr auf den Go Workspace auf Deinem Computer (Ich benutze den unten stehenden Pfad auf meinem Computer; solltest Du eine andere Ordnerstruktur haben, musst Du den Pfad anpassen).
+
+In UNIX-ähnlichen System sollte die Variable dieser ähnlich sein:
+
+ export GOPATH=/home/apple/mygo
+
+In Windows musst Du eine neue Umgebungsvariable mit dem Namen $GOPATH erstellen und ihren Wert auf `C:\mygo`( ***Dieser Wert ist abhängig von dem Pfad Deines Workspaces*** ) setzen.
+
+Es ist in Ordnung, mehr als einen Pfad (bzw. Workspace) im $GOPATH zu speichern, aber bedenke, dass Du die Pfade mit `:` (oder `;` unter Windows) von einander trennen musst. `go get` wird Pakete stets unter dem ersten, angegebenen Workspace speichern.
+
+IM $GOPATH müssen die drei bestimmte Verzeichnisse vorhanden sein:
+
+- `src` für Quellcode mit der Dateiendung .go, .c, .g, .s.
+- `pkg` für kompilierte Dateien mit der Dateiendung .a.
+- `bin` für ausführbare Dateien
+
+
+In diesem Buch ist `mygo` mein einziger Pfad in $GOPATH.
+
+## Paketverzeichnis
+
+Erstelle Quellcodedateien und Ordner wie `$GOPATH/src/mymath/sqrt.go` (`mymath` ist der Paketname) ( ***Der Autor nutzt `mymath` als Paketnamen und gibt den Verzeichnissen, welche die Quellcodedateien beinhalten, den selben Namen***).
+
+Jedes Mal, wenn Du ein neues Paket erstellt, solltest Du einen neuen Ordner im `src` Verzeichnis erstellen. Diese Ordner haben überlicherweise den selben Namen, wie das Paket, welches Du nutzen möchtest. Die Verzeichnisse können zudem beliebig verschachtelt werden. Erstellst Du beispielsweise das Verzeichnis `$GOPATH/src/github.com/astaxie/beedb`, dann wäre das entsprechende Paket `github.com/astaxie/beedb`. Das Paket ist immer das letzte Verzeichnis im Pfad, in diesem Fall `beedb`.
+
+Führe die Folgenden Befehle aus. ( ***Nun widmet sich der Autor wieder den praktischen Dingen.*** )
+
+ cd $GOPATH/src
+ mkdir mymath
+
+Erstelle eine neue Datei mit dem Namen `sqrt.go`, die folgendes beinhalten soll.
+
+ // Quellcode von $GOPATH/src/mymath/sqrt.go
+ package mymath
+
+ func Sqrt(x float64) float64 {
+ z := 0.0
+ for i := 0; i < 1000; i++ {
+ z -= (z*z - x) / (2 * x)
+ }
+ return z
+ }
+
+Nun haben wir das Paketverzeichnis und den dazugehörigen Quellcode. Ich empfehle Dir, alle Paketverzeichnisse nach dem Paket selbst zu benennen und den gesamten, dazugehörigen Quellcode dort zu speichern.
+
+## Pakete kompilieren
+
+Oben haben wir bereits unser Paket erstellt, aber wie kompilieren wir es, um es nutzen zu können? Dafür gibt es zwei Wege.
+
+1. Navigiere im Terminal zum Paketverzeichnis und führe den `go install` Befehl aus.
+2. Führe den oberen Befehl aus, diesmal jedoch mit einem Dateinamen wie `go install mymath`.
+
+
+Nach der Kompilierung können wir den folgenden Ordner öffnen.
+
+ cd $GOPATH/pkg/${GOOS}_${GOARCH}
+ // Wie Du siehst, wurde eine neue Datei erstellt
+ mymath.a
+
+Die Datei mit der Endung `.a` ist die Binärdatei unseres Pakets. Aber wie nutzen wie diese nun?
+
+Logischerweise müssen wir dafür eine neue Anwendung schreiben, um das Paket zu nutzen.
+
+Erstelle ein neues Paket für die Anwendung mit dem Namen `mathapp`.
+
+ cd $GOPATH/src
+ mkdir mathapp
+ cd mathapp
+ vim main.go
+
+Und der Code:
+
+ // Quellcode von $GOPATH/src/mathapp/main.go
+ package main
+
+ import (
+ "mymath"
+ "fmt"
+ )
+
+ func main() {
+ fmt.Printf("Hallo, Welt. Sqrt(2) = %v\n", mymath.Sqrt(2))
+ }
+
+Um die Anwendung zu kompilieren, müssen wir zurück in das Verzeichnis, in welchem die Anwendung liegt; in diesem diesem Falle unter `$GOPATH/src/mathapp`. Führe nun den Befehl `go install` aus. Nun solltest Du eine neue ausführbare Datei mit dem Namen `mathapp` im Verzeichnis `$GOPATH/bin/` vorfinden. Um das Programm auszuführen, tippe den Befehl `./mathapp` ein. Im Terminal solltest Du nun den unteren Text lesen können.
+
+ Hallo, Welt. Sqrt(2) = 1.414213562373095
+
+## Installation von Paketen Dritter (Remote Packages)
+
+Go umfasst ein Werkzeug zum Installieren von Remote Packages, also Paketen die von anderen Programmierern erstellt wurden. Mit dem Befehl `go get` kannst Du diese für die eigene Nutzung installieren. Es unterstützt die meisten Open Source Communities wie GitHub, Google Code, Bitbucket und Launchpad.
+
+ go get github.com/astaxie/beedb
+
+Du kannst `go get -u …` nutzen, um ein Remote Package zu aktualisieren. Zugleich werden auch alle benötigten Abhängigkeiten mit installiert.
+
+Dieser Befehl nutzt verschiedene Versionskontrollsysteme für die verschiedenen Open Source Plattformen. So wird beispielsweise `git` für GitHub und `hg` für Google Code verwendet. Daher musst Du zuerst die entsprechenden Versionskontrollsysteme installieren, ehe Du `go get` nutzen kannst.
+
+Nach dem Ausführen der oben gezeigten Befehle, sollte die Orderstruktur etwa so aussehen.
+
+ $GOPATH
+ src
+ |-github.com
+ |-astaxie
+ |-beedb
+ pkg
+ |--${GOOS}_${GOARCH}
+ |-github.com
+ |-astaxie
+ |-beedb.a
+
+Im Hintergrund "klont" `go get` den Quellcode nach $GOPATH/src auf deinem Computer und nutzt dann `go install` zur Installation der Remote Packages.
+
+Du kannst Remote Packages wie lokale Pakete nutzen.
+
+ import "github.com/astaxie/beedb"
+
+## Die komplette Verzeichnisstruktur
+
+Wenn Du alle Schritte befolgt hast, sollte Deine Verzeichnisstruktur wie folgt aussehen.
+
+ bin/
+ mathapp
+ pkg/
+ ${GOOS}_${GOARCH}, such as darwin_amd64, linux_amd64
+ mymath.a
+ github.com/
+ astaxie/
+ beedb.a
+ src/
+ mathapp
+ main.go
+ mymath/
+ sqrt.go
+ github.com/
+ astaxie/
+ beedb/
+ beedb.go
+ util.go
+
+Nun kannst Du die Ordnerstruktur klar erkennen. `bin` beinhaltet alle ausführbaren Dateien, `pkg` alle compilierten Dateien und `src` den Quellcode der Pakete.
+
+(Das Format von Umgebungsvariable unter Windows ist `%GOPATH%`. Da dieses Buch sich jedoch am UNIX-Stil orientiert, müssen Windowsnutzer das Format von Hand ändern.)
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Installation](01.1.md)
+- Nächster Abschnitt: [Go Befehle](01.3.md)
diff --git a/de/01.3.md b/de/01.3.md
new file mode 100644
index 000000000..a1ef5a721
--- /dev/null
+++ b/de/01.3.md
@@ -0,0 +1,109 @@
+# 1.3 Go Befehle
+
+## Go Befehle
+
+Die Programmiersprache Go bringt viele nützliche Befehle für diverse Anwendungszwecke mit sich. Du erhälst eine Übersicht, indem Du `go` im Terminal ausführst.
+
+
+
+Figure 1.3 Eine detaillierte Übersicht aller Go Befehle
+
+Jeder Befehl kann nützlich für uns sein. Betrachten wir den Anwendungszweck von ein paar Befehlen.
+
+## go build
+
+Dieser Befehl ist für die Kompilierung und das Testen des Quellcodes verantwortlich. Abhängige Pakete werden ebenfalls mit kompiliert, sofern dies nötig ist.
+
+- Wenn das Paket nicht `main` entspricht, wie unser `mymath` Paket aus Abschnitt 1.2 nicht ausgeführt, nachdem Du `go build` ausgeführt hast. Solltest Du Paket-Dateien mit der Endung `.a` in `$GOPATH/pkg`, nutze stattdessen `go install`.
+- Sollte das Paket `main` entsprechen, dann wird eine ausführbare Binärdatei im selben Verzeichnis generiert. Möchtest Du stattdessen, dass Die Binärdatei in `$GOPATH/bin` generiert wird, nutze den Befehl `go install` oder `go build -o ${PATH_HERE}/a.exe.`.
+- Befinden sich viele Dateien in einem Ordner, aber Du möchtest nur eine bestimmte Datei kompilieren, dann füge den Dateinamen am Ende von `go build` hinzu. Ein Beispiel wäre `go build a.go`. `go build` wird alle Dateien im selben Ordner kompilieren.
+- Du kannst alternativ auch den Namen der ausführbaren Binärdatei ändern. So erhält das `mathapp` Projekt (aus Abschnitt 1.2) mit dem Befehl `go build -o astaxie.exe` den Namen `astaxie.exe`, statt `mathapp.exe`. Der Standardname ist immer der Verzeichnisname (sofern es kein `main` Paket ist) oder der Name der ersten, ausführbaren Datei (`main` Paket).
+
+Laut den [Spezifikationen der Go Programmiersprache](https://golang.org/ref/spec) sollten Pakete den Namen tragen, der nach dem Schlüsselwort `package` in der ersten Zeile einer Quellcodedatei steht. Dieser muss nicht gleich dem Verzeichnisnamen sein und die ausführbare Binärdatei wird standardmäßig den Verzeichnisnamen annehmen.
+
+- `go build` ignoriert Dateien, die mit `_` oder `.` beginnen.
+- Möchtest Du für jedes Betriebssystem andere Quellcodedateien erstellen, dann kannst Du den Systemnamen als Suffix im Dateinamen verwenden. Stell Dir vor, Du hast Quellcodedateien zum Laden von Arrays. Sie könnten nach dem folgenden Schema benannt sein:
+
+ array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
+
+`go build` wählt als Suffix den Namen, der mit Deinem Betriebssystem assoziiert ist. So wird einzig `array_linux.go` auf Linux-Systemen kompiliert. Alle anderen Dateien werden ignoriert.
+
+## go clean
+
+Dieser Befehl löscht alle Dateien, die vom Kompiler generiert wurden, einschließlich der unten gelisteten Dateien und Verzeichnisse.
+
+ _obj/ // Altes Verzeichnis von object, als Überreste von Makefiles
+ _test/ // Altes Verzeichnis von test, als Überreste von Makefiles
+ _testmain.go // Altes Verzeichnis von gotest, als Überreste von Makefiles
+ test.out // Altes Verzeichnis von test, als Überreste von Makefiles
+ build.out // Altes Verzeichnis von test, als Überreste von Makefiles
+ *.[568ao] // object Dateien, als Überreste von Makefiles
+
+ DIR(.exe) // Generiert von go build
+ DIR.test(.exe) // Generiert von go test -c
+ MAINFILE(.exe) // Generiert von go build MAINFILE.go
+
+Überlicherweise nutze ich diese Befehle zum Säubern von Projekten, bevor ich diese auf GitHub hochlade. Sie sind nützlich für lokale Tests, aber nutzlos zur Versionskontrolle.
+
+## go fmt und gofmt
+
+Programmierer, die mit C/C++ arbeiten, sollten wissen, das Personen immer darüber debattieren, welcher Code-Stil besser sei: K&R-Stil oder ANSI-Stil. In Go gibt nur einen einzigen, welcher vorrausgesetzt wird. So müssen zum Beispiel offene, geschwungene Schleifen nur am Ende von Zeilen eingefügt werden und können nicht in einer eigenen stehen, da dies einen Kompilierungsfehler zur Folge hat! Jedoch musst Du Dir diese Regeln nicht merken. `go fmt` übernimmt diese Aufgabe für Dich. Führe einfach den Befehl `go fmt .go` im Terminal aus. Persönlich nutze ich diesen Befehl selten, da die meisten IDEs diesen Befehl meist automatisch ausführen, sobald ich eine Datei speichere. Im nächsten Abschnitt werde ich näher auf IDEs eingehen.
+
+
+`go fmt` ist nur ein Alias, welcher den Befehl `gofmt -l -w` bei Paketen anwendet, die in den Importpfaden genannt werden.
+
+Wir nutzen üblicherweise `gofmt -w` statt `go fmt`. Somit wird Deine Quellcodedatei nicht umgeschrieben, nachdem sie formatiert wurde. `gofmt -w src` formatiert dagegen ein gesamtes Projekt.
+
+## go get
+
+Dieser Befehl ermöglicht es, Remote Packages herunterzuladen. Bisher untersützt es Bitbucket, GitHub, Google Code und Launchpad. Es geschehen zwei Dinge, nachdem wir den Befehl ausgeführt haben. Als erstes lädt Go den Quellcode herunter und führt danach `go install` aus. Bevor Du `go get` nutzt, solltest Du vorher die benötigten Versionskontrollsysteme herunterladen.
+
+ BitBucket (Mercurial und Git)
+ GitHub (Git)
+ Google Code (Git, Mercurial, Subversion)
+ Launchpad (Bazaar)
+
+
+Um den Befehl auch nutzen zu können, musst Du diese Programme korrekt installieren. Vergiss nicht, `$PATH` zu setzen. Angemerkt sei, dass auch angepasste Domainnamen unterstützt werden. Nutze `go help remote`, um weitere Informationen zu erhalten.
+
+## go install
+
+Dieser Befehl kompiliert alle Pakete und generiert Dateien, die entweder nach `$GOPATH/pkg` oder `$GOPATH/bin` verschoben werden.
+
+## go test
+
+Dieser Befehl läd alle Dateinen, dessen Name `*_test.go` beinhaltet, generiert Dateien für Tests und gibt anschließend dessen Ergebnisse aus, die wie folgt aussehen können:
+
+ ok archive/tar 0.011s
+ FAIL archive/zip 0.022s
+ ok compress/gzip 0.033s
+ ...
+
+Es nutzt standardmäßig alle vorhanden Test-Dateien. Schaue unter `go help testflag` für Details.
+
+## godoc
+
+Viele Personen sagen, man brauche kein Dokumentationswerkzeug von Dritten, wenn man Go nutzt (obwohl ich mit [CHM](https://github.com/astaxie/godoc) selbst eins schrieb). Go besitzt ein mächtiges Wergzeug, um Dokumentationen nativ zu verwalten.
+
+Aber wie können wir bestimmte Informationen über ein Paket einsehen? So möchtest Du zum Beispiel mehr über das `builtin` Paket wissen. Nutze hierfür `godoc builtin`. Mach es mit `godoc net/http` genauso, wenn Du mehr über das `http` Paket in Erfahrung bringen möchtest. Ist jedoch eine spezifische Funktion gefragt, benutze die `godoc fmt Printf` und `godoc -src fmt Printf` Befehle, um den Quellcode zu betrachten.
+
+Führe den Befehl `godoc -http=:8080` aus und öffne dann `127.0.0.1:8080` in Deinem Browser. Nun solltest Du eine Deiner Sprache angepassten (lokalisierten) Version von golang.org sehen. So kannst Du nicht nur die Dokumentationen zu Paketen der Standardbibliothek ansehen, sondern auch aller Pakete, die unter `$GOPATH/pkg` gepspeichert sind. Dies ist großartig für Menschen, die von der Great Firewall of China im Internet eingeschränkt werden.
+
+## Andere Befehle
+
+Go verfügt über noch mehr Befehle, die wir nicht behandelt haben.
+
+
+ go fix // Überführt alten Go Code von Go1 oder niedriger in eine neuere Version
+ go version // Erhalte nähere Informationen über Deine Go Version
+ go env // Zeigt die alle Umgebungsvariablen von Go
+ go list // Listed alle installierten Pakete
+ go run // Kompiliert temporäre Dateien und führt diese aus
+
+Es gibt noch weitere Aspekte zu den Befehlen, über die ich nicht gesprochen habe. Du kannst `go help ` nutzen, um diese nachzulesen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [$GOPATH und Workspaces](01.2.md)
+- Nächster Abschnitt: [Go Entwicklungswerkzeuge](01.4.md)
diff --git a/de/01.4.md b/de/01.4.md
new file mode 100644
index 000000000..ad65518b8
--- /dev/null
+++ b/de/01.4.md
@@ -0,0 +1,401 @@
+# Go Entwicklungswerkzeuge
+
+In diesem Abschnitt werde ich Dir ein paar IDEs (***Integrated Developement Environments***) vorstellen, die Dir mit Funktionen wie intelligenter Codevervollständigung und automatischer Formatierung dabei helfen, effizienter zu programmieren. Alle Entwicklungsumgebungen sind plattformunabhängig, sodass die hier gezeigten Schritte nicht sehr verschieden seien sollten, auch wenn Du ein anderes Betriebssystem nutzt.
+
+## LiteIDE
+
+LiteIDE ist eine leichtgewichtige IDE, die open source ist und einzig für die Go Programmierung gedacht ist. Entwickelt wurde sie von visualfc.
+
+
+
+Abbildung 1.4 Startansicht von LiteIDE
+
+LiteIDEs Merkmale.
+
+- Plattformunaghängigkeit
+ - Windows
+ - Linux
+ - Mac OS
+- Plattformübergreifende Kompilierung
+ - Verwalte mehrere Kompilierungsumgebungen
+ - Unterstützt die plattformübergreifende Kompilierung von Go-Code
+- Standardisiertes Projektmanagement
+ - Dokumentationsansicht basiert auf $GOPATH
+ - Kompilierungsystem basiert auf $GOPATH
+ - Index der API-Dokumentation basiert auf $GOPATH
+- Go Quellcode Editor
+ - Umschreibung von Code
+ - Vollständige Unterstützung von gocode
+ - Anzeige der Go Dokumentation und ein API Index
+ - Hilfe zu Codefragmenten durch `F1`
+ - Aufrufen von Funktionsdeklerationen durch `F2`
+ - Gdb Unterstützung
+ - Automatische Formatierung durch `gofmt`
+- Anderes
+ - Mehrsprachig
+ - Plugin System
+ - Texteditor Themes
+ - Farbliche Syntaxhervorhebung basierend auf Kate
+ - Intelligente Autovervollständigung basierend auf einer Volltext-Suche
+ - Personalisierbare Tastenkürzel
+ - Markdown Unterstützung
+ - Echtzeit Vorschau
+ - Personalisierbares CSS
+ - Exportoptioen zu HTML und PDF
+ - Konvertierung and Zusammenführung zu HTML und PDF
+
+### LiteIDE Instalation
+
+- Installiere LiteIDE
+ - [Lade LiteIDE herunter](http://code.google.com/p/golangide)
+ - [Quellcode](https://github.com/visualfc/liteide)
+
+ Du musst Go zuerst installieren. Lade dafür die entsprechende Version für Dein Betriebssystem herunter. Entpacke das Archiv um es Programm direkt auszuführen.
+- Installiere gocode
+
+ Im nächsten Schritt muss gocode installiert werden, um die intelligente Autovervollständigung zu nutzen.
+
+ go get -u github.com/nsf/gocode
+
+- Kompilierungsumgebung
+
+ Passe die Einstellungen von LiteIDE Deinen Betriebssystem entprechend an. Unter Windows mit der 64-Bit Variante von Go solltest Du win64 als Umgebung in der Symbolleiste auswählen. Dann wähle `opinion`, finde `LiteEnv` in der Liste auf der linken Seiten und öffne die Datei `win64.env` in der Liste zu Deiner Rechten.
+
+ GOROOT=c:\go
+ GOBIN=
+ GOARCH=amd64
+ GOOS=windows
+ CGO_ENABLED=1
+
+ PATH=%GOBIN%;%GOROOT%\bin;%PATH%
+ 。。。
+
+ Ersetze `GOROOT=c:\go` mit Deinem Installationspfad von Go und speichere. Wenn Du MinGW64 nutzt, füge `C:\MinGW64\bin` der $PATH-Umgebungsvariable hinzu, um `cgo` starten zu können.
+
+ Unter Linux mit einer 64-Bit Variante von Go, solltest Du linux64 als Umgebung in der Symbolleiste auswählen. Dann wähle `opinion`, finde `LiteEnv` in der Liste auf der linken Seiten und öffne die Datei `linux64.env` in der Liste zu Deiner Rechten.
+
+ GOROOT=$HOME/go
+ GOBIN=
+ GOARCH=amd64
+ GOOS=linux
+ CGO_ENABLED=1
+
+ PATH=$GOBIN:$GOROOT/bin:$PATH
+ 。。。
+
+ Ersetzte `GOROOT=$HOME/go` mit Deinem Installationspfad von Go und speichere.
+- $GOPATH
+ $GOPATH ist ein Pfad, der eine Liste von allen Go-Projekten umfasst. Öffne die Kommandozeile (oder drücke `Ctrl+` in LiteIDE) und gib dann `go help gopath` ein, um mehr Details einzusehen. In LiteIDE ist es sehr einfach, den $GOPATH einzusehen und ihn zu verändern. Folge `View - Setup GOPATH`, um dies zu tun.
+
+## Sublime Text
+
+Nun möchte ich dir Sublime Text 2 (oder einfach Sublime) in Kombination mit den Plugins GoSublime, gocode und MarGo vorstellen. Lass mich erklären, warum.
+
+- Intelligente Autovervollständigung
+
+ 
+
+ Abbildung 1.5 Sublimes intelligente Autovervollständigung
+- Automatische Formatierung des Quellcodes
+- Unterstützung für Projektmanagement
+
+ 
+
+ Abbildung 1.6 Projektmanagement in Sublime
+
+- Farbliche Hervorhebung des Synax
+- Es gibt eine Testversion ohne Einschränkungen der Funktionen. Es kann sein, dass Du nach einer Weile daran erinnert wirst, dass Du eine Lizenz kaufen sollest, aber Du kannst diese Meldung auch einfach ignorieren. Wenn Du aber glaubst, dass Sublime Dich produktiver macht und Du den Editor magst, solltest Du eine Lizenz kaufen, um die fortwährende Entwicklung zu unterstützen.
+
+Zu aller erst solltest Du Dir eine für Dein Betriebssystem geeignete Version von [Sublime](http://www.sublimetext.com/) herunterladen.
+
+1. Drücke ``Ctrl+` ``, öffne die Kommandozeile und füge folgenden Codesnippsel ein:
+
+ import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation'
+
+ Starte Sublime Text nach der Installation neu. Nun solltest Du im Menü unter dem Reiter `Preferences` die Option `Package Control` vorfinden.
+
+ 
+
+ Abbildung 1.7 Die Paketverwaltung von Sublime
+
+2. Zur Installation von GoSublime, SidebarEnhancements und Go Build, drücke `Ctrl+Shift+p` um die Paketverwaltung aufzurüfen und gib `pcip` (Kurzform für "Package Control: Install Package") ein.
+
+ 
+
+ Abbildung 1.8 Installation von Paketen in Sublime
+
+ Gib nun "GoSublime" ein, drücke auf OK, um das Paket zu installieren und wiederhole diese Schritte jeweils für SidebarEnhancements und Go Build. Starte den Editor nochmals neu, sobald alle Pakete installiert wurden.
+
+3. Um sicher zu stellen, dass die Installation auch erfolgreich abgeschlossen wurde, starte Sublime und öffne die Datei `main.go`, um zu sehen, ob dessen Syntax farblich hervorgehoben wird. Gib `import` ein, um zu testen, ob die automatische Codevervollständigung nun funktioniert oder nicht.
+
+ Wenn alles erfolgreich Verlaufen ist, können wir ja starten.
+
+ Sollte dies nicht der Fall sein, solltest Du nochmal einen Blick auf die $PATH-Umgebungsvariable blicken. Öffne dazu die Kommandozeile und gib `gocode` ein. Sollte nichts ausgeführt werden, so wird $PATH wahrscheinlich nicht richtig konfiguriert worden sein.
+
+## Vim
+
+Vim ist ein populärer Texteditor unter Programmierern, welcher sich aus seinem minimalistischeren Vorgänger Vi hervorging. Zu seinen Funktionen gehören u.a. die intelligente Autovervollständung von Codesegmenten, Kompilierung und das Springen zu Fehlern im Quellcode.
+
+
+
+Abbildung 1.8 Vims intelligente Autovervollständigung für Go
+
+1. Syntaxhervorhebung für Go
+
+ cp -r $GOROOT/misc/vim/* ~/.vim/
+
+2. Syntaxhervorhebung aktivieren
+
+ filetype plugin indent on
+ syntax on
+
+3. Installiere [gocode](https://github.com/nsf/gocode/)
+
+ go get -u github.com/nsf/gocode
+
+ gocode wird standardmäßig unter `$GOBIN` installiert.
+
+4. Konfiguriere [gocode](https://github.com/nsf/gocode/)
+
+ ~ cd $GOPATH/src/github.com/nsf/gocode/vim
+ ~ ./update.bash
+ ~ gocode set propose-builtins true
+ propose-builtins true
+ ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
+ lib-path "/home/border/gocode/pkg/linux_amd64"
+ ~ gocode set
+ propose-builtins true
+ lib-path "/home/border/gocode/pkg/linux_amd64"
+
+ Einige Worte zur Konfiguration von gocode:
+
+ propose-builtins: aktiviert bzw. deaktiviert die Autovervollständigung; standardmäßig auf false gesetzt.
+ lib-path: gocode sucht lediglich unter `$GOPATH/pkg/$GOOS_$GOARCH` und `$GOROOT/pkg/$GOOS_$GOARCH` nach Paketen. Mit dieser Einstellung können weitere Pfade hinzugefügt werden..
+
+5. Glückwunsch! Tippe `:e main.go` ein und mache Deine ersten Schritte in Go!
+
+## Emacs
+
+Emacs wird auch als "Weapon of God" bezeichnet. Es handelt sich nicht nur um einen Editor, sondern vielmehr um eine mächtige IDE.
+
+
+
+Abbildung 1.10 Emacs Hauptfenster als Go-Editor
+
+1. Syntaxhervorhebung
+
+ cp $GOROOT/misc/emacs/* ~/.emacs.d/
+
+2. Installiere [gocode](https://github.com/nsf/gocode/)
+
+ go get -u github.com/nsf/gocode
+
+ gocode wird standardmäßig unter `$GOBIN` installiert.
+3. Konfiguriere [gocode](https://github.com/nsf/gocode/)
+
+ ~ cd $GOPATH/src/github.com/nsf/gocode/vim
+ ~ ./update.bash
+ ~ gocode set propose-builtins true
+ propose-builtins true
+ ~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
+ lib-path "/home/border/gocode/pkg/linux_amd64"
+ ~ gocode set
+ propose-builtins true
+ lib-path "/home/border/gocode/pkg/linux_amd64"
+
+4. Installiere [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)
+
+ ~ make install DIR=$HOME/.emacs.d/auto-complete
+
+ Konfiguriere die ~/.emacs-Datei
+
+ ;;auto-complete
+ (require 'auto-complete-config)
+ (add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
+ (ac-config-default)
+ (local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
+ (local-set-key "." 'semantic-complete-self-insert)
+ (local-set-key ">" 'semantic-complete-self-insert)
+
+ Folge diesem [Link](http://www.emacswiki.org/emacs/AutoComplete) für weitere Informationen.
+
+5. Konfiguriere .emacs
+
+ ;; golang mode
+ (require 'go-mode-load)
+ (require 'go-autocomplete)
+ ;; speedbar
+ ;; (speedbar 1)
+ (speedbar-add-supported-extension ".go")
+ (add-hook
+ 'go-mode-hook
+ '(lambda ()
+ ;; gocode
+ (auto-complete-mode 1)
+ (setq ac-sources '(ac-source-go))
+ ;; Imenu & Speedbar
+ (setq imenu-generic-expression
+ '(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
+ ("func" "^func *\\(.*\\) {" 1)))
+ (imenu-add-to-menubar "Index")
+ ;; Outline mode
+ (make-local-variable 'outline-regexp)
+ (setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
+ (outline-minor-mode 1)
+ (local-set-key "\M-a" 'outline-previous-visible-heading)
+ (local-set-key "\M-e" 'outline-next-visible-heading)
+ ;; Menu bar
+ (require 'easymenu)
+ (defconst go-hooked-menu
+ '("Go tools"
+ ["Go run buffer" go t]
+ ["Go reformat buffer" go-fmt-buffer t]
+ ["Go check buffer" go-fix-buffer t]))
+ (easy-menu-define
+ go-added-menu
+ (current-local-map)
+ "Go tools"
+ go-hooked-menu)
+
+ ;; Other
+ (setq show-trailing-whitespace t)
+ ))
+ ;; helper function
+ (defun go ()
+ "run current buffer"
+ (interactive)
+ (compile (concat "go run " (buffer-file-name))))
+
+ ;; helper function
+ (defun go-fmt-buffer ()
+ "run gofmt on current buffer"
+ (interactive)
+ (if buffer-read-only
+ (progn
+ (ding)
+ (message "Buffer is read only"))
+ (let ((p (line-number-at-pos))
+ (filename (buffer-file-name))
+ (old-max-mini-window-height max-mini-window-height))
+ (show-all)
+ (if (get-buffer "*Go Reformat Errors*")
+ (progn
+ (delete-windows-on "*Go Reformat Errors*")
+ (kill-buffer "*Go Reformat Errors*")))
+ (setq max-mini-window-height 1)
+ (if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
+ (progn
+ (erase-buffer)
+ (insert-buffer-substring "*Go Reformat Output*")
+ (goto-char (point-min))
+ (forward-line (1- p)))
+ (with-current-buffer "*Go Reformat Errors*"
+ (progn
+ (goto-char (point-min))
+ (while (re-search-forward "" nil t)
+ (replace-match filename))
+ (goto-char (point-min))
+ (compilation-mode))))
+ (setq max-mini-window-height old-max-mini-window-height)
+ (delete-windows-on "*Go Reformat Output*")
+ (kill-buffer "*Go Reformat Output*"))))
+ ;; helper function
+ (defun go-fix-buffer ()
+ "run gofix on current buffer"
+ (interactive)
+ (show-all)
+ (shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
+
+6. Glückwunsch, Du hast es geschafft! Die Schnellzugriffsleiste (Speedbar) ist standardmäßig geschlossen - Entferne die Kommentarzeichen in der Zeile `;;(speedbar 1)`, um diese Funktion zu aktivieren, oder Du benutzt die Speedbar via `M-x speedbar`.
+
+## Eclipse
+
+Eclipse ist ebenfalls ein großartiges Entwicklungswerkzeug. Ich werde Dir zeigen, wie Du mit ihm Programme in Go schreiben kannst.
+
+
+
+Abbildung 1.1 Eclipses Hauptfenster zum Programmieren Go
+
+1. Herunterladen und Installation von [Eclipse](http://www.eclipse.org/)
+2. Lade [goclipse](https://code.google.com/p/goclipse/) herunter
+ [http://code.google.com/p/goclipse/wiki/InstallationInstructions](http://code.google.com/p/goclipse/wiki/InstallationInstructions)
+3. Lade gocode
+
+ gocode auf Github.
+
+ https://github.com/nsf/gocode
+
+ Unter Windows musst Du git installiert haben. Wir nutzen überlicherweise [msysgit](https://code.google.com/p/msysgit/).
+
+ Installiere gocode in der Kommandozeile
+
+ go get -u github.com/nsf/gocode
+
+ Du kannst die Installation mithilfe des Quellcodes selbst durchführen, wenn Du magst.
+4. Installation von [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
+5. Konfiguration der Plugins.
+
+ Windows->Preferences->Go
+
+ (1).Einrichtung des Go-Compiler
+
+ 
+
+ Abbildung 1.12 Go-Einstellungen in Eclipse
+
+ (2).Konfiguriere gocode(optional). Setze den Pfad zu gocode auf den Speicherort von gocode.exe.
+
+ 
+
+ Abbildung 1.13 gocode-Einstellungen
+
+ (3).Konfiguriere gdb(optional). Setze den Pfad zu gdb auf den Speicherort von gdb.exe.
+
+ 
+
+ Abbildung 1.14 gdb-Einstellungen
+6. Überprüfe, ob die Installation erfolgreich verlief
+
+ Erstelle ein neues Go-Project und eine Datei hello.go wie folgt.
+
+ 
+
+ Abbildung 1.15 Erstelle ein neues Projekt und eine Datei
+
+ Überprüfe die Installation wie folgt. (Die Befehle müssen in die Konsole von Eclipse eingegeben werden).
+
+ 
+
+ Abbildung 1.16 Teste ein Go-Programm in Eclipse
+
+## IntelliJ IDEA
+
+Programmierer, die bereits mit Java gearbeitet haben, sollte diese IDE bekannt sein. Es unterstützt die farbliche Hervorhebung von Go-Code und intelligente Autovervollständigung, welches durch ein Plugin erreicht wird.
+
+1. Lade IDEA herunter. Es gibt keinen Unterschied zwischen der Ultimate- und Community-Edition.
+
+ 
+
+2. Installiere das Go-Plugin. Gehe zu `File - Setting - Plugins` und klicke dann auf `Browser repo`.
+
+ 
+
+3. Starte eine Suche mit `golang`, klicke doppelt auf `download and install` und warte, bis der Download abgeschlossen ist.
+
+ 
+
+ Klicke auf `Apply` und starte das Programm neu.
+
+4. Nun kannst Du ein neues Go-Projekt erstellen.
+
+ 
+
+ Gib im nächsten Schritt den Speicherort Deines Go-SDK (***SDK steht für Software Developement Kit***) an - normalerweise handelt es sich hierbei um $GOROOT.
+
+( ***Werfe einen Blick auf diesen [Blogartikel](http://wuwen.org/tips-about-using-intellij-idea-and-go/), welcher die Installation und Einrichtung von IntelliJ IDEA mit Go schrittweise erläutert.*** )
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Go Befehle](01.3.md)
+- Nächster Abschnitt: [Zusammenfassung](01.5.md)
diff --git a/de/01.5.md b/de/01.5.md
new file mode 100644
index 000000000..a0e386d67
--- /dev/null
+++ b/de/01.5.md
@@ -0,0 +1,9 @@
+# 1.5 Zusammenfassung
+
+In diesem Kapitel haben wir die Installation auf drei verschiedene Arten besprochen. Dies waren die manuelle Installation mit Hilfe des Quellcodes von Go, die offiziellen Ein-Klick-Installationen und durch Lösungen Dritter. Danach haben wir uns mit der Konfiguration der Go Entwicklungsumgebung auseinander gesetzt, welche hauptsächlich die Einrichtung Deines `$GOPATH` umfasst. Zudem habe ich Dir gezeigt, wie man Programme kompiliert und einsetzt. Des Weiteren hast Du die verschiedenen Terminal-Befehle zum Kompilieren, Installieren, Formatieren und Testen von Go kennengelernt. Zum Schluss hast Du Dir mächtige Entwicklungswerkzeuge wie LiteIDE, Sublime Text, Vim, GoLand, Emacs, Eclipse, IntelliJ IDEA u.a. zu Nutze gemacht. Suche Dir eines aus, um die Welt von Go zu erforschen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Go Entwicklungswerkzeuge](01.4.md)
+- Nächstes Kapitel: [Grundlegendes Wissen zu Go](02.0.md)
diff --git a/de/02.0.md b/de/02.0.md
new file mode 100644
index 000000000..20b8dfef0
--- /dev/null
+++ b/de/02.0.md
@@ -0,0 +1,17 @@
+# 2 Grundlegendes Wissen zu Go
+
+Go ist eine kompilierte, systemnahe Programmiersprache und ist verwandt mit der C-Familie. Die Kompiliereung ist deutlich schneller als bei anderen C-Sprachen. Sie besitzt nur 25 Schlüsselwörter... also noch weniger als die 26 Buchstaben des deutschen Alphabets! Lass uns einen kurzen Blick auf diese Schlüsselwörter werfen, bevor wir anfangen.
+
+ break default func interface select
+ case defer go map struct
+ chan else goto package switch
+ const fallthrough if range type
+ continue for import return var
+
+In diesem Kapitel werde ich Dir Grundlagen zur Programmierung in Go vermitteln. Du wirst sehen, wie prägnant die Sprache ist und wie schön sie gestaltet wurde. Das Programmieren in Go kann viel Spaß machen. Am Ende dieses Kapitels werden Dir die aufgelisteten Schlüsselwörter in ihrer Funktionsweise bekannt sein.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriges Kapitel: [Kapitel 1 Zusammenfassung](01.5.md)
+- Nächster Abschnitt: ["Hallo Go"](02.1.md)
\ No newline at end of file
diff --git a/de/02.1.md b/de/02.1.md
new file mode 100644
index 000000000..212a41df5
--- /dev/null
+++ b/de/02.1.md
@@ -0,0 +1,53 @@
+# 2.1 Hallo Go
+
+Bevor wir unsere erste Anwendung in Go erstellen, müssen wir erst klein anfangen. Du kannst nicht erwarten, ein Haus bauen zu können, ohne die Grundlagen zu beherrschen. Deshalb werden wir den grundlegenden Syntax in diesem Abschnitt lernen, um ein einfaches Programm zu schreiben.
+
+## Programm
+
+In der Programmierung ist es in Klassiker, als erstes eine Anwendung zu schreiben, die einzig "Hallo Welt" ausgibt.
+
+Bist Du bereit? Los geht's!
+
+ package main
+
+ import "fmt"
+
+ func main() {
+ fmt.Printf("Hallo Welt oder 你好，世界 oder καλημ ́ρα κóσμ oder こんにちは世界\n")
+ }
+
+Es sollte jetzt folgendes ausgegeben worden sein.
+
+ Hallo Welt oder 你好，世界 oder καλημ ́ρα κóσμ oder こんにちは世界
+
+## Erklärung
+
+Eine Sache, die Du zu Beginn wissen solltest, ist, dass Go-Programme stets mit dem Schlüsselwort `package` anfangen.
+
+`package ` (in diesem Fall `package main`) sagt aus, dass diese Quellcodedatei zum Paket `main` gehört. Das Schlüsselwort `main` ist jedoch besonders, da es zu einer ausführbaren Binärdatei kompiliert wird. Normalerweise wird sonst ein Paket in der Dateiendung `.a` generiert.
+
+Jedes ausführbare Programm hat nur ein einziges `main` Paket, dass die Funktion `main` beinhalten muss, die keine Argumente erhält und keine Werte zurückgibt.
+
+Um `Hallo Welt...` auszugeben, haben wir eine Funktion mit dem Namen `Printf` genutzt. Diese Funktion stammt aus dem `fmt` Paket, welches wir in der dritten Zeile mit `import "fmt"` importiert haben.
+
+Pakete werden ähnlich wie in Python behandelt, was ein paar Vorteile mit sich bring: Modularität (das Aufteilen eines Programms in kleinere Codesegmente, genannt Module) und Wiederverwendbarkeit (viele Module können auch in anderen Programmen genutzt werden). Das Konzept um Pakete hatten wir bereits aufgegriffen. Später werden wir auch eigene Pakete erstellen.
+
+In der fünften Zeile haben wir das Schlüsselwort `func` verwendet, um die `main`-Funktion zu definieren. Der Rumpf bzw. Körper einer Funktion befindet sich zwischen `{}`, genau wie in C, C++ und Java.
+
+Wie Du siehst, gibt es keine Argumente, die an die Funktion übergeben worden sind. Wir werden in wenigen Sekunden lernen, wie man diese in Funktionen nutzt. Du kannst auch Funktionen schreiben, die keinen oder beliebig viele Rückgabewerte haben.
+
+In der sechsten Zeile rufen wir die Funktion `Printf` aus dem Paket `fmt` auf. Die geschieht über den Syntax `.`, also ganz im Stil von Python.
+
+Wie in Kapitel 1 angemerkt, können sich der Name des Pakets und der Ordner, indem es sich das Paket befindet, durchaus verschieden sein. Hier stammt der `` vom Namen in `package ` und nicht vom Ordnernamen ab.
+
+Du hast vielleicht mitbekommen, dass unser Beispiel oben viele Nicht-ASCII-Zeichen beinhaltet. Dies hat den Zweck zu zeigen, dass Go UTF-8 standardmäßig unterstützt. Du kannst jedes beliebige UTF-8 Zeichen in Deinen Programmen verwenden.
+
+## Zusammenfassung
+
+Go nutzt `package` (wie Module in Python) zum Strukturieren von Programmen. Die Funktion `main.main()` (diese Funktion muss sich im `main`-Paket befinden) ist der Startpunkt von jedem Programm. Go unterstützt UTF-8-Zeichen, da einer ihrer Schöpfer zugleich UTF-8 mitentwickelt hat. Somit unterstützt Go von Beginn an mehrere Sprachen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Grundlegendes Wissen zu Go](02.0.md)
+- Nächster Abschnitt: [Grundlagen von Go](02.2.md)
\ No newline at end of file
diff --git a/de/02.2.md b/de/02.2.md
new file mode 100644
index 000000000..f910399d5
--- /dev/null
+++ b/de/02.2.md
@@ -0,0 +1,458 @@
+# 2.2 Grundlagen von Go
+
+In diesem Abschnit werden wir lernen, wie man Konstanten und Variablen mit grundlegenden Datentypen definiert, sowie ein paar weitere Fähigkeiten aus der Go-Programmierung.
+
+## Variablen definieren
+
+Es gibt syntaktisch viele Wege, eine Variable in Go zu definieren.
+
+Das Schlüsselwort `var` ist die simpelste Form, eine Variable zu erstellen. Bedenke, dass in Go der Datentyp **hinter** dem Variablennamen steht.
+
+ // Definiere eine Variable mit dem Namen “variableName” vom Typ "type"
+ var variableName type
+
+Definiere mehrere Variablen.
+
+ // Definiere drei Variablen vom Typ "type"
+ var vname1, vname2, vname3 type
+
+Definiere eine Variable mit einem Startwert.
+
+ // Definiere eine Variable mit dem Namen “variableName” vom Typ "type" und dem Wert "value"
+ var variableName type = value
+
+Definiere mehrere Variablen mit einem Startwert.
+
+ /*
+ Definiere drei Variablen vom Typ "type" und gib ihnen drei Startwerte.
+ vname1 ist gleich v1, vname2 ist gleich v2, vname3 ist gleich v3
+ */
+ var vname1, vname2, vname3 type = v1, v2, v3
+
+Findest Du es nicht auch ein wenig mühsehlig, Variablen auf diesem Weg zu definieren? Keine Sorge, denn das Team hinter Go hat auch so gedacht. Daher kannst Du Variablen Startwerte geben, ohne explizit den Datentyp zu definieren. Der Code würde dann so aussehen:
+
+ /*
+ Definiere drei Variablen vom Typ "type" und gib ihnen drei Ausgangswerte.
+ vname1 ist gleich v1, vname2 ist gleich v2, vname3 ist gleich v3
+ */
+ var vname1, vname2, vname3 = v1, v2, v3
+
+Schön, ich weiß das dies immer noch nicht einfach genug für Dich ist. Mal schauen, wie wir das lösen können.
+
+ /*
+ Definiere drei Variablen ohne den Typ "type", ohne das Schlüsselwort "var" und gib ihnen Startwerte.
+ vname1 ist gleich v1，vname2 ist gleich v2，vname3 ist gleich v3
+ */
+ vname1, vname2, vname3 := v1, v2, v3
+
+
+So sieht es schon viel besser aus. Nutze `:=`, um `var` und `type` zu ersetzen. Es handelt sich hierbei um eine Kurzschreibweise. Aber warte, es gibt einen kleinen Haken: diese Form der Definition kann nur innerhalb von Fuktionen genutzt werden. Der Compiler wird sonst eine Fehlermeldung ausgeben, wenn Du es trotzdem außerhalb der `{}` einer Funktion versuchst. Daher nutzen wir meist das Schlüsselwort `var` um globale Variablen zu definieren oder die Funktion `var()`.
+
+`_` (Unterstrich) ist ein besonderer Variablenname. Jeder übergebene Wert wird ignoriert. Übergeben wir zum Beispiel `35` an `b`, so verwerfen wir `34`. ( ***Dieses Beispiel soll nur die Funktionsweise aufzeigen. Es mag, wie in diesem Fall, nutzlos erscheinen, aber wir werden es oft gebrauchen, wenn wir Rückgabewerte von Funktionen erhalten.*** )
+
+ _, b := 34, 35
+
+Wenn Du Variablen in Deinem Programm definierst, aber keine Verwendung finden, wird der Compiler eine Fehlermeldung ausgeben. Versuche den unten stehenden Code zu kompilieren und schaue, was passiert.
+
+ package main
+
+ func main() {
+ var i int
+ }
+
+## Konstanten
+
+Konstanten sind Werte, die während der Kompilierung festgelegt werden und während der Laufzeit nicht veränderbar sind. In Go kannst Du Konstanten als Wert Nummern, Booleans oder Strings geben.
+
+Definiere eine Konstante wie folgt.
+
+ const constantName = value
+ // Du kannst auch den Datentyp hinzufügen, wenn nötig
+ const Pi float32 = 3.1415926
+
+Mehr Beispiele.
+
+ const Pi = 3.1415926
+ const i = 10000
+ const MaxThread = 10
+ const prefix = "astaxie_"
+
+## Grundlegende Datentypen
+
+### Boolean
+
+In Go nutzen wir `bool`, um Booleans (Wahrheitswerte) auszudrücken, die entweder den Zustand `true` oder `false` annehmen können, wobei `false` der Standardwert ist. ( ***Du kannst übrigens Nummern zu Booleans und umgekehrt konvertieren!*** )
+
+ // Beispielcode
+ var isActive bool // Globale Variable
+ var enabled, disabled = true, false // Der Datentyp wird ausgelassen
+ func test() {
+ var available bool // Lokale Variable
+ valid := false // Kurzschreibweise einer Definition
+ available = true // Eine Variable deklarieren
+ }
+
+### Numerische Datentypen
+
+Der Datentyp Integer (ganze Zahlen) kann sowohl den positiven, als auch den negativen Zahlenraum umfassen, was durch ein Vorzeichen kenntlich gemacht wird. Go besitzt `int` und `uint`, welche den selben Wertebereich haben. Dessen Größe hängt aber vom Betriebssystem ab. Es werden 32-Bit unter 32-Bit Betriebssystemen verwendet und 64-Bit unter 64-Bit Betriebssystemen. Go umfasst außerdem Datentypen mit einer spezifischen Länge: `rune`, `int8`, `int16`, `int32`, `int64`, `byte`, `uint8`, `uint16`, `uint32` und `uint64`. Bedenke, dass `rune` ein Alias für `int32` ist und `byte` dem `uint8` gleicht.
+
+Eine wichtige Sache, die Du wissen solltest, ist, dass Du verschiedene Datentypen nicht vermischen kannst, da es sonst zu Fehlern bei der Kompilierung kommt.
+
+ var a int8
+
+ var b int32
+
+ c := a + b
+
+
+Obwohl int32 einen größeren Wertebereich als int8 abdeckt, und beide vom Typ `int` sind, kannst Du sie nicht miteinander kombinieren. ( ***c wird hier der Typ `int` zugewiesen*** )
+
+Floats (Gleitkommazahlen) haben entweder den Datentyp `float32` oder `float64`, aber es gibt keinen Datentyp namens `float`. `float64` wird standardmäßig verwendet, sollte die Kurzschreibweise für eine Variablendekleration genutzt werden.
+
+War das schon alles? Nein! Go unterstützt auch komplexe Zahlen. `complex128` (bestehend aus 64-Bit für den realen Anteil und weiteren 64-Bit für den imaginären Teil) ist der Standarddatentyp. Solltest Du einen kleineren Wertebereich benötigen, kannst `complex64` als Datentyp verwenden (mit 32-Bit für den realen, und nochmals 32-Bit für den imaginären Teil). Die Schreibweise lautet `RE+IMi`, wo `RE` für den realen Teil steht, und `IM` den Imaginären Part repräsentiert. Das `i` am Ende ist die imaginäre Zahl. Hier ist ein Beispiel für eine komplexe Zahl.
+
+ var c complex64 = 5+5i
+ // Ausgabe: (5+5i)
+ fmt.Printf("Der Wert ist: %v", c)
+
+### Strings
+
+Wir sprachen vorhin darüber, das Go eine native UTF-8 Unterstützung mit sich bringt. Strings (Zeichenketten) werden durch Anführungszeichen `""` gekennzeichet, oder durch Backticks (rückwärts geneigtes Hochkomma) ``` `` ```.
+
+ // Beispielcode
+ var frenchHello string // Grundlegende Schreibweise zur Definition eines Strings
+ var emptyString string = "" // Definiert einen leeren String
+ func test() {
+ no, yes, maybe := "no", "yes", "maybe" // Kurzschreibweise
+ japaneseHello := "Ohaiou"
+ frenchHello = "Bonjour" // Grundlegende Deklaration
+ }
+
+Es ist unmöglich, die Zeichen eines Strings anhand ihres Index zu verändern. Du wirst eine Fehlermeldung erhalten, solltest Du dies ausprobieren.
+
+ var s string = "Hallo"
+ s[0] = 'c'
+
+Aber was ist, wenn ich wirklich nur ein Zeichen in einem String ändern möchte? Probieren wir es mit mit diesem Codebeispiel.
+
+ s := "hello"
+ c := []byte(s) // Konvertiere den String zum Typ []byte
+ c[0] = 'c'
+ s2 := string(c) // Wandle den Wert in eine String zurück
+ fmt.Printf("%s\n", s2)
+
+
+Nutze den `+` Operator, um zwei Strings zu verknüpfen.
+
+ s := "Hallo"
+ m := " Welt"
+ a := s + m
+ fmt.Printf("%s\n", a)
+
+
+oder auch
+
+ s := "Hallo"
+ s = "c" + s[1:] // Du kannst die Werte mit Hilfe des Index nicht verändern, aber sie abfragen
+ fmt.Printf("%s\n", s)
+
+
+Was ist, wenn ein String über mehrere Zeilen verlaufen soll?
+
+ m := `Hallo
+ Welt`
+
+`\`` wird die Zeichen in einem String escapen (d.h. mit `\` dessen Ausführung verhindern).
+
+### Fehlermeldungen
+
+Go besitzt mit `error` einen eigenen Datentyp, um mit Fehlermeldungen umzugehen. Zudem gibt es auch ein Paket mit dem Namen `errors`, um weitere Möglichkeiten bereitzustellen, Fehlermeldungen zu verarbeiten.
+
+ err := errors.New("emit macho dwarf: elf header corrupted")
+ if err != nil {
+ fmt.Print(err)
+ }
+
+### Grundeliegende Datenstrukturen
+
+Die folgende Grafik enstammt dem Artikel [Datenstrukturen in Go](http://research.swtch.com/godata) (auf englisch) aus [Russ Coxs Blog](http://research.swtch.com/). Wie Du sehen kannst, nutzt Go Abschnitte des Arbeitsspeichers, um Daten zu speichern.
+
+
+
+Abbildung 2.1 Gos grundlegende Datenstrukturen
+
+## Einige Fähigkeiten
+
+### Gruppierte Definition
+
+Wenn Du mehrere Konstanten und Variablen deklarieren oder Pakete importieren möchtest, kannst Du dies auch gruppiert durchführen.
+
+Übliche Vorgehensweise.
+
+ import "fmt"
+ import "os"
+
+ const i = 100
+ const pi = 3.1415
+ const prefix = "Go_"
+
+ var i int
+ var pi float32
+ var prefix string
+
+Gruppierter Ansatz.
+
+ import(
+ "fmt"
+ "os"
+ )
+
+ const(
+ i = 100
+ pi = 3.1415
+ prefix = "Go_"
+ )
+
+ var(
+ i int
+ pi float32
+ prefix string
+ )
+
+Wird innerhalb von `constant()` einer Konstanten das Schlüsselwort `iota` als Wert zugewiesen, hat sie den Wert `0`. Werden den folgenden Konstanten keine expliziten Werte zugewiesen, wird der letzte zugeweise Wert von `iota` um 1 erhöht und der folgenden Konstante zugewiesen. Dieses Verhalten beleuchten wir im folgenden Absatz.
+
+### Aufzählen mit iota
+
+Go besitzt das Schlüselwort `iota`, um eine Aufzählung zu starten. Der Startwert ist `0` und wird jeweils um `1` erhöht.
+
+ const(
+ x = iota // x == 0
+ y = iota // y == 1
+ z = iota // z == 2
+ w // Folgt dem Namen der Konstante keine Deklaration, so wird die zuletzt erfolgte verwendet. w = iota wird somit implizit auf iota gesetzt. Daher gilt w == 3. Folglich kannst Du bei x und y "= iota" einfach auslassen.
+ )
+
+ const v = iota // Sobald iota erneut auf `const` trifft, wird erneut mit `0` gestartet, also gilt v = 0.
+
+ const (
+ e, f, g = iota, iota, iota // e, f und g haben den selben Wert 0, da sie in der selben Zeile stehen.
+ )
+
+### Einige Regeln
+
+Der Grund, warum Go so prägnant ist, liegt im vorhersehbaren Verhalten der Programmiersprache.
+
+- Jede Variable, die mit einem großgeschriebenen Buchstaben anfängt, kann exportiert werden. Andernfalls ist sie privat.
+- Die selbe Regel gilt auch für Funktionen und Konstanten. Schlüsselwörter wie `public` oder `private` existieren in Go nicht.
+
+## Array, Slice, Map
+
+### Array
+
+Ein `array` ist eine Aneinanderreihung von Daten, die wie folgt definiert wird:
+
+ var arr [n]Datentyp
+
+wobei in `[n]Datentyp` das `n` die Länge des Arrays angibt. `Datentyp` ist selbsterklärend der Datentyp der Elemente (bzw. der aneinandergereihten Daten). Wie in anderen Programmiersprachen nutzen wir `[]`, um Daten im Array zu speichern oder um sie auszulesen.
+
+ var arr [10]int // Ein Array vom Typ [10]int
+ arr[0] = 42 // Der erste Index des Arrays ist 0
+ arr[1] = 13 // Einem Element wird ein Wert zugewiesen
+ fmt.Printf("Das erste Element ist %d\n", arr[0]) // Beim Auslesen des Wertes wird 42 zurückgegeben
+ fmt.Printf("Das letzte Element ist %d\n", arr[9]) // Es gibt den Standardwert des 10. Elements zurück, was in diesem Fall 0 ist.
+
+Da die Länge ein Teil des Array-Typs ist, sind `[3]int` und `[4]int` verschieden, sodass wir die Länge eines Arrays nicht ändern können. Nutzt Du Arrays als Argument in einer Funktion, dann wird eine Kopie des Arrays übergeben, statt einem Zeiger (bzw. ein Verweis) auf das Original. Möchtest Du stattdessen den Zeiger übergeben, dann musst Du einen `slice` verwenden. Darauf gehen wir aber später nochmals ein.
+
+Es ist möglich, `:=` zu nutzen, um ein Array zu deklarieren.
+
+ a := [3]int{1, 2, 3} // Deklariere ein Array vom Typ int mit drei Elementen
+ b := [10]int{1, 2, 3} // Deklariere ein int-Array mit zehn Elementen, bei dem die ersten Drei einen Wert zugewiesen bekommen. Der Rest erhält den Standardwert 0.
+ c := [...]int{4, 5, 6} // Nutze `…` statt der Längenangabe. Go wird die Länge dann selbst bestimmen.
+
+Vielleicht möchtest Du auch Arrays als Element in einem Array nutzen. Schauen wir mal, wie das geht.
+
+ // Deklariere ein zweidimensionales Array mit zwei Elementen, welche jeweils vier Elemente besitzen.
+ doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
+
+
+ // Die Dekleration kann auch ein wenig kompakter geschrieben werden.
+{% raw %} easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}} {% endraw %}
+
+Arrays sind grundlegende Datenstrukturen in Go.
+
+
+
+Abbildung 2.2 Die Zuordnung in einem mehrdimensionalen Array
+
+### Slice
+
+In vielen Situationen ist ein Array als Datentyp keine gute Wahl, wenn wir während der Deklaration dessen Länge noch nicht wissen. Daher brauchen wir so etwas wie ein "dynamisches Array" mit einer variabler Länge. Diese werden in Go `slice` genannt.
+
+`slice` ist nicht wirklich ein `dynamisches Array`. Es ist vielmehr ein Zeiger auf ein darunterliegendes `array` mit einer ähnlichen Deklaration, dass aber keine Länge benötigt.
+
+ // Man deklariert ein Slice wie ein Array, lässt jedoch die Länge weg.
+ var fslice []int
+
+Nun deklarieren wir ein `slice` und vergeben Startwerte.
+
+ slice := []byte {'a', 'b', 'c', 'd'}
+
+`slice` kann existierende Slices oder Arrays verändern. `slice` nutzt `array[i:j]` zum "Herrausschneiden" von Elementen. `i` gibt den Index des Startpunkts an und kopiert alle Elemente bis zum Index `j`. Beachte, dass `array[j]` nicht in dem Ausschnitt enthalten ist, da das Slice eine Länge von `j-i` hat.
+
+ // Deklariere ein Array mit der Länge 10 von vom Typ byte
+ var ar = [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
+
+ // Erstelle zwei Slices vom Typ []byte
+ var a, b []byte
+
+ // 'a' verweist auf die Elemente zwischen Index 3 und 5 im Array ar.
+ a = ar[2:5]
+ // 'a' besitzt nun die Elemente ar[2],ar[3] und ar[4]
+
+ // 'b' ist ein weiterer Ausschnitt (Slice) vom Array ar
+ b = ar[3:5]
+ // 'b' besitzt nun die Elemente ar[3] und ar[4]
+
+Beachte die Unterscheide bei der Deklaration von `slice` und `array`. Wir nutzen `[…]`, um Go die Länge automatisch herausfinden zu lassen, aber nutzen `[]` lediglich zur Deklaration von Slices.
+
+Ihre zugrundeliegenden Datentypen.
+
+
+
+Abbildung 2.3 Der Zusammenhang zwischen Slices und Arrays
+
+Slices haben bestimmte Anwendungsgebiete.
+
+- Ein `slice` beginnt mit dem Index 0, `ar[:n]` gleicht `ar[0:n]`.
+- Der zweite Index gibt die Länge vom Slice an, wenn er ausgelassen wird. `ar[n:]` gleicht `ar[n:len(ar)]`.
+- Du kannst auch `ar[:]` nutzen, um einen gesamtes Array zu kopieren, wie in den ersten beiden Punkten erklärt.
+
+Mehr Beispiele zu `slice`
+
+ // Deklariere ein Array
+ var array = [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
+ // Deklariere zwei Slices
+ var aSlice, bSlice []byte
+
+ // Einige gewöhnliche Anwendungsfälle
+ aSlice = array[:3] // ist das Gleiche wie aSlice = array[0:3]. aSlice hat die Elemente a,b,c
+ aSlice = array[5:] // ist das Gleiche wie aSlice = array[5:10]. aSlice hat die Elemente f,g,h,i,j
+ aSlice = array[:] // ist das Gleiche wie aSlice = array[0:10]. aSlice beinhaltet alle Elemente
+
+ // Ein Slice vom Slice
+ aSlice = array[3:7] // aSlice hat die Elemente d,e,f,g，Anfang=4，Kapazität=7
+ bSlice = aSlice[1:3] // bSlice beinhaltet aSlice[1], aSlice[2], also hat es die Elemente e,f
+ bSlice = aSlice[:3] // bSlice beinhaltet aSlice[0], aSlice[1], aSlice[2], also hat es die Elemente d,e,f
+ bSlice = aSlice[0:5] // Der Slice ist nun länger, sodass bSlice d,e,f,g,h beinhaltet
+ bSlice = aSlice[:] // bSlice hat nun die gleiche Elemente wie aSlice, also d,e,f,g
+
+`slice` ist ein Datentyp mit einem Zeiger, sodass Änderungen am Slice auch andere Variablen verändern, die wiederum selbt auf den Slice verweisen. Wie im oberigen Fall von `aSlice` und `bSlice`: veränderst Du den Wert eines Elements in `aSlice`, wird sich dieser auch im `bSlice` ändern.
+
+`slice` ist ähnlich wie ein Struct und besteht aus drei Komponenten:
+
+- Ein Zeiger, der auf den Beginn des `slice` bzw. zugrundeliegenden Array verweist.
+- Die Länge definiert den Ausschnitt des zugrundeliegenden Arrays.
+- Kapazität definiert die max. Größe des zugrundeliegenden Arrays.
+
+ Array_a := [10]byte{'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
+ Slice_a := Array_a[2:5]
+
+Die zugrundeliegenden Datenstrukturen vom vorherigen Code sehen wie folgt aus:
+
+
+
+Abbildung 2.4 Arrayelemente eines Slice
+
+Es existieren eingebaute Funktionen, um mit Slices zu arbeiten.
+
+- `len` gibt die Länge eines `slice` bzw. Ausschnitts zurück.
+- `cap` gibt die max. Länge (Kapazität) eines `slice` zurück.
+- `append` erweitert den `slice` um ein oder mehrere Elemente, und gibt einen `slice` zurück.
+- `copy` erstellt eine Kopie eines Slices, und gibt die Anzahl der kopierten Elemente zurück.
+
+Achtung: `append` wird das Array, aus das `slice` verweist verändern, sowie andere Slices, die auf das selbe Array verweisen. Sollte de Kapazität des zugrundeliegenden Arrays nicht ausreichen (`(cap-len) == 0`), dann gibt `append` ein neues Array zurück. Dies hat aber keine Auswirkungen auf andere Slices, die auf das alte Array verwiesen.
+
+### Map
+
+`map` verhält sich wie ein Dictionary in Python. Nutze das Schema `map[SchlüsselTyp]WerteTyp`, um es zu deklarieren.
+
+Schauen wir uns ein wenig Code an. Die 'set'- und 'get'-Werte in `map` sind der von `slice` sehr ähnlich. In einem Slice kann der Datentyp des Index nur ein `int` sein. In einer `map` kann es sich jedoch um einen `int`, `string` oder um jeden anderen Datentyp handeln. Du kannst auch `==` und `!=` verwenden, um Werte mit einander zu vergleichen.
+
+ // Nutze 'string' als Datentyp für den Schlüssel, 'int' als Datentyp für den Wert und `make` zum Erstellen.
+ var numbers map[string] int
+ // Ein alternativer Weg zum Deklarieren
+ nummern := make(map[string]int)
+ nummern["eins"] = 1 // Weise ein Wert durch einen Schlüssel zu
+ nummern["zehn"] = 10
+ nummern["drei"] = 3
+
+ fmt.Println("Die dritte Nummer lautet: ", nummern["drei"]) // Lese den Wert aus
+ // Ausgabe: Die dritte Nummer lautet: 3
+
+Einige Anmerkungen zur Nutzung von maps.
+
+- `map` ist ungeordnet. Jedesmal, wenn Du eine `map` ausgeben willst, erhälst Du ein anderes Ergebnis. Dadurch ist es unmöglich, Werte über den `index` abzufragen. Nutze dafür den entsprechenden `Schlüssel`.
+- `map` hat keine feste Länge. Dieser Datentyp ist wie `slice` lediglich ein Verweis.
+- `len` funktioniert bei `map` auch. Es werden die Anzahl der `Schlüssel` zurückgegeben.
+- Es ist ziemlich einfach, der Wert in einer `map` zu ändern. Nutze `nummern["eins"]=11`, um den `Schlüssel` eins den Wert `11` zuzuweisen.
+
+Du kannst das Schema `Schlüssel:Wert` nutzen, um eine `map` mit Startwerten zu erstellen. `map` hat auch eingebaute Funktionen, um die Existenz eines `key` zu überprüfen.
+
+Benutze `delete`, um ein Element in `map` zu löschen.
+
+ // Erstelle eine map
+ bewertung := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
+ // Map hat zwei Rückgabewerte. Der zweite Rückgabewert 'ok' wird, wenn der Schlüssel nicht existiert，aus false gesetzt. Andernfalls wird true zurückgegeben.
+ csharpBewertung, ok := bewertung["C#"]
+ if ok {
+ fmt.Println("C# ist in der map hat die Bewertung ", csharpBewertung)
+ } else {
+ fmt.Println("Es konnte keine Bewertung für C# in der map gefunden werden.")
+ }
+
+ delete(bewertung, "C") // Lösche das Element mit dem Schlüssel "c"
+
+Wie ich bereits sagte, ist `map` lediglich ein Verweis. Verweisen zwei `map`s auf die gleiche, zugrundeliegende Datenstruktur, wird eine Änderung Auswirkungen auf beide `map`s haben.
+
+ m := make(map[string]string)
+ m["Hallo"] = "Bonjour"
+ m1 := m
+ m1["Hallo"] = "Salut" // Nun ist der Wert von m["hello"] Salut
+
+### make, new
+
+`make` reserviert Speicher für die eingebauten Datentypen, wie `map`, `slice`, und `channel`, wo hingegen `new` für selbstdefinierte Datentype (durch `type` definiert) Speicher zuweist.
+
+`new(T)` ordnet dem Datentyp `T` Speicherplatz zu und initialisiert diesen mit den Standardwerten des jeweiligen Datentyps (z.B. `false` für einen `bool`). Anschließend wird die Adresse des Speicherortes in des Datentyps `*T` zurückgegeben. Nach der Definition von Go ist dies ein Zeiger, welcher auf die Standardwerte der Initilisierung von `T` verweist.
+
+`new` gibt Zeiger als Wert zurück.
+
+Die eingebaute Funktion `make(T, args)` hat einen anderen Zweck als `new(T)`. `make` kann für `slice`, `map`, und `channel` genutzt werden und gibt den Datentyp `T` mit seinem definierten Startwert zurück. Der Grund liegt darin, dass das ein Objekt vom zugrundeliegenden Datentyp erst erstellt wird, bevor auf diesen verwiesen werden kann. Dies ist bei diesen drei Datentypen der Fall. Zum Beispiel beinhaltet `slice` einen Zeiger, der auf das zugrundeliegende Array, die Länge und die Kapazität verweist. Vor der Initialisierung der Daten beinhaltet `slice` jedoch nur `nil`. Daher vergibt `make` den Datentypen `slice`, `map` und `channel` geeignetere Werte.
+
+`make` gibt dabei die angesprochenen Standardwerte der entsprechenden Datentypen zurück (z.B. `false` für einen `bool`).
+
+Die folgende Grafik verdeutlicht den Unterschied zwischen `new` und `make`.
+
+
+
+Abbildung 2.5 Wie make und new Datenstrukturen Speicherplatz zuweisen
+
+Standardwerte besitzen einen Wert. Dies sind die gebräuchlichsten Anwendungsfälle. Hier eine kleine Liste von Standardwerten.
+
+ int 0
+ int8 0
+ int32 0
+ int64 0
+ uint 0x0
+ rune 0 // rune ist ein Alias für int32
+ byte 0x0 // byte ist ein Alias für uint8
+ float32 0 // Die Größe beträgt 4 Byte
+ float64 0 // Die Größe beträgt 8 Byte
+ bool false
+ string ""
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: ["Hallo Go"](02.1.md)
+- Nächster Abschnitt: [Kontrollstrukturen und Funktionen](02.3.md)
diff --git a/de/02.3.md b/de/02.3.md
new file mode 100644
index 000000000..be0d87ae6
--- /dev/null
+++ b/de/02.3.md
@@ -0,0 +1,523 @@
+# 2.3 Kontrollstrukturen und Funktionen
+
+In diesem Kapite
+werfen wir einen Blick auf Kontrollstrukturen und Funktionen in Go.
+
+## Kontrollstrukturen
+
+Die beste Erfindung in der Programmierung ist die Möglichkeit, den Ablauf einen Programms dynamisch verändern zu können. Um dies zu ermöglichen, kannst Du Kontrollstrukturen verwenden, um komplexe, logische Verknüpfungen darzustellen. Es gibt drei Arten, den Programmablauf zu ändern: Bedingungen, Schleifen, die eine Aufgabe mehrmals durchführen können und Sprungmarken.
+
+### if
+
+`if` ist das am weitverbreiteste Schlüsselwort in Deinen Programmen. Sollte eine Bedingung erfüllt sein, wird das Programm eine bestimmte Aufgabe ausführen. Wird die Bedingung nicht erfüllt, dann passiert etwas Anderes.
+
+In Go braucht man keine runden Klammern für eine `if`-Bedingung nutzen.
+
+ if x > 10 {
+ fmt.Println("x ist größer als 10")
+ } else {
+ fmt.Println("x ist kleiner gleich 10")
+ }
+
+Der nützlichste Aspekt in Bezug auf `if` ist, dass man vor der Überprüfung der Bedingung noch Startwerte vergeben kann. Die Variablen mit den Startwerten sind aber nur im `if`-Block selbst abrufbar.
+
+ // Gebe x einen Startwert und überprüfe dann, ob x größer als 10 ist
+ if x := berechneEinenWert(); x > 10 {
+ fmt.Println("x ist größer als 10")
+ } else {
+ fmt.Println("x ist kleiner als 10")
+ }
+
+ // Der folgende Code kann nicht kompiliert werden
+ fmt.Println(x)
+
+Benutze if-else für mehrere Bedingungen.
+
+ if integer == 3 {
+ fmt.Println("Der Integer ist gleich 3")
+ } else if integer < 3 {
+ fmt.Println("Der Integer ist kleiner als 3")
+ } else {
+ fmt.Println("Der Integer ist größer als 3")
+ }
+
+### goto
+
+
+Go umfasst auch das `goto` Schlüsselwort, aber benutze es weise. `goto` verändert den Ablauf des Programms, indem es an einer vorher definierten Sprungmarke im selben Codeabschnitt weiterläuft.
+
+ func meineFunktion() {
+ i := 0
+ Hier: // Sprungmarken enden mit einem ":"
+ fmt.Println(i)
+ i++
+ goto Hier // Springe nun zur Sprungmarke "Hier"
+ }
+
+Es wird zwischen der Groß- und Kleinschreibung von Sprungmarken unterschieden. `Hier` ist nicht das Selbe wie `hier`.
+
+### for
+
+`for` ist die mächtigste Kontrollstruktur in Go. Sie kann Daten lesen und sie in jedem Durchgang verändern, ähnlich wie `while`.
+
+ for Ausdruck1; Ausdruck2; Ausdruck3 {
+ //...
+ }
+
+`Ausdruck1`, `Ausdruck2` und `Ausdruck3` sind alle Ausdrücke, aber bei `Ausdruck1` und `Ausdruck3` handelt es sich aber entweder um eine Deklaration von Variablen oder um Rückgabewerte von Funktionen. `Ausdruck2` ist dagegen eine zu erfüllende Bedingung . `Ausdruck1` wird nur einmal vor der Ausführung der Schleife verändert, aber `Ausdruck3` kann mit jedem Durchlauf verändert werden.
+
+Aber Beispiele sagen mehr als tausend Worte.
+
+ package main
+ import "fmt"
+
+ func main(){
+ summe := 0;
+ for index:=0; index < 10 ; index++ {
+ summe += index
+ }
+ fmt.Println("summe hat den Wert ", summe)
+ }
+ // Ausgabe: summe hat den Wert 45
+
+Manchmal müssen wir am Anfang mehrere Deklarationen vornehmen. Da Go für die Trennung der Variablen über kein `,` verfügt, können die Variablen nicht einzeln deklariert werden. Ein Ausweg bietet die parallele Deklaration: `i, j = i + 1, j - 1`.
+
+Wenn nötig, können wir `Ausdruck1` und `Ausdruck3` auch einfach auslassen.
+
+ summe := 1
+ for ; summe < 1000; {
+ summe += summe
+ }
+
+Auch das `;` kann ausgelassen werden. Kommt es Dir bekannt vor? Denn ist das gleiche Verhalten wie bei `while`.
+
+ summe := 1
+ for summe < 1000 {
+ summe += summe
+ }
+
+Es gibt mit `break` und `continue` zwei wichtige Schlüsselwörter bei der Verwendung von Schleifen. `break` wird zum "Ausbrechen" aus einer Schleife genutzt, während `continue` zum nächsten Durchlauf springt. Sollten verschachtelte Schleifen genutzt werden, dann kombiniere `break` mit einer Sprungmarke.
+
+ for index := 10; index>0; index-- {
+ if index == 5{
+ break // oder continue
+ }
+ fmt.Println(index)
+ }
+ // break gibt 10、9、8、7、6 aus
+ // continue gibt 10、9、8、7、6、4、3、2、1 aus
+
+`for` kann auch die Elemente aus einem `slice` oder einer `map` lesen, wenn dies im Zusammenspiel mit `range` geschieht.
+
+ for k, v := range map {
+ fmt.Println("map's Schlüssel:",k)
+ fmt.Println("map's Wert:",v)
+ }
+
+Go unterstützt die Rückgabe mehrerer Werte und gibt eine Fehlermeldung aus, wenn nicht genauso viele Variablen zum Speichern vorhanden sind. Solltest Du einen Wert nicht brauchen, kannst Du ihn mit `_` verwerfen.
+
+ for _, v := range map{
+ fmt.Println("map's Wert:", v)
+ }
+
+### switch
+
+Manchmal findest Du Dich in einer Situation vor, indem viele Bedingungen mit `if-else` geprüft werden müssen. Der Code kann dann schnell unleserlich und schwer anpassbar werden. Alternativ kannst Du Bedingungen auch mit `switch` prüfen.
+
+ switch Audruck {
+ case Fall1:
+ Eine Aufgabe
+ case Fall3:
+ Eine andere Aufgabe
+ case Fall3:
+ Eine andere Aufgabe
+ default:
+ Anderer Code
+ }
+
+Der Datentyp von `Fall1`, `Fall2` und `Fall3` muss der selbe sein. `switch` kann sehr flexible eingesetzt werden. Bedingungen müssen keine Konstanten sein und die einzelnen Fälle werden von oben nach unten geprüft, bis eine passender gefunden wurde. Sollte `switch` kein Ausdruck folgen, dann dann wird von einem `bool` ausgegangen und es wird der Code im Fall `true` ausgeführt.
+
+ i := 10
+ switch i {
+ case 1:
+ fmt.Println("i ist gleich 1")
+ case 2, 3, 4:
+ fmt.Println("i ist gleich 2, 3 oder 4")
+ case 10:
+ fmt.Println("i ist gleich 10")
+ default:
+ fmt.Println("ich weiß nur, dass i ein Integer ist")
+ }
+
+In der fünften Zeile nutzen wir gleich mehrere Fälle auf einmal. Außerdem brauchen wir nicht `break` am Ende jedes Falls einfügen, wie es in anderen Programmiersprachen üblich ist. Mit dem Schlüsselwort `fallthrough` kannst Du nach einem Treffer auch alle folgenden Fälle ausführen.
+
+ integer := 6
+ switch integer {
+ case 4:
+ fmt.Println("integer <= 4")
+ fallthrough
+ case 5:
+ fmt.Println("integer <= 5")
+ fallthrough
+ case 6:
+ fmt.Println("integer <= 6")
+ fallthrough
+ case 7:
+ fmt.Println("integer <= 7")
+ fallthrough
+ case 8:
+ fmt.Println("integer <= 8")
+ fallthrough
+ default:
+ fmt.Println("Standardfall")
+ }
+
+Das Programm gibt folgende Informationen aus.
+
+ integer <= 6
+ integer <= 7
+ integer <= 8
+ Standardfall
+
+## Funktionen
+
+Nutze das Schlüsselwort `func`, um eine Funktion einzuleiten.
+
+ func funcName(eingabe1 typ1, eingabe2 typ2) (ausgabe1 typ1, ausgabe2 typ2) {
+ // Körper bzw. Rumpf der Funktion
+ // Mehrere Werte werden zurückgegeben
+ return wert1, wert2
+ }
+
+Dem gezeigten Beispiel können wir somit folgende Informationen entnehmen:
+
+- Nutze das Schlüsselwort `func`, um die Funktion `funcName` zu erstellen.
+- Funktionen können ein, mehrere oder kein Argument übergeben werden. Der Datentyp wird nach dem Argument angegeben und Argumente werden durch ein `,` getrennt.
+- Funktionen können mehrere Werte zurückgeben.
+- Es gibt zwei Rückgabewerte mit den Namen `ausgabe1` and `ausgabe2`. Du kannst Ihren Namen auch einfach auslassen und nur den Datentyp im Kopf angeben.
+- Wenn es nur einen Rückgabewert gibt, kannst Du die Klammer um den Datentyp im Kopf weglassen.
+- Wenn keine Daten zurückgegeben werden, kannst Du `return` einfach weglassen.
+- Um Werte im Körper der Funktion zurückzugeben, musst Du `return` verwenden.
+
+Gucken wir uns mal ein Beispiel an, in dem wir den Größeren von zwei Werten bestimmen.
+
+ package main
+ import "fmt"
+
+ // Gib den größeren Wert von a und b zurück
+ func max(a, b int) int {
+ if a > b {
+ return a
+ }
+ return b
+ }
+
+ func main() {
+ x := 3
+ y := 4
+ z := 5
+
+ max_xy := max(x, y) // ruft die Funktion max(x, y) auf
+ max_xz := max(x, z) // ruft die Funktion max(x, z) auf
+
+ fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
+ fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
+ fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) // rufe die Funktion hier auf
+ }
+
+Im oberen Beispiel übergeben wir jeweils zwei Argumente vom Typ `int` an die Funktion `max`. Da beide Argumente denn gleichen Datentyp besitzen, reicht es, wenn wir diesen nur einmal angeben. So kannst Du statt `a int, b int` einfach `a, b int` schreiben. Dies gilt auch für weitere Argumente. Wie Du sehen kannst, wird nur ein Wert von `max` zurückgegeben, sodass wir den Namen der Variable weglassen können. Dies wäre einfach die Kurzschreibweise.
+
+### Mehrere Rückgabewerte bei Funktionen
+
+Die Möglichkeit, mehrere Werte zurückgeben zu können, ist ein Aspekt, in der Go der Programmiersprache C überlegen ist.
+
+Schauen wir uns das folgende Beispiel an.
+
+ package main
+ import "fmt"
+
+ // Gebe die Ergebnisse von A + B und A * B zurück
+ func SummeUndProdukt(A, B int) (int, int) {
+ return A+B, A*B
+ }
+
+ func main() {
+ x := 3
+ y := 4
+
+ xPLUSy, xMALy := SummeUndProdukt(x, y)
+
+ fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
+ fmt.Printf("%d * %d = %d\n", x, y, xMALy)
+ }
+
+Das obere Beispiele gibt zwei namenlose Werte zurück. Aber Du kannst sie natürlich auch bennenen, wenn Du magst. Würden wir dies tun, müssten wir mit `return` nur dessen Namen zurückgeben, da die Variablen in der Funktion bereits automatisch initialisiert wurden. Bedenke, dass Funktionen mit einen großen Buchstaben anfangen müssen, wenn Du sie außerhalb eines Pakets verwenden möchtest. Es wäre auch zu empfehlen, die Rückgabewerte zu bennenen, da dies den Code verständlicher macht.
+
+ func SummeUndProdukt(A, B int) (addiert int, multipliziert int) {
+ addiert = A+B
+ multipliziert = A*B
+ return
+ }
+
+### Variablen als Argumente
+
+Go unterstützt auch Variablen als Argumente, was bedeutet, das einer Funktionen auch eine unbekannte Anzahl an Argumenten übergeben werden kann.
+
+ func myfunc(arg ...int) {}
+
+`arg …int` besagt, dass diese Funktionen beliebig viele Argumente entgegennimmt. Beachte, dass alle Argumente vom Typ `int` sind. Im Funktionskörper wird `arg` zu einem `slice` vom Typ `int`.
+
+ for _, n := range arg {
+ fmt.Printf("Und die Nummer lautet: %d\n", n)
+ }
+
+### Werte und Zeiger übergeben
+
+Wenn wir ein Argument einer aufgerufenen Funktion übergeben, dann bekommt diese meist eine Kopie des Arguments und kann somit das Original nicht beeinflussen.
+
+Lass mich Dir ein Beispiel zeigen, um es zu beweisen.
+
+ package main
+ import "fmt"
+
+ // Simple Funktion, die a um 1 erhöht
+ func add1(a int) int {
+ a = a+1 // Wir verändern den Wert von a
+ return a // Wir geben den Wert von a zurück
+ }
+
+ func main() {
+ x := 3
+
+ fmt.Println("x = ", x) // Sollte "x = 3" ausgeben
+
+ x1 := add1(x) // Rufe add1(x) auf
+
+ fmt.Println("x+1 = ", x1) // Sollte "x+1 = 4" ausgeben
+ fmt.Println("x = ", x) // Sollte "x = 3" ausgeben
+ }
+
+Siehst Du es? Selbst wenn wir der Funktion `add1` die Variable `x` als Argument übergeben, um sie um 1 zu erhöhen, so blieb `x` selbst unverändert
+
+Der Grund dafür ist naheliegend: wenn wir `add1` aufrufen, übergeben wir ihr eine Kopie von `x`, und nicht `x` selbst.
+
+Nun fragst Du dich bestimmt, wie ich das echte `x` einer Funktion übergeben kann.
+
+Dafür müssen wir Zeiger verwenden. Wir wissen, das Variablen im Arbeitspeicher hinterlegt sind und sie eine Adresse für den Speicherort besitzen. Um einen Wert zu ändern, müssen wir auch die Adresse des Speicherorts wissen. Daher muss der Funktion `add1` diese Adresse von `x` bekannt sein, um diese ändern zu können. Hier übergeben wir `&x` der Funktion als Argument und ändern damit den Datentyp des Arguments in `*int`. Beachte, dass wir eine Kopie des Zeigers übergeben, und nicht des Wertes.
+
+ package main
+ import "fmt"
+
+ // Simple Funktion, um a um 1 zu erhöhen
+ func add1(a *int) int {
+ *a = *a+1 // Wir verändern den Wert von a
+ return *a // Wir geben den Wert von a zurück
+ }
+
+ func main() {
+ x := 3
+
+ fmt.Println("x = ", x) // Sollte "x = 3" ausgeben
+
+ x1 := add1(&x) // Rufe add1(&x) auf und übergebe die Adresse des Speicherortes von x
+
+ fmt.Println("x+1 = ", x1) // Sollte "x+1 = 4" ausgeben
+ fmt.Println("x = ", x) // Sollte "x = 4" ausgeben
+ }
+
+Nun können wir den Wert von `x` in der Funktion ändern. Aber warum nutzen wir Zeiger? Was sind die Vorteile?
+
+- Es erlaubt uns, mit mehreren Funktionen eine Variable direkt zu benutzen und zu verändern.
+- Es braucht wenig Ressourcen, um die Speicheradresse (8 Bytes) zu übergeben. Kopien sind weniger effizient im Kontext von Zeit und Speichergröße.
+- `string`, `slice` und `map` sind Referenztypen, die automatisch die Referenz (bzw. den Zeiger) der Funktion übergeben. (Achtung: Wenn Du die Länge eines `slice` ändern möchtest, musst Du den Zeiger explizit übergeben).
+
+### defer
+
+Go besitzt mit `defer` ein weiteres nützliches Schlüsselwort. Du kannst `defer` mehrmals in einer Funktion nutzen. Sie werden in umgekehrter Reihenfolge am Ende einer Funktion ausgeführt. Im Fall, dass Dein Programm eine Datei öffnet, muss diese erst wieder geschlossen werden, bevor Fehler zurückgeben werden können. Schauen wir uns ein paar Beispiele an.
+
+ func LesenSchreiben() bool {
+ file.Open("Datei")
+ // Mache etwas
+ if FehlerX {
+ file.Close()
+ return false
+ }
+
+ if FehlerY {
+ file.Close()
+ return false
+ }
+
+ file.Close()
+ return true
+ }
+
+Wir haben gesehen, dass hier der selbe Code öfters wiederhohlt wird. `defer` löst dieses Problem ziemlich elegant. Es hilft Dir nicht nur sauberen Code zu schreiben, sodern fördert auch noch dessen Lesbarkeit.
+
+ func LesenSchreiben() bool {
+ file.Open("Datei")
+ defer file.Close()
+ if FehlerX {
+ return false
+ }
+ if FehlerY {
+ return false
+ }
+ return true
+ }
+
+Wird `defer` mehr als einmal genutzt, werden sie in umgekehrter Reihenfolge ausgeführt. Das folgende Beispiel wird `4 3 2 1 0` ausgeben.
+
+ for i := 0; i < 5; i++ {
+ defer fmt.Printf("%d ", i)
+ }
+
+### Funktionen als Werte und Datentypen
+
+Funktionen sind auch Variablen in Go, die wir mit `type` definieren können. Funktionen mit der selben Signatur, also dem gleichen Aufbau, können als der selbe Datentyp betrachtet werden.
+
+ type schreibeName func(eingabe1 eingabeTyp1 , eingabe2 eingabeTyp2 [, ...]) (ergebnis1 ergebnisTyp1 [, ...])
+
+Was ist der Vorteil dieser Fähigkeit? Ganz einfach: wir können somit Funktionen als Werte übergeben.
+
+ package main
+ import "fmt"
+
+ type testeInt func(int) bool // Definiere eine Funktion als Datentyp
+
+ func istUngerade(integer int) bool {
+ if integer%2 == 0 {
+ return false
+ }
+ return true
+ }
+
+ func istGerade(integer int) bool {
+ if integer%2 == 0 {
+ return true
+ }
+ return false
+ }
+
+ // Übergebe die Funktion f als Argument an eine Andere Funktion
+
+ func filter(slice []int, f testeInt) []int {
+ var ergebnis []int
+ for _, wert := range slice {
+ if f(wert) {
+ ergebnis = append(ergebnis, wert)
+ }
+ }
+ return ergebnis
+ }
+
+ func main(){
+ slice := []int {1, 2, 3, 4, 5, 7}
+ fmt.Println("slice = ", slice)
+ ungerade := filter(slice, istUngerade) // Nutze die Funktion als Wert
+ fmt.Println("Die ungeraden Elemente von slice lauten: ", ungerade)
+ gerade := filter(slice, istGerade)
+ fmt.Println("Die geraden Elemente von slice lauten: ", gerade)
+ }
+
+Dies ist sehr nützlich, wenn wir Interfaces nutzen. Wie Du sehen kannst, wird `testeInt` eine Funktion als Argument übergeben, und die Rückgabewerte besitzen genau den gleichen Datentyp. Somit können wir komplexe Zusammenhänge in unseren Programen flexible warten und erweitern.
+
+### Panic und Recover
+
+Go besitzt keine `try-catch`-Struktur, wie es in Java der Fall ist. Statt eine Exception zu erstellen, nutzt Go `panic` und `recover`. Auch wenn `panic` sehr mächtig ist, solltest Du es nicht all zu oft benutzen.
+
+`panic` ist eine eingebaute Funktion, um den normalen Ablauf des Programms zu unterbrechen und es in eine Art Panikmodus zu versetzen. Wenn die Funktion `F` `panic` aufruft, wird in ihr außer `defer` nichts weiter ausgeführt. Danach geht das Programm zum Ursprungsort des Fehlers zurück. Dies wird nicht geschlossen, ehe alle Funktionen einer `goroutine` `panic` zurückgeben. Einige Fehler erzeugen auch selbst einen Aufruf von `panic`, z.B. wenn der reservierte Speicherplatz eines Arrays nicht ausreicht.
+
+`recover` ist ebenfalls eine eingebaute Fuktion, um `goroutinen` vom Panikmodus zu erlösen. Das Aufrufen von `recover` im Zusammenspiel mit `defer` ist sehr nützlich, da normale Funktionen nicht mehr ausgeführt werden, wenn sich das Programm erst einmal im Panikmodus befindet. Die Werte von `panic` werden so aufgefangen, wenn sich das Programm im Panikmodus befindet. Ansonsten wird `nil` zurückgegeben.
+
+Das folgende Beispiel soll die Nutzung von `panic` verdeutlichen.
+
+ var benutzer = os.Getenv("BENUTZER")
+
+ func init() {
+ if benutzer == "" {
+ panic("Kein Wert für $BENUTZER gefunden")
+ }
+ }
+
+Das nächste Beispiel zeigt, wie der Status von `panic` aufgerufen werden kann.
+
+ func erzeugePanic(f func()) (b bool) {
+ defer func() {
+ if x := recover(); x != nil {
+ b = true
+ }
+ }()
+ f() // Wenn 'f' 'panic' verursacht, wird versucht, dies mit 'recover' zu beheben
+ return
+ }
+
+### Die `main` und `init` Funktion
+
+Go hat zwei besondere Funktionen mit dem Namen `main` und `init`, wobei `init` in jedem Paket aufgerufen werden kann und dies bei `main` nur im gleichnahmigen Paket möglich ist. Beide Funktionen besitzen weder Argumente, die übergeben werden können, noch geben sie Werte zurück. Es ist möglich, die `init`-Funktion innerhalb eines Pakets mehrmals aufzurufen, aber ich empfehle jedoch die Nutzung einer einzelnen, da es sonst unübersichtlich werden kann.
+
+Go ruft `init()` und `main()` automatisch auf, sodass dies nicht manuell geschehen muss. Für jedes Paket ist die `init`-Funktion optional, jedoch ist die `main`-Funktion unter `package main` obligatorisch und kann lediglich ein einziges Mal genutzt werden.
+
+Programme werden vom `main`-Paket aus gestarten. Wenn dieses Paket noch weitere Pakete importiert, geschieht dies einzig während der Kompilierung. Nach dem Importieren von Paketen werden zu erst dessen Konstanten und Variablen initialisiert, dann wird `init` aufgerufen usw. Nachdem alle Pakete erfolgreich initialisiert wurden, geschieht all dies im `main`-Paket. Die folgende Grafik illustriert diesen Ablauf.
+
+
+
+Abbildung 2.6 Der Initialisierungsablauf eines Programms in Go
+
+### import
+
+Oftmals verwenden wir `import` in unseren Go-Programmen wie folgt.
+
+ import(
+ "fmt"
+ )
+
+Dann nutzen wir die Funktionen aus dem Paket wie im Beispiel:
+
+ fmt.Println("Hallo Welt")
+
+`fmt` stammt aus Gos Standardbibliothek, welche sich unter $GOROOT/pkg befindet. Go unterstützt Pakete von Dritten auf zwei Wege.
+
+1. Relativer Pfad
+ import `./model` // Importiert ein Paket aus dem selben Verzeichnis, jedoch empfehle ich diese Methode nicht.
+2. Absoluter Pfad
+ import `shorturl/model` // Lade das Paket mit dem Pfad "$GOPATH/pkg/shorturl/model"
+
+Es gibt spezielle Operatoren beim Importieren von Paketen, die Anfänger oftmals verwirren.
+
+1. Punkt Operator.
+
+ Manchmal sieht man, wie Pakete auf diesem Weg importiert werden.
+
+ import(
+ . "fmt"
+ )
+
+ Der Punkt Operator bedeutet einfach, dass der Name des Paketes beim Aufruf von dessen Funktion weggelassen werden kann. So wird aus `fmt.Printf("Hallo Welt")` einfach `Printf("Hallo Welt")`.
+
+2. Alias Operation.
+
+ Dieser verändert den Namen des Paketes, denn wir beim Aufruf von Funktionen angeben müssen.
+
+ import(
+ f "fmt"
+ )
+
+ Aus `fmt.Printf("Hallo Welt")` wird dann `f.Printf("Hallo Welt")`.
+
+3. `_` Operator.
+
+ Dieser Operator ist ohne Erklärung ein wenig schwer zu erklären.
+
+ import (
+ "database/sql"
+ _ "github.com/ziutek/mymysql/godrv"
+ )
+
+ Der `_` Operator bedeutet einfach nur, das wir das Paket importieren möchten und das dessen `init`-Funktion ausgeführt werden soll. Jedoch sind wir uns nicht sicher, ob wir die anderen Funktionen dieses Pakets überhaupt nutzen wollen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Grundlagen von Go](02.2.md)
+- Nächster Abschnitt: [Struct](02.4.md)
diff --git a/de/02.4.md b/de/02.4.md
new file mode 100644
index 000000000..592d8a6c6
--- /dev/null
+++ b/de/02.4.md
@@ -0,0 +1,214 @@
+# 2.4 Struct
+
+## Struct
+
+Wie in anderen Programmiersprachen können wir auch in Go neue Datentypen erstellen, die als eine "Struktur" verknüpfte Eigenschaften oder Felder zusammenfasst. So können wir Beipielsweise einen neuen Datentyp `person` erschaffen, dessen Eingenschaften der Name und das Alter einer Person sind. Wir nennen diesen Datentyp `struct`.
+
+ type person struct {
+ name string
+ alter int
+ }
+
+Es sieht ziemlich einfach aus, ein `struct` zu definieren, nicht?
+
+Es gibt insgesamt zwei Eigenschaften.
+
+- `name` ist ein `string` und wird genutzt, um den Namen einer Person zu speichern.
+- `alter` is vom Typ `int` und beinhaltet das Alter einer Person.
+
+Schauen wir uns das einmal praktisch an.
+
+ type person struct {
+ name string
+ alter int
+ }
+
+ var P person // p ist vom Typ person
+
+ P.name = "Astaxie" // Weise "Astaxie" der Eigenschaft 'name' von p zu
+ P.alter = 25 // Weise 25 der Eigenschaft 'alter' von p zu
+ fmt.Printf("Der Name der Person lautet %s\n", P.name) // Rufe die Eigenschaft 'name' von p auf
+
+Es gibt noch drei weitere Wege, ein Struct zu definieren.
+
+- Weise Startwerte in der Reihenfolge der Eigenschaften zu.
+
+ P := person{"Tom", 25}
+
+- Oder nutze das Schema `Eigenschaft:Wert`, um ein Struct zu erstellen, ohne dabei auf die Reihenfolge achten zu müssen.
+
+ P := person{alter:24, name:"Bob"}
+
+- Definiere ein "anonymes" Struct und vergebe Startwerte
+
+ P := struct{name string; alter int}{"Amy",18}
+
+Schauen wir uns das vollständige Beispiel an.
+
+ package main
+ import "fmt"
+
+ // Definiere einen neuen Datentyp
+ type person struct {
+ name string
+ alter int
+ }
+
+ // Vergleiche das Alter von zwei Personen. Dann gibt die ältere Person und den Altersunterschied zurück
+ // Structs werden als normaler Wert übergeben
+ func Älter(p1, p2 person) (person, int) {
+ if p1.alter>p2.alter {
+ return p1, p1.alter-p2.alter
+ }
+ return p2, p2.alter-p1.alter
+ }
+
+ func main() {
+ var tom person
+
+ // Initialisierung
+ tom.name, tom.alter = "Tom", 18
+
+ // Initialisiere zwei Werte nach dem Schema "Eigenschaft:Wert"
+ bob := person{alter:25, name:"Bob"}
+
+ // Initialisiere die Eigenschaft nach der Reihenfolge
+ paul := person{"Paul", 43}
+
+ tb_Älter, tb_diff := Älter(tom, bob)
+ tp_Älter, tp_diff := Älter(tom, paul)
+ bp_Älter, bp_diff := Älter(bob, paul)
+
+ fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", tom.name, bob.name, tb_Älter.name, tb_diff)
+
+ fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", tom.name, paul.name, tp_Älter.name, tp_diff)
+
+ fmt.Printf("Von %s und %s ist %s um %d Jahre älter\n", bob.name, paul.name, bp_Älter.name, bp_diff)
+ }
+
+### Eigenschaften in Structs einbetten
+
+Soeben habe ich Dir gezeigt, wie Du ein Struct mit Eigenschaften und Datentypen definieren kannst. Aber Go unterstützt auch Eigenschaften, die keinen Namen besitzen und nur dessen Datentyp angegeben wird. Wir bezeichnen diese als eingebettete Eigenschaften.
+
+Wenn die eingebette Eigenschaft ein weiteres Struct ist, dann all seine Eigenschaften in den Struct übertragen, in dem es eingebettet wurde.
+
+Betrachten wir ein Beispiel.
+
+ package main
+ import "fmt"
+
+ type Mensch struct {
+ name string
+ alter int
+ gewicht int
+ }
+
+ type Student struct {
+ Mensch // Eingebettete Eigenschaft, d.h. Student besitzt alle Eigenschaften von Mensch.
+ fachgebiet string
+ }
+
+ func main() {
+ // Initialisierng eines Studenten
+ mark := Student{Mensch{"Mark", 25, 120}, "Informatik"}
+
+ // Eigenschaften aufrufen
+ fmt.Println("Sein Name lautet ", mark.name)
+ fmt.Println("Sein Alter ist ", mark.alter)
+ fmt.Println("Er wiegt ", mark.gewicht)
+ fmt.Println("Sein Fachgebiet ist ", mark.fachgebiet)
+ // Eigenschaften verändern
+ mark.fachgebiet = "Künstliche Intelligenz"
+ fmt.Println("Mark hat sein Fachgebiet gewechselt")
+ fmt.Println("Sein Fachgebiet lautet ", mark.fachgebiet)
+ // Alter ändern
+ fmt.Println("Mark wurde alt")
+ mark.alter = 46
+ fmt.Println("Sein Alter beträgt ", mark.alter, " Jahre")
+ // Gewicht ändern
+ fmt.Println("Mark ist kein Athlet mehr")
+ mark.gewicht += 60
+ fmt.Println("Er wiegt nun", mark.gewicht)
+ }
+
+
+
+Abbildung 2.7 Einbettung von Mensch in Student
+
+Wie Du siehst, können wir die Eigenschaften `alter` und `name` vom Typ Student genauso aufrufen, wie jene vom Typ Mensch. Genau so funktioniert das Einbetten. Ziemlich einfach, nicht wahr? Aber es gibt noch Kleinigkeit, die ich Dir zeigen möchte. Du kannst auch den Typ Mensch verwenden, um auf Eigenschaften von Student zurückzugreifen.
+
+ mark.Mensch = Mensch{"Marcus", 55, 220}
+ mark.Mensch.alter -= 1
+
+In Go können alle Datenttypen eingebettet werden.
+
+ package main
+ import "fmt"
+
+ type Fähigkeiten []string
+
+ type Mensch struct {
+ name string
+ alter int
+ gewicht int
+ }
+
+ type Student struct {
+ Mensch // Struct als eingebettete Eigenschaft
+ Fähigkeiten // Slice vom Typ string als eingebettete Eigenschaft
+ int // Standard Datentyp als eingebettete Eigenschaft
+ fachgebiet string
+ }
+
+ func main() {
+ // Initialisiere Studentin Jane
+ jane := Student{Mensch:Mensch{"Jane", 35, 100}, fachgebiet:"Biologie"}
+ // Eigenschaften aufrufen
+ fmt.Println("Ihr Name lautet ", jane.name)
+ fmt.Println("Ihr Alter ist ", jane.alter)
+ fmt.Println("Sie wiegt ", jane.gewicht)
+ fmt.Println("Ihr Fachgebiet ist ", jane.fachgebiet)
+ // Änderung des Wertes der Eigenschaft fähigkeit
+ jane.Fähigkeiten = []string{"Anatomie"}
+ fmt.Println("Sie besitzt folgende Fähigkeiten: ", jane.Fähigkeiten)
+ fmt.Println("Sie hat zwei neue Fähigkeiten erworben ")
+ jane.Fähigkeiten = append(jane.Fähigkeiten, "Physik", "Golang")
+ fmt.Println("Sie besitzt nun folgende Fähigkeiten ", jane.Fähigkeiten)
+ // Veränderung einer eingebetteten Eigenschaft
+ jane.int = 3
+ fmt.Println("Ihre bevorzugte Nummer lautet", jane.int)
+ }
+
+Im oberen Beispiel ist erkenntlich, dass alle Datentypen eingebettet werden und Funktionen auf ihre Werte zugreifen können.
+
+Aber es gibt noch ein kleines Problem. Was geschieht, wenn Mensch die Eigenschaft `telefon` besitzt und Student eine Eigenschaft mit dem gleichen Namen besitzt?
+
+Go nutzt einen einfachen Weg zur Unterscheidung. Um die Eigenschaft `telefon` von Student zu erhalten, nutzt Du weiterhein `Student.telefon`. Die gleichnahmige Eigenschaft von Mensch kannst Du erhalten, indem Du `Student.Mensch.telefon` verwendest. Wie Du siehst, muss einfach der eingebette Datentyp vorangestellt werden. Diese Fähigkeiten wird "überladen" genannt (im Englischen `overloading`).
+
+ package main
+ import "fmt"
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string // Mensch hat die Eigenschaft telefon
+ }
+
+ type Mitarbeiter struct {
+ Mensch // Eingebetter Datentyp Mensch
+ spezialisierung string
+ telefon string // Eigenschaft telefon in Mitarbeiter
+ }
+
+ func main() {
+ Bob := Mitarbeiter{Mensch{"Bob", 34, "777-444-XXXX"}, "Designer", "333-222"}
+ fmt.Println("Bobs berufliche Telefonnummer lautet ", Bob.telefon)
+ // Greife auf Eigenschaft telefon in Mensch zu
+ fmt.Println("Bobs private Telefonnummer lauet ", Bob.Mensch.telefon)
+ }
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Kontrollstrukturen und Funktionen](02.3.md)
+- Nächster Abschnitt: [Objektorientiertes Programmieren](02.5.md)
diff --git a/de/02.5.md b/de/02.5.md
new file mode 100644
index 000000000..745bdc259
--- /dev/null
+++ b/de/02.5.md
@@ -0,0 +1,309 @@
+# 2.5 Objektorientierte Programmierung
+
+In den letzen beiden Abschnitten hatten wir uns mit Funktionen und Structs beschäftigt, aber hast Du jemals daran gedacht, Funktionen als Eigenschaft in einem Struct zu verwenden? In diesem Abschnitt werde ich Dir eine besondere Art von Funktionen vorstellen, die einen Reciever (engl. to recieve - empfangen) besitzen. Sie werden auch `Methoden` genannt.
+
+## Methoden
+
+Sagen wir, Du definierst einen Struct mit dem Namen "Rechteck" und möchtest die Fläche ausrechnen. Normalerweise würden wir folgenden Code verwenden, um dies zu bewerkstelligen.
+
+ package main
+ import "fmt"
+
+ type Rechteck struct {
+ breite, höhe float64
+ }
+
+ func Fläche(r Rechteck) float64 {
+ return r.breite*r.höhe
+ }
+
+ func main() {
+ r1 := Rechteck{12, 2}
+ r2 := Rechteck{9, 4}
+ fmt.Println("Fläche von r1: ", Fläche(r1))
+ fmt.Println("Fläche von r2: ", Fläche(r2))
+ }
+
+Das obere Beispiel kann die Fläche eines Rechtecks ermitteln. Dafür haben wir die Funktion `Fläche()` verwendet, aber es ist keine Methode des Structs Rechteck (welche mit einer Klasse in klassischen objektorientierten Sprachen wären). Die Funktion und der Struct sind voneinander unabhängig.
+
+Soweit ist dies noch kein Problem. Wenn Du aber den Flächeninhalt eines Kreies, Quadrahts, Fünfecks oder einer anderen Form berechnen musst, brauchst Du dafür Funktionen mit einem sehr ähnlichen Namen,
+
+
+
+Abbildung 2.8 Beziehung zwischen Funktionen und Structs
+
+Offensichtlich ist dies nicht sehr praktisch. Auch sollte die Fläche eine Eigenschaft des Kreises oder Rechtecks sein.
+
+Aus diesem Grund gibt es das Konzept der `Methoden`. Diese sind immer mit einem Datentyp verbunden. Sie haben den selben Syntax wie normale Funktionen, jedoch besitzen sie einen weiteren Parameter nach dem Schlüsselwort `func`, den `Reciever`.
+
+Im selben Beispiel würde mit `Rechteck.Fläche()` die Methode des Structs Rechteck aufgerufen. Somit gehören `länge`, `breite` und `Fläche()` zum Struct.
+
+Wie Rob Pike sagte:
+
+ "A method is a function with an implicit first argument, called a receiver."
+
+ "Eine Methode ist eine Funktion mit einem ersten, impliziten Argument, welches Reciever genannt wird."
+
+Syntax einer Methode.
+
+ func (r RecieverTyp) funcName(Parameter) (Ergebnis)
+
+Lass uns das Beispiel von vorhin umschreiben.
+
+ package main
+ import (
+ "fmt"
+ "math"
+ )
+
+ type Rechteck struct {
+ breite, höhe float64
+ }
+
+ type Kreis struct {
+ radius float64
+ }
+
+ func (r Rechteck) fläche() float64 {
+ return r.breite*r.höhe
+ }
+
+ func (c Kreis) fläche() float64 {
+ return c.radius * c.radius * math.Pi
+ }
+
+ func main() {
+ r1 := Rechteck{12, 2}
+ r2 := Rechteck{9, 4}
+ c1 := Kreis{10}
+ c2 := Kreis{25}
+
+ fmt.Println("Fläche von r1 ist: ", r1.fläche())
+ fmt.Println("Fläche von r2 ist: ", r2.fläche())
+ fmt.Println("Fläche von c1 ist: ", c1.fläche())
+ fmt.Println("Fläche von c2 ist: ", c2.fläche())
+ }
+
+Anmerkungen zu der Nutzung von Methoden.
+
+- Beide Methoden haben den selben Namen, gehören jedoch verschiedenen Recievern an.
+- Methoden können auf die Eigenschaften des Recievers zugreifen.
+- Nutze `.`, um Methoden wie Eigenschaften aufzurufen.
+
+
+
+Abbildung 2.9 Die Methoden sind in jedem Struct verschieden
+
+Im oberen Beispiel ist die Methode `Fläche()` für Rechteck und Kreis zugänglich, sodass sie zwei verschiedene Reciever besitzt.
+
+Bei der Nutzung von Methoden werden dieser Kopien der Werte eines Structs übergeben. `Fläche()` bekommt also nicht einen Zeiger zum Original übergeben, sondern nur eine Kopie dessen. Somit kann das Orginal nicht verändert werden. Ein `*` vor dem Reciver übergibt dageben den Zeiger und erlaubt damit auch Zugriff auf das Original.
+
+Können Reciever nur in Verbindung mit Structs genutzt werden? Natürlich nicht. Jeder Datentyp kann als Reciever fungieren. Dies wird Dir vielleicht bei selbstdefinierten Datentypen etwas komisch vorkommen, aber mit den Structs haben wir das Selbe gemacht - einen eigenen Datentypen erstellt.
+
+Das Folgende Schema kann genutzt werden, um einen neuen Datentypen zu definieren.
+
+ type Name Datentyp
+
+Beispiele für selbstdefinierte Datentypen:
+
+ type alter int
+
+ type geld float32
+
+ type monate map[string]int
+
+ m := monate {
+ "Januar":31,
+ "Februar":28,
+ ...
+ "Dezember":31,
+ }
+
+Ich hoffe, dass Du die Definition eigener Datentypen jetzt verstanden hast. Es ist `typedef` aus C sehr ähnlich. Im oberen Beispiel ersetzen wir `int` einfach durch `alter`.
+
+Kommen wir zurück zu unseren `Methoden`.
+
+Du kannst soviele Datentypen und dazugehörige Methoden erstellen, wie Du willst.
+
+ package main
+ import "fmt"
+
+ const(
+ WEISS = iota
+ SCHWARZ
+ BLAU
+ ROT
+ GELB
+ )
+
+ type Farbe byte
+
+ type Box struct {
+ breite, höhe, tiefe float64
+ farbe Farbe
+ }
+
+ type BoxListe []Box // Ein Slice mit Elementen vom Typ Box
+
+ func (b Box) Volumen() float64 {
+ return b.breite * b.höhe * b.tiefe
+ }
+
+ func (b *Box) SetzeFarbe(c Farbe) {
+ b.farbe = c
+ }
+
+ func (bl BoxListe) HöchsteFarbe() Farbe {
+ v := 0.00
+ k := Farbe(WEISS)
+ for _, b := range bl {
+ if b.Volumen() > v {
+ v = b.Volumen()
+ k = b.farbe
+ }
+ }
+ return k
+ }
+
+ func (bl BoxListe) MaleAlleSchwarzAn() {
+ for i, _ := range bl {
+ bl[i].SetzeFarbe(SCHWARZ)
+ }
+ }
+
+ func (c Farbe) String() string {
+ strings := []string {"WEISS", "SCHWARZ", "BLAU", "ROT", "GELB"}
+ return strings[c]
+ }
+
+ func main() {
+ boxes := BoxListe {
+ Box{4, 4, 4, ROT},
+ Box{10, 10, 1, GELB},
+ Box{1, 1, 20, SCHWARZ},
+ Box{10, 10, 1, BLAU},
+ Box{10, 30, 1, WEISS},
+ Box{20, 20, 20, GELB},
+ }
+
+ fmt.Printf("Wir haben %d Boxen in unserer Liste\n", len(boxes))
+ fmt.Println("Das Volumen der Ersten beträgt ", boxes[0].Volumen(), "cm³")
+ fmt.Println("Die Farbe der letzen Box ist",boxes[len(boxes)-1].farbe.String())
+ fmt.Println("Die größte Box ist ", boxes.HöchsteFarbe().String())
+
+ fmt.Println("Malen wir sie alle schwarz an")
+ boxes.MaleAlleSchwarzAn()
+ fmt.Println("Die Farbe der zweiten Box lautet ", boxes[1].farbe.String())
+
+ fmt.Println("Offensichtlich ist die größte Box ", boxes.HöchsteFarbe().String())
+ }
+
+Wir hatten ein paar Konstanten und selbstdefinierte Datentypen erstellt.
+
+- Nutze `Farbe` als Alias für `byte`.
+- Wir definierten den Struct `Box` mit den Eigenschaften breite, länge, tiefe und farbe.
+- Wir definierten einen Slice `BoxListe` mit Elementen vom Typ `Box`.
+
+Dann haben wir Methoden für unsere selbsterstellten Datentypen hinzugefügt.
+
+- Volumen() nutzt Box als Reciever und gibt das Volumen einer Box.
+- SetzeFarbe(c Farbe) ändert die Farbe einer Box.
+- GrößteFarbe() gibt die Box mit dem größten Volumen zurück.
+- MaleAlleSchwarzAn() setzt die Farbe aller Boxen auf schwarz.
+- String() benutzt Farbe als Reciever und gibt den Farbnamen als String zurück.
+
+Ist es nicht einfacher, Wörter zum Beschreiben unserer Anforderungen zu benutzen? Oftmals definieren wir unsere Anforderungen schon vor dem Programmieren.
+
+### Zeiger als Reciever
+
+Werfen wir einen näheren Blick auf die Methode `SetzeFarbe()`. Ihr Reciever ist der Zeiger mit dem Verweis zu einer Box. Warum benutzen wir hier einen Zeiger? Wie bereits erwähnt, erhälst Du mit `*Box` Zugriff auf das Original und kannst es somit ändern. Nützten wir keinen Zeiger, so hätte die Methode nur eine Kopie des Wertes übergeben bekommen.
+
+Wenn wir einen Reciever als ersten Parameter einer Methode sehen, dürfte ihr Zweck leicht zu verstehen sein.
+
+Du fragst Dich bestimmt, warum wir nicht einfach `(*b).Farbe=c` verwenden, statt `b.Color=c` in der `SetzeFarbe()` Methode. Beide Wege sind OK und Go weiß die erste Zuweisung zu interpretieren. Findest Du Go nun nicht auch faszinierend?
+
+Des Weiteren fragst Du dich vielleicht auch, warum wir nicht `(&bl[i]).SetzeFarbe(BLACK)` in `MaleAlleSchwarzAn()` nutzen, so wie es in `SetzeFarbe()` der Fall ist. Nochmals, beide Varianten sind OK und Go weiß damit umzugehen.
+
+### Vererbung von Methoden
+
+Wir haben die Vererbung bzw. das Einbetten von Eigengeschaften bereits im letzen Abschnitt kennengelernt. Ähnlich funktioniert auch das Einbetten von Methoden. Wenn ein Struct eigene Methoden hat und es in ein weiteres Struct eingebettet wird, so werden die Methoden wie die Eigenschaften mit eingebettet, also vererbt.
+
+ package main
+ import "fmt"
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string
+ }
+
+ type Student struct {
+ Mensch // Eingebetter Struct als Eigenschaft ohne Namen
+ schule string
+ }
+
+ type Mitarbeiter struct {
+ Mensch
+ unternehmen string
+ }
+
+ // Definiere eine Methode für Mensch
+ func (h *Mensch) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s. Du erreichst mich unter %s\n", h.name, h.telefon)
+ }
+
+ func main() {
+ mark := Student{Mensch{"Mark", 25, "222-222-YYYY"}, "MIT"}
+ sam := Mitarbeiter{Mensch{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
+
+ mark.SagHallo()
+ sam.SagHallo()
+ }
+
+### Das Überladen von Methoden
+
+Wenn wir für Mitarbeiter eine eigene Methode `SagHallo()` erstellen wollen, wird die Methode `SagHallo()` von Mensch durch die von Mitarbeiter überladen.
+
+ package main
+ import "fmt"
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string
+ }
+
+ type Student struct {
+ Mensch
+ schule string
+ }
+
+ type Mitarbeiter struct {
+ Mensch
+ unternehmen string
+ }
+
+ func (h *Mensch) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s und Du erreicht mich unter %s\n", h.name, h.telefon)
+ }
+
+ func (e *Mitarbeiter) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s, arbeite bei %s. Du erreicht mich unter %s\n", e.name,
+ e.unternehmen, e.telefon) // Du kannst die Argumente auch auf zwei Zeilen verteilen.
+ }
+
+ func main() {
+ mark := Student{Mensch{"Mark", 25, "222-222-YYYY"}, "MIT"}
+ sam := Mitarbeiter{Mensch{"Sam", 45, "111-888-XXXX"}, "Golang Inc"}
+
+ mark.SagHallo()
+ sam.SagHallo()
+ }
+
+Nun bist Du bereit, Dein eigenes, objektorientiers Programm zu schreiben. Auch Methoden unterliegen der Regel, dass die Groß- und Kleinschreibung des ersten Buchstaben über die Sichtbarkeit (öffentlich oder privat) entscheidet.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Struct](02.4.md)
+- Nächster Abschnitt: [Interface](02.6.md)
diff --git a/de/02.6.md b/de/02.6.md
new file mode 100644
index 000000000..be3f18de8
--- /dev/null
+++ b/de/02.6.md
@@ -0,0 +1,397 @@
+# 2.6 Interfaces
+
+## Interface
+
+Eines der besten Sprachmerkmale von Go sind Interfaces. Nach dem Lesen dieses Abschnitts wirst Du über dessen Implementation staunen.
+
+### Was ist ein Interface
+
+Kurz gesagt, ein Interface dient der Zusammenfassung von Funktionen, die durch ihren ähnlichen Aufbau eine Beziehung zueinander haben.
+
+Wie im Beispiel aus dem letzten Abschnitt haben Student und Mitarbeiter hier beide die Methode `SagHallo()`, welche sich ähnlich, aber nicht gleich verhalten.
+
+Machen wir uns wieder an die Arbeit, indem wir beiden Structs die Methode `Singen()` hinzufügen. Zudem erweitern wir Student um die Methode `GeldLeihen()` und Mitarbeiter um die Methode `GehaltAusgeben()`.
+
+Nun besitzt Student die drei Methoden `SagHallo()`, `Singen()` und `GeldLeihen()` und Mitarbeiter `SagHallo()`, `Singen()` sowie `GehaltAusgeben()`.
+
+Diese Kombination von Methoden wird Interface genannt und umfasst sowohl Student als auch Mitarbeiter. Somit besitzen beide Datentypen die Interfaces `SagHallo()` und `Singen()`. Jedoch implementieren beide Datentypen keine gemeinsames Interfaces für `GeldLeihen()` und `GehaltAusgeben()`, da diese Methoden nicht für beide Structs definiert wurden.
+
+### Interface als Datentyp
+
+Ein Interface definiert eine Liste von Methoden. Besitzt ein Datentyp alle Methoden, die das Interface definiert, so umfasst das Interface diesen Datentypen. Schauen wir uns ein Beispiel zur Verdeutlichung an.
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string
+ }
+
+ type Student struct {
+ Mensch
+ schule string
+ kredit float32
+ }
+
+ type Mitarbeiter struct {
+ Mensch
+ unternehmen string
+ geld float32
+ }
+
+ func (m *Mensch) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s und Du erreichst mich unter %s\n", m.name, m.telefon)
+ }
+
+ func (m *Mensch) Singen(liedtext string) {
+ fmt.Println("La la, la la la, la la la la la...", liedtext)
+ }
+
+ func (m *Mensch) SichBetrinken(bierkrug string) {
+ fmt.Println("schluck schluck schluck...", bierkrug)
+ }
+
+ // Mitarbeiter "überlädt" SagHallo
+ func (m *Mitarbeiter) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s und arbeite bei %s. Ruf mich unter der Nummer %s an\n", m.name,
+ m.unternehmen, m.telefon) // Du kannst die Argumente auch auf zwei Zweilen aufteilen.
+ }
+
+ func (s *Student) GeldLeihen(betrag float32) {
+ s.kredit += betrag // (immer und immer wieder...)
+ }
+
+ func (m *Mitarbeiter) GehaltAusgeben(betrag float32) {
+ m.geld -= betrag // Einen Vodka bitte!!! Bring mich durch den Tag!
+ }
+
+ // Das Interface definieren
+ type Männer interface {
+ SagHallo()
+ Singe(liedtext string)
+ SichBetrinken(bierkrug string)
+ }
+
+ type JungerMann interface {
+ SagHallo()
+ Singe(liedtext string)
+ GeldLeihen(betrag float32)
+ }
+
+ type Greis interface {
+ SagHallo()
+ Singe(liedtext string)
+ GeldAusgeben(betrag float32)
+ }
+
+Wir wissen, dass ein Interface von jedem Datentypen implementiert werden und ein Datentyp viele Interfaces umfassen kann.
+
+Zudem implementiert jeder Datentyp das leere Interface `interface{}`, da es keine Methoden definiert und alle Datentypen von Beginn an keine Methoden besitzen.
+
+### Interface als Datentyp
+
+Welche Arten von Werten können mit einem Interface verknüpft werden? Wen wir eine Variable vom Typ Interface definieren, dann kann jeder Datentyp, der das Interface implementiert, der Variable zugewiesen werden.
+
+Es ist wie im oberen Beispiel. Erstellen wir eine Variable "m" mit dem Interface Männer, kann jeder Student, Mensch oder Mitarbeiter "m" zugewiesen werden. So könnten wir ein Slice mit dem Interface Männer jeden Datentyp hinzufügen, der ebenfalls das Interface Männer implementiert. Bedenke aber, dass sich das Verhalten von Slices ändert, wenn dies Elemente eines Interface statt eines Datentypes verwendet.
+
+ package main
+
+ import "fmt"
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string
+ }
+
+ type Student struct {
+ Mensch
+ schule string
+ geld float32
+ }
+
+ type Mitarbeiter struct {
+ Mensch
+ unternehmen string
+ geld float32
+ }
+
+ func (m Mensch) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s und Du erreicht mich unter %s\n", m.name, m.telefon)
+ }
+
+ func (m Mensch) Singe(liedtext string) {
+ fmt.Println("La la la la...", liedtext)
+ }
+
+ func (m Mitarbeiter) SagHallo() {
+ fmt.Printf("Hallo, ich bin %s und arbeite bei %s. Rufe mich unter der Nummer %s an\n", m.name,
+ m.unternehmen, m.telefon) // Du kannst die Argumente auch auf zwei Zweilen aufteilen.
+ }
+
+ // Das Interface Männer wird von Mensch, Student und Mitarbeiter implementiert
+ type Männer interface {
+ SagHallo()
+ Singe(liedtext string)
+ }
+
+ func main() {
+ mike := Student{Mensch{"Mike", 25, "222-222-XXX"}, "MIT", 0.00}
+ paul := Student{Mensch{"Paul", 26, "111-222-XXX"}, "Harvard", 100}
+ sam := Mitarbeiter{Mensch{"Sam", 36, "444-222-XXX"}, "Golang Inc.", 1000}
+ tom := Mitarbeiter{Mensch{"Sam", 36, "444-222-XXX"}, "Things Ltd.", 5000}
+
+ // Definiere i vom Typ Interface Männer
+ var i Männer
+
+ // i kann Studenten zugewiesen bekommen
+ i = mike
+ fmt.Println("Das ist Mike, ein Student:")
+ i.SagHallo()
+ i.Singe("November rain")
+
+ // i kann auch Mitarbeiter zugewiesen bekommen
+ i = tom
+ fmt.Println("Das ist Tom, ein Mitarbeiter:")
+ i.SagHallo()
+ i.Singe("Born to be wild")
+
+ // Slice mit Männern
+ fmt.Println("Nutzen wir einen Slice vom Typ Männer und schauen, was passiert")
+ x := make([]Männer, 3)
+ // Alle drei Variablen haben verschiedene Datentypen, implentieren aber das selbe Interface
+ x[0], x[1], x[2] = paul, sam, mike
+
+ for _, wert := range x {
+ wert.SagHallo()
+ }
+ }
+
+
+Ein Interface ist eine Ansammlung von abstrakten Methoden, das jeder Datentypen implementieren kann, die noch nicht Teil des Interfaces sind. Daher kann es sich nicht selbst implemetieren
+
+### Leeres Interface
+
+Ein leeres Interfaces umfasst keine Methoden, sodass alle Datentypen dieses Interface implementieren. Dies ist sehr nützlich, wenn wir irgendwann alle Datentypen speichern möchten. Es ist void* aus C sehr ähnlich.
+
+ // Definition eines leeren Interfaces
+ var a interface{}
+ var i int = 5
+ s := "Hallo Welt"
+ // a kann jeder Datentyp zugewiesen werden
+ a = i
+ a = s
+
+Wenn eine Funktion ein leeres Interface als Argumenttyp verwendet, wird jeder Datentyp akzeptiert. Gleiches gilt für den Rückgabewert einer Funktion.
+
+### Ein Interface als Methodenargument
+
+Jede Variable kann mit einem Interface genutzt werden. Aber wie können wir diese Eigenschaft nutzen, um einen beliebigen Datentyp einer Funktion zu übergeben?
+
+Zum Beispiel nutzen wir `fmt.Println` sehr oft, aber hast Du jemals gemerkt, dass jeder Datentyp verwendet werden kann? Werfen wir mal einen Blick auf den open-source Code von `fmt`. Wir sehen die folgende Definition der Funktion.
+
+ type Stringer interface {
+ String() string
+ }
+
+Dies bedeutet, dass jeder Datentyp, der das Interface Stringer implementiert, `fmt.Println` übergeben werden kann. Beweisen wir es.
+
+ package main
+
+ import (
+ "fmt"
+ "strconv"
+ )
+
+ type Mensch struct {
+ name string
+ alter int
+ telefon string
+ }
+
+ // Mensch implementiert fmt.Stringer
+ func (m Mensch) String() string {
+ return "Name:" + m.name + ", Alter:" + strconv.Itoa(m.alter) + " Jahre, Kontakt:" + m.telefon
+ }
+
+ func main() {
+ Bob := Mensch{"Bob", 39, "000-7777-XXX"}
+ fmt.Println("Dieser Mensch ist: ", Bob)
+ }
+
+
+Werfen wir nochmal einen Blick auf das Beispiel mit den Boxen von vorhin. Du wirst feststellen, dass der Datentyp Farbe ebenfalls das Interface Stringer definiert, sodass wir die Ausgabe formatieren können. Würden wir dies nicht tun, nutzt `fmt.Println()` die Standardformatierung.
+
+ fmt.Println("Die größte Box ist", boxen.HöchsteFarbe().String())
+ fmt.Println("Die größte Box ist", boxen.HöchsteFarbe())
+
+
+Achtung: Wenn Du das Interface `error` implementierst, wird `fmt` `error()` ausrufen, sodass Du ab hier Stringer noch nicht definieren brauchst.
+
+### Datentyp eines Interfaces bestimmen
+
+Wir wissen, dass einer Variable jeder Datentyp zugewiesen werden kann, der ein Interface mit dem originalen Datentypen teilt. Nun stellt sich die Frage, wie wir den genauen Datentypen einer Variable bestimmen können. Hierfür gibt es zwei Wege, die ich Dir zeigen möchte.
+
+- Überprüfung nach dem Komma-ok-Muster
+
+Der in Go übliche Syntax lautet `value, ok := element.(T)`. Er überprüft, ob eine Variable vom erwarteten Datentypen ist. "value" ist der Wert der Variable,"ok" ist vom Typ Boolean, "element" ist eine Interfacevariable und T der zu überprüfende Datentyp.
+
+Wenn das Element dem erwarteten Datentypen entspricht, wird ok auf true gesetzt. Anderfalls ist er false.
+
+Veranschaulichen wir dies anhand eines Beispiels.
+
+ package main
+
+ import (
+ "fmt"
+ "strconv"
+ )
+
+ type Element interface{}
+ type Liste []Element
+
+ type Person struct {
+ name string
+ alter int
+ }
+
+ func (p Person) String() string {
+ return "(Name: " + p.name + " - Alter: " + strconv.Itoa(p.alter) + " Jahre)"
+ }
+
+ func main() {
+ liste := make(Liste, 3)
+ liste[0] = 1 // ein Integer
+ liste[1] = "Hallo" // ein String
+ liste[2] = Person{"Dennis", 70}
+
+ for index, element := range liste {
+ if value, ok := element.(int); ok {
+ fmt.Printf("liste[%d] ist ein Integer mit dem Wert %d\n", index, value)
+ } else if value, ok := element.(string); ok {
+ fmt.Printf("liste[%d] ist ein String mit dem Wert %s\n", index, value)
+ } else if value, ok := element.(Person); ok {
+ fmt.Printf("liste[%d] ist eine Person mit dem Wert %s\n", index, value)
+ } else {
+ fmt.Printf("liste[%d] hat einen anderen Datentyp\n", index)
+ }
+ }
+ }
+
+Dieses Muster ist sehr einfach anzuwenden, aber wenn wir viele Datentypen zu bestimmen haben, sollten wir besser `switch` benutzen.
+
+- Überprüfung mit switch
+
+Machen wir von `switch` gebrauch und schreiben unser Beispiel um.
+
+ package main
+
+ import (
+ "fmt"
+ "strconv"
+ )
+
+ type Element interface{}
+ type Liste []Element
+
+ type Person struct {
+ name string
+ alter int
+ }
+
+ func (p Person) String() string {
+ return "(Name: " + p.name + " - Alter: " + strconv.Itoa(p.alter) + " Jahre)"
+ }
+
+ func main() {
+ liste := make(Liste, 3)
+ liste[0] = 1 // Ein Integer
+ liste[1] = "Hello" // Ein String
+ liste[2] = Person{"Dennis", 70}
+
+ for index, element := range liste {
+ switch value := element.(type) {
+ case int:
+ fmt.Printf("liste[%d] ein Integer mit dem Wert %d\n", index, value)
+ case string:
+ fmt.Printf("liste[%d] ist ein String mit dem Wert %s\n", index, value)
+ case Person:
+ fmt.Printf("liste[%d] ist eine Person mit dem Wert %s\n", index, value)
+ default:
+ fmt.Println("liste[%d] hat einen anderen Datentyp", index)
+ }
+ }
+ }
+
+
+Eine Sache, die Du bedenken solltest, ist, dass `element.(type)` nur in Kombination mit `switch` genutzt werden kann. Andernfalls musst Du auf das Komma-ok-Muster zurückgreifen.
+
+### Eingebettete Interfaces
+
+Eine der schönsten Eigenschaften von Go ist dessen eingebaute und vorrausschauende Syntax, etwa namenlose Eigentschaften in Structs. Nicht überraschend können wir dies ebenfalls mit Interfaces tun, die `eingebettete Interfaces` genannt werden. Auch hier gelten die selben Regeln wie bei namenlosen Eigenschaften. Anders ausgedrückt: wenn ein Interface ein anderes Interface einbettet, werden auch alle Methoden mit übernommen.
+
+Im Quellcode des Pakets `container/heap` lässt sich folgende Definition finden:
+
+ type Interface interface {
+ sort.Interface // Eingetettetes sort.Interface
+ Push(x interface{}) // Eine Push Methode, um Objekte im Heap zu speichern
+ Pop() interface{} // Eine Pop Methode, um Elemente aus dem heap zu löschen
+ }
+
+Wie wir sehen können, handelt es sich bei `sort.Interface` um ein eingebettes Interface. Es beinhaltet neben `Push()` und `Pop()` die folgenden drei Methoden implizit.
+
+ type Interface interface {
+ // Len gibt die Anzahl der Objekte in der Datenstruktur an.
+ Len() int
+ // Less gibt in Form eines Boolean an, ob i mit j getauscht werden sollte
+ Less(i, j int) bool
+ // Swap vertauscht die Elemente i und j.
+ Swap(i, j int)
+ }
+
+Ein weiteres Beispiel ist `io.ReadWriter` aus dem Paket `io`.
+
+ // io.ReadWriter
+ type ReadWriter interface {
+ Reader
+ Writer
+ }
+
+### Reflexion
+
+Reflexion in Go wird genutzt, um Informationen während der Laufzeit zu bestimmen. Wir nutzen dafür das `reflect` Paket. Der offizelle [Artikel](http://golang.org/doc/articles/laws_of_reflection.html) erklärt die Funktionsweise von `reflect` in Go.
+
+Die Nutzung von `reflect` umfasst drei Schritte. Als Erstes müssen wir ein Interface in `reflect`-Datentypen umwandeln (entweder in reflect.Type oder reflect.Value, aber dies ist Situationsabhängig).
+
+ t := reflect.TypeOf(i) // Speichert den Datentyp von i in t und erlaubt den Zugriff auf alle Elemente
+ v := reflect.ValueOf(i) // Erhalte den aktuellen Wert von i. Nutze v um den Wert zu ändern
+
+
+Danach können wir die reflektierten Datentypen konvertieren, um ihre Werte zu erhalten.
+
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ fmt.Println("Datentyp:", v.Type())
+ fmt.Println("Die Variante ist float64:", v.Kind() == reflect.Float64)
+ fmt.Println("Wert:", v.Float())
+
+
+Wollen wir schließlich den Wert eines reflektierten Datentypen ändern, müssen wir ihn dynamisch machen. Wie vorhin angesprochen, gibt es einen Unterschied, wenn wir einen Wert als Kopie oder dessen Zeiger übergeben. Das untere Beispiel ist nicht kompilierbar.
+
+ var x float64 = 3.4
+ v := reflect.ValueOf(x)
+ v.SetFloat(7.1)
+
+Stattdessen müssen wir den folgenden Code verwenden, um die Werte der reflektierten Datentypen zu ändern.
+
+ var x float64 = 3.4
+ p := reflect.ValueOf(&x)
+ v := p.Elem()
+ v.SetFloat(7.1)
+
+Nun kennen wir die Grundlagen der Reflexion. Es erfordert jedoch noch ein wenig Übung, um sich mit diesem Konzept vertraut zu machen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Objektorientierte Programmierung](02.5.md)
+- Nächster Abschnitt: [Nebenläufigkeit](02.7.md)
diff --git a/de/02.7.md b/de/02.7.md
new file mode 100644
index 000000000..f98f38eea
--- /dev/null
+++ b/de/02.7.md
@@ -0,0 +1,244 @@
+# 2.7 Nebenläufigkeit
+
+Es wird behauptet, Go sei das C des 21. Jahrhunderts. Ich glaube, dafür gibt es zwei Gründe: erstens, Go ist eine simple Programmiersprache; zweitens: Nebenläufigkeit (Concurrency im Englischen) ist ein heißes Thema in der heutigen Welt und Go unterstützt die Eigenschaft als ein zentraler Aspekt der Sprache.
+
+## Goroutinen
+
+Goroutinen und Nebenläufigkeit sind zwei wichtige Komponenten im Design von Go. Sie ähneln Threads, funktionieren aber auf eine andere Weise. Ein dutzend Goroutinen haben vielleicht nur fünf oder sechs zugrundeliegende Threads. Des Weiteren unterstützt Go vollständig das Teilen von Speicherressourcen zwischen den Goroutinen. Eine Goroutine nimmt gewöhnlicherweise etwa 4 bis 5 KB Speicher ein. Daher ist es nicht schwer, tausende von Goroutinen auf einem einzelnen Computer zu nutzen. Goroutinen sind weniger ressourcenhungrig, effizienter und geeigneter als Systemthreads.
+
+Goroutinen laufen im Thread Manager während der Laufzeit von Go. Wir nutzen das Schlüsselwort `go`, um eine neue Goroutine zu erstellen, wobei es sich eigentlich um eine interne Funktion von Go handelt ( ***main() ist ebenfalls eine Goroutine*** ).
+
+ go Hallo(a, b, c)
+
+Schauen wir uns ein Beispiel an.
+
+ package main
+
+ import (
+ "fmt"
+ "runtime"
+ )
+
+ func sag(s string) {
+ for i := 0; i < 5; i++ {
+ runtime.Gosched()
+ fmt.Println(s)
+ }
+ }
+
+ func main() {
+ go sag("Welt") // Erzeugt eine neue Goroutine
+ sag("Hallo") // Aktuelle Goroutine
+ }
+
+Ausgabe:
+
+ Hallo
+ Welt
+ Hallo
+ Welt
+ Hallo
+ Welt
+ Hallo
+ Welt
+ Hallo
+
+Wie es scheint, ist es sehr einfach, Nebenläufigkeit in Go durch das Schlüsselwort `go` zu nutzen. Im oberen Beispiel teilen sich beide Goroutinen den selben Speicher. Aber es wäre besser, diesem Rat folge zu leisten: Nutze keine geteilten Daten zur Kommunikation, sondern kommuniziere die geteilten Daten.
+
+`runtime.Gosched()` bedeutet, das die CPU andere Goroutinen ausführen und nach einiger Zeit an den Ausgangspunkt zurückkehren soll.
+
+Das Steuerungsprogramm nutzt einen Thread, um alle Goroutinen auszuführen. Das bedeutet, dass einzig dort Nebenläufigkeit implementiert wird. Möchtest Du mehr Rechnenkerne im Prozessor nutzen, um die Vorteile paralleler Berechnungen einzubringen, musst Du `runtime.GOMAXPROCS(n)` aufrufen, um die Anzahl der Rechenkerne festzulegen. Gilt `n<1`, verändert sich nichts. Es könnte sein, dass diese Funktion in Zukunft entfernt wird. Für weitere Informationen zum verteilten Rechnen und Nebenläufigkeit findest Du in diesem [Artikel](http://concur.rspace.googlecode.com/hg/talk/concur.html#landing-slide).
+
+## Channels
+
+Goroutinen werden im selben Adressraum des Arbeitsspeichers ausgeführt, sodass Du in den Goroutinen die genutzen Ressourcen synchronisieren musst, wenn diese geteilt werden sollen. Aber wie kommuniziere ich zwischen verschiedenen Goroutinen? Hierfür nutzt Go einen sehr guten Mechanismus mit dem Namen `channel`. `channel` ist wie eine bidirektionale Übertragungsleitung (Pipe) in Unix-Shells: nutze `channel` um Daten zu senden und zu empfangen. Der einzige Datentyp, der in Kombination mit diesen Datenkanälen genutzt werden kann, ist der Typ `channel` und das Schlüsselwort `chan`. Beachte, dass Du `make` brauchst, um einen neuen `channel` zu erstellen.
+
+ ci := make(chan int)
+ cs := make(chan string)
+ cf := make(chan interface{})
+
+`channel` nutzt den Operator `<-`, um Daten zu senden und zu empfangen.
+
+ ch <- v // Sende v an den Kanal ch.
+ v := <-ch // Empfange Daten von ch und weise sie v zu
+
+Schauen wir uns weitere Beispiele an.
+
+ package main
+
+ import "fmt"
+
+ func summe(a []int, c chan int) {
+ gesamt := 0
+ for _, v := range a {
+ gesamt += v
+ }
+ c <- gesamt // Sende gesamt an c
+ }
+
+ func main() {
+ a := []int{7, 2, 8, -9, 4, 0}
+
+ c := make(chan int)
+ go summe(a[:len(a)/2], c)
+ go summe(a[len(a)/2:], c)
+ x, y := <-c, <-c // Empfange Daten von c
+
+ fmt.Println(x, y, x + y)
+ }
+
+
+Das Senden und Empfangen von Daten durch die Datenkanäle wird standardmäßig gestoppt, um die Goroutinen einfach synchron zu halten. Mit dem Blocken meine ich, dass eine Goroutine nicht weiter ausgeführt wird, sobald keine Daten mehr von einem `channel` empfangen werden (z.B. `value := <-ch`) und andere Goroutinen keine weiteren Daten über den entsprechenden Kanal senden. Anderseits stoppt die sendende Goroutine solange, bis alle Daten (z.B. `ch<-5`)über den Kanal empfangen wurden.
+
+## Gepufferte Channels
+
+Eben habe ich die nicht-gepuffter Datenkanäle vorgestellt. Go unterstützt aber auch gepufferte Channel, die mehr als ein Element speichern können, z.B. `ch := make(chan bool, 4)`. Hier wurde ein Channel mit der Kapazität von vier Booleans erstellt. Mit diesem Datenkanal sind wir in der Lage, vier Elemente zu senden, ohne das die Goroutine stoppt. Dies passiert aber bei dem Versuch, ein fünftes Element zu versenden, ohne das es von einer Goroutine empfangen wird.
+
+ ch := make(chan type, n)
+
+ n == 0 ! nicht-gepuffert（stoppt）
+ n > 0 ! gepuffert（nicht gestoppt, sobald n Elemente im Kanal sind）
+
+Experimentiere mit dem folgenden Code auf Deinem Computer und verändere die Werte.
+
+ package main
+
+ import "fmt"
+
+ func main() {
+ c := make(chan int, 2) // Setze 2 auf 1 und Du erzeugst einen Laufzeitfehler. Aber 3 ist OK.
+ c <- 1
+ c <- 2
+ fmt.Println(<-c)
+ fmt.Println(<-c)
+ }
+
+## Range und Close
+
+Wir können `range` in gepufferten Kanlen genauso nutzen, wie mit Slices und Maps.
+
+ package main
+
+ import (
+ "fmt"
+ )
+
+ func fibonacci(n int, c chan int) {
+ x, y := 1, 1
+ for i := 0; i < n; i++ {
+ c <- x
+ x, y = y, x + y
+ }
+ close(c)
+ }
+
+ func main() {
+ c := make(chan int, 10)
+ go fibonacci(cap(c), c)
+ for i := range c {
+ fmt.Println(i)
+ }
+ }
+
+`for i := range c` wird nicht eher mit dem Lesen von Daten aus dem Channel aufhören, ehe dieser geschlossen ist. Wir nutzen das Schlüsselwort `close`, um den Datenkanal im oberen Beispiel zu schließen. Es ist unmöglich, Daten über einen geschlossenen Channel zu senden oder zu empfangen. Mit `v, ok := <-ch` kannst Du den Status eines Kanals überprüfen. Wird `ok` auf false gesetzt, bedeutet dies, dass sich keine weiteren Daten im Channel befinden und er geschlossen wurde.
+
+Denke aber immer daran, die Datenkanäle auf seiten der Datenproduzenten zu schließen und nicht bei den Empfängern der Daten. Andernfalls kann es passieren, dass sich Dein Programm in den Panikmodus versetzt.
+
+Ein weiterer Aspekt, den wir nicht unterschlagen sollten, ist, dass Du Channels nicht wie Dateien behandeln solltest. Du brauchst sie nicht andauernd schließen, sondern erst, wenn Du sicher bist, dass sie nicht mehr gebraucht werden oder Du das Abfragen der übertragenen Daten mit dem Schlüsselwort `range` beenden willst.
+
+## Select
+
+In den vorherigen Beispielen haben wir bisher immer nur einen Datenkanal verwendet, aber wie können wir Gebrauch von mehreren Channels machen? Go erlaubt es, mit dem Schlüsselwort `select` viele Kanäle nach Daten zu belauschen.
+
+`select` stoppt standardmäßig eine Goroutine und wird einzig ausgeführt, wenn einer der Channels Daten sendet oder empfängt. Sollten mehrere Kanäle zur gleichen Zeit aktiv sein, wird ein zufälliger ausgewählt.
+
+ package main
+
+ import "fmt"
+
+ func fibonacci(c, quit chan int) {
+ x, y := 1, 1
+ for {
+ select {
+ case c <- x:
+ x, y = y, x + y
+ case <-quit:
+ fmt.Println("Fertig")
+ return
+ }
+ }
+ }
+
+ func main() {
+ c := make(chan int)
+ quit := make(chan int)
+ go func() {
+ for i := 0; i < 10; i++ {
+ fmt.Println(<-c)
+ }
+ quit <- 0
+ }()
+ fibonacci(c, quit)
+ }
+
+
+`select` hat ebenfalls einen Standardfall wie `switch`, mit dem Namen `default`. Wenn kein Datenkanal aktiv sein sollte, wird der Standardfall ausgeführt (es wird auf keinen Kanal mehr gewartet).
+
+ select {
+ case i := <-c:
+ // Benutze i
+ default:
+ // Dieser Code wird ausgeführt, sollte c gestoppt worden sein
+ }
+
+## Zeitüberschreitung
+
+Manchmal kann es vorkommen, dass eine Goroutine gestoppt wird. Wie können wir verhindern, dass daraus resultierend das gesamte Programm aufhört zu arbeiten? Es ist ganz einfach. Es muss lediglich eine Zeitüberschreitung in `select` festgelegt werden.
+
+ func main() {
+ c := make(chan int)
+ o := make(chan bool)
+ go func() {
+ for {
+ select {
+ case v := <- c:
+ println(v)
+ case <- time.After(5 * time.Second):
+ println("Zeitüberschreitung")
+ o <- true
+ break
+ }
+ }
+ }()
+ <- o
+ }
+
+## Runtime goroutine
+
+Das Paket `runtime` beinhaltet ein paar Funktionen zum Umgang mit Goroutinen.
+
+- `runtime.Goexit()`
+
+ Verlässt die aktuelle Goroutine, aber verzögerte Funktionen werden wie gewohnt ausgeführt.
+
+- `runtime.Gosched()`
+
+ Lässt die CPU vorerst andere Goroutinen ausführen und kehrt nach einiger Zeit zum Ausgangspunkt zurück.
+
+- `runtime.NumCPU() int`
+
+ Gibt die Anzahl der Rechenkerne zurück.
+
+- `runtime.NumGoroutine() int`
+
+ Gibt die Anzahl der Goroutinen zurück.
+
+- `runtime.GOMAXPROCS(n int) int`
+
+ Legt die Anzahl der Rechenkerne fest, die benutzt werden sollen.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Interfaces](02.6.md)
+- Nächster Abschnitt: [Zusammenfassung](02.8.md)
\ No newline at end of file
diff --git a/de/02.8.md b/de/02.8.md
new file mode 100644
index 000000000..ad7784ba2
--- /dev/null
+++ b/de/02.8.md
@@ -0,0 +1,32 @@
+# 2.8 Zusammenfassung
+
+In diesem Kapitel haben wir uns hauptsächlich mit den 25 Schlüsselwörtern in Go auseinandergesetzt. Schauen wir sie und ihre Funktionweise uns noch einmal an.
+
+ break default func interface select
+ case defer go map struct
+ chan else goto package switch
+ const fallthrough if range type
+ continue for import return var
+
+- `var` und `const` werden benutzt, um Variablen und Konstanten zu definieren.
+- `package` und `import` sind für die Nutzung von Paketen nötig.
+- `func` wird zur Definition von Funktionen und Methoden verwendet.
+- `return` wird genutzt, um Werte von Funktionen und Methoden zurückzugeben.
+- `defer` wird genutzt, um Funktionen zu definieren, die als letzte Anweisung ausgeführt werden.
+- `go` definiert und startet eine neue Goroutine.
+- `select` erlaubt das Kommunizieren über mehrere Channels.
+- `interface` definiert ein Interface.
+- `struct` lässt uns speziell angepasste Datentypen erstellen.
+- `break`, `case`, `continue`, `for`, `fallthrough`, `else`, `if`, `switch`, `goto` und `default` wurden in Abschnitt 2.3 vorgestellt.
+- `chan` ist ein Datentypen für Channel, die es erlauben, zwischen Goroutinen zu kommunizieren.
+- `type` dient zur Erstellung eigener Datentypen.
+- `map` definiert eine Map, welche Hashtabellen in anderen Programmiersprachen ähneln.
+- `range` wird genutzt, um Daten aus einem `slice`, einer `map` oder einem`channel` zu erhalten.
+
+Wenn Du verstanden hast, wie die 25 Schlüsselwörter einzusetzen sind, dann hast Du bereits eine Menge über Go gelernt.
+
+## Links
+
+- [Inhaltsverzeichnis](preface.md)
+- Vorheriger Abschnitt: [Nebenläufigkeit](02.7.md)
+- Nächstes Kapitel: [Grundlagen des Internets](03.0.md)
diff --git a/de/03.0.md b/de/03.0.md
new file mode 100644
index 000000000..a61c72521
--- /dev/null
+++ b/de/03.0.md
@@ -0,0 +1,9 @@
+# 3 Internet Grundlagen
+
+Der Grund warum du dieses Buch liest, ist das du lernen möchtest wie man mit Go Webanwendungen erstellt. Wie ich schon sagte, stellt Go viele mächtige Pakete wie `http` zur Verfügung. Die Pakete können dir eine große Hilfe sein um Webanwendungen zu erstellen. In den nächsten Kapiteln werde ich dir hierzu alles beibringen, was du wissen musst. Wir werden in diesem Kapitel über einige Konzepte des Internet und wie man Webanwendung mit Go ausführt sprechen.
+
+## Links
+
+- [Directory](preface.md)
+- Previous chapter: [Chapter 2 Summary](02.8.md)
+- Next section: [Web working principles](03.1.md)
diff --git a/de/03.1.md b/de/03.1.md
new file mode 100644
index 000000000..ca91cd869
--- /dev/null
+++ b/de/03.1.md
@@ -0,0 +1,153 @@
+# Web working principles
+
+Every time you open your browsers, type some URLs and press enter, you will see beautiful web pages appear on your screen. But do you know what is happening behind these simple actions?
+
+Normally, your browser is a client. After you type a URL, it takes the host part of the URL and sends it to a DNS server in order to get the IP address of the host. Then it connects to the IP address and asks to setup a TCP connection. The browser sends HTTP requests through the connection. The server handles them and replies with HTTP responses containing the content that make up the web page. Finally, the browser renders the body of the web page and disconnects from the server.
+
+
+
+Figure 3.1 Processes of users visit a website
+
+A web server, also known as an HTTP server, uses the HTTP protocol to communicate with clients. All web browsers can be considered clients.
+
+We can divide the web's working principles into the following steps:
+
+- Client uses TCP/IP protocol to connect to server.
+- Client sends HTTP request packages to server.
+- Server returns HTTP response packages to client. If the requested resources include dynamic scripts, server calls script engine first.
+- Client disconnects from server, starts rendering HTML.
+
+This is a simple work flow of HTTP affairs -notice that the server closes its connections after it sends data to the clients, then waits for the next request.
+
+## URL and DNS resolution
+
+We always use URLs to access web pages, but do you know how URLs work?
+
+The full name of a URL is Uniform Resource Locator. It's for describing resources on the internet and its basic form is as follows.
+
+ scheme://host[:port#]/path/.../[?query-string][#anchor]
+ scheme assign underlying protocol (such as HTTP, HTTPS, FTP)
+ host IP or domain name of HTTP server
+ port# default port is 80, and it can be omitted in this case. If you want to use other ports, you must specify which port. For example, http://www.cnblogs.com:8080/
+ path resources path
+ query-string data are sent to server
+ anchor anchor
+
+DNS is an abbreviation of Domain Name System. It's the naming system for computer network services, and it converts domain names to actual IP addresses, just like a translator.
+
+
+
+Figure 3.2 DNS working principles
+
+To understand more about its working principle, let's see the detailed DNS resolution process as follows.
+
+1. After typing the domain name `www.qq.com` in the browser, the operating system will check if there are any mapping relationships in the hosts' files for this domain name. If so, then the domain name resolution is complete.
+2. If no mapping relationships exist in the hosts' files, the operating system will check if any cache exists in the DNS. If so, then the domain name resolution is complete.
+3. If no mapping relationships exist in both the host and DNS cache, the operating system finds the first DNS resolution server in your TCP/IP settings, which is likely your local DNS server. When the local DNS server receives the query, if the domain name that you want to query is contained within the local configuration of its regional resources, it returns the results to the client. This DNS resolution is authoritative.
+4. If the local DNS server doesn't contain the domain name but a mapping relationship exists in the cache, the local DNS server gives back this result to the client. This DNS resolution is not authoritative.
+5. If the local DNS server cannot resolve this domain name either by configuration of regional resources or cache, it will proceed to the next step, which depends on the local DNS server's settings.
+-If the local DNS server doesn't enable forwarding, it routes the request to the root DNS server, then returns the IP address of a top level DNS server which may know the domain name, `.com` in this case. If the first top level DNS server doesn't recognize the domain name, it again reroutes the request to the next top level DNS server until it reaches one that recognizes the domain name. Then the top level DNS server asks this next level DNS server for the IP address corresponding to `www.qq.com`.
+-If the local DNS server has forwarding enabled, it sends the request to an upper level DNS server. If the upper level DNS server also doesn't recognize the domain name, then the request keeps getting rerouted to higher levels until it finally reaches a DNS server which recognizes the domain name.
+
+Whether or not the local DNS server enables forwarding, the IP address of the domain name always returns to the local DNS server, and the local DNS server sends it back to the client.
+
+
+
+Figure 3.3 DNS resolution work flow
+
+`Recursive query process` simply means that the enquirers change in the process. Enquirers do not change in `Iterative query` processes.
+
+Now we know clients get IP addresses in the end, so the browsers are communicating with servers through IP addresses.
+
+## HTTP protocol
+
+The HTTP protocol is a core part of web services. It's important to know what the HTTP protocol is before you understand how the web works.
+
+HTTP is the protocol that is used to facilitate communication between browsers and web servers. It is based on the TCP protocol and usually uses port 80 on the side of the web server. It is a protocol that utilizes the request-response model -clients send requests and servers respond. According to the HTTP protocol, clients always setup new connections and send HTTP requests to servers. Servers are not able to connect to clients proactively, or establish callback connections. The connection between a client and a server can be closed by either side. For example, you can cancel your download request and HTTP connection and your browser will disconnect from the server before you finish downloading.
+
+The HTTP protocol is stateless, which means the server has no idea about the relationship between the two connections even though they are both from same client. To solve this problem, web applications use cookies to maintain the state of connections.
+
+Because the HTTP protocol is based on the TCP protocol, all TCP attacks will affect HTTP communications in your server. Examples of such attacks are SYN flooding, DoS and DDoS attacks.
+
+### HTTP request package (browser information)
+
+Request packages all have three parts: request line, request header, and body. There is one blank line between header and body.
+
+ GET /domains/example/ HTTP/1.1 // request line: request method, URL, protocol and its version
+ Host：www.iana.org // domain name
+ User-Agent：Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.4 (KHTML, like Gecko) Chrome/22.0.1229.94 Safari/537.4 // browser information
+ Accept：text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 // mime that clients can accept
+ Accept-Encoding：gzip,deflate,sdch // stream compression
+ Accept-Charset：UTF-8,*;q=0.5 // character set in client side
+ // blank line
+ // body, request resource arguments (for example, arguments in POST)
+
+We use fiddler to get the following request information.
+
+
+
+Figure 3.4 Information of a GET request caught by fiddler
+
+
+
+Figure 3.5 Information of a POST request caught by fiddler
+
+**We can see that GET does not have a request body, unlike POST, which does.**
+
+There are many methods you can use to communicate with servers in HTTP; GET, POST, PUT and DELETE are the 4 basic methods that we typically use. A URL represents a resource on a network, so these 4 methods define the query, change, add and delete operations that can act on these resources. GET and POST are very commonly used in HTTP. GET can append query parameters to the URL, using `?` to separate the URL and parameters and `&` between the arguments, like `EditPosts.aspx?name=test1&id=123456`. POST puts data in the request body because the URL implements a length limitation via the browser. Thus, POST can submit much more data than GET. Also, when we submit user names and passwords, we don't want this kind of information to appear in the URL, so we use POST to keep them invisible.
+
+### HTTP response package (server information)
+
+Let's see what information is contained in the response packages.
+
+ HTTP/1.1 200 OK // status line
+ Server: nginx/1.0.8 // web server software and its version in the server machine
+ Date:Date: Tue, 30 Oct 2012 04:14:25 GMT // responded time
+ Content-Type: text/html // responded data type
+ Transfer-Encoding: chunked // it means data were sent in fragments
+ Connection: keep-alive // keep connection
+ Content-Length: 90 // length of body
+ // blank line
+
+
+
+
+
+
+
+