DEV Community: Abdul Ghofur

Machine Learning & Data Science

Abdul Ghofur — Wed, 15 Jan 2025 23:53:51 +0000

Mengenal dan membedakan Machine Learning, Data Science, Deep Learning dan Neural Networks

Original Version

https://abdulghofurme.github.io/posts/ml-ds-dl-nn/

Proses belajar kali ini cukup melelahkan.

Tentunya karena merupakan hal yang sangat baru & berbeda.
Banyak hal-hal,
istilah-istilah yang totally baru.

Berasa bodoh sekali diri ini.

Well, mari kita lanjut isi kekosongan ini, :)

Disclaimer

Mungkin terdapat perbedaan penggunaan terminology

Machine Learning & Data Science

Dari artikel sebelumnya kita telah mengetahui apa itu Machine Learning.

Sederhananya merupakan alat,
dalam hal ini mesin yang terus belajar dari data.
Memetakan input dan output sehingga didapatkan Supervised Learning,
untuk memprediksi output yang didapat dari sebuah input data sejenis.

Lantas apa perbedaannya dengan Data Science?

Dari sumber yang aku baca.
Sekali lagi, mungkin terdapat perbedaan penggunaan/pengertian terminology.

Keduanya ML & DS belajar, mengolah & mengambil kesimpulan dari sekumpulan data, yang kita sebut dengan dataset.

Perbedaanya ada di output atau hasil pengolahan data tersebut.

Sementara ML menghasilkan Supervised Learning untuk memprediksi output dari data input sejenis.
Maka, DS menghasilkan insight yang membantu pengambilan keputusan bisnis.
Selama ini kukira itu Data Analyst.

Deep Learning & Neural Network

Sama saja.
Pada dasarnya sama saja.

"Deap Learning" hanyalah nama lain yang dirasa "much better sounding brand" dari para penggiatnya.

Karena sebenarnya sama saja,
lantas sebenarnya apa itu DL atau Naural Network?

Neural Network terinspirasi dari otak manusia dalam memproses informasi.
Terdiri dari banyak neuron yang terhubung satu sama lain.

Dalam konteks Machine Learning,
ini merupakan "mathematical equation" yang mengolah data input untuk melakukan tugas pengenalan, klasifikasi & prediksi.

AI: I'll take your job

Abdul Ghofur — Thu, 09 Jan 2025 23:38:50 +0000

I was scared, so I learned it.

https://abdulghofurme.github.io/posts/ai-101/

ANI

Artificial Narrative Intelligence.

Merupakan AI yang dapat melakukan hal-hal seperti:

Smart speaker
Self driving car
Web search
dan lainnya.

Gen AI

Generative Artificial Intelligence.

Merupakan AI yang dapat melakukan hal-hal seperti:

ChatGPT
Midjourney
dan lainnya.

AGI

Artificial General Intelligence.

Merupakan AI yang dapat melakukan hal-hal yang sama dengan manusia.
Adalah tujuan dari AI.
Dan ini pula yang ditakutkan oleh manusia.
Namun, untuk saat ini, tujuan itu masih jauh dari tercapai.

Machine Learning

Merupakan teknik yang memungkinkan AI untuk belajar dari data.
Kebanyakan darinya belajar mapping dari input ke output,
A ke B.
Hingga kita dapatkan Supervised Learning.

Sebagai contoh, kita dapat membuat AI yang dapat mengenali gambar.
Kita hanya perlu memberikan data gambar, dan AI akan belajar untuk mengenalinya.

Dari hal ini, kita dapat menggunakannya pada:

Image classification
Object detection
dan lainnya.

Dengan hasil akhir, seperti:

Defect detection untuk pengujian kualitas produk di pabrik.
Face recognition.
Traffic sign recognition.
Self driving car.
dan lainnya.

LLM

Contoh sebelumnya,
adalah supervised learning yang belajar dari gambar.

Large Language Model.

Merupakan supervised learning yang belajar dari teks,
sehingga dapat memahami bahasa manusia.

Inilah yang kita kenal sebagai Gen AI,
dan digunakan pada ChatGPT, dan chatbot lainnya.

Juga digunakan pada IDE, text-editor lainnnya yang berbasis AI.
Yang idenya cukup sederhana,
yaitu "memprediksi kata selanjutnya yang mungkin akan kita tulis".

This will take my job 🥲.

Ingredient

Data
Processors

Well, karena AI belajar dari data,
maka data itu penting.

Semakin banyak semakin baik.

Selanjutnya, tentu tools yang dapat memproses data tersebut.

Tribute

Thanks @fahrulalwan for the motivation & sharing.

Book: Clean Code - Background

Abdul Ghofur — Sat, 28 Dec 2024 21:37:22 +0000

Tulisan ini diisi dari apa yang aku perhatikan,
suka & aku kira perlu aku catatan sepanjang membaca buku Clean Code.

Sebuah buku karya Robert Cecil Martin,
yang pertama rilis pada Agustus 2008.

Mungkin sangat jauh waktunya,
sudah lama sekali.
Aku membacanya di era AI sudah meraja lela,
dan banyak rumor tersebar Programmer akan digantikan AI.

Terlepas dari itu,
buku ini sangat menyenangkan untuk dibaca.
Meskipun baca buku ini harus siap handphone,
mengingat sesekali menemukan kata, kalimat yang asing.

Kenapa Clean Code penting

Pada chapter 1 buku,
kita disuguhkan berbagai alasan kenapa Clean Code itu penting.

Salah satu cerita yang membekas

Pada akhir tahun 80an,
sebuah perusahaan membuat aplikasi yang singkatnya sangat popular.
Namun seiring waktu, release demi relase.
Bug tidak diperbaiki, load time & crash semakin meningkat.
Akhirnya persusahaan pun gulung tikar.

Dua dekade setelahnya penulis bertemu & bertanya pada salah satu pegawainya.
Singkatnya, mereka terburu-buru untuk segera release product,
dan berakhir pada kode yang berantakan.

Seiring feature bertambah,
bertambah buruk pula kode yang ada.
Sampai pada titik kode itu tidak sapat di-manage lagi.

It was the bad code that brought the company down

Buku ini ngena banget sih,

Terburu-buru
Merasa tidak punya waktu untuk melakukannya dengan baik
Merasa mungkin bos akan merasa marah bila kita butuh waktu lebih
Mungkin juga memang sudah lelah saja dengan kodenya dan ingin segera selesai, sudah terlalu berantakan, entah dari legacy atau bahkan kita sendiri, :D
Atau mungkin tidak fokus karena module-module lain yang sudah dekat deadline-nya, akhirnya yaudah diburu-buru semua

Akhirnya yasudah,
terlepas dari berantakan itu kode,
kita memutuskan untuk membiarkannya untuk rafactor lain waktu.

working mess is better than nothing

Celakanya "lain waktu" itu tak pernah datang

LeBlanc's law: Later equals never

Harga yang harus dibayar

Pernahlah kerja kita lebih lambat dikarenakan kode yang berantakan,
baik dari kode orang lain, ataupun kode kita yang kemarin-kemarin.
Well, entah itu kode siapa, we have to deal with it.
Kita harus sepakat itu "kode kita" sekarang.

Semakin lama, semakin parah.
Feature yang seharusnya selasai dalam 1 sprint,
kini melebar menjadi beberapa sprint.

Bukan dari scope feature,
melainkan dari kode kita yang berantakan.
Karena pada akhirnya kita harus mondar-mandir baca kodenya,
scroll atas, scroll bawa, buka file/module lain,
mondar-mandir untuk memahamai semua kekacauan itu.

Feature terlambat release,
tidak achieve, akhirnya semakin buruk dan buruk.

Solusi??

Lelah terbenam dalam kode yang berantakan,
akhirnya muncullah usulan redesign,
untuk membuat ulang semuanya dengan code base baru,
architecture baru, mungkin juga tech stack baru.

Kemungkinan management akan menolak.
Masih banyak feature, milestone, goal yang perlu dicapai.
Tentu "dirasa" buang-buang waktu & resource hanya untuk membuat ulang sesuatu yang sama.

Diskusi demi diskusi, nego & pertimbangan.
Okay kita akan redesign.

Resource dibagi menjadi team redesign & team feature.
Yah setidaknya dibagi-bagi, ditambah, dikurang, diatur menjadi sejenisnya.
Ada yang redesign dan ada yang mengerjakan feature-feature baru.

Waktu berlalu yang pastinya tidak sebentar,
redesign code semakin bertambah.
Namun seiring waktu, orang datang dan pergi, team berubah.
Redesign code yang semula fresh & clean kini mungkin mulai berantakan juga.

Yah, mungkin belum seberantakan yang lama.
Tidak papa, belum sekacau itu, nanti bisa refactor, dan yah...
"At least, tech stack baru, architecture baru, lebih modern, lebih kenceng"??

Another messy codes.

Salah siapa?

This may be a bitter pill to swallow.
How could this mess be our fault?
What about the requirements?
What about the schedule?
What about the stupid managers and the useless marketing types?
Don't they bear some of the blame?

Masih banyak excuse yang bisa ditulis.

They may defend the schedule and requirements with passion; but that's their job.
It's your job to defend the code with equal passion

You will not make the deadline by makin the mess.
Indeed, the mess will slow you down instantly,
and will force you to miss the deadline.

The only way to make the deadline--
the only way to go fast--
is to keep the code as clean as possible at all times.

Attitude

Tidak ada kode yang berantakan dari awal.
Semua dimulai dengan fresh & clean, ya setidaknya blank, :D.
Kode berantakan seiring waktu.

Agar itu tidak terjadi,
pastikan meninggalkan kode lebih bersih dari sebelumnya.

Sesedarhana, nama variable yang membingungkan kita ubah 1.
Atau tambah komentar/dokumentasi dari sebuah fungsi, dan lain sebagainya.

Leave the campground cleaner than you found it

Can you imagine working on a project where the code simply got better
as time passed?

Akhir

Kita adalah pembaca.
Untuk bisa menulis kode, kita harus membaca,
memahami apa yang terjadi di program kita.
Pusing sekali baca kode yang sulit dibaca.

Namun kita juga penulis.
Untuk kita di lain waktu,
untuk orang lain yang mengunjungi kode kita.

Jadilah penulis kode yang membuat pembaca menghargai crafting kita akan program itu.

https://abdulghofurme.github.io/posts/book-clean-code/

Transform zod error into readable error response

Abdul Ghofur — Fri, 27 Dec 2024 20:09:41 +0000

Transform zod validation error into FE readable key message object in NestJS

Bahasa Indonesia Version

https://abdulghofurme.github.io/posts/transform-zod-error-into-readable-error-response

Perspective

As a Frontend Engineer,
I have occasionally encountered validation errors that are less easy to process.

Well, I’m not an expert,
but in my opinion, it would be better if the validation errors received were easier to handle.

Purpose

To transform Zod validation errors like this:

{
    "issues": [
        {
            "code": "too_small",
            "minimum": 3,
            "type": "string",
            "inclusive": true,
            "exact": false,
            "message": "The category name must be at least 3 characters long",
            "path": ["name"]
        }
    ],
    "name": "ZodError"
}

into an error response in the key: message format like this:

{
    "name": "The category name must be at least 3 characters long"
}

With the key: message format above,
I think it is easier to read and process.

Once again,
this doesn’t mean the first format is difficult. Of course, it can be processed, but it requires an additional step to extract error messages from each input field.

The Code

We will use an Error/Exception Filter,
a standard approach for handling errors centrally.

You can generate the filter with this command:

nest g f error
# nest generate filter [filter_name]

Here’s the implementation:

// ./error/error.filter.ts

import { ArgumentsHost, Catch, ExceptionFilter, HttpException, HttpStatus } from "@nestjs/common";
import { Response } from "express";
import { TWebResponse } from "src/model/web.model";
import { ZodError, ZodIssue } from "zod";

@Catch()
export class ErrorFilter<T> implements ExceptionFilter {
    zodErrorToKeyedObject(error: ZodError): Record<string, string> {
        return error.errors.reduce(
            (acc, issue) => {
                const key = issue.path.join(".");
                acc[key] = issue.message;
                return acc;
            },
            {} as Record<string, string>,
        );
    }

    catch(exception: any, host: ArgumentsHost) {
        const response: Response = host.switchToHttp().getResponse();
        let result: {
            status: HttpStatus;
            json: TWebResponse;
        };

        if (exception instanceof HttpException) {
            result = {
                status: exception.getStatus(),
                json: {
                    message: exception?.message,
                },
            };
        } else if (exception instanceof ZodError) {
            result = {
                status: HttpStatus.BAD_REQUEST,
                json: {
                    message: "Validation error",
                    errors: this.zodErrorToKeyedObject(exception),
                },
            };
        } else {
            result = {
                status: HttpStatus.INTERNAL_SERVER_ERROR,
                json: {
                    message: exception?.message,
                },
            };
        }

        response.status(result.status).json(result.json);
    }
}

Next, apply the filter to your application:

// app/global module
...
import { APP_FILTER } from '@nestjs/core';
import { ErrorFilter } from './error/error.filter';
...
@Module({
...
  providers: [
    ...
    {
      provide: APP_FILTER,
      useClass: ErrorFilter,
    },
  ],
  ...
})

Explanation

HTTPException

...
if (exception instanceof HttpException) {
    result = {
        status: exception.getStatus(),
        json: {
            message: exception?.message,
        },
    };
}
...

Handles the HttpException and forwards it, so that:

...
throw new HttpException(
  'Category not found',
  HttpStatus.NOT_FOUND,
);
...

will return this response:

{
    "status": 404,
    "data": {
        "message": "Category not found"
    }
}

ZodError

...
else if (exception instanceof ZodError) {
    result = {
        status: HttpStatus.BAD_REQUEST,
        json: {
            message: 'Validation error',
            errors: this.zodErrorToKeyedObject(exception),
        },
    };
}
...

Captures a ZodError, and the method:

...
zodErrorToKeyedObject(error: ZodError): Record<string, string> {
    return error.errors.reduce(
        (acc, issue) => {
            const key = issue.path.join('.');
            acc[key] = issue.message;
            return acc;
        },
        {} as Record<string, string>,
    );
}
...

transforms the ZodError into a key: message error object as per our goal.

This results in a response like this:

{
    "status": 400,
    "data": {
        "message": "Validation error",
        "errors": {
            "name": "Field-specific error message"
        }
    }
}

Else

...
else {
    result = {
        status: HttpStatus.INTERNAL_SERVER_ERROR,
        json: {
            message: exception?.message,
        },
    };
}
...

Handles any other errors, returning an internal server error (500).

Conclusion

I believe everyone has their own opinions and standards.

However, from this noob FE’s perspective,
validation errors are easier to handle if they are in the key: message object format,
allowing them to be directly extracted and displayed for each input field.

That said, if the team already has a different standard,
make sure to accept, ask questions, and discuss it well.
There might be better reasons behind it.

Feel free to share other considerations. 😉

zod vs class-validator & class-transformer

Abdul Ghofur — Wed, 18 Dec 2024 02:36:39 +0000

Comparison of zod with class-validator & class-transformer in NestJS

I was confused, or at least curious between zod or class-validator & class-transformer
as a validation library in NestJS.

Bahasa Indonesia Version

https://abdulghofurme.github.io/posts/zod-vs-class-validator-n-class-transformer

Main Point

Just go straight to it.

1. Reason for choosing `class-validator` & `class-transformer`

Is a duo package that is common & widely used in NestJS
The writing method is "very NestJS", because it is decorator-based validation
clean & seamless integration with its use with class-transformer & ValidationPipe

2. Reason for choosing `zod`

Framework agnostic
Very Typescript
For those who prefer functional & schema-based approach
Performance & lightweight validation is critical

Detail

class-validator & class-transformer are the 2 packages most commonly used as validation in NestJS,
yes, apart from the fact that the writing method is the same as NestJS using decorator-based,
also because it is clean & seamless because it can be used with ValidationPipe as DTO.

So, the incoming data/payload received by the controller has been validated and changed/transformed according to its definition.
Meanwhile zod still needs to validate the data/payload it receives manually,
yes, maybe only 1 or a maximum of 3 lines,
but of course, the more validation functions are needed the more manual processes are required.

Procedure details

Here is a detailed procedure (perhaps subjective) for comparison.

`class-validator` & `class-transformer`

1. Installation

npm install class-validator class-transformer

2. Enable Global Validation

// main.ts
....
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
....
  // Enable validation globally
  app.useGlobalPipes(new ValidationPipe({
    transform: true, // Automatically transform payloads to DTO instances
    whitelist: true, // Strip unknown properties
    forbidNonWhitelisted: true, // Throw error for unknown properties
  }));
....
}
....

3. Define DTO(Data Transfer Object)

import { IsNotEmpty, IsString, IsInt, Min } from "class-validator";
import { Type, Transform } from "class-transformer";

export class CreateUserDto {
    @Transform(({ value }) => value.trim()) // Trim whitespaces
    @IsNotEmpty({ message: "Nama tidak boleh kosong" })
    @IsString({ message: "Nama harus berupa string" })
    @Min(3, { message: "Minimal panjang nama 3 karakter" })
    name: string;

    @Type(() => Number) // Transform input into Number type
    @IsNotEmpty({ message: "Nama tidak boleh kosong" })
    @IsInt({ message: "Umur harus berupa bilangan bulat" })
    @Min(17, { message: "Minimal umur terdaftar 17 tahun" })
    age: number;
}

Quite long, yes, but it's decorator-based.

4. Penggunaan validasi

import { Body, Controller, Post } from "@nestjs/common";
import { CreateUserDto } from "./create-user.dto";

@Controller("users")
export class UsersController {
    @Post()
    create(@Body() createUserDto: CreateUserDto) {
        // At this point data/payload createUserdDto
        // has been validated & changed according to the definition
        // developers can directly execute the service
        // or other logic
    }
}

`zod`

1. Installation

npm install zod

2. Create Validation Schema

// user.validaiton.ts
import { z, ZodType } from "zod";

export class UserValidation {
    static readonly CREATE: ZodType = z.object({
        name: z
            .string({ message: "Nama harus berupa string" })
            .nonempty({ message: "Nama tidak boleh kosong" })
            .min(3, "Minimal panjang nama 13 karakter"),
        age: z
            .number({ message: "Umur harus berupa angka" })
            .int({ message: "Umur harus berupa bilangan bulat" })
            .min(17, "Minimal umur terdaftar 17 tahub"),
    });
}

export type TCreateUserPayload = z.infer<typeof UserValidation.CREATE>;

*Personal: I prefer reading this schema compared to the one above

3. Validation Implementations

import { Body, Controller, Post } from "@nestjs/common";
import { UserValidation, TCreateUserPayload } from "./user.validation.ts";

@Controller("users")
export class UsersController {
    @Post()
    create(@Body() createUserPayload: TCreateUserPayload) {
        const payload = UserValidation.CREATE.parse(createUserPayload);
        // At this point data/payload payload
        // has been validated & changed according to the definition
        // developers can directly execute the service
        // or other logic
    }
}

Conclusion

Personally, I prefer the use of zod.
However, what needs to be underlined is choose according to the team's needs & standards.

Prisma & MongoDB: server to be run as a replica set

Abdul Ghofur — Wed, 18 Dec 2024 02:31:07 +0000

Solution for: "Prisma needs to perform transactions, which requires your MongoDB server to be run as a replica set"

Problem

Service & controller sudah dibuat, seharusnya semua aman.
Namun ketika hit API, muncullah Prisma needs to perform transactions, which requires your MongoDB server to be run as a replica set.

Root cause

Error tersebut di atas hanya terjadi pada operasi create, update, dan delete,
karena Prisma perlu MongoDB berjalan sebagai replica set untuk menjalankan operasi-operasi tersebut.

Solution

Edit `mongodb.conf`

Pastikan /etc/mongod.conf mempunyai code di bawah

replication:
  replSetName: rs0

Restart MongoDB

Restart mongod service setelah perubahan config

sudo systemctl restart mongod

https://abdulghofurme.github.io/posts/prisma-mongodb-server-to-be-run-as-a-replica-set/

JavaScript: Don't use replaceAll

Abdul Ghofur — Wed, 26 Jan 2022 02:50:03 +0000

Instead of using replaceAll, it is better to use replace.
But why? Doesn't replace just replace the first character/sentence it finds?

The context of our discussion this time is replace & replaceAll which is a built-in function/method for String in JavaScript.

First, let's see how to use it

const kalimat = 'Kita akan membuka toko. Kita akan menjual kebab' 

// replaceAll
const kalimatReplacedAll = kalimat.replaceAll('Kita', 'Saya')

// replace
const kalimatReplaced = kalimat.replace('Kita', 'Saya')

console.table({
  kalimat,
  kalimatReplacedAll,
  kalimatReplaced,
})

Above code will have output message like

(index)	Value
kalimat	'Kita akan membuka toko. Kita akan menjual kebab'
kalimatReplacedAll	'Saya akan membuka toko. Saya akan menjual kebab'
kalimatReplaced	'Saya akan membuka toko. Kita akan menjual kebab'

replace & replaceAll don't change the value, it returns the changed value.

Therefore we have to accommodate the changes into a new variable.
replaceAll changes all findings, whereas replace changes only the first finding.

Problem

Then why?
The problem is in compatibility

The problem that may occur is Runtime Error on some older devices/browsers.

Especially for friends who develop webview apps, this needs to be a concern.

Solution

Use replace.
If you want to replace all findings, use Regular Expression with replace, as follows

const kalimatReplacedNew = kalimat.replace(/Kita/g, 'Saya')
console.log(kalimatReplacedNew) // 'Saya akan membuka toko. Saya akan menjual kebab'

Okay thanks.

Source

Abstraction of Testing

Abdul Ghofur — Sun, 26 Sep 2021 21:05:47 +0000

Sebelum kita jauh belajar mengenai testing, mari kita buat contoh sederhana dari 0, agar lebih mudah untuk memahami.

Well, sesuai namanya testing, digunakan untuk memeriksa kode kita,
dan sesegera mungkin mengidentifikasi di mana letak kesalahannya.

Dari kode berikut kita menemukan error

if (result !== expected) throw new Error(`${result} is not equal to ${expected}`)
                         ^

Error: -4 is not equal to 10
    at Object.<anonymous> (/simple.js:6:32)

Separate code & testing

Alih alih menempatkan target testing & testing code kita dalam 1 file, mari kita pisahkan terlebih dahulu.

Kode kita dalam math.js

const sum = (a, b) => a - b;
const subtract = (a, b) => a - b;

module.exports = {
  sum,
  subtract,
};

Dan testing code kita dalam assertion-library.js

const { sum, subtract } = require("./math");

let result, expected;

result = sum(3, 7);
expected = 10;
if (result !== expected)
  throw new Error(`${result} is not equal to ${expected}`);

result = subtract(7, 3);
expected = 4;
if (result !== expected)
  throw new Error(`${result} isn not equal to ${expected}`);

Refactor Assertion Library

Pada testing file, kita melihat kode yang berulang.

if (result !== expected)
  throw new Error(`${result} is not equal to ${expected}`);

Untuk satu/dua testing mungkin tidak masalah.
Namun akan jadi masalah untuk banyak testing.

Mari kita sederhanakan

// assetion-library.js
const { sum, subtract } = require("./math");

let result, expected;

result = sum(3, 7);
expected = 10;
expect(result).toEqual(expected);

result = subtract(7, 3);
expected = 4;
expect(result).toEqual(expected);

function expect(actual) {
  return {
    toEqual(expected) {
      if (actual !== expected)
        throw new Error(`${actual} is not equal to ${expected}`);
    },
  };
}

Anyway, ini juga bertujuan untuk membuat pesan error lebih konsisten.
Dan tentu saja kita dapat menambah fungsi selain toEqual,
seperti toBe, toBeGreaterThan dan lainnya

Mengatasi "failed test menghentikan eksekusi kode"

Sadar atau tidak,
pada kode di atas, apabila kita gagal test, maka test berikutnya tidak dijalankan,
dengan kata lain eksekusi kode berhenti.

Tentu saja, karena kita menggunakan throw new Error()

Mari kita ubah assertion-library untuk mengatasi hal ini.

function test(title, callback) {
  try {
    callback();
    console.log(`✅  ${title}`);
  } catch (error) {
    console.error(`❌ ${title}`);
    console.log(error);
  }
}

try catch di atas berfungsi untuk mengatasi throw new Error, dengan begitu, failed test tidak akan menhentikan eksekusi testing file.
berfungsi juga untuk merapikan pesan yang tampil kepada kita

Adapun implementasinya

test("sum function", () => {
  const result = sum(3, 7);
  const expected = 10;
  expect(result).toEqual(expected);
});

Maka pesan yang akan kita terima

❌ sum function
Error: -4 is not equal to 10
    at Object.toEqual (/assertion-library.js:29:15)
    ...
✅  subtract function

File penuhnya sebagai berikut

// assertion-library.js
const { sum, subtract } = require("./math");

test("sum function", () => {
  const result = sum(3, 7);
  const expected = 10;
  expect(result).toEqual(expected);
});

test("subtract function", () => {
  const result = subtract(7, 3);
  const expected = 4;
  expect(result).toEqual(expected);
});

function test(title, callback) {
  try {
    callback();
    console.log(`✅  ${title}`);
  } catch (error) {
    console.error(`❌ ${title}`);
    console.log(error);
  }
}

function expect(actual) {
  return {
    toEqual(expected) {
      if (actual !== expected)
        throw new Error(`${actual} is not equal to ${expected}`);
    },
  };
}

Support Async Function to Test

Sejauh ini library kita bekerja,
namun apakah juga bekerja untuk fungsi dengan kondisi spesial seperti promise/async function?

mari kita buat fungsi & test-nya

// math.js
...
const sumAsync = (a, b) => Promise.resolve(sum(a, b));

module.exports = {
  ...
  sumAsync,
};

// assertion-library.js
const { ... sumAsync } = require("./math");

...
test("sum async", async () => {
  const result = await sumAsync(3, 7);
  const expected = 10;
  expect(result).toEqual(expected);
})
...

maka pesan yang akan kita dapat adalah

...
✅  sum async
/assertion-library.js:35
        throw new Error(`${actual} is not equal to ${expected}`);
              ^

Error: -4 is not equal to 10
    at Object.toEqual (/assertion-library.js:35:15)
    at /assertion-library.js:18:18
    ...

Pengecekan berhasil, tapi menunjukkan pesan error? aneh bukan?

Karenanya kita perlu mengubah testing library kita agar bisa support baik pada fungsi biasa ataupun async function

// assertion-library.js
...
async function test(title, callback) {
  try {
    await callback();
    console.log(`✅  ${title}`);
  } catch (error) {
    console.error(`❌ ${title}`);
    console.log(error);
  }
}
...

Dengan kode di atas, pesan yang kita dapat akan seperti berikute

❌ sum async
Error: -4 is not equal to 10
    at Object.toEqual (/assertion-library.js:35:15)
    at /assertion-library.js:18:18

well, test gagal dengan pesan error, sesuai yang diharapkan.

Rust - Control Flow (Iteration/Repetition & keywords)

Abdul Ghofur — Thu, 01 Jul 2021 03:25:30 +0000

Pada dasarnya, iteration/repetition digunakan untuk mengulangi sebuah block kode, sesuai dengan kondisi yang diberikan.

Semua materi merupakan rangkuman belajar.

Untuk bacaan yang lebih langkap & update, dipersilahkan akses pada
The Book

Adapun iteration/repetition meliputi

loop
while
for in

Sekalian akan kita bahas beberapa keyword yang terdapat pada control flow

break
continue
juga support control flow label dengan 'label:

`loop`

Sederhananya,
loop adalah infinite loop/iteration/repetition,
atau apapun namanya,
yang merupakan pengulangan tanpa henti.

fn main() {
    loop {
        println!("tidur");
    }
}

Kode di atas, akan menampilkan kata tidur "tanpa" henti, nah kita dapat menghentikannya dengan paksa, tentu dengan ctrl + c.

Tapi apa di dalam program kita juga bisa menghentikannya?

Jawabannya bisa, dengan break.

fn main() {
    let mut piring_makan = 0;
    let harga = 15_000;

    let totalan = loop {
        piring_makan += 1;

        if piring_makan == 5 {
            break piring_makan * harga;
        }
    };

    println!("makan {} piring, masing-masing harganya {}, jumlahnya {}", piring_makan, harga, totalan);
}

loop tidak bisa ditempel kondisi, karenanya disebut infinite loop
block kode yang diulangi berada dalam body, dibungkus { }
kita hanya dapat menghentikannya dari program dengan break.

Tentu dengan kondisi kapan kita ingin menghentikannya.

break bersifat sebagai expression, karenanya kita dapat mengembalikan nilai dari loop.

Gunakan seperti halnya memakai return dalam function, perlu ;

BTW, hasil code di atas adalah

makan 5 piring, masing-masing harganya 15000, jumlahnya 75000

`while`

Alih alih menuliskan kondisi di dalam loop.
Lebih praktis menggunakan while.

Selain kode lebih pendek, juga lebih mudah dibaca.

fn main() {
    let mut istirahat_in_minutes = 60;

    while istirahat_in_minutes != 0 {
        println!("lanjuuut.... masih ada {} menit", istirahat_in_minutes);

        if istirahat_in_minutes == 50 {
            println!("udahan ah, banyak kerjaan");
            break;
        }

        istirahat_in_minutes -= 1;
    }

    println!("udahan bosque, kerja kerja");
}

kondisi tidak perlu ( )
block kode yang diulangi berada dalam body, dibungkus { }
meski sudah dengan kondisi, kita tetap bisa menggunakan kondisi di dalamnya.

Yah, barangkali kita ingin melakukan sesuatu yang lain.

Kita masih bisa menggunakan break untuk menghentikannya
Namun kita tidak dapat menggunakan while untuk mengembalikan nilai, (sepengetahuanku ya)

Hasil code di atas adalah

lanjuuut.... masih ada 60 menit
lanjuuut.... masih ada 59 menit
lanjuuut.... masih ada 58 menit
lanjuuut.... masih ada 57 menit
lanjuuut.... masih ada 56 menit
lanjuuut.... masih ada 55 menit
lanjuuut.... masih ada 54 menit
lanjuuut.... masih ada 53 menit
lanjuuut.... masih ada 52 menit
lanjuuut.... masih ada 51 menit
lanjuuut.... masih ada 50 menit
udahan ah, banyak kerjaan
udahan bosque, kerja kerja

`for in`

for in adalah yang paling ideal kita gunakan untuk melakukan pengulangan pada list/collection.

Tentu kita dapat melakukannya dengan while juga.

    let my_special_ages = [0, 5, 6, 11, 14, 17, 18];

    for age in my_special_ages.iter() {
        match age {
            0 => println!("lahir lah"),
            5 | 6 | 14 => println!("masuk sekolah"),
            11 | 17 => println!("lulus sekolah"),
            18 => break,
            _ => println!("pokoknya spesial"),
        }
    }

kondisi tidak perlu ( )
block kode yang diulangi berada dalam body, dibungkus { }
kita tetap bisa menggunakan kondisi & break di dalamnya

kode di atas menghasilkan

lahir lah
masuk sekolah
masuk sekolah
lulus sekolah
masuk sekolah
lulus sekolah

Kita dapat menggunakan semua yang di atas secara nested

Sejauh ini kita telah menggunakan break
Yang berfungsi untuk menghentikan pengulangan
Selanjutnya kita bahas sisanya dengan contoh nested

fn main() {
    // nested
    let days = [
        "minggu", "senin", "selasa", "rabu", "kamis", "jumat", "sabtu",
    ];

    println!("budak korporate");
    'daysloop: for day in days.iter() {
        println!("hari {}", day);
        let day = *day;

        if day == "sabtu".to_string() || day == "minggu".to_string() {
            println!("libur");
            continue 'daysloop;
        }

        let hours = 0..=24;
        let workhours = 9..=17;
        'hoursloop: for hour in hours {
            if hour == 17 {
                println!("pulang pulang");
                break 'hoursloop;
            }

            if !workhours.contains(&hour) {
                continue 'hoursloop;
            }

            println!("kerja.., jam {}", hour);
        }
    }
}

Bila break digunakan untuk menghentikan pengulangan,
continue digunakan untuk loncat pada pengulanga item selanjutnya
Sementara label digunakan pada break ataupun continue untuk menjalankannya pada spesifik iteration yang kita maksud,
biasa digunakan pada nested iteration

Semoga mudah dimengerti,

Terima kasih.

BTW, kode di atas akan menghasilkan

budak korporate
hari minggu
libur
hari senin
kerja.., jam 9
kerja.., jam 10
kerja.., jam 11
kerja.., jam 12
kerja.., jam 13
kerja.., jam 14
kerja.., jam 15
kerja.., jam 16
pulang pulang
hari selasa
kerja.., jam 9
kerja.., jam 10
kerja.., jam 11
kerja.., jam 12
kerja.., jam 13
kerja.., jam 14
kerja.., jam 15
kerja.., jam 16
pulang pulang
hari rabu
kerja.., jam 9
kerja.., jam 10
kerja.., jam 11
kerja.., jam 12
kerja.., jam 13
kerja.., jam 14
kerja.., jam 15
kerja.., jam 16
pulang pulang
hari kamis
kerja.., jam 9
kerja.., jam 10
kerja.., jam 11
kerja.., jam 12
kerja.., jam 13
kerja.., jam 14
kerja.., jam 15
kerja.., jam 16
pulang pulang
hari jumat
kerja.., jam 9
kerja.., jam 10
kerja.., jam 11
kerja.., jam 12
kerja.., jam 13
kerja.., jam 14
kerja.., jam 15
kerja.., jam 16
pulang pulang
hari sabtu
libur

Rust - Control Flow (Condition)

Abdul Ghofur — Mon, 28 Jun 2021 01:49:10 +0000

Seperti namanya, fungsinya adalah mengatur arus/jalan dari program kita.
Apakah kita harus belok kanan, ataukah kiri,
ataukah putar balik,
itulah bahasa sederhana dari Control Flow

Semua materi merupakan rangkuman belajar.

Untuk bacaan yang lebih langkap & update, dipersilahkan akses pada
The Book

Adapun control flow di Rust meliputi

condition
- if & else
- match
iteration/repetition
- loop
- while
- for in
control flow keyword
- break
- continue
- juga support control flow label dengan 'label:

`if` & `else`

fn main() {
    let umur = 21;

    if umur < 18 {
        println!("kemudaan");
    } else if umur > 60 {
        println!("kayaknya waktunya pensiun");
    } else {
        println!("boleh lah");
    }

    // Karena if else 
    // merupakan expression 
    // ( dapat mengembalikan nilai )
    // kita dapat menggunakannya ke dalam variable
    let umur = if umur < 18 {
        "kemudaan"
    } else if umur > 60 {
        "kayaknya waktunya pensiun"
    } else {
        "boleh lah"
    };
    // pada contoh di atas 
    // kita menggunakan 
    // shadowing pada variable umur
    // & expression untuk mengembalikan nilai

    println!("{}", umur);
}

Kita tidak perlu menuliskan kurung sebagai bungkus dari kondisi
Body kondisi dibungkus dengan kurung kurawal { }
Karena merupakan expression, kita dapat menggunakannya ke dalam variable.
Kita juga dapat menggunakan expression sebagai return di dalam body kondisinya
Bila menggunakannya sebagai expression, pastikan nilai return bertipe data sama.
if & else hanya menerima nilai boolean ke dalam kondisinya, tidak seperti JavaScrip yang dapat menerima nilai truly/falsy

`match`

Pada Dasarnya match seperti switch pada beberapa bahasa pemrograman lain.
Nah, bedanya di Rust kita harus menangani segala kemungkinan yang terjadi.

fn main() {
    let nilai = 90;

    match nilai {
        0 => println!("Wah ini sih parah"),
        1 | 2 | 3 => println!("Niat ngga sih?"),
        4..=35 => println!("F"),
        31..=50 => {
            println!("Hmmm");
            println!("E");
        },
        51..=65 => println!("D"),
        66..=75 => println!("C"),
        76..=85 => println!("B"),
        86..=98 => println!("A"),
        99..=100 => println!("A+"),
        _ => println!("???"),
    }

    let boolean = true;

    let boolean = match boolean {
        false => 0,
        true => 1,
    };

    println!("{}", boolean);

}

Nilai yang akan diperiksa, tidak perlu tanda kurung
Kurung kurawa sebagai body pengecekan & kondisi (apabila lebih dari 1 baris).
=> dan , sebagai batas tiap kondisi
_ digunakan sebagai else atau default, kemungkinan yang lain akan masuk ke dalam kondisi ini
Kita juga dapat menggunakannya sebagai expression.

pastikan nilai return bertipe data sama

Untuk control flow yang lain akan dibahas secara terpisah.

Terima kasih.

Rust - Function & Comment

Abdul Ghofur — Sat, 26 Jun 2021 22:44:04 +0000

Seperti halnya variable,
Rust menggunakan snake case sebagai gaya penulisannya.

Dan seperti beberapa bahasa pemrograman lain,
Rust mengguanakan main function sebagai entry point program.

Semua materi merupakan rangkuman belajar.

Untuk bacaan yang lebih langkap & update, dipersilahkan akses pada
The Book

Okay, berikut contoh format penuh dari sebuah function

use rand::Rng;

fn main() {
    let kamu = "aku".to_string();
    let doi = String::from("dia");
    let is_jodoh = jodohin(&kamu, &doi);

    println!("apakah aku jodoh dengan {}, {}", doi, is_jodoh);
}

fn jodohin(a: &String, b: &String) -> bool {
    // Generate angka acak untuk menentukan jodoh
    let random_nasib: u8 = rand::thread_rng().gen_range(0..2);

    println!("{}", random_nasib);
    if random_nasib == 1 {
        println!("{} dan {} berjodoh", a, b);
        return true;
    }

    println!("{} dan {} tidak berjodoh", a, b);
    // Rust merupakan expression-based language
    // Kamu bisa mengembalikan nilai
    // menggunakan expression seperti ini
    // di akhir & tanpa ;
    // bila menggunakan ;
    // harus dengan keyword return
        false
}

main function merupakan entry point program.
Fungsi ditandai dengan keyword fn
Rust tidak peduli dimana letak fungsi yang dipanggil, bisa sebelum pemanggilan, atau setelahnya
Parameter ditulis dalam tanda kurung & bersama tipe datanya

(a: &String, b: &String)
Argument ditulis berurutan sesuai penulisan parameter

jodohin(&kamu, &doi);
Body fungsi ditulis dalam kurung kurawal { }
Nilai Return ditandai tanda panah & hanya ditulis tipe datanya

-> bool
Cara mengembalikan nilai
- Statement, harus dengan keyword return dan tanda ;
- Expression, diletakkan di akhir fungsi dan tanpa ;

Statement, adalah instruksi/code yang tidak mengembalikan nilai
Expression, mengembalikan nilai

Comment

Rust hanya mendukung inline comment dengan tanda //.
Yang artinya, jika kita ingin menulis multiline comment, kita harus menuliskan // tiap barisnya, heheee.

Contohnya ada di atas.

Rust menggunakan use untuk import package/dependency dari luar,
jangan lupa menulisakan package nya pada Cargo.toml

Dan contoh pembuatan String seperti di atas,
lebih jelasnya akan dilanjutkan pada bahasan tersendiri

Terima kasih.

Rust - Tipe Data Compound

Abdul Ghofur — Mon, 14 Jun 2021 02:33:26 +0000

Compound Types

Semua materi merupakan rangkuman belajar.

Untuk bacaan yang lebih langkap & update, dipersilahkan akses pada
The Book

Seperti disebutkan sebelumnya, Compound Types merupakan kelompok dari beberapa nilai.

Dibagi menjadi 2:

Tuple
- dapat menampung beberapa tipe data yang berbeda
Array
- hanya dapat menampung tipe data sejenis

Persamaan dari 2 jenis Compound di atas adalah
sama-sama memiliki panjang yang pasti (tidak dapat dirubah)

Oke, langsung contoh

Tuple

fn main() {
  // Deklarasi dengan tipe data
  let nilai: (u8, f32, u8) = (80, 9.3, 77);

  // Deklarasi tanpa tipe data
  let nilai_b = ('A', 79, 9.3);

  // Destructuring
  let (x, y, z) = nilai;
  println!("{}, {}, {}", x, y, z);

  // Directly access element
  let h = nilai_b.0;
  println!("{}", h);
}

Tuple ditandai dengan tanda kurung ( ).
Dapat dideklarasi dengan atau tanpa tipe data element-nya.
Mengambil nilai element dapat dilakukan dengan 2 cara
1. Destructuring
  seperti saat deklarasi, akses pun menggunakan tanda kurung ( ).
  
  Perlu diperhatikan, akses nilai dengan destructuring
  harus menyesaikan dengan panjang tuple-nya.
  
  Bila ada element yang tidak akan dipakai,
  maka dapat menggunakan _ sebagai variable nya
```
fn main() {
  let nilai_b = ('A', 79, 9.3);

  let (h, _, _) = nilai_b;

  println!("{}", h);
}
```

2. Directly access
    dengan menggunakan `.`, dan index yang diawali dengan 0.

Array

Hanya satu tipe data dan panjangnya tidak dapat diubah.

fn main() {
  // Deklarasi dengan tipe data
  let nilai_matematika: [u8; 5]  = [8, 4, 9, 8, 8];

  // Deklarasi tanpa tipe data
  let nilai_ipa = [8, 7, 5, 6, 5]; 

  // Destructuring
  let [_, kedua, _, keempat, _] = nilai_matematika;
  println!("{}, {}", kedua, keempat);

  // Directly access element
  let ipa_kedua = nilai_ipa[1];
  println!("{}", ipa_kedua);
}

Array ditandai dengan tanda kurung siku [ ].
Dapat dideklarasi dengan atau tanpe tipe data.
Saat menggunakan tipe datanya, yang ditulis adalah
[u8; 5] tipe datanya (u8) dan panjang array nya (5),
dengan ; sebagai pemisah.

Denga metode ini, kita juga dapat membuat array dengan panjang dan nilai yang sama,
contohnya,
```
let nilai_ips = [7; 5];
```
Hal ini sama dengan kita menulis let nilai_ips = [7, 7, 7, 7, 7].
Mengambil nilai element dapat dilakukan dengan 2 cara, sepertihalnya Tuple
1. Destructuring
  dengan tanda akses nya [ ].
  
  Dan ketentuan error sepertihalnya Tuple.
2. Directly access
  dengan menggunaan tanda [ ], dan index 0 sebagai awalnya.

Demikian Sesi Tipe Data.
Semoga bermanfaat, dan terima kasih.

DEV Community: Abdul Ghofur

Machine Learning & Data Science

Machine Learning & Data Science

Deep Learning & Neural Network

AI: I'll take your job

ANI

Gen AI

AGI

Machine Learning

LLM

Ingredient

Tribute

Book: Clean Code - Background

Kenapa Clean Code penting

Harga yang harus dibayar

Solusi??

Salah siapa?

Attitude

Akhir

Transform zod error into readable error response

Perspective

Purpose

The Code

Explanation

HTTPException

ZodError

Else

Conclusion

zod vs class-validator & class-transformer

Main Point

1. Reason for choosing class-validator & class-transformer

2. Reason for choosing zod

Detail

Procedure details

class-validator & class-transformer

1. Installation

2. Enable Global Validation

3. Define DTO(Data Transfer Object)

4. Penggunaan validasi

zod

1. Installation

2. Create Validation Schema

3. Validation Implementations

Conclusion

Prisma & MongoDB: server to be run as a replica set

Problem

Root cause

Solution

Edit mongodb.conf

Restart MongoDB

JavaScript: Don't use replaceAll

Problem

Solution

Source

Abstraction of Testing

Separate code & testing

Refactor Assertion Library

Mengatasi "failed test menghentikan eksekusi kode"

Support Async Function to Test

Rust - Control Flow (Iteration/Repetition & keywords)

loop

while

for in

Rust - Control Flow (Condition)

if & else

match

Rust - Function & Comment

Comment

Rust - Tipe Data Compound

Compound Types

Tuple

Array

1. Reason for choosing `class-validator` & `class-transformer`

2. Reason for choosing `zod`

`class-validator` & `class-transformer`

`zod`

Edit `mongodb.conf`

`loop`

`while`

`for in`

`if` & `else`

`match`