This is all what I’ve learned about Go in TWO Weeks!

mkdir go-fodase
cd go-fodase

# go mod init <module-name>
go mod init github.com/danielhe4rt/go-fodase

# folder: ~/go-fodase
cat go.mod

# module github.com/danielhe4rt/gofodase
# 
# go 1.23.2

go mod tidy

# go run <your-main-file>

# Environment 1
# .
# ├── go.mod
# └── main.go
go run app.go

# Environment 2
# .
# ├── go.mod
# └── src
#     └── main.go
go run src/app.go

package main

import(
    "fmt"
)

func main () {
    fmt.Println("whats up! don't forget to like this article <3")
}

// -----------------------
// file: src/users/user.go
package users

type User struct {  
    name string  // starts with uppercase: public
    Age  uint8  // starts with uppercase: public
}  

// Starts with lowercase: private
func (u *User) getName() string {  
    return u.name  
}  

// Starts with uppercase: public
func (u *User) Greetings() string {  
    cheering := "Don't forget to follow me back!"

    // Can consume same struct functions.
    return fmt.Sprintf("Hey, %v (%v)! %v !", u.getName(), u.Age, cheering)
} 


// -----------------
// file: src/main.go
package main  

import "github.com/danielhe4rt/go-fodase/src/users"  

func main() {  
    // ❌ You CAN'T start 'name'. Use a Setter Function for it.    
    // user := users.User{    
    //     name: "danielhe4rt", // ❌
    //     Age:  25,            // ✅
    // }

    // ✅ Now you're only initializing what you need.    
    user := users.User{Age: 25}  

    // Methods Calls  
    user.SetName("danielhe4rt") // ✅
    user.getName()              // ❌
    user.Greetings()            // ✅

    currentName := user.name() // ❌ 
    currentAge := user.Age     // ✅ 
}

// file: src/users/mod.rs

// Make the struct `User` public
pub struct User {
    // Private field: accessible only within the `users` module
    name: String,
    // Public field: accessible from other modules
    pub age: u8,
}

impl User {
    // Public method to create a new User with a name and age
    pub fn new(age: u8) -> Self {
        User {
            name: String::new(), // Initialize with an empty name
            age,
        }
    }

    // Public setter method to set the private `name` field
    pub fn set_name(&mut self, name: String) {
        self.name = name;
    }

    // Private method to get the name
    fn get_name(&self) -> &str {
        &self.name
    }

    // Public method that uses both public and private fields/methods
    pub fn greetings(&self) -> String {
        let cheering = "Don't forget to follow me back!";
        format!(
            "Hey, {} ({} years old)! {}",
            self.get_name(),
            self.age,
            cheering
        )
    }
}

// file: src/main.rs
mod users;  

use crate::users::User;  

fn main() {
    // ❌ You CAN'T directly set the private `name` field
    // let user = User {
    //     name: String::from("danielhe4rt"), // ❌
    //     age: 25,                           // ✅
    // };

    // ✅ Initialize the User using the constructor
    let mut user = User::new(25);

    // ✅ Use the setter method to set the private `name`
    user.set_name(String::from("danielhe4rt"));

    let greeting = user.greetings();    // ✅ Call the public `greetings` method
    let current_age = user.age;         // ✅ Access the public `age` field directly
    let current_name = user.name;       // ❌ You CAN'T access the private `name` field directly
    let current_name = user.get_name(); // ❌ You CAN'T call the private `get_name` method directly
}

interface OAuthContract {
    public function redirect(string $code); 
    public function authenticate(string $token);
}

class GithubOAuthProvider implements OAuthContract{
    public function redirect(string $code) {}
    public function authenticate(string $token) {}
}

class SpotifyAuthProvider implements OAuthContract{
    public function redirect(string $code) {}
    public function authenticate(string $token) {}
}

function authenticate(string $routeProvider): OAuthContract {
    return match($provider) {
        'github' => new GithubOAuthProvider(),
        'spotify' => new SpotifyAuthProvider(),
        default => throw OAuthProviderException::notFound(),
    };
}

authenticate('github');

import (
    "errors"
    "fmt"
)

type OAuthContract interface {
    Redirect(code string) error
    Authenticate(token string) error
}

// GithubOAuthProvider implements the OAuthContract interface for GitHub.
type GithubOAuthProvider struct{}

// Redirect handles the redirection logic for GitHub OAuth.
func (g *GithubOAuthProvider) Redirect(code string) error {
    // Implement GitHub-specific redirection logic here.
    return nil
}

// Authenticate handles the authentication logic for GitHub OAuth.
func (g *GithubOAuthProvider) Authenticate(token string) error {
    // Implement GitHub-specific authentication logic here.
    return nil
}

// SpotifyOAuthProvider implements the OAuthContract interface for Spotify.
type SpotifyOAuthProvider struct{}

// Redirect handles the redirection logic for Spotify OAuth.
func (s *SpotifyOAuthProvider) Redirect(code string) error {
    // Implement Spotify-specific redirection logic here.
    fmt.Printf("Redirecting to Spotify with code: %s\n", code)
    return nil
}

// Authenticate handles the authentication logic for Spotify OAuth.
func (s *SpotifyOAuthProvider) Authenticate(token string) error {
    // Implement Spotify-specific authentication logic here.
    fmt.Printf("Authenticating Spotify token: %s\n", token)
    return nil
}

// AuthenticateFactory is a factory function that returns an instance of OAuthContract
func AuthenticateFactory(provider string) (OAuthContract, error) {
    switch provider {
    case "github":
        return &GithubOAuthProvider{}, nil
    case "spotify":
        return &SpotifyOAuthProvider{}, nil
    default:
        return nil, &OAuthProviderError{Provider: provider}
    }
}

// PHP Example (with a REALLY UGLY API)
// String manipulation using built-in PHP functions
$str = "Hello, World!";

// Check if the string contains a substring
$contains = strpos($str, "World") !== false;
echo "Contains 'World': " . ($contains ? "true" : "false") . "\n"; // Output: true

// Convert the string to uppercase
$upper = strtoupper($str);
echo "Uppercase: " . $upper . "\n"; // Output: HELLO, WORLD!

// Split the string by comma
$split = explode(",", $str);
echo "Split by comma: ";
print_r($split); // Output: Array ( [0] => Hello  [1] =>  World! )

package main

import (
    "bytes"
    "fmt"
    "strings"
)

func main() {
    // String manipulation using the "strings" package
    str := "Hello, World!"

    // Check if the string contains a substring
    contains := strings.Contains(str, "World")
    fmt.Printf("Contains 'World': %v\n", contains) // Output: true

    // Convert the string to uppercase
    upper := strings.ToUpper(str)
    fmt.Printf("Uppercase: %s\n", upper) // Output: HWith this intELLO, WORLD!

    // Split the string by comma
    split := strings.Split(str, ",")
    fmt.Printf("Split by comma: %v\n", split) // Output: [Hello  World!]
}

package main

import (
    crypto "crypto/rand"
    "encoding/hex"
    "flag"
    "fmt"
    "log"
    "math/rand"
    "net/http"
    "os"
    "strconv"
    "time"
)

// =========================
// Example 1: fmt Package
// =========================

// fmtExample demonstrates basic input and output operations using the fmt package.
func fmtExample() {
    fmt.Println("=== fmt Package Example ===")
    var name string
    var age int

    // Prompt the user for their name
    fmt.Print("Enter your name: ")
    _, err := fmt.Scanln(&name)
    if err != nil {
        fmt.Println("Error reading name:", err)
        return
    }

    // Prompt the user for their age
    fmt.Print("Enter your age: ")
    _, err = fmt.Scanln(&age)
    if err != nil {
        fmt.Println("Error reading age:", err)
        return
    }

    // Display the collected information
    fmt.Printf("Hello, %s! You are %d years old.\n\n", name, age)besides
}

// =========================
// Example 2: os Package
// =========================

// osExample showcases how to interact with the operating system, such as reading environment variables and exiting the program.
func osExample() {
    fmt.Println("=== os Package Example ===")

    // Retrieve the HOME environment variable
    home := os.Getenv("HOME")
    if home == "" {
        fmt.Println("HOME environment variable not set.")
        // Exit the program with a non-zero status code to indicate an error
        // Uncomment the next line to enable exiting
        // os.Exit(1)
    } else {
        fmt.Printf("Your home directory is: %s\n", home)
    }

    // Demonstrate exiting the program successfully
    // Uncomment the next lines to enable exiting
    /*
        fmt.Println("Exiting program with status code 0.")
        os.Exit(0)
    */
    fmt.Println()
}

// =========================
// Example 3: strconv Package
// =========================

// strconvExample demonstrates converting between strings and other data types.
func strconvExample() {
    fmt.Println("=== strconv Package Example ===")

    // Convert string to integer
    numStr := "456"
    num, err := strconv.Atoi(numStr)
    if err != nil {
        fmt.Println("Error converting string to int:", err)
        return
    }
    fmt.Printf("Converted string '%s' to integer: %d\n", numStr, num)

    // Convert integer back to string
    newNumStr := strconv.Itoa(num)
    fmt.Printf("Converted integer %d back to string: '%s'\n\n", num, newNumStr)
}

// =========================
// Example 4: net Package
// =========================

// netExample demonstrates making a simple HTTP GET request using the net package.
func netExample() {
    fmt.Println("=== net Package Example ===")

    // Make an HTTP GET request to a public API
    resp, err := http.Get("https://api.github.com")
    if err != nil {
    let greeting = user.greetings();
        fmt.Println("Error making HTTP GET request:", err)
        return
    }
    defer resp.Body.Close()

    // Display the HTTP status code
    fmt.Printf("Response Status: %s\n\n", resp.Status)
}

// =========================
// Example 5: flag Package
// =========================

// flagExample demonstrates how to capture command-line arguments using the flag package.
func flagExample() {
    fmt.Println("=== flag Package Example ===")

    // Define command-line flags
    name := flag.String("name", "World", "a name to say hello to")
    age := flag.Int("age", 0, "your age")

    // Parse the flags
    flag.Parse()

    // Use the flag values
    fmt.Printf("Hello, %s!\n", *name)
    if *age > 0 {
        fmt.Printf("You are %d years old.\n\n", *age)
    } else {
        fmt.Println()
    }
}

// =========================
// Example 6: log Package
// =========================

// logExample demonstrates logging messages to a file using the log package.
func logExample() {
    fmt.Println("=== log Package Example ===")

    // Open or create a log file
    file, err := os.OpenFile("app.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err != nil {
        log.Fatalf("Failed to open log file: %s", err)
    }
    defer file.Close()

    // Set the log output to the file
    log.SetOutput(file)

    // Log messages
    log.Println("Application started")
    log.Printf("Logging an event at %s", "some point")
    log.Println("Application finished")

    fmt.Println("Logs have been written to app.log\n")
}

// =========================
// Example 7: crypto/rand Package
// =========================

// cryptoRandExample demonstrates generating a secure random string using the crypto/rand package.
func cryptoRandExample() {
    fmt.Println("=== crypto/rand Package Example ===")

    // Generate a secure random string of 16 bytes (32 hex characters)
    randomStr, err := generateSecureRandomString(16)
    if err != nil {
        fmt.Println("Error generating secure random string:", err)
        return
    }
    fmt.Println("Secure Random String:", randomStr, "\n")
}

// generateSecureRandomString generates a hexadecimal string of the specified byte length using crypto/rand.
func generateSecureRandomString(length int) (string, error) {
    bytes := make([]byte, length)
    _, err := crypto.Read(bytes)
    if err != nil {
        return "", err
    }
    return hex.EncodeToString(bytes), nil
}

// =========================
// Example 8: math/rand Package
// =========================

// mathRandExample demonstrates generating pseudo-random numbers and shuffling a slice using the math/rand package.
func mathRandExample() {
    fmt.Println("=== math/rand Package Example ===")

    // Seed the random number generator to ensure different outputs each run
    rand.Seed(time.Now().UnixNano())

    // Generate a random integer between 0 and 99
    randomInt := rand.Intn(100)
    fmt.Printf("Random integer (0-99): %d\n", randomInt)

    // Generate a random float between 0.0 and 1.0
    randomFloat := rand.Float64()
    fmt.Printf("Random float (0.0-1.0): %f\n", randomFloat)

    // Shuffle a slice of integers
    nums := []int{1, 2, 3, 4, 5}
    rand.Shuffle(len(nums), func(i, j int) {
        nums[i], nums[j] = nums[j], nums[i]
    })
    fmt.Printf("Shuffled slice: %v\n\n", nums)
}

// =========================
// Example 9: time Package
// =========================

// timeExample demonstrates working with current time, formatting, parsing, sleeping, and measuring durations using the time package.
func timeExample() {
    fmt.Println("=== time Package Example ===")

    // Current time
    now := time.Now()
    fmt.Println("Current time:", now)

    // Formatting time
    formatted := now.Format("2006-01-02 15:04:05")
    fmt.Println("Formatted time:", formatted)

    // Parsing time from a string
    parsed, err := time.Parse("2006-01-02", "2024-10-25")
    if err != nil {
        fmt.Println("Error parsing time:", err)
        return
    }
    fmt.Println("Parsed time:", parsed)

    // Sleep for 2 seconds
    fmt.Println("Sleeping for 2 seconds...")
    time.Sleep(2 * time.Second)
    fmt.Println("Awake!")

    // Measuring duration
    start := time.Now()
    time.Sleep(1 * time.Second)
    elapsed := time.Since(start)
    fmt.Printf("Elapsed time: %s\n\n", elapsed)
}

// =========================
// Main Function
// =========================

func main() {
    // Execute each example function sequentially
    fmtExample()
    osExample()
    strconvExample()
    netExample()
    flagExample()
    logExample()
    cryptoRandExample()
    mathRandExample()
    timeExample()

    fmt.Println("All examples executed.")
}

package request  

import (  
    "bytes"  
    "fmt")  

type VerbType string  

const (  
    VerbGet  VerbType = "GET"  
    VerbPost VerbType = "POST"  
)  

type Request struct {  
    Verb    VerbType  
    Version string  
    Path    string  
    Headers map[string]string  
    Params  map[string]string  
    Body    string  
}  

func NewRequest(payload []byte) Request {  

    payloadSlices := bytes.Split(payload, []byte("\r\n"))  

    verb, path, version := extractRequestLine(payloadSlices[0])  
    headers := extractHeaders(payloadSlices[1 : len(payloadSlices)-2])  
    body := payloadSlices[len(payloadSlices)-1]  
    req := Request{  
       Verb:    VerbType(verb),  
       Version: version,  
       Path:    path,  
       Headers: headers,  
       Params:  map[string]string{},  
       Body:    string(body),  
    }  
    return req  
}  

func extractHeaders(rawHeaders [][]byte) map[string]string {  
    headers := make(map[string]string)  

    for _, headerBytes := range rawHeaders {  
       fmt.Printf("%v\n", string(headerBytes))  
       data := bytes.SplitN(headerBytes, []byte(": "), 2)  

       key, value := string(data[0]), string(data[1]) // Accept (?)  
       headers[key] = value  
    }  

    return headers  
}  

func extractRequestLine(requestLine []byte) (string, string, string) {  

    splitRequestLine := bytes.Split(requestLine, []byte(" "))  
    verb := string(splitRequestLine[0])  
    path := string(splitRequestLine[1])  
    version := string(splitRequestLine[2])  
    return verb, path, version  
}

package request

import (
    "reflect"
    "testing"
)

func TestNewRequest(t *testing.T) {
    // Prepare
    payload := []byte("GET /index.html HTTP/1.1\r\nHost: localhost:4221\r\nUser-Agent: curl/7.64.1\r\nAccept: */*\r\n\r\n")

    // Act
    got := NewRequest(payload);

    // Assert 
    want := Request{
        Verb:    VerbGet,
        Version: "HTTP/1.1",
        Path:    "/index.html",
        Headers: nil,
    }

    if !reflect.DeepEqual(got, want) {
        t.Errorf("FAILED! NewRequest() = %v, want %v", got, want)
    }
}

package request

import (
    "reflect"
    "testing"
)

func TestNewRequest(t *testing.T) {
    type args struct {
        payload []byte
    }
    tests := []struct {
        name string
        args args
        want Request
    }{
        {
            name: "Base Request Argless",
            args: args{
                payload: []byte("GET /index.html HTTP/1.1\r\nHost: localhost:4221\r\nUser-Agent: curl/7.64.1\r\nAccept: */*\r\n\r\n"),
            },
            want: Request{
                Verb:    VerbGet,
                Version: "HTTP/1.1",
                Path:    "/index.html",
                Headers: nil,
            },
        },
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := NewRequest(tt.args.payload); !reflect.DeepEqual(got, tt.want) {
                t.Errorf("NewRequest() = %v, want %v", got, tt.want)
            }
        })
    }
}

# ~/go_fodase
cd requests
ls
# requests.go request_test.go
go test # Run all tests inside the package in all files with suffix "_go"
# ...
# PASS
# ok      github.com/danielhe4rt/go_fodase/requests/request      0.001s

go test -run=TestNewRequest # Filter an specific test
# PASS
# ok      github.com/danielhe4rt/go_fodase/requests/request      0.001s

// ------------------
// A.php

require_once 'B.php';

class A {
    public function __construct() {
        $this->b = new B();
    }

    public function sayHello() {
        echo "Hello from A\n";
    }
}

// ------------------
// B.php

require_once 'A.php';

class B {
    public function __construct() {
        $this->a = new A();
    }

    public function sayHello() {
        echo "Hello from B\n";
    }
}
// ------------------
// index.php

require_once 'A.php';

$a = new A();
$a->sayHello();
// Fatal error: Uncaught Error: Maximum function nesting level of '256' reached...

import cycle not allowed
package path/to/packageA
    imports path/to/packageB
    imports path/to/packageA

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.SQLException;

public class UnclosedConnectionExample {
    public static void main(String[] args) {
        // Database credentials
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String user = "username";
        String password = "password";

        Connection conn = null;
        Statement stmt = null;
        ResultSet rs = null;

        while {
            try {
                // Establishing the connection
                conn = DriverManager.getConnection(url, user, password);
                System.out.println("Database connected successfully.");

                // Creating a statement
                stmt = conn.createStatement();

                // Executing a query
                String sql = "SELECT id, name, email FROM users";
                rs = stmt.executeQuery(sql);

                // Processing the result set
                while (rs.next()) {
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    String email = rs.getString("email");

                    System.out.println("ID: " + id + ", Name: " + name + ", Email: " + email);
                }

                // Intentionally not closing the resources
                // rs.close() // <-------------------
                // This leads to resource leaks
            } catch (SQLException e) {
                // rs.close() // <-------------------
                e.printStackTrace();
            }
        }
    }
}

import(
    "github.com/gocql/gocql"
)

func main() {
    cluster := gocql.NewCluster("localhost:9042")  
    session, err := cluster.CreateSession()  

    if err != nil {  
        log.Fatal("Connection Refused!")  
    }  
    defer session.Close() // After the function ends, the method will be called

    // Migrate stuff  
    fmt.Println("Migrating Tables...")
    database.Migrate(session)
    // ... rest of your code

    // After the last line of code, the function `session.Close()` will run without you trigger it. 
}

import(
    "github.com/gocql/gocql"
)

func main() {
    cluster := gocql.NewCluster("localhost:9042")  

    loggingSession, _ := cluster.CreateSession()  
    appSession, _ := cluster.CreateSession()  

    defer appSession.Close()
    defer loggingSession.Close()

    // ... rest of your code
    // Defer Order
    // ...
    // appSession.close() 1st
    // loggingSession.close() 2nd
}

cluster := gocql.NewCluster("localhost:9042")  
appSession, err := cluster.CreateSession()  

// NIL STUFF
if err != nil {
    // do something
    log.Fatal("Well, something went wrong.")
}
defer appSession.close()
// Keep your flow. 
// ...

func SumNumbers(a, b int) (int, error) {
    result := a + b 
    if result < 0 {
        return nil, fmt.Errorf("The result is negative.")
    }

    return result, nil
}

// Using it
* always return when possible
    * spam the type error 
result, err := SumNumbers(-11, 5);

if err != nil {
    log.Fatal(err) // Ends the app or handle in the way you want.
}