Durable execution?

It means, the process or function or method that you want to run will never failed. (it actually will failed, based on the maximum attempt that you decide to put). What it means to be never failed is, it will do exponential backoff retry, to ensure the process succeed. Even if it is failed, it can continue from the last state or checkpoint it failed within the workflow.

In order to do this, Temporal saves the state in the event history, which has limited of payload size, which has became a headache for me to solve the issue at first (but then can be solve using Temporal features).

The reason is the limitation of the payload size, although you can overwrite it in config (sadly cannot configured through Python SDK, but in Go), is first because of the durable execution itself. Imagine, you have something huge, which is the payload that you fetched from API or database. The workflow then failed, which then will be retry again from the last checkpoint saved in the event history but fetching again; this workflow then will consume so much computation as it will retry and trying to process that big chad payload and still save it into the history, that soon will affect the performance.

Hence to solve this, Temporal introduced continue_as_new and child_workflow to solve the problem. By having continue-as-new, it will create a new fresh empty event history to run the workflow, while using the child workflow by iterating through all the item can batch the workflow into respective item to be executed, instead of relying on a single workflow.

This would also help the monitoring the workflow progression, and ensure decoupling and atomic workflow.

Functional or OOP

In Temporal, the Workflow components consists of function, or can be called as Activity. Activity can be a function or a method (OOP). Personally if I can turn back time I will just do functional programming, instead of OOP in my pipeline. I used OOP because it is easier for me to access the method within the class, as of the assistance of intelli-sense within the VSCode.

Nevertheless, you can just design a stateless OOP, because we cannot having state within Temporal due to the durable execution again. Hence, to use OOP, you need to design in away either of staticmethod or just treat it like a normal function, but just in a class. (not saving or mutating the object attribute).

Non-deterministic

Another concept that I learned is the non-deterministic, which is from the non-deterministic error. This is just another fancy words in data engineering, similar to idempotent, which is the consistent value produced whenever the process run.

This happened when I intend to get the current timestamp using datetime.now() in the workflow. Anything that is non-deterministic are not allowed in the Workflow, also due to the durable execution. Temporal need to ensure that whenever the Workflow crashed or reset, and undergo retrying, the Workflow still have the same value like the first time execution. Using datetime.now() will produce different value whenever retrying happened, as it dynamically change the value based on the current time, hence it is not allowed in Temporal.

To solve this problem, we can declare the current time on the client side. This will make sure the execution of the time value variable like now, or yesterday would be consistent and allowed by Temporal.

Steep learning curve

I have some experience of using other data orchestrator such Airflow, Prefect and Dags, however Temporal giving the steepest learning curve for me to understand, given its design of durability execution and gRPC, and also the method of running the Activity and Workflow is different compared to Airflow and other dags based orchestrator that only required functions to be wrapped and executed.

Always in my mind during the development of the pipeline without Temporal that why it was limiting the payload size and history, because without Temporal, my current machine can easily handle it and run the process without any issues; while post-wrapped with Temporal has introduced the issue of the history (multiple times asking myself why I used this tool!)

However, thinking on Temporal architecture with retry, state checkpointing and durability features, I am insisted to grasp and understand it better, although the concept is kinda hard for me, especially the feature of Signal, Message and Query. At the moment, I just used Signal and not the later, although the implementation was not pushed to the production as of what I intended to develop is to schedule a series of workflow that is/are depend on others, communicated through Signal.

The problem is, using Signal required a static workflow id so that it can fetch the workflow id if the signal is send. (I called this - waiting mode to fire). Unfortunately, on the current Temporal version, if you schedule the workflow, it will create a workflow id appended with the timestamp, which makes the workflow id string dynamic, and hardly to hard code (inaccurate when I used .now()) ! The issue has been arisen in the the community forum and Github issue but still not patched and solved.

Nevertheless, let it be, as I found a workaround by

1. Ensure all workflow is trigger with endpoint. (/etl_1 , /etl_2, etl_n…)

2. Create an Activity that call the endpoint. (/schedule_all_endpoint)

3. Create a workflow that call this endpoint - SchedulerWorkflow

4. Create an endpoint with client to schedule this workflow.

5. Trigger this endpoint. Boom, scheduled.

Asynchronous

You need to ensure everything is async, with the respect of whom. One workflow might async to another workflow, but dependent (previous need to be completed) to another. Every function written should support async function. For example, the api request, the db query, any process related to I/O cpu bound need to be async else it will be blocked and become sync.

And this is also to ensure we can implement Queue-Worker process, where you polling multiple workers that waiting for task to be queue and executed once queueing, that will speed up the process for every Workflows. Just ensure everything is async, and we good to go.

Async, or asynchronous is not as an asing things in programming. However, due to no real world use case for utilization of the concept, I tend to ignore it in my codes. Then it has became my concerns in my current working project as it required me to build a vast and robust pipeline that is operated efficiently and relatively faster.

Why Use

• Time is money

• Speed

• Optimization

When to Use

1. Use it whenever you have a function that took so much time, yet you want other function to run int the background or while waiting the slow guy to complete.

2. Use it when you want to increase the efficiency of the code, increase the potential and speed of the operation by not blocking other function(s).

The Burger Analogy

Below is the approaches to complete any process or operation, or any task in life. To understand this, imagine a situation when a man need to cook a burger in a restaurant. The man need to completed 10 set of burgers by following the common cooking process.

Pure Sync

• A man cooking a burger sequentially (single thread)

1. Man cook a patty with no timer.

2. Man waiting until the patty cooks and cannot do the next step until the patty is cooked. (blocking)

3. Once cooked, man slice the bread.

4. Man then frying the fries with no timer features. Man waiting until fries is completely cooked. (blocking)

5. Man put lettuce and mayo on the bread and stack up with the patty.

6. Man put fries as side dish.

7. Man do step 1 to 4, until it completed 10 burgers.

8. Man tired.

Took so so much time. :(

Pure Async

• A man cooking a burger (single thread)

1. Man cook a patty.

2. While waiting patty to cook, man slice a bread.

3. Man go flip the patty and set a timer for five minutes.

4. While waiting patty cook, man fry fries in a fryer with timer for 3 minutes.

5. Man put lettuce on the bread.

6. While waiting the patty cook, fry timer ended. Man take the french fries and put in the plate.

7. Patty cooked, man put patty on the stacked bread with lettuce.

Fast and efficient.

Pure Async + Multithreading

• 4 men cooking a burger (4 threads)

1. Man-A cook a patty, Man-B slice bread, Man-C frying fries, Man-D arrange the lettuce.

2. While patty cook, Man-B take lettuce on bread, Man-C put the fries on the plate.

3. Patty cook, Man B took patty and stack on bread.

4. Complete.

Faster, but more complex to control more men.

Coding Mindset

1. Do async function for function that potentially taking too much time.

2. Wrap the expression(s) in a function. Atomize it.

3. Prefix with async and await the async-ing function.

Async Code

In Python, we will handle the async function with asyncio Package and it will do all the magics behind it.

Basics

Terms

• coroutine - when it is async, the function will be call as the coroutine object or function

Task

Task is fancy terms for the function you want to execute. Task is optional. You can explicitly create it with with asyncio.create_task() or, directly run it with asyncio.run() or asyncio.gather() + asyncio.run() for multiple async function.

• asyncio.create_task() — create task immediately, can run later with await if you want, independent task, cancellable

• asyncio.gather() — gather all coroutine function together, don’t want run the function later, non cancellable, return list

Non-dependent async function

• simple coroutine functions with asyncio.run() and asyncio.gather()

async function():
    asyncio.sleep(10) # just to simulate a time consuming function
    return "a"
async function()_1:
    asyncio.sleep(10)
    return "b"
async function()_2:
    asyncio.sleep(10)
    return "c"
async function()_3:
    asyncio.sleep(10)
    return "b"


async def main():
    # singlefunction
    asyncio.run(function()) 

    # multiple async function
    asynction.gather(function_1(), function_2(), function_3())

# run the corouting function
asyncio.run(main())

Dependent function

• function_a dependent on function_b to complete first. Hence the async is contagious.

import asyncio
async def do_things():
    print("Currently doing things...")
    asyncio.sleep(100)  # fake a function that took so much time!
    return "yes"

async def process_output(out):
    if out == "yes":
        return "completed"

def check_something():
    out = await do_things()
    process = await process_output(out) # need to await coz do_things took time to complete
    return process

asyncio.run(check_somoething)
# await check_something() # notebook
Output:
"yes"

Off-loading blocking tasks

• There is sync function that will blocked the operation (legacy, or unsupported)

  asyncio.to_thread() | asyncio.loop.run_in_executor()

function():return "a" # sync, legacy or unsupported for async
async function()_1:return "b"
async function()_2:return "c"
async function()_3:return "b"


async def main():
    # singlefunction
    asyncio.run(asyncio.to_thread(function())) # or loop.run_in_executor()

    # multiple async function
    asynction.gather(function_1(), function_2(), function_3())

# run the corouting function
asyncio.run(main())

Potential Bugs

If pure async approach is possible, why there is blocking function?

1. Legacy sync function.

2. Unsupported async feature in package.

3. Some function easily handled as sync.

Overwhelming. How to start?

1. For time consuming function, make it async. Use async in front of def.

2. Calling async function require you to use await. Hence include it if it is called.

3. Start with asyncio.run() for easy execution of async function. Then can try asyncio.gather([list of async function]) + asyncio.run() for multiple async functions.

4. Once comfortable, implement intermediate async feature, such async time base, prioritization base, and queue.

Conclusion

I hope this will help the beginners or any level of programmer to understand the async concept. If you have any commenta, please leave the comment below. I appreciate it. Thank you.

I started to find any free API that provide a real time info. Talk about real time, Zach is true about how do you define the real time. Stakeholders almost knew nothing about it. Real time, near real time, batching, micro-batching will always be assumed the same. For them as long as it ‘quick’, then it can be real time. Why the understanding real time is important? Technically because of the complexity. The more it near to real time, the higher the complexity. I can’t say more about this, because the API that I just used is not actually a real-time API as it is updated every 30 seconds, however it has shown its complexity compare to my daily job that only require to fetch the data from database as per requirement.

I started with playing around with the API. Simply using Python you can fetch the information of the feeder bus in KL with certain information return such as the trip time, latitude, longitude, bearing, and speed. Then I decided to build an internal monitoring dashboard that can

1. Monitor the behavior of the driver - safe, cautious and dangerous driving behavior

2. Monitor the condition of the bus - bus that has mileage more than 10,000 km that require service

3. Monitor the current location of the bus - observe the density bus movement

First draft

To build this, I started by draw the first draft of data orchestration infrastructure.

(yea it is so bad, but I will provide the final draft at the end of this article by using excalidraw)

The first plan is to use Airflow, Dbt, Postgres, and Apache Superset, by containerize them. No reason of why I used Postgres as it is the common usage and previously used in my project. Airflow, Dbt and Apache Superset is new to me, but it is learnable.

Database and Dbt

I started by setup the database first, then playing with SQL on Jupyter Notebook. The first problem that I faced is to ensure the data integrity of data insertion in the database. This is because I used change the json return from the request into dataframe before doing the insertion using Pandas .to_sql(). This method be able to change the schema of the database and would not be able to ensure the data type as of it just insert any kind of data format (including if it has different column name) into database. So I used the native SQL instead of using Pandas method.

Then I artificially normalized the data by adding bus and driver table. The bus is coming from the original data but the driver is generated. Then I write the script for recurring and cumulative table which will update daily for the monitoring. All of this SQL query is written following the Dbt methodology, where I can modularize the script, reuse and recall whenever I want. Personally, this is a good way for having version control especially for a potential scalable project that require many changes in the future. Other than modularization, Dbt has testing feature where I can ensure the data type and column name to be matched what is expected (good because I don’t need another external packages like Pydantic or Pytest itself).

Orchestration

My first plan on implementing data orchestration is using Airflow (of course after I watched Zach). The tools provided a complete data orchestration tool, however the size of the image is too heavy; at least for my local machine to endure. This is actually because it has a lot of battery include features which is in my case is overkill (what I want is just automation). Then, I found Prefect. Based on Reddit forum and tested myself, Prefect image is much lighter and this will allow me to develop the pipeline locally. The syntax is also much simpler, which require task and flow; just need to understand on how to test your flow locally as the docs is quite deviated for beginners use.

Visualization

As you can see on the paper, it stated Apcahe Superset. I also changed my plan from using this, as of it is quite unstable in terms of container building where it has error of npm and build-essential. All the docker-compose provided surprisingly produced error (I found the workaround but that is after I implement the other alternative) and that makes me change to Metabase. Also, much simpler, stable and easy to use. Just that it has only daily database sync, which is not what I want on the first plan where I want the visualization to update

Progress

The following is my final architecture for the project

Instead of using MLFlow, I changed it Dagster with a smaller size image so I can run smoothly (RAM poor lol). I also use Metabase instead of Apache Superset, due to some image bug happened in Superset. The weakness of Metabase is it cannot established a near real time visualization as the quickest is one day.

While doing this project, I have discussed with my colleague where I got several input on the improvement. First and foremost, the API itself can’t be a real time due to its HTTP request feature. Instead, I need a web-hook API or implement PubSub method.

Current

The project still not achieve my ultimate goals, but I learned a lot about Data Engineering with such a small project. Shout out to Zach the YT Data Engineer for the knowledge sharing (though he already hide the series) and myself.

Linked List

Fundamental

This problem require an understanding to the concept of Linked List. To be honest, I have watched some videos and read some articles on the internet but still failed to grasp the main concept of it. I guess I need to face the problem first then my brain can work 100% efficiently.

So, what I realized, the first thing you need to put in your mind while learning about Linked List is

To remove the concept of common list that I understand, which a list that can be access by indices (index).

Why? Because I realized the blockade that prevent me to understand the concept of linked list. The main concept of Linked List is the

1. Node

2. Pointer

Only this, then the manipulation of memory allocation. Reading the theory personally make me feels dizzy, so I straight away going to the code. The problem is, how do they thought on the way to create the Linked List is in this way?

class ListNode:
    def __init__(self, val=0, next=None):
            self.val = val
            self.next = next

Remember that, if you instantiate an object from a class, it will allocate the object (which variable also one of it) into the memory.

Hence, to utilize this feature, they write a single Node as an object in the variable.

From the code you can see there is 2 object attributes (val and next) which represents

1. val — value that we want to store in the node

2. next — an attribute that we use to manipulate the state of pointer

By using this Class, we can create a Linked List and store the value in it. Let’s do some simple proves. To create a linked list, we use this function;

def list_to_linked_list(lst):
    dummy = ListNode() # first node
    temp = dummy

    # for every, initially create new node, then create new node
    # after it
    for val in lst:
        temp.next = ListNode(val)
        temp = temp.next
    return dummy.next # in the end it point to the head of the ll

Pseudocode:

1. We first instantiate the first node with dummy

2. Then we copy the object to temp

3. For every integer in the list, I will assign the .next value from temp a node with the integer value.

4. Then I will overwrite the temp with temp.next for the next iteration.

5. The next iteration, we actually create a node for temp.next.next.

6. Until the iteration end.

7. Then we point the pointer to the first node, which is dummy

Example:

l1 = list_to_linked_list([1,2,3])

a = l1.next
b = a.next

print(l1.val, a.val, b.val)

#### OUTPUT ######
(1, 2, 3)

This is actually similar to

print(l1.val, l1.next.val, l1.next.next.val)

#### OUTPUT ######
(1, 2, 3)

To visualize this,

Okay that solved the Linked List part, not the problem yet. Honestly, I did not solved the problem, but I learned from the solution.

Solution

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        # Dummy node to start the new list
        dummy = ListNode()
        temp = dummy
        carry = 0

        # Loop until both lists are processed or there is a carry
        while l1 or l2 or carry:
            # Get values from the current nodes or use 0 if the node is None
            val1 = l1.val if l1 else 0
            val2 = l2.val if l2 else 0

            # Calculate the sum and the new carry
            # carry - imagine standard written method,
            # where if the the summation is more than 10,
            # it will carry the 1 value to the next side opearation
            total = val1 + val2 + carry
            carry = total // 10
            value = total % 10

            # Create a new node with the current value and move the pointer
            temp.next = ListNode(value)
            temp = temp.next

            # Move to the next nodes in the input lists if they exist
            if l1:
                l1 = l1.next
            if l2:
                l2 = l2.next

        # Return the head of the new linked list
        return dummy.next

So, based on the code, we can see a similar code structure like the way we create the linked list above.

Common parts;

1. ListNode()

2. dummy

3. temp

4. carry

The extras is before we create the Node and store the value, we do something with the linked list. In this part, we need to imitate the elementary school standard operation procedure in addition, where if the operation of integer is more than 10, then we need to bring the 1 to the next position.

In Leetcode, they use the word traversing which simply means

Iterate until there is no value, or simply said , while True

1. So, traversing into first and second linked list, we take the value and total it up. We check if there is a carry (more than 1 and take the value 1 to the next) and bring keep for the next iteration.

2. We then keep the total addition operation by doing modulo and keep it in a new node, and keep it in temp.

3. The current temp already has value, hence we overwrite it and create a new one.

4. Since l1 and l2 is already a Linked list, we can move to the next node for the next operation.

5. Finally, after the linked list creation complete, we point and skipped the dummy node.

Recap

1. To solve the linked list is to have the linked list mindset in mind (not the common Python list that I learned in the fundamental part).

2. Input linked list, output linked list.

3. Basic structure of linked list to have value and pointer.

4. Manipulate the pointer following to what the problem or stuffs you need to solve.

5. Common manipulation use dummy and temp in order to achieve the objective.

1. Complete all the Kaggle mini-course. This mini-course is provided on Learn tab on Kaggle. Most of ml tutorial taught about the text book of DS, but this mini-course taught the technique which is what makes it priceless. Technique is what I feel I had lost comparing with all the expertise, especially on the feature creation and validation methodology where it is really useful for most of the cases.

2. Read the Kaggle forum. This is the gold mine treasure where a pool of Kaggle master and grandmaster having fantastic discussion together. Hate to say that we are not getting some of the knowledge in article such Medium, because they just talked casually here. Other than question answering, the Kaggle discussion also shared their solution which is another precious diamond, with the title, 1st place solution.

3. Join competition. By joining competition, we will understand how Kaggle works. There is two type of competition which is code competition and submission competition. When I first knew about code competition, where we need to turn off the internet, it feels really weird. But that how the competition worked.

4. Listen to the Kaggle master and grandmaster talk/podcast. My friend who are Kaggle master always did this to learn something new and implementing in his code. Last weekend, I listened to Giba, the NVIDIA Kaggle Grandmaster. As a novice, he taught a lot of very useful information, tips and technique that can be applied within the data science project or competition.

There might be more. I will update the article soon or later. (Last update: 15-9-2024)

Until I learned about test code, during the time I have been allocated a task which required myself to create an API, was my first encountered of learning the test code and Test Driven Development (TDD).

At that time, my current mind paradigm was challenged by a different idea, by needing to be firm first, then execute. At first, it is such irritating whenever I saw all the errors, due to the code test failure.

However, after a month development and slowly used with it, my way of thiunking has gradually changed, since during the development process, I will put my objective first, before start building the code. It make me a an objective-focus person in order to met the requirement and the test code as the benchmark of the truthfulness.

Not only that, sometimes if I saw that my objective (or test) has sligthly wrong, I need to decide whether to alter the test methodology (reducing the test strictness) or by doing the last choice - moving the goalpost. The later choice is not good practice, but in some situation, it is necessary. Imagine that you want to test the strength of a car. You have decide the shoot the car with M16. Logically it is not the best approach, instead the best way is by crashing car to the wall (according the real world case scenario). Sometimes, the test is wrong, but most of the time your code does not met what you really want.

While, this might be not useful during modelling, due to the nature of experimenting and validating in order to approve or reject the null hypothesis, but at least the process of building pipeline (feature engineering, cleaning, imputation, etc.) would be robust and not a guessing game.

However, due to this setting, Python learning process has removed certain important concept that is quite useful for beginners that I found out in - Rust.

My objective of learning Rust is actually simple. To learn a static typing programming language and taste the memory safety conceptual in coding (which actually I need to learn by enrolling computer science course). I am not sure that I might build something with Rust in the future or what people said just to feel, but I hope I can bring some paradigm that I learn in Rust during writing with Python in my daily task.

The first thing that I found giving some culture shock is the static typing itself. In Python, sometimes we never bother the parameter type hint and return type; due the nature of non-enforcement type hinting in the code. Type hinting is just to help the programmer in developing the project as it will pop-up associated method for the particular type of value in the VSCode. However in Rust, type hint, or what they called types are enforced and also being used by the compiler to do something. For example for casting (or converting) data type in Rust, the type that we put will be used by the compiler so it can know what kind of data type that we want to convert to.

Not only that, I observed that, by enforcing types, the code is much robust, readable and easy for hand-over process in work wise. Just to say that if you felt overwhelmed seeing this kind of heavy type include code, it just a skill issue - no, just kidding, it just you don't know like me and let's learn together. Having types make the code easier to read by other programmers, as they know what kind of types is the parameter, what kind of types return by the function. Simple types that does not existed in Python which is u32 or unsigned 32-bytes integer, which referred to no sign (negative) integer which means, the number will always positive. It is small but somehow cool.

Rust compiler also doing an amazing job of checking the consistency of types and return a helpful stack-trace message for the user so we can check the error part. Another cool stuff of Rust, its compiler stack trace.

Besides, the mutability and ownership concept. In Python, at least in my experience of using Notebook, there is always a situation of what I called as state-conflict where I have no idea what value the variable is actually hold on too and conflicting with another code block; due to running multiple code block in no order, and changing the variable value on another code block, while sharing the same state. With mutability by default in Rust, all variable is immutable unless the mut syntax is implemented. There is no such thing in Python of having bother about mutability where ironically some of the compound data type itself can be manipulated even though it has been stated as immutable (tuple in Python) where there is work around to make it mutable. As per stated by default variable is immutable in Rust, we need to explicitly include mut if we want to enforce the mutability and also consider whether it is growable or not. For example, str is a string that is not growable (cannot add new char in it), while String is growable. Which bring to the next concept which is ownership.

Ownership stated that, a variable always an owner, every value has a single owner, owner will dropped once it is out of scope. A simple objective of implementing ownership is to somehow to avoid "copy"-ing value in order to utilize the memory, by deallocate it once it is out of scope. To be honest, it took me a times to understand this concept, because it is newly introduced to me (which no one care passing value and about memory allocation in Python) and it's quite daunting whenever it comes to struct and implementing the borrowing, as it is proned to error.

And because of the static typing paradigm (where it feels like living in a prison where everything is being observed), your "freedom of not including the type" is also required, within the Generic chapter. What I meant here is, there is a point where we don't want to explicitly put concrete types (i32, String) but we just want to make it general. Hence, to make it general, we need to explicitly tell Rust that we want to do this by using T type. It really feels like in concentration camps, but I kind like about this verbosity.

Rust also has OOP such Python that used struct and their own abstract base classes (ABC) that worked as contract by using impl. To compare both of this language almost has the same feature, however the thing that I loved in Rust is in the module part. In this part, we can explicitly declare the module to become public and private to be access by user by using the syntax pub. I know there is such thing in Python, where it used dunder method (underscore) to make it private and protected, but it seems kind implicit comparing to putting the syntax within the code explicitly. We can exactly see which part of the module, struct, method that can be access and not, making it much easier (I think) in building an the crate and import wise.(I am avoid on talking about Python unresolved parents/relative module import issue that has various kind of answers in Stack Overflow discussion).

If you are a C or Cpp user, I am apologize because all of this things has existed in your language. But I found that Rust has cool documentation and fantastic lesson written so I took the opportunity to learn from it. So far, this is what I felt while learning Rust. It somehow gave me some another point of view of coding that I might bring in my Python style (or if I do build with Rust later on). I still learning (if you found any of the facts are wrong or inaccurate, please do comment so I can correct it), and currently on chapter 10.

I might update this articles later or create new pages for the next updates.

• If you want to learn Python, learn from Corey Chafer or Caleb Curry.

• If you want to learn about Scikit-learn, here is the series from DataSchool.

• If you want to learn Deep Learning, learn from Jared Howard (fast-ai) Series 1, and Series 2

• If you want to start a journey with Pytorch, learn from this series. Good kickstart before rowing the boat yourself.

• If you want to start a journey with Tensorflow, learn from this course. Worth every pennies, rich resources.

• If you want to start learning Huggingface, with all the big giga chad pretrained model, code along with this Transformers docs towards the end.

• If you want to learn FastAPI, learn directly (do hands-on, don't copy) from the docs written by Tiangolo.

• If you want to learn about Linux (though it just to feel), setup your laptop with WSL by following this series (pre-requisite before installing Docker).

• If you want to learn Docker, learn from this page. And checkout this useful cheatsheet too.

• If you want to learn about SQL, but lazy to setup the workbench and server, just use DuckDb with Python.

• Or can just visit my repo where I dumped all useful resources.

• Every programmer started on the line 0.

• Every programmer started with "hello world".

• Every programmer started with a single variable, then function, then OOP (if they want to).

• Every programmer faced the bugs.

• Every programmer started with knew nothing.

• Every programmer did a silly mistake.

• Every programmer felt the impostor in them, while suffer from Dunning-Kruger effect.

• Every programmer has a different pace and capability.

• Every programmer started with a bad practice.

• Every programmer learn new things everyday.

What make them difference, they just persistent.

Artikel asal: https://norvig.com/21-days.html

Penterjemah: Ammar Azman

Pembaca pruf: Ilham Nordin

Kenapa semua orang kelam-kabut?

Menapak ke mana-mana toko buku, anda akan lihat buku bertajuk How to Teach Yourself Java in 24 hours bersama lambakan buku yang lain yang menawarkan pembelajaran dalam beberapa hari atau jam untuk C, SQL, Ruby, Algoritma, dan lain-lain. Carian canggih Amazon untuk [title: teach, yourself, hours, since: 2000] telah menjumpai sebanyak 512 buku. Dalam carta sepuluh teratas, sembilan daripadanya adalah buku-buku pengaturcaraan (sebuah lagi tentang pembukuan). Hasil carian yang sama juga terhasil dengan menukar kata kunci "teach yourself" kepada "learn" atau "hours" kepada "days".

Tuntasnya adalah, sama ada semua orang sedang kelam-kabut untuk belajar tentang pengaturcaraan, atau ilmu pengaturcaraan itu kadang-kadang kelihatan terlalu mudah untuk dituntut berbanding hal-hal yang lain. Felleisen et al. bersetuju dengan tren ini dalam buku mereka How To Design Programs, apabila mereka mengatakan, "Pengaturcaraan yang teruk itu mudah. Si bebal mampu mempelajarinya dalam masa 21 hari, walaupun mereka itu bodoh." Dalam komik Abstruse Goose juga mengatakan sedemikian.

Mari kita cerakin apa maksud yang boleh difahami melalui tajuk buku seperti Teach Yourself C++ in 24 hours:

• Teach Yourself: Dalam masa 24 jam, anda tidak punya masa yang cukup untuk menulis beberapa program yang berkesan dan belajar sesuatu daripada kejayaan dan kegagalan anda melaluinya. Anda tidak punya masa untuk bekerja dengan pengatur cara yang berpengalaman, dan memahami bagaimana hidup dalam suasana dikelilingi C++. Pendek kata, anda tak akan belajar banyak dalam masa yang singkat. Maka, buku ini hanya mampu berbicara tentang perkara-perkara asas, bukannya sesuatu yang mendalam pemahamannya. Sepertimana yang dikatakan Alexander Pope, pelajaran yang singkat itu mengundang nahas.

• C++ : Dalam masa 24 jam, anda mungkin mampu mempelajari beberapa sintaks C++ (jika anda telah pun mengetahui bahasa lain), namun anda tidak mampu untuk belajar bagaimana cara untuk menggunakan bahasa ini. Pendek kata, jika anda, misalnya, seorang pengatur cara Basic, anda boleh mempelajari untuk menulis program dalam langgam Basic menggunakan sintaks C++, namun anda tidak akan mampu belajar apakah kelebihan (dan kekurangan) C++ itu. Jadi, apa gunanya? Alan Perlis pernah menukilkan, "Sebuah bahasa yang tidak memberi impak langsung kepada cara kamu berfikir dalam pengaturcaraan, tidak berbaloi pun untuk kamu tahu." Mungkin anda kena mempelajari secubit C++ (ataupun sesuatu seperti Javascript atau Processing), kerana anda perlu meggunakan alat yang sudah tersedia untuk menyempurnakan tugas tertentu. Tetapi sayangnya, anda tidak belajar untuk mengatur cara, hanya belajar untuk menyelesaikan tugasan.

• in 24 Hours: Malang sekali, ini tidak memadai; sebagaimana yang diterangkan dalam bahagian seterusnya.

Ajar Diri Anda Pengaturcaraan Selama Sepuluh Tahun

Penyelidik (Bloom (1985), Bryan & Harter (1998), Hayes (1989), Simmon & Chase (1973)) telah membuktikan bahawa ia akan mengambil masa selama 10 tahun untuk membina seorang pakar dalam apa jua bidang, termasuklah bermain catur, komposisi muzik, operasi telegraf, mengecat, bermain piano, berenang, bermain tenis, dan penyelidikan dalam neuropsikologi, dan topologi. Kuncinya adalah, latihan secara berterusan yang bermatlamat: bukan hanya mengulang dan mengulang, namun mencabar diri dengan tugasan di luar nalar kemampuan, mencuba, menganalisa prestasi semasa dan selepas melakukannya, dan membetulkan kesilapan. Kemudian ulang. Dan ulang lagi. Sepertinya tiada jalan singkat: walaupun Mozart sendiri, seorang prodigi muzik seawal usia 4 tahun, memakan masa 13 tahun sebelum menghasilkan muzik berkelas dunia. Dalam genre lain, kumpulan Beatles seperti muncul secara tiba-tiba dengan sejumlah lagu bercarta #1, dan membuat kemunculan dalam rancangan Ed Sullivan pada tahun 1964. Namun sebelum itu, mereka telah membuat persembahan di kelab-kelab kecil di Liverpool dan Hamburg sejak 1957, dan meskipun mereka mendapat perhatian ramai sejak awal lagi, kejayaan besar mereka yang pertama, Sgt. Peppers, telah diluncurkan pada 1967.

Malcolm Gladwell telah mempopularkan idea ini, walaupun dia memberi penekanan pada 10,000 jam, bukan 10 tahun. Henri Cartier-Bresson (1980-2004) mempunyai metrik berbeza: "10,000 gambar pertama kamu adalah yang terburuk." (Beliau tidak menyangka bahawa dengan kamera digital, sesetengah orang mampu mencapai jumlah gambar tersebut dalam masa seminggu.) Kepakaran yang sebenar mungkin mengambil masa seumur hidup: Samuel Johnson (1709-1784) berkata "Kecemerlangan dalam mana-mana bidang hanya boleh dicapai dengan hasil kerja seumur hidup; ia tidak akan dapat dibeli pada harga yang lebih murah." Chaucer (1340-1400) pula mengeluh, "Hidup terlalu pendek, menjadi pakar mengambil waktu untuk dipelajari." Hippocrates (c. 400 sebelum masihi) dikenali dengan "ars longa, vita brevis" yang merupakan cebisan daripada madah "Ars longa, vita brevis, occasio praeceps, experimentum periculosum, iudicium difficile", yang mana dalam Bahasa Melayu diterjemah sebagai, "Hidup pendek, belajar banyak, peluang sebentar, eksperimen berliku, penilaian sukar." Sudah tentu, tiada nombor tunggal yang boleh menjadi jawapan akhir: tidak munasabah untuk diandaikan bahawa semua kemahiran (misalnya, pengaturcaraan, bermain catur, bermain dam, bermain muzik) mampu digapai dengan jumlah waktu yang sama untuk menjadi mahir, atau diandaikan bahawa semua orang akan mengambil waktu yang sama untuk menggapainya. Sepertimana yang dikatakan Prof. K, Anders Ericsson, "Dalam kebanyakan domain, luar biasa benar, betapa banyak masa yang diperlukan untuk mencapai prestasi pencapaian tertinggi, walaupun oleh individu yang paling berbakat. Nombor 10,000 jam hanya memberi satu anggaran bahawa kita sedang berbicara tentang 10 hingga 20 jam seminggu, buat bertahun-tahun lamanya; tahun-tahun yang dikatakan perlu dicapai, meskipun mereka yang semula jadinya, paling berbakat."

Jadi Anda Mahu Jadi Pengatur Cara

Berikut adalah resepi saya dalam kejayaan pengaturcaraan:

• Harus ada minat dalam pengaturcaraan, juga buatlah sesetengahnya kerana rasa seronok. Pastikan ia kekal dan cukup seronok agar anda rela hati untuk berkorban selama 10 tahun/10,000 jam.

• Mengatur cara. Cara pembelajaran yang paling baik adalah belajar sambil buat. Secara teknikalnya, "Prestasi aras maksimum setiap individu dalam setiap domain tidak akan diperoleh secara automatik hasil daripada pengalaman yang panjang, namun aras prestasi boleh ditingkatkan, walaupun individu tersebut berpengalaman tinggi, hasil usaha yang bermatlamat untuk menambah baik." (p.366) dan "pembelajaran paling efektif memerlukan tugasan dengan definisi yang jelas bersama kesukaran yang bersesuaian untuk individu tertentu, maklum balas berinformasi, dan peluang untuk mengulangi dan membetulkan ralat." (p. 20-21). Buku Cognition in Practice: Mind Mathematics, and Culture in Everyday Life merupakan rujukan yang menarik untuk sudut pandang ini.

• Bercakap dengan pengatur cara lain; baca program orang lain. Ini lebih mustahak daripada membaca mana-mana buku atau kursus latihan.

• Jika anda mahu, luangkan 4 tahun di kolej (atau lebih, di sebuah universiti). Ini akan memberikan anda akses kepada sesetengah pekerjaan yang memerlukan tauliah, dan ini akan memberikan anda pemahaman yang mendalam dalam bidang ini, namun, jika anda tidak menikmati sekolah, anda boleh (dengan sedikit dedikasi) mendapatkan pengalaman yang sama, secara sendiri atau dengan cara bekerja. Dalam apa jua keadaan, membaca buku tidak akan pernah memadai. "Pembelajaran sains komputer tidak akan menjadikan sesiapa pakar pengatur cara sebagaimana mempelajari berus dan pigmen tidak akan menjadikan seseorang pakar pelukis." kata Eric Raymond, penulis The New Hacker's Dictionary. Salah seorang pengatur cara terbaik yang pernah bekerja dengan saya hanya mempunyai lulusan sekolah menengah; dia telah menghasilkan pelbagai perisian yang baik, mempunyai kumpulan akhbarnya tersendiri, dan cukup berharta dengan stok saham untuk membeli kelab malamnya sendiri.

• Ceburkan diri dalam projek dengan pengatur cara lain. Jadi pengatur cara terbaik dalam sesetengah projek, jadi yang paling teruk dalam sesetengah yang lain. Bila anda merupakan yang terbaik, anda mampu menguji kemampuan anda untuk mengetuai projek tersebut, dan menginspirasi orang lain dengan visi anda. Bila anda yang paling teruk, anda akan belajar apa yang dilakukan oleh mereka yang mahir, dan anda akan belajar apa yang mereka tidak suka lakukan (kerana mereka menyuruh anda lakukan perkara itu untuk mereka!)

• Ceburkan diri dengan projek pasca pengatur cara lain. Fahamkan program yang ditulis oleh orang lain. Lihat bagaimana untuk memahami dan membaikinya apabila pengatur cara asal tidak berada di sekeliling. Fikir tentang bagaimana untuk menggubah program untuk menjadikan ia lebih mudah untuk mereka yang akan mengekalkannya selepas anda.

• Belajar sekurang-kurangnya enam bahasa pengaturcaraan. Masukkan bahasa yang mementingkan pengabstrakan (seperti Java atau C++), satu yang mementingkan pengabstrakan fungsi (seperti Lisp, ML, atau Haskell), satu yang menyokong pengabstrakan sintaktik (seperti Lisp), satu yang menyokong spesifikasi deklaratif (seperti Prolog atau templat C++), dan satu yang mementingkan paralelisme (seperti Clojure atau Go).

• Ingat bahawa adanya "komputer" dalam "sains komputer". Ketahui masa yang diambil untuk komputer anda menjalankan arahan, mendapatkan perkataan daripada memori (dengan dan tanpa cache miss), membaca perkataan berturutan daripada cakera, dan mencari lokasi baru pada cakera. (Jawapan disini)

• Libatkan diri dengan usaha pempiawaian bahasa. Sama ada dengan jawatankuasa ANSI C++, atau menetapkan cara pengekodan anda mempunyai 2 atau 4 aras ruang perenggan. Dengan apa cara pun, anda akan belajar mengenai kegemaran orang lain dalam bahasa, sedalam mana perasaan mereka tentangnya, dan mungkin juga sedikit tentang sebab-sebab mereka rasa sedemikian.

• Mempunyai firasat yang baik untuk keluar daripada usaha pempiawaian bahasa secepat mungkin.

• Dengan segala yang di atas, sejauh mana anda mampu belajar hanya melalui buku menjadi sebuah keraguan. Sebelum kelahiran cahaya mata pertama saya, saya telah membaca kesemua buku How To, dan masih rasa seperti seorang pemula yang dangkal. 30 bulan kemudian, sementara menanti kelahiran cahaya mata kedua, adakah saya kembali kepada buku-buku tersebut sebagai ulang kaji? Tidak. Malah, saya bergantung pada pengalaman peribadi, yang terbukti lebih berguna dan lebih meyakinkan saya berbanding beribu muka surat tulisan pakar-pakar.

Fred Brooks, dalam bukunya No Silver Bullet mengenal pasti rancangan 3 bahagian untuk mencari pereka perisian terbaik:

1. Mengenal pasti pereka terbaik secara sistematik, seawal yang mampu.

2. Meletakkan seorang mentor karier yang bertanggungjawab membangunkan prospek dan menyimpan fail karier secara teliti.

3. Menyediakan peluang bagi pereka yang sedang bertumbuh untuk berinteraksi dan merangsang satu sama lain.

Ini dengan andaian bahawa sesetengah orang telah pun mempunyai kualiti yang diperlukan untuk menjadi pereka yang baik, yang tinggal hanyalah memujuk mereka untuk kerja bersama. Alan Perlis mengatakannya dengan lebih ringkas, "Semua orang boleh diajar untuk mengukir: Michelangelo sepatutnya diajar bagaimana untuk tidak mengukir. Begitu jugalah dengan pengatur cara yang hebat." Perlis mengatakan yang kecemerlangan itu hadir daripada kualti dalaman yang terpancar dengan latihan. Namun, daripada manakah kualiti itu datang? Adakah secara semula jadi? Atau mereka membangunkannya dengan kerajinan? Sepertimana kata Auguste Gusteau (chef fiksyen dalam Ratatouille), "Semua orang boleh memasak, tetapi hanya yang berani akan cemerlang." Saya memandangnya lebih kepada kerelaan hati untuk menumpukan sebahagian besar kehidupan seseorang kepada latihan yang bermatlamat. Mungkin, berani adalah cara untuk mengatakannya dengan ringkas. Atau, seperti kata pengkritik Gusteau, Anton Ego: "Tidak semua orang boleh menjadi artis yang hebat, namun artis yang hebat boleh hadir daripada mana-mana."

Maka, pergilah beli buku Java/Ruby/Javascript/PHP itu; anda mungkin akan beroleh sedikit manfaat daripadanya. Namun, anda tidak akan mengubah hidup anda, atau keseluruhan kemahiran sebenar anda sebagai pengatur cara dalam masa 24 jam atau 21 hari. Bagaimana kalau anda bekerja keras dengan tekal untuk menambah baik selama 24 bulan? Mungkin lepas itu ada progres yang boleh dilihat.

Apendiks: Pemilihan Bahasa

Beberapa orang telah bertanya apakah bahasa pengaturcaraan yang mereka harus belajar dahulu. Tiada jawapan yang tetap, namun timbangkan hujah-hujah berikut:

• Gunakan rakan anda. Apabila ditanya, “Apa sistem pengoperasian yang sepatutnya saya guna, Windows, Unix, atau Mac?” jawapan saya biasanya, “Guna apa sahaja yang rakan anda guna.” Kelebihan yang anda akan dapat dengan pembelajaran daripada rakan-rakan, akan membuatkan perbezaan intrinsik antara sistem operasi atau antara bahasa pengaturcaraan menjadi kecil. Juga pertimbangkan rakan-rakan anda di masa depan: komuniti pengatur cara yang anda akan turut bersama jika anda masih mengatur cara. Adakah anda memilih bahasa yang mempunyai komuniti yang berkembang, atau yang kecil dan sedang nazak? Adakah terdapat buku, laman sesawang, dan forum dalam talian untuk mendapatkan jawapan? Adakah anda suka orang-orang di dalam forum-forum tersebut?

• Ringkaskan. Bahasa pengaturcaraan seperti C++ dan Java direka untuk pembangunan professional oleh pengatur cara berpengalaman dalam sebuah kumpulan besar di mana mereka cakna mengenai kecekapan “run-time” dalam kod mereka. Hasilnya, bahasa-bahasa ini mempunyai bahagian-bahagian rumit yang direka khas untuk keadaan tertentu. Anda mahu mempelajari pengaturcaraan. Anda tidak perlukan kerumitan itu. Anda mahukan bahasa yang rekaannya mudah untuk dipelajari dan diingati oleh setiap pengatur cara baharu.

• Bermain. Cara mana yang anda mahu untuk pembelajaran piano, secara normal dan interaktif, di mana anda mendengar setiap not sejurus selepas anda menekan kekunci; atau mod "kumpulan", di mana anda hanya akan mendengar not selepas keseluruhan lagu tamat? Jelaslah, mod interaktif membuatkan pembelajaran lebih mudah untuk piano, dan juga pengaturcaraan. Pilih bahasa dengan mod interaktif dan gunakannya

Berdasarkan kriteria ini, cadangan saya untuk bahasa pengaturcaraan pertama seharusnya Python atau Scheme. Pilihan lain adalah Javascript, bukan sebab ia direka dengan baik dan sempurna untuk pemula, tetapi kerana terdapat banyak tutorial dalam talian, seperti tutorial Khan Academy. Namun, situasi anda mungkin berbeza, dan terdapat pilihan lain yang lebih baik. Jika umur anda adalah nombor tunggal, anda mungkin lebih suka Alice atau Squeak atau Blockly (pelajar lama juga mungkin gemarkan yang ini). Paling utama adalah anda pilih, dan mula.

Apendiks: Buku dan Sumber-sumber Lain

Beberapa orang telah bertanya daripada buku dan laman sesawang apa yang mereka harus belajar. Saya ulang, “buku sahaja tidak mencukupi”, tapi saya akan mencadangkan berikut:

• Skema: Structure and Interpretation of Computer Programs (Abelson & Sussman) berkemungkinan merupakan pengenalan terbaik untuk sains komputer, dan ia mengajarkan pengaturcaraan sebagai satu cara memahami sains komputer. Anda boleh lihat syarahan dalam talian tentang buku ini, dan juga teks lengkapnya. Buku ini mencabar dan akan menyingkirkan beberapa orang yang mungkin akan berjaya dengan pendekatan berbeza.

• Skema: How to Design Programs (Felleisen et al.) adalah salah satu buku terbaik berkaitan perekaan atur cara dengan cara yang berfungsi dan anggun.

• Python: Python Programming: An Intro to CS (Zelle) adalah bagus untuk pengenalan menggunakan Python.

• Python: Beberapa tutorial dalam talian berada di Python.org.

• Oz: Concepts, Techniques, and Models of Computer Programming (Van Roy & Haridi) dilihat oleh beberapa orang hari ini sebagai pengganti Abelson & Sussman. Ia sebuah perjalanan menyusuri idea-idea besar pengaturcaraan, melingkupi julat yang lebih luas berbanding Abelson & Sussman tetapi lebih mudah untuk dibaca dan diikuti. Ia menggunakan satu bahasa, Oz, yang tidak digunakan secara meluas namun menyediakan asas untuk mempelajari bahasa-bahasa lain.

Nota

T.Capey menyatakan yang muka Complete Problem Solver di Amazon sekarang mempunyai buku "Teach Yourself Bengali in 21 days" dan "Teach Yourself Grammar and Style" di bawah bahagian “pelanggan yang membeli barangan, juga membeli barangan ini”. Saya merasakan sebagian besar orang yang melihat buku itu datang daripada muka surat ini. Terima kasih Ross Cohen untuk bantuan bagi Hippocrates.

Artikel ini ditulis dalam Bahasa Melayu bagi memudahkan pemahaman dalam masa yang sama mengekalkan beberapa perkataan Inggeris yang digunakan secara global.

Penulis telah terpanggil untuk menulis artikel ini dalam proses membuat REST API deployment menggunakan servis AWS beberapa minggu lepas disebabkan hampir tiada atau kurang lengkap artikel yang menerangkan bagaimana cara untuk membuat deployment menggunakan trio - FastAPI, Lambda beserta API Gateway. Segala komen dan kritikan amatlah dihargai daripada para pembaca.

Dalam tutorial ini, penulis hanya memfokuskan langkah-langkah sahaja tanpa pergi terlalu detail kepada servis berkenaan.

Metodologi

FastAPI

Langkah-langkah

1. Cipta virtual environment, aktifkan kemudian install pakej FastAPI dan Mangum.

2. Tulis kod menggunakan pakej FastAPI. Dibawah penulis sertakan contoh kod asas yang akan digunakan.

# main.py
import os
from fastapi import FastAPI
from mangum import Mangum

stage = os.environ.get("STAGE", None)
app = FastAPI(title="My Cat API", 
                root_path="/{stage}/" if stage else "/"),
                openapi_url = "/pet/openapi.json", 
                docs_url = "/pet/docs"
    )

router = APIRouter(prefix="/pet")

@router.get("/")
async def get_root():
    return {
        "author": "Ammar Azman", 
        "status": "succeed!"
    }

@router.get("/meow")
async def hungry():
    return {
        "sound":"meow!"
    }


app.include_router(router)

lambda_handler = Mangum(app)

Keterangan kod

• Environment diperlukan kerana dalam API Gateway terdapat bahagian Stage (yang wajib di-setup!) yang akan menjadikan path API kita mempunyai prefix /dev (berfungsi sebagai proxy). Kod di lokal tetap akan berfungsi (kerana tiada .env) dengan menggunakan logik diatas.

• Prefix untuk setiap path ditambah menggunakan class APIRouter, oleh kerana dalam konfigurasi API Gateway, kita perlu cipta Resource (nama perlu sama, iaitu /pet) supaya API Gateway dapat hit path tersebut. Disebabkan itu juga, string untuk openapi_url dan docs_url juga perlu diubahsuai dengan menambah /pet dihadapan bagi membolehkan kita melihat dokumentasi API.

• Mangum digunakan supaya kesemua API boleh diwrap menjadi lambda function, yang juga akan dipanggil semasa konfigurasi AWS Lambda.

• Jalankan command dibawah dan uji API anda -

uvicorn main:app --reload

• Uji kesemua API dengan membuat request. Jika okay, sambung ke proses seterusnya.

AWS Lambda

Nota: Sebelum anda setup Lambda, penulis menganggap bahawa anda telah mendapatkan segala permission untuk mencipta fungsi Lambda di AWS Lambda dan API Gateway.

Langkah-langkah

1. Cipta fungsi Lambda baharu. Katakan nama fungsi adalah, my_cat_lambda.

   

2. Pilih runtime versi Python yang merujuk kepada versi Python yang anda gunakan. (wajib sama!)

3. Setelah selesai, pergi kepada Configuration tab >> Edit.

4. Tambah Key - "STAGE" dan Value - "dev" dalam Environment Variable.

5. Kemudian, pada Code tab, ubah handler kepada app.main.lambda_handler.

6. Selesai ubah, muat naik fail zip yang mempunyai kod dan semua pakej ke S3, dan pass URL object tersebut. (pastikan kod berada dalam fail - bererti dalam format modul. Dalam tutorial ini, kod berada dalam direktori /app)

7. Tekan pautan yang diberikan Lambda.

8. Pastikan untuk tambah /pet diakhir URL (disebabkn prefix dalam router).

9. Anda akan lihat output dibawah pada skrin

    {
            "author": "Ammar Azman", 
            "status": "succeed!"
        }
   

10. Tambah lagi /docs pada hujung URL untuk melihat API docs. Pautan tersebut akan gagal. Akan tetapi, ini telah dijangka disebabkan terdapat "dev" dalam environment.

Nota: Anda boleh automate proses (CI/CD) muat naik setiap kali mengemaskini kod baru dengan menggunakan Git Action.

API Gateway

Langkah-langkah

1. Pada muka AWS Lambda, tekan Add trigger.

2. Pilih API Gateway dan new api.

3. Pilih REST API.

4. Tekan Add.

5. Pada search bar, cari servis API Gateway dan klik.

6. Cari nama fungsi Lambda anda (my_cat_lambda) dan klik. Anda akan dibawa ke muka dimana terdapat API Gateway untuk fungsi Lambda anda.

7. Pada Resource tab, klik Create Resource.

   

8. Setkan Resource path kepada / dan Resource name kepada nama prefix dalam kod (pet). Klik tanda pada CORS juga. Kemudian klik Create resource.

9. Langkah 8 akan diulang semula dengan Resource path kepada /pet dan Resource name kepada {proxy+}.

10. Setelah selesai, cipta Method untuk /pet dan {proxy+} dengan method ANY.

11. Kemudian, klik Deploy API dan pilih stage dev jika sudah dicipta pada Stage, atau jika belum, cipta satu Stage bernama dev.

12. Klik Deploy API.

13. Pergi semula kepada muka AWS Lambda anda, dan klik Configuration >> Trigger.

14. Klik URL yang diberikan API Gateway dan boleh cuba request.

15. Jika berjaya, tahniah, anda telah berjaya deploy API anda!

Konklusi

Langkah diatas mungkin akan obsolete pada masa akan datang. Namun penulis berharap tutorial ini dapat memudahkan anda yang merancang untuk deploy API anda menggunakan servis AWS.

Sebarang komen penambah-baikan amatlah dialukan. Jika tutorial ini membantu, kongsikan pada rakan-rakan anda. Sampai jumpa lagi.

Mentaliti Progressive Overload, Mula daripada kecil, dan KISS

Konsep ini saya ambil daripada konsep asal mengangkat beban di gimnasium, iaitu pendekatan progressive overload. Konsep progressive overload adalah dimana seseorang itu bermula mengangkat beban yang ringan, seterusnya beban ditambah dan ditambah yang akan melatih dan meningkatkan kekuatan dan daya tahan otot.

Konsep ini boleh diaplikasikan kepada seorang pengaturcara dalam fasa pembangunan kod. Hatta, dalam proses pembelajaran pun, kita semua bermula dengan "Hello World" dan bukan Object Oriented Programming! Kita semua bermula dengan asas, kemudian secara kumulatif kesukaran itu ditingkatkan dan ditingkatkan. Gunakan pendekatan Keep It Simple Stupid (KISS) sebelum menggubah kod kepada bentuk yang lebih sofistikated.

Mulakan dengan langkah kecil.

Memecahkan Masalah kepada Blok Kecil

80% kerja seorang pengaturcara adalah menyelesaikan masalah. Masalah boleh terjadi akibat daripada struktur kod, konsep fundamental, nyahpepijat dan lain-lain lagi. Dalam hal ini, ia tertakluk bagaimana seorang pengaturcara menghadapi masalah. Dengan cara yang betul, masalah boleh diselesaikan, walaupun mungkin bukan dalam jangka masa yang pantas sekalipun.

Kita boleh menyelesaikan masalah dengan cara memecahkannya kepada blok-blok yang lebih kecil. Umumnya, apabila kita menghadapi masalah, kita akan cenderung untuk berfikir lebih kehadapan dengan persoalan what if atau "Macam mana kalau...". Namun, praktis ini kurang baik kerana membuatkan kita menjadi seorang yang lewah fikir (over thinking) yang mana akhirnya tidak menyelesaikan masalah yang dihadapi.

Dengan memecahkan masalah menjadi lebih kecil, kita akan cuba mendalami setiap komponen masalah dengan lebih teliti dan sistematik. Teliti dengan makna kata, masalah mungkin berpunca daripada perkara fundamental seperti tidak membaca dokumentasi, tersilap pada konsep asas, atau perkara remeh yang kita tidak perasan. Sistematik pula adalah kita dapat mengesan satu persatu punca permasalahan tersebut dan merekod status masalah supaya tidak berlaku pengulangan masalah akibat daripada pendekatan yang tidak teratur dalam menyelesaikan masalah.

Penulis mencadangkan pembaca untuk cuba menggunakan Obsidian ataupun Notion untuk mengaplikasikan teknik ini.

Mencari Kebenaran Tunggal dan Mengesahkan Andaian

Salah satu proses pembelajaran adalah apabila kita yakin dengan kebenaran sesebuah fakta tersebut melalui bukti dan timbang tara dalam berfikir. Perkara ini normal, namun adakalanya sikap "yakin" ini terbawa-bawa kepada seorang pengaturcara apabila menghadapi pepijat dalam kod ataupun pandangan berbeza yang datang di kemudian hari. Ini tidak akan berlaku jika kita berada dalam skeptik yang terkawal dan tidak mudah-mudah menjadikan ia sebagai sebuah perkara tuntas.

Kita boleh skeptik dengan 2 cara iaitu dengan mengesahkan pengangan kita melalui bukti daripada sumber terpercaya yang menjadi kebenaran tunggal (iaitu dokumentasi) ataupun dengan cara mencabarnya dalam bentuk hipotesis. Hipotesis boleh kekal dalam bentuk hipotesis selagimana ia tidak disandarkan pada bukti, dan juga boleh runtuh jika dicabar dengan hipotesis yang lain yang disandarkan pada bukti. Dengan itu, kebenaran tadi tidak akan bersifat asbolut, terus disahkan, dan kita akan lebih fleksibel untuk menerima perkara baru.

Dalam aspek pengaturcaraan pula, kita boleh menggunakan testing sebagai alat untuk menguji kod yang telah ditulis supaya ia mengikut spesifikasi yang diharapkan (juga kebenaran tunggal). Disebabkan itu, pendekatan Test Driven Development (TDD) adalah sangat penting supaya kod yang kita hasilkan tidak tergelincir daripada objektif yang telah kita tetapkan lantas perasaan skeptik dalam diri kita dapat disucikan.

Alat adalah Alat, yang Penting Fungsinya

Masalah yang selalu terjadi terutamanya kepada pemula adalah, terlalu kerap berfikir dan bertanya "Mana yang lebih baik?"

Sehinggakan akhirnya tidak mula bertindak dan berbuat apa-apa. Ini barangkali disebabkan lewah fikir, terlalu risau dan takut mengambil risiko (walaupun risiko masih dalam kawalan). Walhal apa yang dibandingkan itu mempunyai objektif akhir yang sama, namun disebabkan terlalu membanding-banding, akhirnya masa terbuang begitu sahaja tanpa apa apa tindakan.

Umpama kita ingin bergerak ke suatu destinasi dan dihadapan kita terdapat 2 buah basikal, iaitu basikal merah dan biru. Kedua-duanya mempunyai objektif yang sama iaitu membawa kita ke titik destinasi. Basikal merah dan biru mungkin mempunyai sedikit perbezaan namun tidaklah terlalu ketara. Namun, jika kita terlalu runsing memikirkan basikal mana yang lebih baik, yang lebih mudah, yang lebih lancar, tidak akan membuatkan kita jatuh ketanah dan terluka, akhirnya sampai esok tidak akan sampai ke destinasi akhir! Seolah-olah kita takut untuk jatuh daripada basikal tersebut, walaupun hakikatnya kita belum pun mula mengayuh lagi.

Jika anda mengalami masalah ini, penulis cadangkan berfikir dengan cara - nothing to lose. Mulalah dengan mana-mana alat sekalipun. Kalaupun kita silap memilih alat, kita telah mempelajari sesuatu daripada kesilapan tersebut. Setelah membuat silap, kita bergerak dan cari solusi yang lain. Hidup ini memang begitu, tak semua yang kita harapkan menjadi, maka kita belajar.

Tetap Belajar

Dalam dunia teknologi yang bergerak semakin pantas, kita tidak ada pilihan lain untuk tetap belajar dan belajar. Semangat ini penting atas beberapa sebab yang saya rasakan amat mustahak untuk dinyatakan.

Pertama, tetap belajar mengasah skil menyelesaikan masalah. Semakin banyak kita belajar, semakin banyak kita buat silap, semakin tinggi daya dan kebolehan kita untuk menghasilkan jalan penyelesaian sama ada pendek atau panjang.

Kedua, tetap belajar menjadikan kita manusia yang tidak mudah selesa dengan sesuatu. Mempelajari sesuatu bermakna kita juga perlu menghadapi cabaran-cabaran yang baharu. Cabaran ini membuatkan kita tidak selesa namun dalam konotasi yang positif. Proses "tidak selesa" bermakna otak sedang mencerna sesuatu. Seperti kita melihat pupa rama-rama yang bersungguh-sunggu melepaskan diri daripada kongkongan pupa, yang akhirnya di akhir proses tersebut menjadikan ia seekor rama-rama yang indah, seperti itulah kita akan mencapai tahap "Ohh..." dimana kefahaman tercapai.

Akhir sekali, tetap belajar menjadikan kita lebih merendah diri dalam apa-apa bidang sekalipun. Biasa kita mendengar ungkapan "Semakin kita belajar, semakin banyak yang kita tidak tahu." (Dunning-Kruger Effect). Sikap rendah diri ini menyebabkan kita akan lebih laparkan ilmu pengetahuan dan terus menerus memperbaiki diri semasa ke semasa.

Kesimpulan

Cara fikir yang dinyatakan diatas tidak mampu dibentuk dalam masa sehari. Ia memerlukan proses, yang mungkin memakan masa berbulan mahupun bertahun. Namun penting untuk kita fikirkan dan tanam dalam diri supaya ia dapat membantu kita menjadi seorang pengaturcara yang lebih baik, suatu hari nanti.

Sumber

1. The Pragmatic Programmer - Andrew Hunt & David Thomas

2. 5 Ways First Principle Thinking Helps You Code Better - ArjanCodes Channel

3. Obisidian

Setahun selepas penulis memulakan perjalanan dalam arena pengaturcaran dan cuba mengamalkan pendekatan ini, banyak yang penulis telah pelajari. Bukan sahaja dapat belajar perkara baharu, tetapi juga berkenalan dengan mereka yang lebih berpengalaman, mengorek ilmu pengetahuan mereka sekaligus meningkatkan mutu kod dan pengetahuan. Beberapa cara yang telah penulis lakukan sewaktu mengamalkan pendekatan kod di khalayak.

Komuniti

Untuk sesetengah manusia, mungkin bertanya adalah sesuatu yang berat, sesuatu yang memerlukan kekuatan. Tetapi dengan hanya bertanya, dengan sebuah soalan, ia menjadi pintu kepada sebuah perjalanan dan pengalaman baharu. Dengan wujudnya komuniti, anda tidak perlu lagi khuatir kerana disini anda akan jumpa dengan ramai pengaturcara untuk mendapatkan sokongan dan bantuan.

Penulis mempunyai beberapa tempat yang biasanya digunakan bagi menyelesaikan masalah kod atau debug.

Biasanya penulis akan mulakan dengan Stack Overflow. Disini tempat dimana berkumpulnya soalan-soalan daripada segenap pelusuk dunia. Masalah dalam pengaturcaraan biasanya dialami oleh pengaturcara lain. Masalah yang anda hadapi berkemungkinan besar telah dihadapi dan telah diselesaikan oleh orang lain. Namun, jika anda telah mencari sepuasnya di Internet, mahupun di Stack Overflow tetapi tidak menjumpai, maka anda boleh mula untuk bertanya disana.

Pastikan anda menulis konteks persoalan atau masalah yang telah berlaku dengan jelas. Jika ada, sediakan tangkap layar atau sebahagian baris daripada kod dan juga mesej ralat yang terhasil. Ini bagi memudahkan pengguna lain yang mempunyai jawapan untuk menjawab soalan yang ditanyakan.

Jika masalah tidak juga dapat diselesaikan, maka anda boleh cuba untuk bertanya dalam kumpulan komuniti dalam talian. Contohnya adalah komuniti di Telegram, Discord dan Slack. Kumpulan dalam talian juga adalah tempat dimana pakar, pengaturcara senior, junior, pemula berkumpul dan membincangkan hal-hal yang berkaitan dengan teknologi dan pengaturcaraan.

Sumber Terbuka

Dengan sumber terbuka, anda boleh memilih sama ada untuk menulis projek anda sendiri ataupun menyumbang kepada projek orang lain.

Menulis projek sendiri memberikan pengalaman untuk merasai pengalaman membuat sebuah aplikasi. Anda adalah laksamana dalam kapal anda. Anda yang menetapkan objektif projek, bahasa pengaturcaran, pengkalan data, tabung awan dan sebagainya.

Apabila ia dinamakan projek sumber terbuka, maka ia terbuka kepada sesiapa yang mahu menyumbang kepada projek ini. Maka daripada sini, budaya perbincangan, persoalan, cadangan penambahbaikan akan bercambah sekaligus mempercepatkan pembangunan projek menuju kepada objektif yang telah ditetapkan.

Jika tidak ingin menulis projek sendiri, menyumbang kepada projek sumber terbuka juga adalah salah satu cara untuk belajar daripada kesilapan. Anda boleh menyumbang apa jua jenis pertolongan kepada projek terbuka daripada sekecil-kecil membetulkan kesalahan ejaan dalam dokumentasi, sehingga sebesar-besar pemfaktoran (jika diterima haha!).

Apa yang lebih penting sebenarnya adalah bagaimana anda mampu mencipta masalah dan menawarkan solusi yang mana menjadi salah satu proses untuk terus belajar dan belajar.

Jika anda berminat untuk menyumbang kepada sumber terbuka, beberapa perkara yang anda harus ketahui iaitu:

1. Git

2. Github

Selepas anda mempelajari kedua perkara ini, anda boleh melayari laman sesawang Free-XP iaitu sebuah laman sesawang yang menyenaraikan senarai projek terbuka di Github. Anda boleh memilih mana-mana projek yang anda minati dan mulakan perjalanan kod di khalayak pertama anda!

Media Sosial

Penulis mendaikan anda pastinya mempunyai media sosial, samada Facebook, Instagram mahupun Twitter. Disini juga anda boleh mempraktikkan kod di khalayak dengan bertanyakan soalan ataupun menjawab pertanyaan orang lain.

Media sosial bukan sahaja tempat anda bersosial, malah bertemu dengan professional. Maka gunakan media sosial dengan sewajarnya supaya anda dapat mempelajari sesuatu dan memudahkan proses pembelajaran anda ke peringkat seterusnya.

Ada juga sesetengah pengaturcara yang menulis kod secara siaran langsung dengan menggukan aplikasi Twitch mahupun Tiktok. Orang ramai dapat melihat secara langsung proses penulisan kod dan (barangkali) dapat melatih anda untuk menghadapi tekanan semasa menulis kod sambil diperhatikan.

Kesimpulan

Tuntasnya, kod di khalayak mampu menjadi catalyst untuk anda terus belajar dengan lebih efektif dan pantas. Menyimpan masalah anda seorang diri adalah tidak digalakkan kerana akan membantutkan lengkung pembalajaran anda.

Sekian artikel kali ini, sampai jumpa!

As on 11th May 2023, 9:32 AM, these are some of the setups that I found might be useful for a small project.

1. Decide who is the admin and maintainer. Both have different access in the repo.

2. Plan how the project would be built based on the branch that would be created.

   1. You can decide whether to preserve themain branch code as it is without doing any commit on it or make it a branch that you will add a new feature (or patch) for the dev_branch.

   2. You can create a branch for deployment as it becomes the base branch (other than main) to become the core source for dev branch.

   3. For debugging or adding a simple feature, you can create a branch from the base branch (might be the dev branch where bugs exist) and apply fast-forward merge to solve it.

3. Create branch rule.

   This is crucially important to strictly prohibit the flow of merging the code to the main or base branch. In branch rules;

   1. At least 1 or 2 people to review the Pull Request before proceeding to merge.

   2. Prevent force pushing.

   3. Restrict who can push to matching branches — restricting certain people who can push directly to the base branch. Other than the allowed person, they can make a PR but are not allowed to merge in PR.

4. Required status checks.

   1. Checking one by one the commit in the PR — checks using Github Action

      https://github.com/marketplace/actions/easy-coding-standard-action

   2. Unit test

5. Define CODEOWNERS

   • define the specific reviewers; ie expertise

This writing might be updated soon or future whenever found new advice or suggestion.

Merge adalah sebuah tindakan dimana git akan menggabungkan commit yang telah dibuat menjadi satu commit yang baharu pada hujung (tip) sesebuah git history.

Jika di lokal, kita boleh melakukan git merge untuk mencantumkankan commit daripada feature_branch kepada main_branch. Namun, ia sedikit berbeza apabila kita ingin melakukannya pada penyedia cloud hosting seperti Github.

Terdapat dua keadaan yang membezakan cara untuk merge commit di Github.

1. Keadaan Branch tidak dilindungi

2. Keadaan Branch dilindungi

Branch tidak dilindungi

Sebuah branch yang tidak dilinduingi bermaksud branch tersebut tidak termaktub kepada peraturan-peraturan tertentu yang boleh di buat pada Github. Misalnya branch ini membenarkkan sesiapa sahaja untuk di- merge kepada dan juga daripada mana-mana feature branch yang ada.

Untuk branch jenis ini, kita boleh sahaja membuat commit dan merging seperti biasa di lokal kemudian push ke Github.

# pastikan berada di main branch 
$ git checkout main
# commit sesuatu perubahan 
$ git checkout -b feature_1 
$ git add . 
$ git commit -m "commit pertama"

# push branch ke remote
$ git push --set-upstream feature_1 origin 

# proses merge
$ git checkout main
$ git merge feature_1 

# push ke remote github
$ git push

Selepas menjalankan command diatas, kita akan mendapati main branch pada remote telah dikemaskini daripada feature_1 branch. Proses merging telah berjaya tanpa melibatkan penggunaan UI di Github (iaitu Pull Request atau PR)

Branch dilindungi

Sebaliknya, jika branch tersebut dilindungi; yakni terdapat peraturan yang telah ditetapkan supaya pengaturcara tidak boleh sewenang-wenangnya merge dan push daripada branch lain seperti yang berlaku keadaan branch tidak dilindungi. Disebabkan ia dilindungi, maka cara yang ditunjukkan pada keadaan pertama tidak dapat dilakukukan.

Ini keraana atas sebab peraturan yang telah ditetapkan, Github akan menghalang daripada pengguna untuk push commit tersebut melaikan ia melepasi pertaturan yang telah ditetapkan.

Kebiasaannya branch dilindungi akan mempunyai lapisan dibawah

1. Code review — kod akan disemak oleh ahli projek dan menunggu untuk approval

2. Code testing — Kod akan melalui testing (unit test, etc) yang telah ditetapkan dalam Git Actions.

Maka, apakah langkah untuk melakukan merge kepada main branch supaya anda boleh mengemaskini/menambah kod baru kepada projek anda untuk keadaan ini?

Kita perlu melakukan apa yang dinamakan sebagai Pull Request.

Pull Request

Proses Pull Request (PR) adalah seperti berikut:

1. Buat commit seperti biasa

# Cipta branch baharu
$ git checkout -b my_branch 
$ git push --set-upstream my_branch origin 
$ git add . 
$ git commit -m "menambah sesuatu"

1. Github akan mengeluarkan notifikasi mengenai commit yang telah berlaku dengan butang pull request. Tekan butang pull request tersebut.

   (Jika tidak ada notifikasi tekan pull request pada projek repo anda di Github dan tekan Create new pull request.)

2. Setelah menekan Pull request, Github akan memaparkan Compare change dan kita perlu memilih

   • Compare branch (feature branch)

   • Base branch (main branch)

3. Pilih my_branch sebagai compare, dan main sebagai base untuk kita merge my_branch kepada main.

4. Selepas itu Github akan memaparkan seksyen dimana jika kod anda melepasi testing dan juga kod anda perlu melalui code review (approval boleh dibuat oleh sesiapa sahaja yang terlibat dalam projek, atau orang tertentu.)

5. Selepas Approve dan Submit review diberikan oleh pengaturcara lain, maka kod anda telah bersedia untuk dicantukan kepada base branch yang telah ditetapkan.

6. Tekan Merge pull request dan kod akan dicantumkan. Siap!

Mengapa perlu sedemikian?

Anda sedia maklum bahawa penggunaan Git dapat membantu projek yang besar dan melibatkan ramai pengaturcara. Github telah menjadi sebuah tempat dimana sumber kod disimpan dan digunakan untuk tujuan deployment. Maka amat mustahak kod-kod ini dijaga dan dilindungi daripada sebarang kesilapan dan masalah yang boleh menyebabkan kod-kod legasi tadi mengalami ralat.

PR secara tidak langsung mencipta satu lapisan (boleh jadi beberapa lapisan) yang menjadi penghalang sebelum sesebuah feature atau penambahan berlaku ke dalam kod yang asal.

Dalam code review, pengaturcara lain boleh menyemak struktur kod tersebut samada boleh diterima, tidak baik atau memerlukan penambah baikan. Disini juga pengaturcara boleh mengkritik mengenai kod yang ditulis sekaligus menjadi tempat perbincangan.

Code testing pula boleh di setup bagi memeriksa kod yang ditulis seperti, memenuhi kriteria cara penulisan kod untuk projek tersebut, atau menyemak samada kod tersebut tidak terdedah kepada penyelewengan dan sebagainya.

Anda boleh menetapkan peraturan-peraturan sesebuah branch di Setting dan pilih Branch untuk menentukan bagaimana branch tersebut dilindungi.

Sekian itu saja daripada saya. Cuba lakukan PR anda sendiri dan komen jika artiken ini membantu. Selamat mencuba.

Sumber

1. Rajah: https://wac-cdn.atlassian.com/dam/jcr:c6db91c1-1343-4d45-8c93-bdba910b9506/02%20Branch-1%20kopiera.png?cdnVersion=1031

Object-oriented programming (OOP) adalah sebuah pendekatan dalam pengaturcaraan yang menjadikan objek sebagai rujukan akses kepada metod (fungsi) tertentu. Dalam Python, OOP diprogram menggunakan katakunci Class.

Dalam Class, anda boleh rangkumkan beberapa metod atau operasi yang mempunyai perkatainan antara satu sama lain. Misalanya jika kita mencipta Class operasi matematik, dalam Class tersebut seharusnua terdapat metod penambahan, penolakan, pembahagian dan lain-lain lagi, bergantung kepada pengaturcara itu sendiri. Anda juga boleh mencipta atribut (seperti pemboleh ubah jika diluar Class) yang dapat digunakan oleh metod Class tersebut.

Dalam membangunakan OOP, terdapat beberapa konsep atau pendekatan tertentu yang biasa dipraktikkan.

Antara pendekatan yang biasa digunakan adalah:

1. Perwarisan (Inheritance)

2. Pengkapsulan (Encapsulation)

3. Polimorphism (Polymorphism)

Nota:

Jika anda belum terbiasa dengan konsep OOP, penulis menyarankan anda untuk berkenalan dengan OOP dahulu sebelum meneruskan pembacaan artikel ini.

Perwarisan

Seperti namanya, perwarisan boleh dianalogikan seperti ibubapa yang mewariskan genetik mereka pada si anak.

Dalam konteks Python, terdapat Class ibubapa dan Class anak.

Class anak akan mewarisi Class ibu bapa, seperti mana anak yang mewarisi ciri ibu bapanya.

Mari kita lihat bagaimana caranya untuk menggunakan Perwarisan dalam Class.

class Animal:
    def __init__(self, height, animal_type):
        self.size = height
        self.animal_type = animal_type

    def get_height(self):
        print(self.height)

    def get_animal_type(self):
        print(self.animal_type)

# perwarisan
class ExtendAnimal(Animal):
    def init(self, height, weight, animal_type, movement):
        self.height = height
        self.weight = weight
        self.animal_type = animal_type
        self.movement = movement
    def get_height_weight(self):
        self.get_height()
        print(self.weight) # extension
    def get_type_movement(self):
        self.get_animal_type()
        print(self.movement) # extension


fish = ExtendAnimal(5, 10, 'Amphibian', 'Swimming')
fish.get_height_weight()
fish.get_type_movement()

Output:
5
10
Amphibian
Swimming

Contoh kod diatas adalah contoh perwarisan Class.

Class yang pertama iaitu Animal adalah Class yang memaparkan ciri haiwan iaitu height dan animal_type.

Class yang kedua iaitu ExtendAnimal telah mewarisi (class ExtendAnimal(Animal)) daripada Class yang pertama dan telah menambah keupayaan Class pertama jika dilihat pada metodnya.

Kita dapat melihat bagaimana Perwarisan dapat menambah lagi fungsi Class pada metod get_height_weight()yang mengeluarkan output height yang diwariskan daripada Class Animal. Metod ini juga adalah extension daripada metod get_height daripada class Animal yang mana ia mengoutput weight dalam masa yang sama.

Dengan mewarisi Class ibubapa, Class anak mempunyai keupayaan tertentu hasil daripada perwarisan tadi. Antaranya;

1. Class anak mempunyai ciri yang sama daripada Class ibu bapa.

2. Class anak boleh ditambah kemampuan kegunaan metodnya.

3. Class anak boleh dikemasikini (*update*) tanpa mengganggu kod asal daripada Class ibubapa.

4. Atribut dan method dalam Class anak boleh mengatasi (*override*) Class ibubapa.

5. Class ibubapa boleh berkongsi atribut kepada Class anak.

6. Mencipta heirarki Class berturutan daripada Class ibubapa kepada Class anak.

Jadi apa kebaikan jika kita menggunakan pendekatan ini?

1. Pengaturcara mampu menambah baik kod asal tanpa mengubahsuai struktur kod tersebut.

2. Class anak boleh mewarisi keseluruhan ciri Class ibubapa, atau mewarisi sebahagian sahaja daripada ciri Class ibubapa. Ini memberi kawalan yang baik kepada pengaturcara untuk menambah baik Class ibubapa dengan had tertentu.

Pengkapsulan

Pengkapsulan adalah sebuah pendekatan dimana metod-metod dirangkumkan dalam satu unit.

Penggunaan Class dalam Python itu sendiri adalah sebuah pengkapsulan.

Pengkapsulan dapat menyekat akses kepada atribut dan metod dalam Class (underscore variable dan penggunaan metod yang hanya diketahui oleh pencipta kod tersebut) yang dapat mengelakkan daripada data diubahsuai daripada kod atau pengguna luar.

Andaikan anda ingin mencipta sebuah Class yang mengandungi maklumat rahsia ejen peribadi. Tentu sahaja anda tidak mahu informasi ini dimanipulasi atau diubahsuai oleh kod atau pengguna luar.

Maka untuk menjadikan atribut tersebut peribadi, gunakan 2 underscore seperti kod dibawah;

class ClassifiedInfo:
    def init(self, name, height, weight, country, gender):
        self.name = name
        self.__height = height
        self.__weight = weight
        self.__country = country
        self.__gender = gender
    def get_agent_information(self):
        print(f'{self.name} information:\
        \nGender: {self.__gender}, \
        \nCountry: {self.__country},')
    def get_agent_height(self):
        print(f'Height: {self.__height}')

agent_1 = ClassifiedInfo("Jack", 178, 89, "Brazil", "Male")\
agent_1.get_agent_information()
agent_1.__height

Output:

Jack information:
Gender: Male,
Country: Brazil,
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[34], line 20
17 agent_1 = ClassifiedInfo("Jack", 78, 189, "Brazil", "Male")\
19 agent_1.get_agent_information()
---> 20 agent_1.__height
AttributeError: 'ClassifiedInfo' object has no attribute '__height'

Jika diperhatikan, output daripada agent_1.__height adalah ralat atribut. Ini bermakna maklumat height tidak mampu diakses sewenenang-wenangnya.

Dengan menggunakan dua underscore, ia boleh melindungi atribut dalam Class daripada dimanipulasi oleh kod atau pengguna luar.

Jadi bagaimana caranya untuk mengakses atribut peribadi ini? Dengan mencipta metod yang dapat diaksesnya. Dalam kod diatas, penulis telah mencipta sebuah metod get_agent_height yang mana metod ini akan mengeluarkan output maklumat ketinggian agent ini.

Ini bermakna, pengguna luar tidak berupaya untuk mengakses atribut peribadi dalam sesebuah kod, dan hanya pembangun kod sahaja yang mampu mengakses data tersebut dengan menggunakan metod yang dia ciptakan.

Dalam kod diatas, penulis telah mencipta metod get_agent_height() untuk mengakses maklumat atribut height .

# mengakses atribut peribadi
agent_1.get_agent_height()

Output:

Height: 178

Maklumat height telah berjaya diakses.

Kebaikan menggunakan pengkapsulan adalah;

1. Punca ralat dapat dikenalpasti dengan merujuk nama Class dan metod.

2. Pengaturcara dapat melindungi data tertentu daripada diubahsuai oleh pengguna luar.

Polimorfism

Polimorfism berasal daripada bahasa Greek, bermakna sesuatu yang wujud dalam bentuk (morfo) yang pelbagai (poli).

Dalam konteks OOP, Class akan yang sama akan dicipta dalam pelbagai bentuk.

Konsep polimorfism telah digunakapakai secara meluas dalam pengaturcaraan. Antara contoh polimorfism dalam Python adalah simbol tambah (+) itu sendiri.

# penambahan nombor
value_a = 12
value_b = 5
print(a+b)
# penggabungan string
string_1 = “Hello”
space = “ “
string_2 = “World!”
print( string_1 + space + string_2)

Output:
17
Hello World!

Dalam Python, jika simbol tambah digunakan pada nombor (interger), ia akan menambahkan nilai nombor tersebut. Manakala jika digunakan pada perkataan (string), perkataan tersebut akan digabungkan. Maka simbol tambah ini bergantung kepada input apa yang diberikan. Ia simbol yang sama, tapi boleh wujud dalam kegunaan berbeza.

Mari kita lihat bagaimana anda boleh mengaplikasikan polimorfism pada Class dalam Python.

class Jack:
def init(self, age, gender, address):
    self.age = age
    self.gender  = gender
    self.address = address

    def get_age(self):
        print(f'Age: {self.age}')

    def get_gender(self):
        print(f'Gender: {self.gender}')

    def get_address(self):
        print(f'Address: {self.address}')

class Jenny:
    def __init__(self, age, gender, address):
        self.age = age
        self.gender  = gender
        self.address = address

    def get_age(self):
        print(f'Age: {self.age}')

    def get_gender(self):
        print(f'Gender: {self.gender}')

    def get_address(self):
        print(f'Address: {self.address}')

jack = Jack(19, 'male','USA')
jenny = Jenny(21, 'female', 'Colombia')

Dalam kod diatas, Class Jack and Jenny mempunyai struktur yang sama; dengan nama metod yang sama tetapi bentuk (nama Class) yang berbeza. Ini adalah konsep polimorfism.

Daripada objek diatas, anda boleh menggunakan kesemua metod untuk mendapatkan output dengan cara berikut:

1. Menggunakan for loop

for info in (jack, jenny):
    info.get_age()
    info.get_gender()
    info.get_address()

1. atau; Menggunakan class atau function lain

class Extract:
    def get_info(self, object_class):
        object_class.get_age()
        object_class.get_gender()
        object_class.get_address()

extract = Extract()
extract.get_info(jack)
extract.get_info(jenny)

Kedua dua cara di atas akan menghasilkan output yang sama.

Output:

Age: 19
Gender: male
Address: USA
Age: 21
Gender: female
Address: Colombia

Gabungan konsep

Ketiga-tiga pendekatan diatas boleh digunakan secara bersendirian. Namun ini tidak bermakna kita tidak boleh menggabungkannya ataupun menggunakan satu pendekatan untuk mencipta pendekatan yang lain.

Contohnya:

1. Perwarisan dan Polimorfism boleh digunakan untuk mencipta class yang mampu untuk overriding atribut dari Class sebelumnya.

2. Dalam pengkapsulan boleh ada sebuah perwarisan (antara subclass)

Penutup

Bentuk-bentuk ini bergantung kepada kesesuaian keadaan dan bagaimana seorang pengaturcara untuk menyelesaikan masalah yang dihadapinya semasa membangunakan sesebuah kod.

Idea untuk menentukan pendekatan yang mana lebih baik tidak hadir dalam masa yang singkat. Pengalaman yang ditambah secara konsisten dalam pengaturcaraan dan kaedah cubajaya dapat membantu pengaturcara untuk menentukan konsep yang terbaik.

Sampai disini sahaja artikel kali ini. Jangan lupa untuk cipta Class anda selepas ini menggunakan konsep-konsep diatas. Jika terdapat kekeliruan ataupun persoalan atau penambahbaikan, penulis mengalu-alukan komen pembaca pada ruangan dibawah.

Sampai jumpa, salam!

Apabila kita menulis kod, kebanyakan masanya kita akan menggunakan pakej atau pustaka untuk tujuan tertentu. Misalnya meggunakan pakej Sklearn untuk mesin pembelajaran, Pandas untuk mengendalikan data dan juga pelbagai pakej lain yang ada.

Untuk menggunakan pustaka ini, anda perlu muat turun ia terlebih dahulu. Pakej-pakej tadi akan disimpan terus ke dalam fail dimana pelaksana Python disimpan. Ini bermakna ia disimpan secara global. 🌎

Makna global disini adalah sistem yang menjadi panduan atau rujukan bagi keseluruhan komputer.

Namun, bagaimana jika projek yang kita sedang jalankan itu adalah sebuah projek yang menggunakan pakej yang mempunyai versi yang spesifik, sama ada yang lebih rendah (contoh Pandas 1.3.5) atau tinggi (Pandas 1.4.3) berbanding dengan apa yang telah kita muat turun tadi?

Apakah kita perlu menurunkan gred versi pakej itu semata-mata bagi memenuhi kehendak projek yang kita jalankan? Jika kita menurunkan gred pakej tersebut, bagaimana nanti jika kita ada projek yang menggunakan versi pakej yang lebih tinggi? Adakah kita perlu buang dan muat turun semula? 🤔

Masalah ini sebenarnya mampu diselesaikan dengan persekitaran maya (virtual environment). Dapat dilihat tanpa persekitaran maya, perjalanan projek kita akan menjadi kucar-kacir. Jadi, ayuh berkenalan dengan apa itu persekitaran maya.

Persekitaran Maya

Persekitaran maya adalah satu persekitaran terasing (berbentuk folder); dimana pelaksana Python, pustaka dan skrip berada di dalamnya. Dengan keberadaan folder ini, anda boleh melaksanakan projek tanpa bergantung dengan pelaksana dan fail luar.

Kata kunci penting disini adalah

terasing.

Bayangkan sebuah bekas kosong. Kita letakkan barang-barang di dalamnya. Maka Barang-barang tersebut telah berada dalam lingkungan bekas tersebut dan terhindar daripada perkara-perkara yang tidak diingini.

Begitu juga persekitaran maya.

Persekitaran maya mencipta satu ruang terasing dimana fail Python tersebut hanya tertakluk apa yang ada dalam persekitaran ini sahaja.

Misalnya, jika terdapat Python versi 3.8 dalamnya, pelaksana itu yang digunakan untuk melaksanakan fail py dan bukan pelaksana Python global. Begitu juga dengan pakej dan pustaka. Segala pakej dan pustaka harus dimuat turun dalam persekitaran ini, dan dengan itu tidak menggunakan pakej yang dimuat turun secara global. Ini dapat membantu mengelakkan pencemaran global apabila segalanya tertakluk hanya dalam linkungan persekitaran.

Jadi bagaimana kita mahu mencipta persekitaran?

Mari kita mula mengekod! 👩‍💻

Kod

Pertama sekali anda perlu mengetahui asas baris perintah (command line) untuk menggunakan Command Prompt (CMD).

Baris perintahnya adalah:

1. mkdir
2. cd
3. cd ..

Ini asas yang harus diketahui oleh anda setakat ini.

mkdir : mencipta folder (make directory)

cd: menukar folder ke hadapan (forward change directory)

cd .. : menukar folder ke belakang (backward change directory)

Sekarang, pergi ke skrin desktop anda dan cipta folder baru. Namakan folder itu sebagai projek_abc.

Kemudian, buka CMD anda. Boleh cari menggunakan fungsi Search di Taskbar.

Pada CMD tersebut pastikan ia berada dalam laluan (path) D. Kebiasaanya Dekstop berada dalam pemacu D. Tapi ada juga yang berada dalam pemacu C (C drive). Anda perlu semak sendiri dimana Desktop anda tersimpan.

Untuk penulis, Desktop berada dalam pemacu D. Jadi penulis menulis D: supaya ia dapat menukar daripada pemacu C kepada pemacu D.

Selepas itu, beri arahan cd Desktop dan tekan Enter. CMD sekarang berada pada Desktop.

Kemudian beri arahan cd projek_abc. Sekarang CMD berada dalam folder projek_abc.

Sekarang barulah kita boleh mencipta persekitran maya tadi. Cara untuk mencipta persekitaran ini adalah dengan baris perintah berikut

python -m venv venvMyproject

venvMyproject adalah nama persekitaran maya anda. Anda boleh memilih apa-apa nama sepeti venvMain, venvProject mengikut apa yang anda inginkan.

Setelah menekan Enter, anda akan lihat satu folder akan muncul dalam folder projek_abc. Itu bermakna anda telah berjaya mencipta persekitaran tersebut. Terbaik! 🙌

Jika anda tekan fail tersebut, anda dapat melihat beberapa fail di dalamnya termasuk Lib. Lib adalah fail untuk penyimpanan pakej atau pustaka yang anda telah muat turun di dalam persekitaran.

Dengan keberadaan folder Lib, boleh memuat turun apa apa pakej dalam persekitaran tanpa masuk campur atau menggangu pakej yang berada di luar persekitaran ini. 🤯

Sekarang, bagaimana kita ingin menggunakan persekitaran ini?

Mari kita pergi ke bahagian seterusnya.

Penggunaan

Muat turun pustaka dalam persekitaran maya

Pertama sekali, buka mana mana IDE kesukaan anda. Untuk permulaan, saya cadangkan IDE yang boleh menggunakan script* dan bukan notebook. Penulis menggunakan IDE Visual Code Studio atau VS Code.

Cipta satu fail py. Kemudian simpan fail tersebut dalam venvMyproject. Sekarang fail py anda telah berada dalam folder venvMyproject. Tetapi persekitaran ini tidak akan dipakai, melainkan setelah anda mengaktifkan persekitaran ini dahulu.

Cara untuk mengaktifkannya mudah sahaja.

Buka CMD dalam terminal VS Code (bahagian terminal). Pastikan CMD anda berada pada direktori venvMyproject. Kemudian tulis baris perintah di bawah;

venvMyproject\Scripts\activate.bat

Setelah anda menekan Enter, anda akan perhatikan pada hujung kiri CMD ada terpapar

(venvMyproject) yang membawa maksud persekitaran anda telah diaktifkan!

Apabila persekitaran anda telah diaktifkan, anda boleh mula memuat turun pustaka yang anda inginkan. Seperti biasa dengan arahan pip install <library>.

Nota tambahan: Anda boleh memuat turun pustaka dengan versi spesifik.

Contohnya untuk Pandas versi 1.3.5. 

Apa yang dimaksudkan dengan 1.3.5?

1 --> nombor merujuk kepada versi Major

3 --> nombor merujuk kepada versi versi Minor

5 --> nombor merujuk kepada versi versi Patch

Run fail py dalam persekitaran maya

Selain perlu mengaktifkan untuk memuat turun pustaka, anda juga perlu mengaktifkan persekitaran maya ini dalam IDE anda supaya projek anda dapat dilaksanakan dalam persekitaran yang telah dicipta.

Dalam Visual Code Studio, caranya adalah dengan menekan versi Python pada bawah kanan skrin. Anda perlu mencari fail Python.exe dalam folder Scripts; yang berada di dalam folder venvMyproject. Jika telah diaktifkan, ia akan berubah kepada ('vevMyproject':venv).

Apabila persekitaran sudah aktif dalam IDE, barulah fail Python anda akan merujuk kepada komponen yang berada di dalam persekitaran venvMyproject.

Penutup

Persekitaran maya adalah sebuah praktis yang sangat baik sebelum kita memulakan apa-apa projek. Antara kelebihannya adalah:

1. Konfigurasi sistem terjaga daripada komponen-komponen global.

2. Mampu menaikkan atau menurunkan versi pakej tanpa memberi kesan pada pustaka global.

3. Boleh menyenaraikan versi pustaka yang digunakan, supaya jika ada orang lain yang ingin membantu projek ini dapat memuat turun versi pustaka yang sama yang digunakan.

Penulis berharap artikel ini bermanfaat untuk anda dalam meningkatkan pengetahuan dalam bidang pengaturcaraan. Setakat ini sahaja artikel untuk kali ini. Jika anda ada punya soalan, cadangan, atau komen, boleh kemukakan dibahagian bawah. 😎

Salam jumpa, ciao! 👋

Kemajuan kecerdasan buatan saban hari meningkat secara eksponen. Lebih ramai pakar mahupun orang awam yang telah melibatkan diri dalam menyumbang kepada teknologi kecerdasan buatan yang menjadikan kadar kemajuannya semakin pantas.

Namun, sayang sekali kesedaran mengenai kecerdasan buatan tidaklah terlalu menggalakkan dalam negara ini. Jarang sekali kita berborak soal ini seperti mana kita berborak isu-isu Sains yang lain seperti Fizik (yang masyhur seperti lubang hitam, teori relativiti dan Fizik kuantum), Sains politik (yang seharusnya menjadi topik hangat), bola sepak dan lain-lain lagi.

Kecerdasan buatan belum kelihatan lagi seksi di mata kita. 😶

Tetapi, tahukah anda, pada hari ini, kecerdasan buatan sudah memeluk pelbagai bidang? Ini termasuklah ekonomi, Sains, sejarah, politik, mata wang dan pelbagai lagi. Anda pasti tertanya-tanya, bagaimana kecerdasan buatan menyumbang 'kepintarannya' dalam semua bidang ini.

Ayuh kita bedah satu persatu!

Sejarah

Ilmu statistik adalah sebuah ilmu yang sudah bermula sejak sekian lamanya. Dikatakan, ia telah bermula dari abad ke 17 lagi. Namun pada masa itu, penggunaanya tidak meluas seperti hari ini. Cabang ini berkembang maju apabila memasuki abad ke 19, apabila ia mula digunakan dalam bidang ekonomi dan pengiraan populasi, disebabkan kemampuannya dalam menganalisis.

William Petty seorang ahli ekonomi yang menggunakan statistik untuk menganalisis data demografik.

Mungkin, anda pernah merasakan mempelajari Statistik di sekolah adalah sesuatu yang tidak berguna. Mengapa kita harus mengira mod, median dan julat? Mengapa kita harus membuat graf itu dan ini? Mengapa kita mengetahui jenis-jenis taburan?

Namun sebenarnya, ilmu Statistiklah yang menjadi batu asas kepada pembinaan teknologi pada tahap yang seterusnya iaitu kecerdasan buatan.

Apa itu kecerdasan buatan?

Kecerdasan Buatan

Kecerdasan buatan adalah sebuah algoritma (susunan kod-kod yang memberi makna sesuatu) yang mempunyai kemampuan untuk melakukan sesuatu yang mampu dilakukan manusia sejagat seperti berfikir dan mengenalisis, melihat dan membaca.

Ha?

Ya, kecerdasan buatan mampu untuk melakukan semua ini, menggunakan dasar ilmu pengetahuan yang saya telah sebutkan tadi iaitu Statistik.

Bagaimana kecerdasan buatan mampu berfikir dan menganalisis?

Mari kita bedah dengan lebih lanjut.

Berfikir dan menganalisis

Manusia cenderung untuk melihat corak (pattern) apabila melihat sesuatu perkara. Kadangkala bila kita melihat awan, secara tiba-tiba kita merasakan awan itu berbentuk beruang yang sedang memeluk bantal.

Ataupun pada setiap minggu, kita mampu mengagak keputusan perlawanan pasukan Manchester United berdasarkan keputusan permainan mereka daripada permainan sebelum ini.

Inilah yang dipanggil sebagai corak.

Daripada pemerhatian kita terhadap corak-corak ini, kita akan mula menyambung titik-titik tersebut bagi menatijahkan konklusi akhir.

Dalam kecerdasan buatan, terdapat sebuah teknologi yang dikenali sebagai mesin pembelajaran; yang mengaplikasikan pola fikir analisis ini. Bezanya, pola pemikiran ini mempunyai disiplinnya yang tersendiri supaya konklusi yang dicipta pada akhirnya nanti menepati objektif yang telah ditapkan.

Model

Mari kita lihat satu contoh bagaimana mesin pembelajaran mampu melakukan semua ini. Terdapat sejenis mesin pembelajaran yang menggunakan asas statistik dan salah satunya dikenali sebagai model regresi (regression model).

Model regresi adalah sebuah model yang mampu melihat keterkaitan antara satu ciri pemboleh ubah bersandar dengan satu ciri akibat daripada pemboleh ubah tersebut. Model ini menggunakan garisan lurus sebagai panduan kepada corak data tersebut.

Contoh eksperimen mudah adalah melihat sama ada berat tikus dan saiz matanya adalah berkadar langsung dengan tinggi tikus.

Kemudian, mari kita bina satu algoritma mesin pembelajaran model regresi. Model ditulis dengan menggunakan bahasa pengaturcaraan Python.

Berikut contoh kod;

from sklearn.linear_model import LinearRegression

berat_dan_saiz_mata = [[1, 3], [4, 5], [6, 10]] 
tinggi = [1,6,8] 

reg = LinearRegression()

reg.fit(berat_dan_saiz_mata, tinggi)

x_new = [[1, 4], [4, 2], [6, 11]]
y_pred = reg.predict(x_new)

print(y_pred)

Output:

[0.63636364 7.09090909 7.63636364]

Penerangan kod

- Ciri-X

Ciri x merujuk kepada data yang digunakan untuk meramal ciri sasaran iaitu ciri y. Dalam hal ini diwakili berat dan saiz mata seekor tikus. Dengan menggunakan 3 ekor tikus, kita telah merekod berat dan saiz mata mereka, untuk digunakan sebagai data kepada model mesin.

- Ciri-y

Data y pula merujuk kepada nilai sasaran yang kita tentukan untuk diramal. Dalam hal ini, diwakili oleh tinggi tikus tersebut. Data ini juga diberikan pada model mesin supaya 'beliau' mampu mengenalpasti corak daripada data ini, menggunakan 'pola fikir' model ini iaitu regresi.

- model.fit(X, y)

Kita akan menggunakan metod fit untuk mengarahkan mode yang telah kita pilih untuk mempelajari data.

- model.predict(data_baru)

Menggunakan metod predict, kita boleh meramal tinggi tikus tikus lain dengan menyediakan data berat dan saiz mata tikus yang baharu hanya dengan kod semudah ini! 😎

- Output

Output yang telah dihasilkan adalah nilai ramalan tinggi tikus setelah kita memasukkan data baharu.

Jadi, bayangkan jika anda sedang membuat satu ekperimen yang kompleks berskala besar.

Data anda adalah bersandar kepada data yang satu lagi. Maka, dengan menyediakan data anda yang lengkap, anda dengan mudah dapat meramal output yang baharu dengan mengaplikasikan model mesin pembelajaran ini! (kod di atas adalah eksperimen mudah, terdapat pelbagai lagi perkara lain yang harus ditimbang tara).

Sheeessh! 🤯

Melihat

Pada hari ini, mesin pembelajaran sudah sampai kesebuah tahap mereka mampu 'melihat' seperti manusia. Teknologi ini dipanggil sebagai Pengesanan Karakter secara Optikal.

Melalui teknologi ini, mesin akan 'melihat' sesebuah objek dan mengekstrak info yang berguna seperti nama, umur, dan sebagainya. Sebagai contoh, jika kita memberikan salinan kad pengenalan kita kepada mesin, mesin akan mengetahui dimanakah posisi nama, alamat, agama, dan gambar kad pengenalan! 😮

Bayangkan kerja harian manusia akan menjadi bertambah mudah jika kita dapat mengaplikasikan dan mengembangkan teknologi ini.

Membaca

Selain itu, terdapat juga mesin yang dipanggil sebagai Pemprosesan Bahasa Alami (PBA) atau lebih biasa dikenali sebagai Natural Language Processing (NLP).

NLP mempunyai fungsi untuk mengesan makna disebalik struktur ayat percakapan seharian kita. Contohnya, sebagai manusia, kita semestinya faham jika seseorang berkata,

1. "Saya sangat gembira dengan pencapaian kamu."

2. "Saya sudah tak mampu untuk melihat gambarnya lagi."

3. "Saya sayang kerajaan saya, kerana ia bebas daripada rasuah."

Frasa pertama menunjukkan frasa yang gembira. Frasa kedua menunjukkan perasaan yang sedih. Frasa ketiga lebih kepada sarkastik, skeptik dan tidak percaya.

Sebagai manusia, umumnya kita akan memahami konteks sesebuah ayat itu berdasarkan pengalaman kita berkomunikasi dalam seharian.

Tetapi, bagaiamana mesin pembelajaran memahami semua ini? Mereka menggunakan alat yang dipanggil sebagai Alatan Bahasa Alami atau lebih biasa dikenali sebagai Natural Language Toolkits atau NLTK.

Menggunakan NLTK, alat ini mampu memecah-beraikan frasa ayat, mengesan perkataan yang berulang, mencari perkataan akar (untuk perkataan berimbuhan) dan lain-lain lagi.

Daripada itu, kita boleh meramal konteks frasa ini dengan menggunakan mesin pembelajaran klasik, dengan cara kita melatih data (dipanggil sebagai korpus). Menggunakan korpus, mesin dapat mempelajari, apakah yang dimaksudkan dengan gembira, apakah yang dimaksudkan dengan sedih, apakah yang dimaksudkan dengan sarkastik, dan lain-lain lagi.

Kesimpulan

Begitulah antara contoh mesin pembelajaran yang menjadi komponen kecerdasan buatan pada hari ini. Cool kan? 😛

Terdapat banyak lagi model atau mesin pembelajaran yang wujud, namun tidak muat jika ingin dihimpunkan ke dalam satu artikel. Tetapi jangan risau, waktu demi waktu, saya akan cuba memilih model mesin pembelajaran untuk dikupas secara konseptual untuk artikel seterusnya.

Jika anda punya apa-apa komen, pembetulan, soalan atau cadangan, jangan malu atau segan untuk terus menulisnya dibahagian komen. Sampai disini sahaja artikel kali ini.

Selamat berhujung minggu, dan selamat berkoding! 💻

Anneyong! 👋

Menulis adalah sebuah seni. Menulis esei, pantun, sajak, puisi, gurindam dan sebagainya adalah sebuah seni yang indah. Seni tidak terbatas dalam ruang lingkup atau peraturan yang ketat tetapi, ada di antaranya yang mempunyai aturan dan disiplin tersendiri.

Pantun harus mempunyai rima, sajak dan puisi lebih bebas penulisannya, dan pelbagai lagi peraturan dalam mencipta seni penulisan.

Seperti juga Python, bahasa pengaturcaraan ini juga mempunyai amalan ataupun praktis yang terbaik dalam menulis kod.

Salah seorang jurutera perisian yang juga merangkap perintis Python, Tim Peters telah menulis 20 prinsip Python berbentuk pujangga. Ia telah dikenali sebagai Zen of Python (nama formalnya ialah PEP20).

Zen of Python

Beautiful is better than ugly.

Explicit is better than implicit.

Simple is better than complex.

Complex is better than complicated.

Flat is better than nested.

Sparse is better than dense.

Readability counts.

Special cases aren't special enough to break the rules.

Although practicality beats purity.

Errors should never pass silently.

Unless explicitly silenced.

In the face of ambiguity, refuse the temptation to guess.

There should be one-- and preferably only one --obvious way to do it.

Although that way may not be obvious at first unless you're Dutch.

Now is better than never.

Although never is often better than right now.

If the implementation is hard to explain, it's a bad idea.

If the implementation is easy to explain, it may be a good idea.

Namespaces are one honking great idea -- let's do more of those!

Daripada Zen of Python ini barulah muncul PEP8, sebuah dokumentasi Python yang menerangkan panduan gaya penulisan Python yang disarankan oleh penemu bahasa pengaturcaraan ini, Guido Von Rossum.

Guido berkata,

Dalam kebanyakan masa, kita lebih banyak membaca kod daripada menulis kod.

Justeru itu, kod seharusnya mempunyai ciri kebolehbacaan. Selaras dengan salah satu Zen dalam Zen of Python ;-

Readability counts.

Jadi, bagaimana kita boleh menulis kod Python dengan gaya penulisan yang menepati ciri kebolehbacaan sekaligus menulis kod dengan lebih baik?

Berikut saya sertakan 5 amalan yang disarankan kepada pengaturcara Python untuk dipraktik daripada dokumen PEP8.

(nota: Penulis mengandaikan pembaca sudah mempunyai sedikit asas Python sebelum membaca artikel ini.)

1. Menggunakan perenggan untuk membezakan sesuatu.

Perenggan adalah antara identiti utama Python. Perenggan digunakan dalam penyata bersyarat, fungsi,class dan lingkaran.

Oleh sebab itu, PEP8 telah menyelaraskan beberapa cara yang terbaik bagi menggunakan perenggan. Misalnya, jika kita menulis sebuah fungsi yang mempunyai beberapa argumen di dalamnya, cara yang baik ✅ adalah seperti berikut;

my_func = nama_fungsi_panjang(arg_1, arg_2, 
                              arg_3, arg_4)

Ini adalah cara menggunakan perenggan supaya kod kelihatan kemas dan mudah untuk dibezakan antara fungsi dan argumen. Cara penulisan yang kurang baik ❌adalah seperti berikut;

my_func = nama_fungsi_panjang(arg_1, arg_2, 
          arg_3, arg_4)

Ini juga boleh digunakan untuk menulis list atau dictionary seperti contoh berikut;

my_list = [
           1, 2, 3, 
           4, 5, 6, 
           7, 8, 9
    ]

my_dictionary = { 
                  1: "Isnin", 
                  2: "Selasa",
                  3: "Rabu
        }

Elemen di dalam list dapat dilihat dengan jelas dan tersusun.

Menulis dengan menggunakan perenggan dengan betul dapat memudahkan pembaca (pengaturcara) untuk membaca kod, lebih-lebih lagi jika kita ingin membaca kod yang ditulis oleh orang lain dan sebaliknya.

2. Maksimum character untuk satu barisan.

Bagi mengelakkan kod ditulis terlalu panjang, PEP8 telah menghadkan supaya maksimum karakter yang ditulis untuk satu barisan iaitu 79 karakter.

Anda tak perlulah mengira satu persatu huruf pada kod, tetapi anda boleh agak-agak panjang kod anda dalam sebaris itu supaya tidak terlalu panjang dan meleweh-leweh. Jika kod anda mempunya koma, sambung ke barisan yang seterusnya.

Selain daripada memudahkan tujuan pembacaan, ini juga membantu pengaturcara yang ingin membuka dua buah skrip kod sekaligus bersebelahan membaca kod kedua-dua skrip.

3. Menggunkan satu jenis pembuka kata.

Jika anda perhatikan di papan kekunci, terdapat dua jenis pembuka kata iaitu pembuka kata jenis tunggal ' ' dan jenis ganda " ".

PEP8 menyarankan pengaturcara untuk membiasakan diri dengan menggunakan salah satu sahaja antara dua jenis pembuka kata ini, bagi menjamin konsistensi penulisan kod

Konsistensi akan menjadikan kod lebih kemas dan tidak bercampur baur.

4. Pemilihan dan gaya penulisan nama.

Pilih nama yang mempunyai kaitan dengan isi kandungan fungsi, pemboleh ubah atau class tersebut. Ini bagi memudahkan anda untuk merujuk semula kod tersebut sama ada untuk menyerunya ke dalam fungsi atau mengoutputkannya.

Contoh yang baik ✅

senarai_nom = [1,2,3,4,5,6]

def filter_func(num):
      for val in num:
          if val < 3:
                print("Nilai lebih rendah daripada 3.")
          else:
                print("Nilai lebih tinggi daripada 3.")

Contoh yang kurang baik ❌

a = [1,2,3,4,5,6]

def my_func(x):
      for i in x:
          if i < 3:
                print("Nilai lebih rendah daripada 3.")
          else:
                print("Nilai lebih tinggi daripada 3.")

Kedua-dua kod di atas mempunyai tujuan yang sama, tetapi pemilihan nama yang berbeza. Kod yang pertama lebih jelas dan mudah dibaca kerana pemilihan nama yang mempunyai kaitan, manakala kod kedua hanya menggunakan huruf sahaja yang jelas tidak menerangkan konteks kod.

Gaya penulisan nama juga mempunyai cara yang tersendiri. Jika ingin menulis fungsi atau pemboleh ubah, nama fungsi seharusnya berhuruf kecil, dengan nama yang disambung menggunakan underscore bagi meningkatkan kebolehbacaan.

Contoh yang baik ✅

# dengan underscore
senarai_nom_ganjil = [1,3,5]
def fungsi_nombor(senarai):
        print(senarai)

fungsi_nombor(senarai_nombor_ganjil)

Contoh kurang baik ❌

# tanpa underscore
senarainomganjil = [1,3,5]
def fungsinombor(senarai):
        print(senarai)

fungsinombor(senarainomborganjil)

Anda boleh menilai sendiri penggunaan nama yang mana satu yang sedap mata memandang dan mudah dibaca.

Antara cadangan gaya penulisan lain adalah;

• nama pemboleh ubah malar -> SEMUA HURUF BESAR

Contoh:

PI_VALUE = 3.14159
BETA_VALUE = 12

• nama class -> Huruf Besar Di Awal Setiap Nama

Contoh:

class MyDog:
       def __init__(self, name, age):
              self.name = name
              self.age = age

5. Cara menulis komen.

Seperti yang telah dibincangkan dalam artikel sebelum ini, terdapat 2 cara untuk kita menulis komen di dalam kod, iaitu

1. Menggunakan tanda pagar, #
2. 3 pembuka dan penutup kata (atau dikenali sebagai docstring jika tidak disabitkan pada mana-mana fungsi)

Menulis komen juga terdapat 2 cara penulisan iaitu,

• Secara blok
• Secara didalam satu barisan yang sama.

Cara blok adalah seperti berikut;

#semak sama ada harga melebih atau tidak
harga_ikan = 10
if harga_ikan > 10:
       print("Harga terlalu mahal")

Cara menulis dalam satu barisan;

harga_ikan = 10           #semak sama ada harga melebih atau tidak
if harga_ikan > 10:
       print("Harga terlalu mahal")

Disarankan untuk diperenggankan dengan beberapa tab sebelum menulis komen bagi cara menulis komen atas barisan yang sama.

Bagi menggunakan 3 pembuka dan penutup kata bagi tujuan komen atau docstring pula, jika komen tersebut hanya mempunyai satu barisan, maka pembuka dan penutup kata adalah di atas barisan yang sama dengan karakter.

Contoh;

'''Ini adalah nota kecil tentang kod berikut.'''

Tetapi, jika komen terdiri daripada beberapa barisan, hanya pembuka sahaja di atas barisan yang sama pada barisan pertama, tetapi penutup kata harus berada satu barisan dibawah barisan terakhir.

Contoh;

'''Fungsi ini berkenaan sebuah operasi matematik.

Fungsi ini masih belum lengkap.
'''

Kesimpulan

Begitulah sedikit sebanyak rumusan daripada PEP8 yang harus anda tahu.

Mulakan menulis kod dengan disiplin yang betul adalah sebuah tabiat yang baik daripada mebiasakan diri dengan penulisan yang kurang baik.

Namun, jika anda sudah berpengalaman dalam Python dan terdapat beberapa cara penulisan anda yang bercanggah dengan PEP8, maka masih punya masa untuk memperbetulkannya dan menulis kod Python dengan lebih kemas dan menarik.

Anda boleh baca dengan lebih lanjut lagi pada pautan yang saya telah sertakan dibawah pada bahagian sumber.

Sampai disini sahaja artikel kali ini. Saya berharap artikel ini bermanfaat untuk para pembaca sekalian. Sampai jumpa lagi, salam! 👋

Sumber:

1. PEP20: https://peps.python.org/pep-0020/
2. PEP8: https://peps.python.org/pep-0008/
3. PEP257: https://peps.python.org/pep-0257/