Go-Lang Development Fundamentals

Dalam pengembangan perangkat lunak modern, bahasa pemrograman Go (atau Go-Lang) telah menjadi salah satu pilihan utama bagi para developer yang menginginkan performa tinggi, efisiensi dalam pemanfaatan sumber daya, dan dukungan bawaan untuk konkurensi. Namun, banyak developer menghadapi tantangan dalam memahami sintaks dasar Go, pengelolaan memori, dan implementasi konkurensi yang efektif. Selain itu, pemahaman mengenai error handling dan penggunaan module serta package dalam proyek Go sering menjadi hambatan dalam pengembangan aplikasi yang scalable dan maintainable. Banyak developer baru menghadapi kesulitan dalam mengoptimalkan penggunaan pointers, memahami konsep interface, dan mengelola dependensi dengan Go Modules (State of Go, 2023).

Training Go-Lang Development Fundamentals ini dirancang untuk memberikan pemahaman mendalam mengenai bahasa pemrograman Go dengan pendekatan yang sistematis dan berbasis praktik. Peserta akan mempelajari dasar-dasar Go mulai dari setting up environment, deklarasi variabel, tipe data, dan penggunaan fungsi hingga konsep yang lebih kompleks seperti penggunaan pointer, interface, error handling, dan generics. Selain itu, peserta akan diperkenalkan dengan konsep konkurensi di Go menggunakan goroutines dan channels, serta memahami best practices dalam pengujian aplikasi menggunakan testing framework bawaan Go

Fokus utama dalam pelatihan ini meliputi pengenalan dasar Go, pengelolaan tipe data dan fungsi, penggunaan package dan module, serta implementasi konkurensi yang efektif. Dengan menguasai aspek-aspek ini, peserta akan lebih siap dalam membangun aplikasi Go yang efisien dan scalable. Training ini juga akan memberikan insight mengenai tooling dalam Go, debugging, dan pengelolaan dependensi untuk memastikan pengembangan aplikasi yang lebih terstruktur dan maintainable.

OBJECTIVES

1. Mengatur environment pengembangan Go dan memahami dasar-dasar Go Tools
2. Menggunakan tipe data predeclared dan composite dalam Go
3. Mengembangkan aplikasi dengan struktur kontrol yang efisien (if, for, switch, goto)
4. Menerapkan prinsip dasar fungsi dan pointer dalam Go
5. Memahami konsep metode, interface, dan generics untuk meningkatkan fleksibilitas kode
6. Mengelola error dengan pendekatan yang efektif dan memahami error wrapping
7. Menggunakan module dan package untuk membangun aplikasi Go yang terorganisir
8. Mengimplementasikan konkurensi dengan goroutines dan channels
9. Memanfaatkan pustaka standar Go untuk pengembangan aplikasi web dan logging
10. Menggunakan praktik terbaik dalam pengujian aplikasi Go, termasuk testing dan debugging

AUDIENCE

1. Developer
2. Software Engineer
3. Backend Engineer
4. System Programmer

PREREQUISITES

Tidak ada training khusus yang dipersyaratkan

CONTENT

1. Setting Up Environment

1.1 Installing the Go Tools
1.2 Go Tools
1.3 Programming File
1.4 The Go Compatibility Promise

2. Predeclared Types and Declarations

2.1 The Predeclared Types
2.2 var Versus :=
2.3 Using Const
2.4 Typed and Untyped Constants
2.5 Unused Variables
2.6 Naming Variables and Constants

3. Composite Types

3.1 Arrays
3.2 Strings and Runes and Bytes
3.3 Maps
3.4 Structs

4. Blocks, Shadows, and Control Structures

4.1 Blocks
4.2 Shadowing Variables
4.3 If
4.4 For
4.5 Switch
4.6 Goto

5. Functions

5.1 Declaring and Calling Functions
5.2 Functions Are Values
5.3 Closures
5.4 Defer
5.5 Go Is Call by Value

6. Pointers

6.1 A Quick Pointer Primer
6.2 Pointers Indicate Mutable Parameters
6.3 Pointers Are a Last Resort
6.4 Pointer Passing Performance
6.5 The Zero Value Versus No Value
6.6 The Difference Between Maps and Slices
6.7 Slices as Buffers
6.8 Reducing the Garbage Collector’s Workload
6.9 Tuning the Garbage Collector

7. Types, Methods, and Interfaces

7.1 Types in Go
7.2 Methods
7.3 Use Embedding for Composition
7.4 Embedding Is Not Inheritance
7.5 A Quick Lesson on Interfaces
7.6 Interfaces Are Type-Safe Duck Typing
7.7 Embedding and Interfaces
7.8 Type Assertions and Type Switches
7.9 Use Type Assertions and Type Switches Sparingly
7.10 Function Types Are a Bridge to Interfaces
7.11 Implicit Interfaces Make Dependency Injection Easier
7.12 Wire

8. Generics

8.1 Generics Reduce Repetitive Code and Increase Type Safety
8.2 Introducing Generics in Go
8.3 Generic Functions Abstract Algorithms
8.4 Generics and Interfaces
8.5 Use Type Terms to Specify Operators
8.6 Type Inference and Generics
8.7 Type Elements Limit Constants
8.8 Combining Generic Functions with Generic Data Structures
8.9 Things That Are Left Out
8.10 Idiomatic Go and Generics
8.11 Adding Generics to the Standard Library

9. Errors

9.1 How to Handle Errors
9.2 Use Strings for Simple Errors
9.3 Sentinel Errors
9.4 Errors Are Values
9.5 Wrapping Errors
9.6 Wrapping Multiple Errors
9.7 Wrapping Errors with defer
9.8 Getting a Stack Trace from an Error

10. Modules, Packages, and Import

10.1 Repositories, Modules, and Packages
10.2 Using Go.mod
10.3 Building Packages
10.4 Working with Modules
10.5 Publishing Module
10.6 Versioning Module
10.7 Module Proxy Servers
10.8 Additional Details

11. Go Tooling

11.1 Using Go Run to Try Out Small Programs
11.2 Adding Third-Party Tools with Go Install
11.3 Improving Import Formatting with Goimports
11.4 Using Code-Quality Scannerss
11.5 Using Govulncheck to Scan for Vulnerable Dependencies
11.6 Embedding Content into Your Program
11.7 Embedding Hidden Files
11.8 Using Go Generate
11.9 Working with Go Generate and Makefiles
11.10 Reading the Build Info Inside a Go Binary
11.11 Building Go Binaries for Other Platforms
11.12 Using Build Tags
11.13 Testing Versions of Go
11.14 Using Go Help to Learn More About Go Tooling

12. Concurrency in Go

12.1 When to Use Concurrency
12.2 Goroutines
12.3 Channels
12.4 Reading, Writing, and Buffering
12.5 Using For-Range and Channels
12.6 Closing a Channel
12.7 Select
12.8 Concurrency Practices and Patterns
12.9 Embedding Hidden Files
12.10 Using Go Generate
12.11 Working with Go Generate and Makefiles

13. The Standard Library

13.1 Io and Friends
13.2 Time
13.3 Encoding/json
13.4 Net/http
13.5 Structured Logging

14. Writing Tests

14.1 Understanding the Basics of Testing
14.2 Running Table Tests
14.3 Running Tests Concurrently
14.4 Checking Your Code Coverage
14.5 Fuzzing
14.6 Using Benchmarks
14.7 Using Stubs in Go
14.8 Using Httptest
14.9 Using Integration Tests and Build Tags
14.10 Finding Concurrency Problems with the Data Race Detector