DEV Community: Rexsy Bima Trima Wahyu

Mastering Go is Easy Actually, part 2 : Understanding Go's Predeclared Types and Declarations

Rexsy Bima Trima Wahyu — Wed, 23 Apr 2025 07:31:30 +0000

Now that your development environment is set up, it's time to explore Go's language features and best practices. The guiding principle? Write code that clearly communicates your intentions. As we dive into Go's built-in types and variable declarations, you'll see how subtle differences from other languages can impact readability and functionality.

The Predeclared Types

Go comes with several built-in types, known as predeclared types. These include familiar options like booleans, integers, floats, and strings. While they may seem straightforward, transitioning developers often need to adjust to Go's idiomatic usage. Before examining each type, let's cover some universal concepts.

The Zero Value

Like many modern languages, Go assigns a default zero value to any declared but unassigned variable. This explicit zeroing eliminates bugs common in languages like C and C++. Each type's zero value will be discussed alongside its details.

Literals

Go literals represent explicitly specified numbers, characters, or strings. There are four common kinds (plus a rare fifth for complex numbers):

Integer literals: Base 10 by default, with prefixes for binary (0b), octal (0o), and hexadecimal (0x). Underscores improve readability (e.g., 1_234).
Floating-point literals: Include a decimal point or exponent (6.03e23). Hexadecimal floats use 0x and p for exponents.
Rune literals: Represent characters in single quotes, with various numeric escapes (e.g., '\u0061' for 'a').
String literals: Use double quotes for interpreted strings (processing escapes) or backticks for raw strings (no escapes).

Literals are untyped, defaulting to a type when context doesn't specify one.

Booleans

The bool type holds true or false, with a zero value of false.

Numeric Types

Go offers 12 numeric types across three categories:

Integer Types

Signed and unsigned integers range from 1 to 8 bytes (see table in original text). All have a zero value of 0.

Special Integer Types

byte: Alias for uint8.
int and uint: Platform-dependent (32 or 64 bits). Integer literals default to int.
rune and uintptr: For Unicode code points and pointer arithmetic, respectively.

Choosing an Integer

Match external formats (e.g., network protocols).
Use generics for library functions.
Default to int otherwise.

Integer Operators

Standard arithmetic (+, -, *, /, %) and bitwise operations (<<, >>, &, |, ^). Division truncates toward zero.

Floating-Point Types

float32 and float64 follow IEEE 754. Prefer float64 for precision. Avoid floats for exact decimals (e.g., money).

Complex Types

complex64 and complex128 support complex numbers via the complex function. Rarely used outside niche applications.

Strings and Runes

Strings are immutable, Unicode-compatible, and support concatenation (+). The rune type (alias for int32) represents Unicode code points. Zero value is an empty string.

Explicit Type Conversion

Go requires manual conversion between types, even for similar numerics. For example:

var x int = 10
var y float64 = 30.2
sum := float64(x) + y // Explicit conversion

No non-boolean type can be converted to bool; use comparisons instead.

Literals Are Untyped

Literals adapt to compatible types but can't overflow variables (e.g., assigning 1000 to a byte errors).

Variable Declarations: `var` vs. `:=`

var for zero values, package-level vars, or explicit types.
:= for type-inferred local variables (must declare at least one new var).

Constants

Declared with const, constants are immutable and computed at compile time. They can be typed or untyped (more flexible).

Naming Conventions

Use camelCase, not snake_case.
Short names in small scopes (e.g., i, k).
Descriptive names at package level.
Avoid underscores and Unicode look-alikes.

Unused Variables

Go enforces local variable usage (compile-time error if unused). Package-level vars and constants are exempt but discouraged.

Exercises

Declare an integer i as 20, assign to float f, and print both.
Create a constant assignable to int and float64, then print both.
Assign max values to byte, int32, and uint64 vars, increment, and print.

Wrapping Up

You've now mastered Go's predeclared types, declarations, and idioms. Next, we'll explore composite types like slices and maps, and revisit strings and runes in depth.

Mastering Go is Easy Actually, part 1 : Setting up Go Development Environment

Rexsy Bima Trima Wahyu — Wed, 23 Apr 2025 07:00:23 +0000

Setting Up Your Go Development Environment: A Comprehensive Guide

Every programming language requires a proper development environment, and Go is no exception. Whether you're a seasoned Go developer or just starting out, setting up your environment correctly is crucial for a smooth coding experience. In this guide, we'll walk you through installing Go, writing your first program, and exploring essential tools that make Go development efficient and enjoyable.

Installing the Go Tools

The first step is to download and install the Go development tools. Visit the official Go downloads page and select the appropriate installer for your operating system:

Mac users: Use the .pkg installer or install via Homebrew with brew install go
Windows users: Use the .msi installer or install via Chocolatey with choco install golang
Linux/BSD users: Download the gzipped TAR file and install manually:

$ tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bash_profile
$ source $HOME/.bash_profile

Verify your installation by running:

$ go version

You should see output similar to go version go1.20.5 darwin/arm64 (Mac) or go version go1.20.5 linux/amd64 (Linux).

Your First Go Program

Let's create the classic "Hello, World!" program to test your setup:

Create a new directory for your project:

$ mkdir ch1
$ cd ch1

Initialize a Go module:

$ go mod init hello_world

Create a file named hello.go with the following content:

package main

import "fmt"

func main() {
    fmt.Println("Hello, world!")
}

Build and run your program:

$ go build
$ ./hello_world
Hello, world!

Essential Go Tools

Go comes with powerful built-in tools that help maintain code quality:

go fmt

The go fmt command automatically formats your code to match Go's standard style:

$ go fmt ./...

go vet

go vet detects potential bugs in your code that might compile but could cause issues:

$ go vet ./...

go run

For quick testing without building an executable:

$ go run hello.go

Choosing Development Tools

While you can write Go code with any text editor, these IDEs offer excellent Go support:

Visual Studio Code

Free and open-source
Install the Go extension for full support
Features: auto-formatting, code completion, debugging

GoLand

Commercial IDE from JetBrains
Comprehensive Go support out of the box
Free trial available

The Go Playground

For quick experimentation without local setup:

Access The Go Playground
Write and run small Go programs
Share code via unique URLs

Automating with Makefiles

Create a Makefile to automate common tasks:

.DEFAULT_GOAL := build

.PHONY: fmt vet build
fmt:
    go fmt ./...

vet: fmt
    go vet ./...

build: vet
    go build

Run with:

$ make

Staying Up-to-Date

Go maintains strong backward compatibility. To update:

Mac/Windows: Re-run installer or package manager
Linux/BSD:

$ mv /usr/local/go /usr/local/old-go
$ tar -C /usr/local -xzf go1.20.6.linux-amd64.tar.gz
$ rm -rf /usr/local/old-go

Exercises

Run "Hello, World!" on The Go Playground and share the link
Add a clean target to your Makefile
Experiment with formatting and see how go fmt responds

Conclusion

You now have a fully functional Go development environment! With these tools in place, you're ready to explore Go's features and start building robust applications. In the next chapter, we'll dive into Go's type system and variable declarations.

Django Class Based View made easy

Rexsy Bima Trima Wahyu — Sat, 12 Oct 2024 05:48:00 +0000

As we all know, django uses MVT (model-view-template) for its design on developing web application.

View itself is a callable which takes a request and returns a response. its more than just a function as Django provides something called Class Based View, so developer can write a view using, well, a class based approach or you can say an OOP approach. This Class Based View is designed so we can structure our views and can be reused by the power of inheritance and mixins.

As documented well in django docs, one of the problem with function based view is that there is no way to extend or customize them beyond some configuration options, limiting their usefulness in many real-world applications.

The toolkit of base classes and mixins in django is designed for maximum flexibility. Lets take a look how we can use most basic Class Based View in django using View class inheritance and compare it to function based view.

#views.py using View class inheritance
from django.views import View
from django.http import HttpResponse, HttpRequest

class IndexView(View):
    def get(self, request: HttpRequest):
        # imagine 10 line of view logic here
        return HttpResponse("Hello world from indexview")

    def post(self, request: HttpRequest):
        # imagine 10 line of view logic here
        return HttpResponse("Hello world from indexview in post method")

#views.py function based view
from django.http import HttpResponse, HttpRequest

def index(request: HttpRequest):
    if request.method == "GET":
        # imagine 10 line of view logic here
        return HttpResponse("Hello world from index funcion view")
    elif request.method == "POST":
        # imagine 10 line of view logic here
        return HttpResponse("Hello world from index funcion view in post method")

If you look at above, a class-based view allows you to respond to different HTTP request methods with different class instance methods, instead of with conditionally branching code inside a single view function. now imagine in each view above that we added 10 lines of logic each method, you should be can tell which one is easier to walkthrough.

In order to register the class based view into the url configuration is that we must call as_view() class method which will basically convert the Class View into a callable function. this converted function will call setup() to initialize its attribute and then calls dispatch() to check which method user have (a GET, POST, or other method) and will connect the request method to coressponding matching method the class based view originally have

#urls.py

from django.urls import path
from myapp.views import IndexView, index

urlpatterns = [
    path("", IndexView.as_view(), name=IndexView.__name__), 
    path("index/", index, name=index.__name__),

]

class based view also supports all http shourtcut django has, such as render() function to render a template, here is a modified example of django cbv using render shortcut and cooperated with django messages framework

class IndexView(View):
    def get(self, request: HttpRequest):
        # imagine 10 line of view logic here
        return render(request, "GEtindex.html")

    def post(self, request: HttpRequest):
        # imagine 10 line of view logic here
        messages.add_message(request, messages.INFO, "POST Success") #add display success message here by django messages framework
        return render(request, "POSTindex.html")

Overall django class based view allow developer to write better to understand view logic, the more complex a view logic is, Im pretty sure it will be harder to read if we just use function based view (too many if statement to check what method are user using for an example) and hard to scale, meanwhile django cbv is designed to break our view logic to multiple method like get and post method. and can be used again in inheritance if you want, altho i can argue that the more inheritance we have in a class it will be harder to read due to its abstraction.

you can check more about class based view in django docs starts from here, here, here

Also a good alternative docs that focuses in django class based view is ccbv.co.uk <- i use this website to know which view template logic i can use fast!

DEV Community: Rexsy Bima Trima Wahyu

Mastering Go is Easy Actually, part 2 : Understanding Go's Predeclared Types and Declarations

The Predeclared Types

The Zero Value

Literals

Booleans

Numeric Types

Integer Types

Special Integer Types

Choosing an Integer

Integer Operators

Floating-Point Types

Complex Types

Strings and Runes

Explicit Type Conversion

Literals Are Untyped

Variable Declarations: var vs. :=

Constants

Naming Conventions

Unused Variables

Exercises

Wrapping Up

Mastering Go is Easy Actually, part 1 : Setting up Go Development Environment

Setting Up Your Go Development Environment: A Comprehensive Guide

Installing the Go Tools

Your First Go Program

Essential Go Tools

go fmt

go vet

go run

Choosing Development Tools

Visual Studio Code

GoLand

The Go Playground

Automating with Makefiles

Staying Up-to-Date

Exercises

Conclusion

Django Class Based View made easy

Variable Declarations: `var` vs. `:=`