Forem: Rizky Haksono

Why Men Can't Cry?

Rizky Haksono — Fri, 04 Apr 2025 08:26:49 +0000

For centuries, society has conditioned men to believe that crying is a sign of weakness. From childhood, boys are often told to "man up," "be strong," or "stop crying like a girl." These messages create a deep-rooted belief that expressing emotions, particularly through tears, is unacceptable for men. But why is this the case? And what are the consequences of suppressing emotions?

The things that men shouldn't cry is ingrained in many cultures worldwide. This belief stems from traditional ideas of masculinity, which equate strength with emotional stoicism. Boys are raised to believe that vulnerability makes them less masculine, leading them to suppress their feelings from a young age. This conditioning is reinforced by media, literature, and even family expectations.

The stigma around male vulnerability has significant consequences. Men who feel they cannot express their emotions may experience:

Mental Health Struggles: Suppressing emotions can lead to anxiety, depression, and increased stress levels.
Difficulty in Relationships: Emotional unavailability can create barriers in personal and romantic relationships.
Unhealthy Coping Mechanisms: Many men turn to alcohol, aggression, or isolation as a way to cope with repressed emotions.
Higher Suicide Rates: Studies show that men are less likely to seek help for emotional distress, leading to higher suicide rates compared to women.

It’s time to challenge the outdated belief that men can’t cry. Society must create a safe space for men to express their emotions without fear of judgment. Here’s how we can help:

Normalize Crying: Public figures and role models should speak openly about their emotions to break the stigma.
Encourage Open Conversations: Friends and family should support emotional honesty in men.
Provide Mental Health Support: Therapy and counseling should be promoted as a strength, not a weakness.
Reframe Masculinity: True strength lies in emotional intelligence, self-awareness, and the ability to express feelings.

Just let me know, if you are not okay. Write an anonymous message through my "contact me", so I can be there for you.

It's okay to be not okay..

Here’s how to manage your own time efficiently

Rizky Haksono — Mon, 02 Dec 2024 17:22:26 +0000

Time is a precious resource—one that’s easy to squander but impossible to replenish. Learning to manage your time efficiently can lead to increased productivity, reduced stress, and more opportunities to achieve your goals. Here’s a practical guide to mastering time management and making the most of your day.

Set Clear Goals

Before diving into tasks, it’s essential to know where you’re headed. Whether personal or professional, set SMART goals—Specific, Measurable, Achievable, Relevant, and Time-bound. Clear goals provide direction and keep distractions at bay.

Prioritize Your Tasks

Use the Eisenhower Matrix to categorize tasks:

Urgent and Important: Do these first.
Important but Not Urgent: Schedule these for later.
Urgent but Not Important: Delegate if possible.
Neither Urgent nor Important: Eliminate them.
This approach helps focus your energy on what truly matters.

Plan Your Day Start each day with a solid plan:

Create a to-do list.
Allocate specific times for each task.
Use time-blocking techniques to schedule tasks into your calendar.
Planning prevents decision fatigue and keeps your day structured.

Avoid Multitasking

Contrary to popular belief, multitasking often reduces efficiency and leads to mistakes. Focus on one task at a time to ensure quality and complete it faster.

Minimize Distractions

Identify and eliminate distractions:

Turn off unnecessary notifications.
Use apps like Focus@Will or Forest to maintain focus.
Set boundaries with colleagues or family during work hours.
Creating a dedicated workspace can also help maintain concentration.

Take Breaks

Productivity doesn’t mean working non-stop. Use techniques like the Pomodoro Technique: work for 25 minutes, then take a 5-minute break. Regular breaks refresh your mind and prevent burnout.

Learn to Say No

Your time is valuable. Politely decline requests or commitments that don’t align with your goals. Saying no ensures you stay focused on priorities.

Use Technology Wisely

Leverage tools to boost efficiency:

Trello or Asana for task management.
Google Calendar for scheduling.
Notion for note-taking and organizing ideas.
These tools simplify managing tasks and deadlines.

Reflect and Adjust

At the end of each day or week, evaluate your progress:

What worked well?
What could be improved?
Are you spending time on your priorities?
Adjust your strategy as needed to improve continuously.

Practice Self-Care

Efficient time management isn’t just about tasks—it’s about maintaining balance. Ensure you’re:

Getting enough sleep.
Exercising regularly.
Spending time with loved ones.
A well-rounded life fosters energy and focus.

Conclusion

Efficient time management isn’t about working harder—it’s about working smarter. By setting clear goals, planning strategically, and maintaining balance, you can take control of your time and achieve more with less stress. Start implementing these tips today, and watch your productivity soar!

Quick look of Elysia.js, new gen of Backend!

Rizky Haksono — Mon, 02 Dec 2024 17:19:42 +0000

Elysia.js is TypeScript with End-to-End Type Safety, type integrity, and exceptional developer experience. Supercharged by Bun.

To create a new project using this command

bun create elysia app

Once done, you should see the folder name app in your directory.

cd app

Start a development server by:

bun dev

Navigate to localhost:3000 should greet you with "Hello Elysia".

What is docker? And how is it works?

Rizky Haksono — Mon, 02 Dec 2024 17:17:23 +0000

What is Docker? And How Does It Work?

Docker has become a cornerstone of modern software development, revolutionizing how applications are built, shipped, and deployed. But what exactly is Docker, and how does it work? This blog will demystify Docker and explain its role in simplifying development workflows.

What is Docker?

Docker is an open-source platform that enables developers to automate the deployment of applications inside lightweight, portable containers. These containers bundle everything an application needs to run, including code, libraries, dependencies, and runtime, ensuring consistency across different environments.

Key Features of Docker:

Portability: Run the same container on your laptop, testing server, or production environment.
Isolation: Containers run in isolated environments, preventing conflicts between applications.
Efficiency: Containers share the host system's kernel, making them lightweight and faster than virtual machines.
Scalability: Easily scale your application by spinning up multiple containers.

Install Docker using the apt repository

Before you install Docker Engine for the first time on a new host machine, you need to set up the Docker apt repository. Afterward, you can install and update Docker from the repository.

Set up Docker's apt repository.

sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

- Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update

Install the Docker packages.

sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Install Portainer CE with Docker on Linux

Deployment

docker volume create portainer_data

Then, download and install the Portainer Server container:

docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:2.21.4

Portainer Server has now been installed. You can check to see whether the Portainer Server container has started by running docker ps:

root@server:~# docker ps
CONTAINER ID   IMAGE                          COMMAND                  CREATED       STATUS      PORTS                                                                                  NAMES             
de5b28eb2fa9   portainer/portainer-ce:2.21.4  "/portainer"             2 weeks ago   Up 9 days   0.0.0.0:8000->8000/tcp, :::8000->8000/tcp, 0.0.0.0:9443->9443/tcp, :::9443->9443/tcp   portainer

Now that the installation is complete, you can log into your Portainer Server instance by opening a web browser and going to:

https://localhost:9443

SSR vs ISR vs CSR in Next.js: Understanding the Key Rendering Strategies

Rizky Haksono — Mon, 02 Dec 2024 17:16:31 +0000

When building web applications with Next.js, understanding its rendering strategies is crucial for optimizing performance and user experience. This blog will dive into Server-Side Rendering (SSR), Incremental Static Regeneration (ISR), and Client-Side Rendering (CSR), their use cases, and how to implement them.

What is SSR (Server-Side Rendering)?

Server-Side Rendering in Next.js involves generating the HTML for a page on the server for every request. This ensures that users always receive the latest data when they visit the page.

Key Features of SSR:

Fresh data: HTML is generated dynamically for every request.
SEO-friendly: Since the content is pre-rendered on the server, search engines can easily index it.
Increased server load: Rendering on each request can increase server processing time.

How to Implement SSR in Next.js:

Use the getServerSideProps function to fetch data at request time:

export async function getServerSideProps(context) {
  const res = await fetch('https://api.example.com/data');
  const data = await res.json();

  return {
    props: { data }, // Will be passed to the page component as props
  };
}

export default function Page({ data }) {
  return <div>{data.title}</div>;
}

What is ISR (Incremental Static Regeneration)?

Incremental Static Regeneration allows you to update static pages after the build process, without rebuilding the entire site. This is a powerful feature for pages that don’t require real-time updates but need occasional content refresh.

Key Features of ISR:

Static performance with flexibility: Combines the speed of static pages with the ability to update content.
Efficient caching: Pages are regenerated in the background while users see the cached version.
Best for dynamic content: Ideal for blogs, e-commerce product pages, or any page updated at regular intervals.

How to Implement ISR in Next.js:
Use the getStaticProps function with the revalidate option:

export async function getStaticProps() {
  const res = await fetch('https://api.example.com/data');
  const data = await res.json();

  return {
    props: { data }, // Will be passed to the page component as props
    revalidate: 10, // Regenerate the page every 10 seconds
  };
}

export default function Page({ data }) {
  return <div>{data.title}</div>;
}

What is CSR (Client-Side Rendering)?

Client-Side Rendering relies on JavaScript to fetch and render content in the browser after the initial page load. This approach is common in single-page applications (SPAs).

Key Features of CSR:

Dynamic interactions: Great for highly interactive applications.
SEO challenges: Content is rendered after the initial load, which can make it harder for search engines to index.
Fast initial load: Initial HTML is light, as it contains minimal content.

How to Implement CSR in Next.js:
Fetch data using React’s useEffect hook or a data-fetching library like SWR:

import { useEffect, useState } from 'react';

export default function Page() {
  const [data, setData] = useState(null);

  useEffect(() => {
    fetch('https://api.example.com/data')
      .then((res) => res.json())
      .then((data) => setData(data));
  }, []);

  if (!data) return <div>Loading...</div>;

  return <div>{data.title}</div>;
}

Comparison Table: SSR vs ISR vs CSR

Feature	SSR	ISR	CSR
Rendering	Server-side, per request	Static, with periodic updates	Client-side, in browser
Performance	Slower, depends on server	Fast, cached static pages	Fast initial load
SEO	Excellent	Excellent	Challenging
Use Cases	Real-time data, user-specific pages	Content-heavy sites, blogs	SPAs, interactive apps

When to Use Each Rendering Strategy?

Use SSR when:

You need real-time data updates.
SEO is a priority for frequently changing content.
Pages are personalized for each user.

Use ISR when:

Your data changes periodically.
You want to serve static pages but keep them updated.
Scalability and performance are important.

Use CSR when:

Your app requires heavy interactivity.
SEO is not a priority.
You’re building SPAs with minimal server-side dependencies.

Conclusion

Next.js provides a versatile toolkit with SSR, ISR, and CSR, allowing developers to build tailored experiences. By understanding the strengths and weaknesses of each, you can choose the best strategy for your application’s needs. Whether it's a high-performance blog, a real-time dashboard, or an interactive SPA, Next.js has you covered.

Which rendering strategy do you use in your projects? Let us know in the comments!

SDLC Method: What is SDLC?

Rizky Haksono — Tue, 03 Sep 2024 04:15:25 +0000

The Software Development Life Cycle (SDLC) is a process for creating and modifying systems, including models and methodologies used to develop software engineering systems. SDLC methods are designed to assist you in product development. There are various types of SDLC methods, but here we will focus on just four. Below are the four SDLC methods for software development:

Source: https://www.dicoding.com/blog/metode-sdlc

The First SDLC Method: Waterfall

The Waterfall method emphasizes sequential and systematic phases. It is called "waterfall" because the process flows in one direction "downward" like a waterfall. This method must be followed sequentially according to the specified phases.

Here are the development phases in the Waterfall method:

Requirement Gathering and Analysis
Collecting and analyzing complete requirements to define what the program should achieve. Information can be gathered through interviews, discussions, or surveys.
Design
Designing the software as a blueprint before creating the code. System designs can be made using flowcharts, mind maps, or Entity Relationship Diagrams (ERDs).
Implementation
This phase involves converting the previously created designs into code. The output at this stage is individual modules that need to be integrated in the next step.
Integration & Testing
Combining the modules created earlier and testing the software to ensure it matches the design and intended functions.
Verification
In this phase, users or clients directly test the system to confirm whether it meets the agreed-upon requirements.
Operation & Maintenance
This is the final phase, where the completed system is deployed and maintained. Maintenance includes fixing errors that were not detected in earlier stages.

Every method has its own advantages and disadvantages.

Advantages of the Waterfall method:

The structured process allows for well-scheduled and easily manageable work. Suitable for systems with low complexity (predictable).
Each process is distinct, preventing overlap.

Disadvantages of the Waterfall method:

The development time is relatively longer since each phase must be completed before moving on to the next.
Higher costs due to the extended development time.
This model is less suitable for complex projects.

Prototype

The next SDLC method is the Prototype model. This method allows users to get an initial visualization of the software being developed, as well as conduct early testing before the software is finalized.

The Prototype method aims to develop a model into a final software product. It accelerates system development and reduces costs. This method involves several stages in software development:

Stages of software development using the Prototype method:

Requirement Analysis
At this stage, developers identify the software and system requirements to be created.
Creating the Prototype
Designing a temporary model that focuses on the program flow for the user.
Prototype Evaluation
Evaluating whether the prototype aligns with expectations.
System Coding
If the prototype is approved, it is translated into the appropriate programming language.
System Testing
Once the software is ready, it undergoes testing, usually with techniques such as White Box Testing or Black Box Testing.
System Evaluation
Users evaluate whether the software meets their expectations. If yes, proceed to the next step; if not, repeat the coding and testing phases.
Using the System
The software that has been tested and approved is ready for use.

MBKM Batch 6: A Journey of Growth and Learning in the Tech Industry

Rizky Haksono — Mon, 02 Sep 2024 10:25:18 +0000

Participating in MBKM Batch 6 has opened up numerous opportunities for me to gain valuable experience across various industries, especially in technology. I had the privilege of interning as a full-stack developer at PT. Bejana Investidata Globalindo in 2024. During this six-month internship, I focused on developing robust and scalable base code for their systems while taking on diverse and exciting challenges.

Diving into Full-Stack Development

Being a full-stack developer isn't easy, especially without a strong foundation in the industry. In my first month, I was tasked with building an application using WebSocket for real-time communication. This application not only facilitated seamless interactions but also ensured data storage using PostgreSQL.

Exploring .NET and Debugging Challenges

My curiosity drove me to explore unfamiliar technologies. For instance, the company had a project built on .NET. It was my first time debugging in this environment, and I was assigned to fix a bug in the eCRF Project by Biofarma, specifically related to patient status. This experience significantly enhanced my debugging skills and broadened my technical expertise.

Developing Features with React and Spring Boot

In April, I worked on a project involving data export functionality using React and Spring Boot (Java). Learning Spring Boot was particularly intriguing as its verbose syntax demands careful attention to detail. Despite the complexity, I successfully implemented the feature within three days, which was a rewarding accomplishment.

Continuous Learning and Logic Challenges

Every Thursday, I attended knowledge-sharing sessions and practiced LeetCode challenges to improve my problem-solving skills.

In May, I was assigned to the Info Pangan Jakarta Admin and User Project, where I learned best practices for writing clean and efficient code. This project helped me refine my skills in structuring folders and organizing code effectively.

Self Reward

Every weekend, my friends and I hang out somewhere in Jogja City to unwind and recharge after a busy week. We explore various spots, from cozy cafés to vibrant street markets, indulging in local delicacies and enjoying the lively atmosphere.

Sometimes, we visit iconic landmarks like Malioboro Street or relax at serene places like Kidul Mountain. On other days, we might take short trips to nearby cities to catch a breathtaking sunset.

Celebrating Success

On June 21, 2024, we celebrated BIGIO's Anniversary with a joyful gathering and delicious nasi kuning. It was a memorable moment to unwind and connect with the team.

Reflection

My six-month journey with PT. Bejana Investidata Globalindo was filled with opportunities to explore new technologies, solve real-world problems, and grow as a developer. This internship not only sharpened my technical skills but also enriched my understanding of collaboration and project management.

I am grateful for this invaluable experience and excited about what lies ahead in my career.