Forem: Possawat Sanorkam

Microservices are Technical Debt

Possawat Sanorkam — Sun, 22 Sep 2024 16:55:15 +0000

The video is a discussion about microservices trade-offs and I just generated a summary with AI.

Summary

Microservices can create technical debt, leading to distributed monoliths. It’s crucial to balance speed and architecture in software development.

Highlights

🚀 Microservices vs. Monoliths: Transitioning from a monolithic architecture to microservices can enhance team agility.
🔄 Independent Deployments: Microservices allow for independent deployment, reducing conflicts among teams.
⚖️ Scaling Challenges: As teams grow, scaling a monolith can become problematic, prompting the need for microservices.
💡 Technical Debt: Microservices can initially speed up development but may lead to long-term maintenance challenges.
🛠️ Sociotechnical Problems: The interplay between technology and team dynamics complicates microservices adoption.
📊 Quality of Assertions: Test coverage metrics can be misleading; quality assertions matter more than quantity.
🤖 Need for New Frameworks: The industry should develop alternatives to monolith and microservices to better suit evolving software needs.

Key Insights

🔍 Understanding Microservices: While microservices can improve speed, they often introduce complexities that require careful management. Teams must ensure they’re not just replicating existing monolith issues in a distributed form.
🛡️ Technical Debt Awareness: Acknowledging that microservices are, in part, technical debt helps teams prioritize long-term sustainability alongside immediate needs.
🔗 Interdependencies: As microservices proliferate, managing interdependencies becomes critical. Teams should strive for a balance between independence and necessary communication.
🧠 Philosophy in Development: Developers often adhere to dogmatic principles that may not suit their specific context. Flexibility and a focus on practical solutions are essential.
⚙️ Tooling Matters: Effective tools can mitigate the challenges of microservices; companies should invest in developing or adopting tools that simplify error tracing and performance monitoring.
🎯 Focus on User Needs: Ultimately, software should serve user needs effectively, regardless of the underlying architecture. Prioritizing user experience over technical perfection is vital.
🏗️ Future of Software Architecture: The industry should explore new frameworks that bridge the gap between monoliths and microservices, fostering more efficient development practices.

Code and Chill Guide 2023

Possawat Sanorkam — Sat, 22 Jul 2023 09:50:21 +0000

Banner from Linda Nguyen on Unsplash

For the sake of productivity and to record my progress of how I use tools to write code and maintain my projects. These are the steps or checklist for me to follow every time I got a new laptop.

Buy more monitors

Definitely, you should have at least 2 monitors. Switching between code and docs and other communication tools (ms team, LINE, etc.) would be too frustrating believe me.

Set up the terminal

For me, I think the new Macbook Air will always be my first suggestion for the laptop to buy. It is productive to use most of the time.

With a good terminal, you can work 2-4 times faster. This will save time and reduced your errors. You can also use fuck (just like how you swear most of the time) to correct errors easily.

Use the tools that suits you

Personally, it is great to code with VScode with extensions installed. You can actually use profiles with VScode to help you personalize your style.

However, the project indexing in Python is quite disappointing. I prefer using PyCharm from JetBrains for most stuff related to python.

In case you have high wpm typing speed, you can try neovim. This will take practices and once you are comfortable with this. You can work 2-3 times faster than average IDE users. It will rely on both typing speed and accuracy also to maximize the potential.

Manage your browser tabs

Recently, Apple announced the new features for the upcoming macOS. Well, it is also available in Google Chrome already. You can try to use it also. For me, I use it to group tabs from Github, Gitlab, and my jira projects.

Listen to music

Get a playlist of your taste and listen to them while you code. It does not make you work faster, but it is good for your mental health and it is fun!

To stay focus, try white noise and set the volume to where you feel relaxed.

Rest

Yup, just rest. Maintaining your work-life balance is the chill part. Eventually, you will spend less time than most people on average and still get your job done.

Please follow me, bookmark this, give this a like and share it to those who are not chilled or not coding. Thank you guys!

How to manage VSCode extensions?

Possawat Sanorkam — Thu, 09 Mar 2023 07:59:13 +0000

The new update from VSCode is Profiles system.

From the doc, you can see that you can share your profiles by exporting it.

That means, we can quickly set up the VSCode for any dev from a gist or file.

So, every collaborator will share the same environment and you can work together with the same tools. Possibly, you can add more extensions on your behalf and keep working also.

Generating TypeScript APIs with OpenAPI Generator and Keeping Attribute Names Unchanged

Possawat Sanorkam — Thu, 12 Jan 2023 14:56:29 +0000

To generate the API in TypeScript with the attribute name's first letter not capitalized, you can use the --model-name-prefix option in the openapi-generator-cli command. This will allow you to specify a prefix that will be added to the beginning of all generated model names. For example:

openapi-generator-cli generate -i /path/to/spec.yaml -g typescript-fetch -o /output/directory --model-name-prefix=''

This will generate the TypeScript API in the specified output directory, and the attribute names in the generated models will have the first letter not capitalized.

Effective End-to-End Testing: A Beginner's Guide to Playwright

Possawat Sanorkam — Wed, 11 Jan 2023 08:46:47 +0000

Introduction

We can ensure the reliability and functionality of a deployed service using health check and smoke tests.

Health Check

Health check is used to verify that all endpoints of a deployed service are accessible and return the expected status code of 200 (OK).

To implement health check tests using Playwright, you can create a script that sends requests to each endpoint of your service and asserts that the response has a status code of 200.

Smoke test

Smoke tests, on the other hand, cover all endpoints as well but with more extensive assertions.

Fun fact: In plumbling, smoke testing is just another tool used to find leaks or sources of odor in pipes and sewage systems. It is not actually smoke, but the same type substance that comes out of fog machines. It is used to detect sewer gas leaks caused by broken pipes, bad connections, venting issues, open pipes or fittings

To implement smoke tests using Playwright, you can create a script that sends requests to each endpoint of your service and asserts that the response has the expected status code, body and error message

Health check example

const { playwright } = require('playwright');

(async () => {
    // Start a browser
    const browser = await playwright.chromium.launch();

    // Create a new context (page)
    const context = await browser.newContext();

    // Create a new page
    const page = await context.newPage();

    // Define the endpoint URLs that you want to test
    const endpoints = [
        'https://example.com/api/users',
        'https://example.com/api/orders',
        'https://example.com/api/products',
    ];

    for (const endpoint of endpoints) {
        // Send a GET request to each endpoint
        const response = await page.goto(endpoint);

        // Assert that the status code is 200
        for (const endpoint of endpoints) {
        // Send a GET request to each endpoint
        const response = await page.goto(endpoint);

        // Assert that the status code is 200
        expect(code).toBe(200)
        }

    }

    // Close the browser
    await browser.close();
})();

Smoke test example

const { playwright } = require('playwright');
const assert = require('assert');

(async () => {
    // Start a browser
    const browser = await playwright.chromium.launch();

    // Create a new context (page)
    const context = await browser.newContext();

    // Create a new page
    const page = await context.newPage();

    // Define the endpoint URLs that you want to test
    const endpoints = [
        { url: 'https://example.com/api/users', expectedStatusCode: 200, expectedBody: { id: 1, name: "user1" } },
        { url: 'https://example.com/api/orders', expectedStatusCode: 200, expectedBody: { id: 1, name: "order1" } },
        { url: 'https://example.com/api/products', expectedStatusCode: 404, expectedBody: { message: "product not found" } },
    ];

    for (const endpoint of endpoints) {
        // Send a GET request to each endpoint
        const response = await page.goto(endpoint.url);

        // Assert that the status code is as expected
        assert.strictEqual(response.status(), endpoint.expectedStatusCode);

        // Assert that the response body is as expected
        const responseBody = await page.evaluate(() => JSON.parse(document.body.textContent));
        assert.deepEqual(responseBody, endpoint.expectedBody);
    }

    // Close the browser
    await browser.close();
})();

Surprise! This article is written by ChatGPT!

What diagram should I know as a software engineer? Part 2

Possawat Sanorkam — Tue, 03 Jan 2023 07:42:33 +0000

Here are a few types of diagrams that are commonly used in software development management:

Gantt charts

Gantt Chart: Definition, Benefits, and How It’s Used

A Gantt chart is a visual representation of a project schedule, showing the start and finish date of several elements of a project.

investopedia.com

Gantt charts are used to visually represent the timeline and dependencies of tasks in a project. They can be used to track progress, identify bottlenecks, and plan resources.

Kanban boards

What Is a Kanban Board? A Comprehensive Guide

Uncover the power of Kanban boards to visualize, manage, and optimize your workflow. This comprehensive guide will empower you to create effective Kanban boards, track progress, and achieve peak productivity.

businessmap.io

Kanban boards are used to visualize the workflow of a project and the status of tasks. They can be used to track the movement of tasks through different stages of development and to identify bottlenecks in the process.

Project roadmap

Project Roadmap: What Is It & How To Create One To Manage Stakeholder Expectations?

A project roadmap is a high-level, visual overview of a project that helps kick off a project and manage stakeholder expectations. Learn how to create one.

toggl.com

A project roadmap is a high-level visual representation of the goals, milestones, and deliverables of a project. It can be used to communicate the overall direction and progress of a project to stakeholders.

Swimlane diagrams

mindmanager.com

Swimlane diagrams show the flow of tasks or activities within a project, often used to model the workflow of a project and to identify bottlenecks or inefficiencies.

Value stream maps

Value stream maps show the flow of value through a process, often used to identify and eliminate waste in a process and to improve efficiency.

Surprise! This article is written by ChatGPT! I added some useful links to further read more about these diagrams.

Optimizing Go code with GCCGO for improved performance

Possawat Sanorkam — Thu, 29 Dec 2022 16:24:22 +0000

One day, my teacher asked me why Go compiled program has terrible perfomance and he kept mentioning about how a good compiler should behave.

Tldr; Check out my demo!

It is using gccgo -O3 -o cool main.go instead of go build main.go.

Basically, you will find that some code could run faster by changing the compiler instead of rewriting the code.

So, we want to turn our code into its peak performance despite getting bugs.

Consider the following code...

package main

import (
    "errors"
    "fmt"
)

const limA = 2000

type EulerSolution struct {
    first   int
    second  int
    third   int
    fourth  int
    culprit int
}

func intPow(n, m int) int {
    if m == 0 {
        return 1
    }
    result := n
    for i := 2; i <= m; i++ {
        result *= n
    }
    return result
}

func computeEuler() (EulerSolution, error) {
    for e := 1; e < limA; e++ {
        for a := 1; a < e; a++ {
            var a5 = intPow(a, 5)
            for b := 1; b <= a; b++ {
                var b5 = intPow(b, 5)
                for c := 1; c < b; c++ {
                    var c5 = intPow(c, 5)
                    for d := 1; d < c; d++ {
                        var d5 = intPow(d, 5)
                        var e5 = intPow(e, 5)
                        var got int = a5 + b5 + c5 + d5

                        if got == e5 {
                            return EulerSolution{
                                first:   a,
                                second:  b,
                                third:   c,
                                fourth:  d,
                                culprit: e,
                            }, nil
                        }

                    }
                }
            }
        }
    }

    return EulerSolution{}, errors.New("Euler solution")
}

We know that this code is poorly written. Let's write the another function that produce similar result.

func computeBeastEuler() (EulerSolution, error) {
    for e := 1; e < limA; e++ {
        var e5 = intPow(e, 5)
        for a := 1; a < e; a++ {
            var a5 = intPow(a, 5)
            for b := 1; b <= a; b++ {
                var b5 = intPow(b, 5)
                for c := 1; c < b; c++ {
                    var c5 = intPow(c, 5)
                    for d := 1; d < c; d++ {
                        var d5 = intPow(d, 5)
                        var got int = a5 + b5 + c5 + d5
                        if got == e5 {
                            return EulerSolution{
                                first:   a,
                                second:  b,
                                third:   c,
                                fourth:  d,
                                culprit: e,
                            }, nil
                        }

                    }
                }
            }
        }
    }

    return EulerSolution{}, errors.New("Euler solution")
}

Much better, now we want to prove that the new function, computeBeastEuler, is faster.

go test -bench main_test.go -v

=== RUN   Test_computeEuler
=== RUN   Test_computeEuler/empty
--- PASS: Test_computeEuler (4.19s)
    --- PASS: Test_computeEuler/empty (4.19s)
=== RUN   Test_computeBeastEuler
=== RUN   Test_computeBeastEuler/empty
--- PASS: Test_computeBeastEuler (2.51s)
    --- PASS: Test_computeBeastEuler/empty (2.51s)
PASS
ok      go-beast-demo   6.705s

It is better, and we expect our go build to do the optimization for us.

go build main.go
time ./main 
{133 110 84 27 144}

real    0m4.371s
...

Well, it is not what we expected. The problem is that Go compiler is not focusing on optimization by default. It only focuses on compilation speed.

Now, let me talk about another compiler that will help us get the faster program using the same code.

Let's install gccgo to our machine. Make sure that you are not using Darwin OS!

git clone --branch devel/gccgo git://gcc.gnu.org/git/gcc.git gccgo
mkdir objdir
cd objdir
../gccgo/configure --prefix=/opt/gccgo --enable-languages=c,c++,go --with-ld=/opt/gold/bin/ld
make
make install

References:
gccgo

Anyway, you might run into some problems with its prerequisites for the compiler.

cd gccgo
./contrib/download_prerequisites

The script will download all you need for the gccgo.

Instead, we can just use a dockerfile to help us set up the environment for our new compiler.

# Download base image ubuntu 20.04
FROM ubuntu:20.04

# Disable Prompt During Packages Installation
ARG DEBIAN_FRONTEND=noninteractive

# Update Ubuntu Software repository
RUN apt update

RUN apt-get update -y

RUN apt-get install -y gccgo

WORKDIR /go/app

COPY . .

RUN gccgo -O3 -o cool main.go

CMD ["./cool"]

References:
gcc optimize

Inside the container, let's do the benchmarking again!

docker compose build
docker run -it go-beast-mode_app bash

Inside my container, here is what I got.

time ./cool
{133 110 84 27 144}

real    0m0.906s
user    0m0.583s
sys     0m0.028s

It is even 2x faster than our computeBeastEuler in time.

In fact, Go can compile blazingly fast, but the trade-off is the lost of performance. If we want to optimize our Go program, then this is an example of what you could try. It will be compiled slower, but the performance is greatly increased along with the slight increase in memory usage.

What diagram should I know as a software engineer?

Possawat Sanorkam — Wed, 28 Dec 2022 18:10:04 +0000

Prerequisite

As a software engineer, it's important to be familiar with a variety of diagrams and notations that are used to design, model, and document software systems. Some common types of diagrams that you may encounter include:

Class diagrams

How to turn your golang programs into UML Class diagrams

jfeliu007 ・ Jul 9 '19

#go #uml

Class diagrams are used to model the static structure of a system, showing the relationships between classes, interfaces, and other objects.

Component diagrams

Component diagrams show the relationships between the components of a system, often used to model the structure of a software system.

Object diagrams

Object diagrams show the relationships between objects in a system, often used to model the static structure of a system at a specific point in time.

Communication diagrams

Communication diagrams show the interactions between objects or components in a system, often used to model the communication between objects in a system.

Sequence diagrams

Sequence diagrams are so powerful

Richard Kovacs ・ Apr 10 '22

#design #productivity #programming

Sequence diagrams show the interactions between objects or components in a system, showing the order in which messages are sent and received.

State diagrams

State Machine Diagrams | Unified Modeling Language (UML) - GeeksforGeeks

Your All-in-One Learning Portal: GeeksforGeeks is a comprehensive educational platform that empowers learners across domains-spanning computer science and programming, school education, upskilling, commerce, software tools, competitive exams, and more.

geeksforgeeks.org

State diagrams show the possible states of a system and the transitions between those states, often used to model the behavior of a system.

Activity diagrams

Activity diagrams show the flow of activities or actions within a system, often used to model business processes or workflows.

Use case diagrams

Use Case Diagram for Online Banking System - GeeksforGeeks

geeksforgeeks.org

Use case diagrams show the interactions between a system and its users, showing the different ways that a system can be used.

Deployment diagrams

Deployment diagrams show the physical components of a system and how they are deployed on hardware, often used to model the architecture of a distributed system.

Data flow diagrams

What is DFD (Data Flow Diagram) - GeeksforGeeks

geeksforgeeks.org

Data flow diagrams show the flow of data within a system, showing the input, output, and processing of data.

Entity relationship diagrams

Introduction of ER Model - GeeksforGeeks

geeksforgeeks.org

Entity relationship diagrams show the relationships between entities in a database, used to model the structure of a database.

Collaboration diagrams

Collaboration diagrams show the interactions between objects or components in a system, often used to model the dynamic behavior of a system.

Network diagrams

smartdraw.com

Network diagrams show the connections between devices on a network, often used to model the topology of a network.

Interaction overview diagrams

Interaction overview diagrams show the flow of messages between objects or components in a system, often used to model the overall flow of interactions in a system.

Timing diagrams

Timing diagrams show the behavior of a system over time, often used to model the timing and duration of events in a system.

Object constraint language (OCL) diagrams

OCL diagrams use a specialized notation to describe constraints on the behavior of a system, often used to specify the behavior of a system in more detail. It is an advanced concept, so here is the lecture note.

Graphical user interface (GUI) diagrams

Graphical user interface (GUI) diagrams are visual representations of the user interface (UI) of a software application or system. GUI diagrams show how the UI is organized and how it interacts with the user. These diagrams can be used to design and document the UI of a software application, and they can also be helpful for understanding and navigating an existing UI.

GUI diagrams typically include elements such as windows, dialog boxes, buttons, menus, and other interactive elements that are used to interact with the software. They may also include representations of data and other information that is displayed to the user. GUI diagrams are often created using specialized diagramming tools, and they may be included in software design documents or used as part of the development process.

Surprise! This article is written by ChatGPT! I added some useful links to further read more about these diagrams.

Using Git to track down deleted code in a large project

Possawat Sanorkam — Mon, 19 Dec 2022 05:47:20 +0000

My code is now deleted in file A around line 800, and I do not know when it was deleted. How to find the person who deleted my code from git?

TLDR;

# Search from line
git blame -L 800,800 A

# Search from text
git log -S "CODE_TO_SEARCH" A

To find out who deleted code from a file using git, you can use the git blame command. This command shows the last commit that modified each line of code in a file, along with the author and date of the commit.

To see the commit that deleted a specific line of code, you can use the git blame command with the -L option, which allows you to specify a range of lines. For example, to see the commit that deleted code around line 800 in file A, you can use the following command:

git blame -L 800,800 A

This will show the commit that modified line 800 in file A, along with the author and date of the commit. ~~If the code was deleted in this commit, it will also show the line of code that was deleted.~~

@hrnkas Git does not show deleted lines when using blame. It only shows information for remaining lines, and that is the commit information when those line have last been changed.

You can also use the git log command with the -S option to search the commit history for a specific string of code. This can be helpful if you don't know the exact line number where the code was deleted.

For example, to search for the commit that deleted a specific string of code from file A, you can use the following command:

git log -S "CODE_TO_SEARCH" A

@hrnkas Actually, the exact solution would be git log -S "CODE_TO_SEARCH" -c --cc A
You also need -c and --cc flags to show commits where search text has been deleted.

Replace CODE_TO_SEARCH with the string of code you want to search for. This will show a list of commits that include the specified code, along with the commit message and any other information about the commit.

Surprise, this article was generated by ChatGPT!

Git Rebase: The Power Tool for Clean Git Histories

Possawat Sanorkam — Sun, 18 Dec 2022 16:13:50 +0000

Here is an example of using git rebase to incorporate the latest changes from the master branch into a feature branch:

$ git checkout feature
# switch to the feature branch

$ git rebase master
# apply the commits from the feature branch on top of the latest commits in the master branch

# If there are conflicts during the rebase, you will need to resolve them
# and then use `git add` to mark the resolved files, and then use
# `git rebase --continue` to continue the rebase.

$ git push -f origin feature
# push the feature branch to the remote repository, using the -f flag to force the push
# (necessary because the commit history of the feature branch has been modified by the rebase)

Here is an example of using git rebase to "squash" multiple commits into a single commit:

$ git checkout feature
# switch to the feature branch

$ git rebase -i HEAD~3
# interactively rebase the last 3 commits

# This will open a text editor, showing the list of commits that will be modified by the rebase.
# You can use the `squash` command to merge commits together. For example:
#
# pick abcdefg Some commit message
# squash hijklmn Another commit message
# squash opqrstu Yet another commit message

# Save and close the editor. Git will then apply the changes and open another editor
# for you to modify the commit message of the combined commit.

$ git push -f origin feature
# push the feature branch to the remote repository, using the -f flag to force the push
# (necessary because the commit history of the feature branch has been modified by the rebase)

It's important to note that git rebase should be used with caution, as it modifies the existing commit history of a branch. This can make the commit history more difficult to understand and can cause problems if other people are working on the same branch.

Therefore, it's usually a good idea to use git merge instead of git rebase when working with other people.

Surprise, this article was generated by ChatGPT!

What are your New Year's resolutions?

Possawat Sanorkam — Sun, 18 Dec 2022 08:49:19 +0000

I will work towards becoming a senior developer by expanding my skills and knowledge in backend development through continuous learning and practice. I will also focus on building my professional network and seeking out opportunities for professional growth.

It's great to have goals and resolutions for the new year! Here are a few tips for setting and achieving your new year resolutions:

Make your resolutions specific and achievable: Instead of resolving to "exercise more," try setting a specific goal such as "exercise for 30 minutes at least three times a week."
Break your resolution down into smaller goals: If your resolution is a big one, it can be helpful to break it down into smaller, more manageable goals. This will make it easier to track your progress and stay motivated.
Create a plan: Think about the steps you need to take to achieve your resolution and make a plan to follow. For example, if your resolution is to exercise more, you might plan to join a gym or find an exercise class that you enjoy.
Monitor your progress: Keep track of your progress and celebrate your successes along the way. This will help you stay motivated and on track.
Be flexible: It's okay if you have setbacks or if things don't go exactly as planned. Just stay positive and adjust your plan as needed.

Remember, the key to achieving your new year resolutions is to be patient, persistent, and positive. With hard work and determination, you can achieve your goals!

Surprise, this article was generated by ChatGPT!

How to use Apache Kafka in GO using Echo framework?

Possawat Sanorkam — Thu, 15 Dec 2022 17:56:21 +0000

To set up Kafka in a Go application using the Echo web framework, you would first need to install the sarama package, which provides a Go client for Apache Kafka. You can do this using the go get command:

go get github.com/Shopify/sarama

Once the sarama package is installed, you can use it to connect to Kafka and publish and consume messages. Here is an example of how to set up a Kafka producer in a Go application using the Echo framework and the sarama package:

package main

import (
    "fmt"
    "time"

    "github.com/Shopify/sarama"
    "github.com/labstack/echo"
)

var (
    kafkaBrokers = []string{"localhost:9092"}
)

func main() {
    // Create a new Echo web server
    e := echo.New()

    // Set up a route to handle HTTP POST requests to the /messages endpoint
    e.POST("/messages", func(c echo.Context) error {
        // Read the message body from the request
        message := c.FormValue("message")

        // Create a new Kafka producer
        producer, err := sarama.NewSyncProducer(kafkaBrokers, nil)
        if err != nil {
            return err
        }
        defer producer.Close()

        // Publish the message to the "messages" topic
        msg := &sarama.ProducerMessage{
            Topic: "messages",
            Value: sarama.StringEncoder(message),
        }
        partition, offset, err := producer.SendMessage(msg)
        if err != nil {
            return err
        }

        // Return a response to the client
        return c.String(http.StatusOK, fmt.Sprintf("Message published to partition %d at offset %d", partition, offset))
    })

    // Start the Echo web server
    e.Start(":8080")
}

This Go application uses the Echo framework to handle HTTP POST requests to the /messages endpoint. When a request is received, the application reads the message body from the request and uses the sarama package to publish the message to the "messages" topic in Kafka.

Surprise, this article was generated by ChatGPT!