Forem: Sukma Rizki

UNSUPERVISED LEARNING

Sukma Rizki — Wed, 31 Dec 2025 11:02:12 +0000

Unsupervised learning occurs when the algorithm is not given a specific “wrong” or “right” outcome. Instead, the algorithm is given unlabeled data.

Mastering Rate Limiting in Golang Strategies for Scalable APIs

Sukma Rizki — Thu, 24 Jul 2025 06:03:53 +0000

In the rapidly growing landscape of microservices and global APIs, managing request volume is critical. Enter rate limiting—a technique every Golang developer should master to maintain performance, prevent abuse, and safeguard infrastructure.

Why Rate Limiting Matters in 2025.

As apps scale and edge deployments increase, controlling how often users or services access APIs has become foundational. Whether you're managing burst traffic from IoT devices or throttling spammy requests in a messaging queue, Golang offers elegant solutions to keep services responsive.

Each strategy balances efficiency and control differently. For most real-world APIs, Sliding Window and Token Bucket offer a robust combination of flexibility and accuracy.

implementation Tip, Redis-Powered Distributed Limiter
Rate limiting across multiple servers? Use Redis for atomic counters and expiration windows.

client.Eval(`
  local current = redis.call("INCR", KEYS[1])
  if current > tonumber(ARGV[1]) then return 0 end
  if current == 1 then redis.call("EXPIRE", KEYS[1], ARGV[2]) end
  return 1
`, []string{key}, limit, window)

This approach keeps things centralized and synchronized—perfect for microservice architectures.

Best Practices
Combine token-based limiting with IP behavior tracking to detect trolls.

Use libraries like golang.org/x/time/rate for a clean API and solid performance.

Monitor key metrics (latency, error rates) and tune limits as traffic evolves.

Final Thoughts
Rate limiting is no longer just a protective measure—it's a design tool for resilience and fairness. Whether you're building financial apps, chat platforms, or mobile APIs, these concepts are crucial.

Use of Defer and Close in go

Sukma Rizki — Wed, 16 Jul 2025 04:34:35 +0000

Defer is used to terminate the execution of a statement just before the function block is completed. While Exit is used to forcefully stop the program(remember, stopping the program, unlike return which only stops a block of code)

Implementation keyword defer

As briefly explained above, defer is used to delay the execution of a line of code within the scope of a function block. When the execution of the block is almost complete, the deferred statement is executed. Defer can be placed anywhere, the beginning or the end of the block. But it does not affect when it is executed, it will always be executed at the end.

 package main
 import "fmt"
 func main() {
 defer fmt.Println("halo")
 }
    fmt.Println("selamat datang")

The keyword defer above will terminate the execution of in effect the message
fmt.Println("hello"),
"hello" will appear after
"welcome".
The deferred statement will still appear even if the code block is dismissed midway using return. For example, as in the following code.

Certified Cyber

Sukma Rizki — Wed, 04 Jun 2025 04:31:01 +0000

https://pauljerimy.com/security-certification-roadmap/

Main difference between struct and class.

Sukma Rizki — Sun, 04 May 2025 07:33:32 +0000

The main difference between structs and classes in Swift lies in the way they store and manage data (value type vs. reference type), as well as additional features that only classes have.

Here are the main differences:
1.Type: value Type vs Reference Type
Comparison: swift

Data Storage value type(independent copy) Example: var a1 = b1 creates a new copy

class
Reference Type (Reference to the same object)
var a1 = b1 (pointing to the same object )

Example Value Type (struct):

struct Person {
    var name: String
}

var person1 = Person(name: "Andry")
var person2 = person1
person2.name = "Budi"

print(person1.name) // Andry
print(person2.name) // Budi

Example Reference Type (class):

class Person {
    var name: String
    init(name: String) {
        self.name = name
    }
}

var person1 = Person(name: "Andry")
var person2 = person1
person2.name = "Budi"

print(person1.name) // Budi
print(person2.name) // Budi

2.Inheritance
struct : does not support inheritance
class : support inheritance

Example:

class Animal {
    var name: String = "Unknown"
}

class Dog: Animal {
    var breed: String = "Bulldog"
}

3.Deinitializers
struct : no deinit.
class : has deinit for cleanup when the object is removed from memory.

class MyClass {
    deinit {
        print("Object is being deallocated")
    }
}

4.Mutability (Data Changes)
struct: requires the mutating keyword to change properties from within the method.
class: bebas mengubah properti tanpa keyword tambahan.

struct Counter {
    var count = 0

    mutating func increment() {
        count += 1
    }
}

If you're building a Swift/iOS app, most data models can simply use structs. But for UI components and complex logic with inheritance, classes are more appropriate.

Observer Pattern

Sukma Rizki — Sat, 01 Feb 2025 09:01:58 +0000

The Observer Pattern is a behavioral design pattern that defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. This pattern is particularly useful for implementing distributed event-handling systems.

Purpose

Establish a one-to-Many dependency between objects.
Automatically notify and update dependents when the state of the subjet changes

Structure

Subject : Maintains a list of observers and provides methods to attach and detach observers.
Observer : Defines an updating interfaces for objects that should be notified of changes in the subject
Concrete Subject: Implements the subject interface and maintains state tha interest the observers.
Concurete Observer : Implements the observer interface and keeps a reference to a concrete subject.

Implementation in Dart or Flutter Framework

Let create an Example:

Explanation

Observer Interface: NewsSubscriber defines an interface for updating objects.
Subject: NewsPublisher maintains a list of subscribers and notifies them of any changes.
Concrete Observer: ConcreteNewsSubscriber implements the observer interface and updates its state when notified.
Client: The main function subscribes observers to the publisher and triggers notifications.

Use Case

Event Handling: When a change in one object requires others to be notified and updated.
Data Binding: In GUI components where changes in the model should reflect in the view.
Logging: When multiple logging objects need to be notified of an event.

Benefits

Loose Coupling: Observers are loosely coupled to the subject, allowing for easier maintenance and scalability.
Dynamic Relationships: Observers can be added or removed at runtime.

Drawbacks

Memory Leaks: If observers are not properly removed, it can lead to memory leaks.
Unpredictable Behavior: Notifications can cause unpredictable behavior if not managed carefully.
The Observer Pattern is quite powerful for creating systems where changes in one part need to be reflected in others. Let me know if you need more details or want to explore another design pattern!

Stay Connected with Me!
Hey there! If you’ve enjoyed my content, let’s stay connected across multiple platforms. Follow me to stay updated with the latest insights, tips, and discussions.

Builder Pattern-Pattern

Sukma Rizki — Sat, 01 Feb 2025 07:37:31 +0000

The Builder Pattern is a creational design pattern that allows for the step-by-step creation of complex objects. It separates the construction of an object from its representation, enabling the same construction process to create various representations.
Purpose
Construct a complex object step by step.
Separate the construction process from the actual representation.
Structure
Builder Interface: Specifies the abstract steps for creating a product.
Concrete Builder: Implements the builder interface to create specific parts of the product.
Product: The complex object that is being built.
Director: Controls the building process.
Example: Custom Card Builder
We’ll create a CustomCard widget using the Builder Pattern.

Explanation
Adaptee: SquarePeg is the existing class that we want to adapt.
Target: RoundHole is the interface that SquarePeg needs to adapt to.
Adapter: SquarePegAdapter converts the SquarePeg interface to RoundHole.
Use Case
In this example, we are adapting a SquarePeg to fit into a RoundHole using an adapter that converts the width of the square peg to the radius of the round hole. This allows us to determine if the square peg can fit into the round hole.

The Adapter Pattern is quite helpful when you need to integrate classes that have incompatible interfaces but you want them to work together seamlessly.

Singleton Pattern

Sukma Rizki — Fri, 31 Jan 2025 08:42:36 +0000

1.Purpose
The Singleton Pattern is a creational design pattern that ensures a class has only one instance and provides a global point of acces to that instance.it's commonly used managing shared resources like configuration settings, logging, or network connections.

Core Concepts

Single Instance: The class ensures that only one instance of itself is created.
Global Access: Provides a global access point to this instance, allowing it to be accessed from anywhere in the application.

Benefits

Controlled Access : Ensures tha a class has only one instance, controlling acces to shared resources.
Memory Efficiency: Reduces memory consumption by reusing the same instance.
Global State : Maintains a global state that can be accessed from anywhere. Let'go to Example Code.

Define the Singleton Class

Use The Singleton in App

However, it’s important to use Singleton Pattern judiciously as overuse can lead to issues with testing and can cause hidden dependencies.

You may provide additional references to make this writing more perfect.
Enjoy the Coding. Enjoy the Process

Flutter Design Pattern Bussines Logic Component (BLOC)

Sukma Rizki — Sat, 11 Jan 2025 06:17:05 +0000

BLoC (Business Logic Component) Design Pattern
Purpose: The BLoC (Business Logic Component) design pattern is used to separate business logic from the UI in Flutter applications, making the code more maintainable and testable. It utilizes streams to manage state and makes the app reactive.

Core Concepts:

Events: Inputs to the BLoC that represent actions or triggers, such as button clicks or user inputs.
States: Outputs from the BLoC that represent the current state of the application or UI.
Streams: Used to manage the flow of data. Events are added to a stream, processed by the BLoC, and result in new states emitted through another stream.
Benefits:
Separation of Concerns: Keeps business logic separate from UI code.
Reusability: Business logic can be reused across different parts of the application.
Testability: Business logic can be tested independently of the UI.
Reactive Programming: Makes the app responsive and able to handle asynchronous data streams.
Example Code:
Let’s create a simple counter app using the BLoC pattern.

Step 1: Define Events

Step 2: Define States

Step 3: Create the BLoC

Step 4: Connect BLoC to UI

This example demonstrates a simple counter application where the BLoC pattern is used to manage the state. The CounterBloc listens for Increment and Decrement events and updates the counter state accordingly. The UI subscribes to the state stream and updates the display when the state changes.

Design Pattern in Flutter MVVM

Sukma Rizki — Wed, 08 Jan 2025 06:51:12 +0000

Purpose: The MVVM (Model-View-ViewModel) pattern is used to separate the UI (View) from the business logic and data (Model) in Flutter applications. This separation improves code maintainability, testability, and scalability.
Core Concepts:

Model: Represents the data and business logic.
View: Displays the data and listens to user interactions.
ViewModel: Acts as a mediator between the View and the Model. It handles the presentation logic and exposes data to the View.
Benefits:
Separation of Concerns: Keeps the UI code separate from the business logic.
Testability: Makes it easier to test the business logic and UI separately.
Maintainability: Simplifies the codebase and makes it easier to maintain.
Example Code:
Let’s create a simple counter app using the MVVM pattern.

Step 1: Create the Model


// models/counter_model.dart
class CounterModel {
  int counter;

  CounterModel({this.counter = 0});
}

Step 2: Create the ViewModel

// viewmodels/counter_view_model.dart
import 'package:flutter/material.dart';
import '../models/counter_model.dart';

class CounterViewModel extends ChangeNotifier {
  CounterModel _counterModel = CounterModel();

  int get counter => _counterModel.counter;

  void increment() {
    _counterModel.counter++;
    notifyListeners();
  }

  void decrement() {
    _counterModel.counter--;
    notifyListeners();
  }
}

Step 3: Provide the ViewModel
Wrap your main app widget with a ChangeNotifierProvider:

// main.dart
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'viewmodels/counter_view_model.dart';
import 'views/counter_page.dart';

void main() {
  runApp(
    ChangeNotifierProvider(
      create: (context) => CounterViewModel(),
      child: MyApp(),
    ),
  );
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: CounterPage(),
    );
  }
}

Step 4: Create the View
Use the Consumer widget to listen to changes and rebuild the UI:

// views/counter_page.dart
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../viewmodels/counter_view_model.dart';

class CounterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('MVVM Counter'),
      ),
      body: Center(
        child: Consumer<CounterViewModel>(
          builder: (context, counterViewModel, child) {
            return Text(
              'Counter: ${counterViewModel.counter}',
              style: TextStyle(fontSize: 24),
            );
          },
        ),
      ),
      floatingActionButton: Column(
        mainAxisAlignment: MainAxisAlignment.end,
        children: [
          FloatingActionButton(
            onPressed: () => context.read<CounterViewModel>().increment(),
            child: Icon(Icons.add),
          ),
          SizedBox(height: 8),
          FloatingActionButton(
            onPressed: () => context.read<CounterViewModel>().decrement(),
            child: Icon(Icons.remove),
          ),
        ],
      ),
    );
  }
}

In this example, the CounterModel class holds the data. The CounterViewModel class acts as a mediator between the model and the UI, handling the presentation logic. The CounterPage widget is the View, which uses the CounterViewModel to display and interact with the counter data.

By using the MVVM pattern, we achieve a clean separation of concerns, making our code more maintainable and testable.

Interesting Control Flow in the circle

Sukma Rizki — Wed, 28 Aug 2024 16:46:41 +0000

in Go (Golang), control flow is managed using several fundamental constructs, including conditionals (if, else), loops (for), and switch statements. Here's an overview of how these constructs work in Go:

Conditionals: if, else, else if In Go, if statements are used to execute code based on a condition. Unlike some other languages, Go doesn't require parentheses around the condition. However, the curly braces {} are mandatory.

Basic Statement

package main

import "fmt"

func main() {
    age := 20

    if age >= 18 {
        fmt.Println("You are an adult.")
    }
}

'if-else statement' Example
`package main

import "fmt"

func main() {
age := 16

if age >= 18 {
    fmt.Println("You are an adult.")
} else {
    fmt.Println("You are not an adult.")
}

}
`
'if-else if-else' Statement:

package main

import "fmt"

func main() {
    age := 20

    if age >= 21 {
        fmt.Println("You can drink alcohol.")
    } else if age >= 18 {
        fmt.Println("You are an adult, but cannot drink alcohol.")
    } else {
        fmt.Println("You are not an adult.")
    }
}

2.Loops: for
Go uses the 'for' loop for all looping needs; it does not have a 'while' or loop
basic 'for' loop:

package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
}

'for' as a 'while' loop:

package main

import "fmt"

func main() {
    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }
}

Infinite Loop:

package main

func main() {
    for {
        // This loop will run forever
    }
}

'for' loop with 'range':
This is often used to iterate over slices,arrays,maps or strings.

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}

    for index, value := range numbers {
        fmt.Println("Index:", index, "Value:", value)
    }
}

Switch Statement Go The 'Switch' statement in Go is used to select one of many code blocks to be executed.Go 'switch'is more powerful than in some other languages and can be used with any type of value, not just integers.

Basic 'switch'

package main

import "fmt"

func main() {
    day := "Monday"

    switch day {
    case "Monday":
        fmt.Println("Start of the work week.")
    case "Friday":
        fmt.Println("End of the work week.")
    default:
        fmt.Println("Midweek.")
    }
}

Switch with multiple expressions in a case:

package main

import "fmt"

func main() {
    day := "Saturday"

    switch day {
    case "Saturday", "Sunday":
        fmt.Println("Weekend!")
    default:
        fmt.Println("Weekday.")
    }
}

A switch with no expression acts like a chain of if-else statements.

package main

import "fmt"

func main() {
    age := 18

    switch {
    case age < 18:
        fmt.Println("Underage")
    case age >= 18 && age < 21:
        fmt.Println("Young adult")
    default:
        fmt.Println("Adult")
    }
}

Defer, panic and recover

package main

import "fmt"

func main() {
    defer fmt.Println("This is deferred and will run at the end.")
    fmt.Println("This will run first.")
}

Panic And Recover

package main

import "fmt"

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()

    fmt.Println("About to panic!")
    panic("Something went wrong.")
}

Query a database Using Go

Sukma Rizki — Thu, 15 Aug 2024 17:30:22 +0000

Step 1: Install the MySQL driver
First, you'll need to install a MySQL driver for Go. A popular one is go-sql-driver/mysql. You can install it using:

go get -u github.com/go-sql-driver/mysql

Step 2: Write the Go code
Here’s an example of how you can connect to a MySQL database and query data:

package main

import (
    "database/sql"
    "fmt"
    "log"

    _ "github.com/go-sql-driver/mysql"
)

func main() {
    // Open the database connection
    db, err := sql.Open("mysql", "username:password@tcp(127.0.0.1:3306)/dbname")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // Ping the database to check if the connection is alive
    if err := db.Ping(); err != nil {
        log.Fatal(err)
    }

    // Define the query
    query := "SELECT id, name FROM users WHERE active = ?"
    active := true

    // Execute the query
    rows, err := db.Query(query, active)
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    // Iterate through the result set
    for rows.Next() {
        var id int
        var name string
        if err := rows.Scan(&id, &name); err != nil {
            log.Fatal(err)
        }
        fmt.Printf("ID: %d, Name: %s\n", id, name)
    }

    // Check for errors from iterating over rows
    if err := rows.Err(); err != nil {
        log.Fatal(err)
    }
}

Explanation:
Import necessary packages: You import the database/sql package for database interactions and the MySQL driver (github.com/go-sql-driver/mysql).

Open the database connection: You open a connection to the database using sql.Open. The connection string format is username:password@tcp(host:port)/dbname.

Ping the database: It’s a good practice to ping the database to ensure that the connection is established.

Execute the query: You execute a query using db.Query. The Query method returns a *sql.Rows object, which you can iterate over to get the result set.

Iterate through the results: You use a loop to iterate through the rows and Scan each row into variables.

Handle errors: You should handle any errors that occur during the execution of the query or during iteration.

Step 3: Run your code
Make sure to replace username, password, 127.0.0.1:3306, and dbname with your actual MySQL credentials and database details.

Run your Go program, and it should output the results of your query.

This example can be adapted for other databases by changing the driver and connection string accordingly.