Forem: Asharib Ahmed

Why Go Developers Avoid panic() - And When It's Actually Okay to Use

Asharib Ahmed — Mon, 05 May 2025 04:28:28 +0000

If you're coming to Go from another language, you might be surprised to find that Go developers don't really throw exceptions. In fact, they mostly avoid Go’s built-in panic() function unless absolutely necessary.

But that doesn’t mean panic is bad. It just has a specific purpose, and misusing it can lead to rigid, brittle, and unpredictable code.

Let’s break down why panic() is usually discouraged, when it is acceptable, and how Go’s unique approach to error handling makes your code more explicit, testable, and robust.

☠️ What Exactly Is `panic()`?

In Go, calling panic() stops the normal flow of execution. The program begins unwinding the call stack, running any defer functions along the way, until it either:

recovers (via recover()), or
crashes the program entirely.

It’s Go’s version of an unrecoverable error — a loud, immediate halt.

🧘 Why Returning Errors Is Preferred

Go was designed around simplicity and explicit error handling. The idiomatic way to handle issues is by returning an error as a second value:

result, err := doSomething()
if err != nil {
    // Handle it
}

Here’s why that’s usually better than panicking:

1. Gives the Caller Control

When a function returns an error, the caller has options. They can:

Retry the operation
Wrap the error with more context
Log it
Ignore it (rarely, but sometimes valid)

With panic(), all control is lost — unless you catch it with recover(), which is clunky and rarely worth it.

2. Easier to Test

It’s straightforward to test a function that returns an error:

go if err := myFunc(); err != nil { t.Errorf("unexpected error: %v", err) }

Testing for panics requires a deferred recover() block, which adds boilerplate and confusion to your test code.

3. Better for Libraries and APIs

If you're writing a package for others, panicking is a poor user experience. Your panic could crash their entire application — something they didn’t sign up for. Returning an error lets them decide what to do.

4. More Informative Errors

Go makes it easy to wrap errors with context:

go return fmt.Errorf("loading config: %w", err)

This provides a breadcrumb trail of what went wrong and where. A panic just dumps a stack trace, which may or may not help.

5. It’s the Go Way

Go’s standard library overwhelmingly favors returning errors over panicking. This consistency is part of what makes Go easy to read, maintain, and understand.

⚠️ So... When Is `panic()` Appropriate?

Despite all the caution, panic() does have its place — just use it sparingly and intentionally.

Here are the legitimate use cases:

✅ 1. Truly Unrecoverable Errors

If your application reaches a state it should never be in, panicking can be appropriate.

go func mustGetEnv(key string) string { val, ok := os.LookupEnv(key) if !ok { panic("missing required env var: " + key) } return val }

You’re signaling: “This is a developer mistake, not a runtime issue.”

✅ 2. During Initialization

It’s okay to panic when your program can’t even start correctly.

go var cfg = loadConfig() // panics if config file is malformed

Failing fast during startup is better than limping along in a broken state.

✅ 3. For Internal Tooling or Scripts

If you’re writing a short CLI tool or internal script, and you’re just validating a few assumptions, panicking can save time — though error handling is still better if you expect others to reuse your code.

✅ 4. In Tests

In unit tests, panic isn’t harmful — it just fails the test. You can use t.Fatal or even call panic() yourself for early exits in setup failures.

🔚 Final Thoughts

panic() isn’t evil — it’s just blunt. Like a fire alarm, you don’t want to pull it unless things have truly gone off the rails.

In almost every case, returning an error is better:

It’s more flexible
Easier to test
Safer for library consumers
More aligned with Go’s philosophy

Stick with explicit error handling, and reserve panic() for when you really mean, “This should never happen.”

TL;DR

Use Case	Recommendation
Invalid user input	Return `error`
File not found	Return `error`
Internal bug	Use `panic()`
Missing config	Panic at startup
Unexpected nil	Panic
Library package	Never panic

💬 Want to see real-world code examples comparing panic vs returned errors? Let me know in the comments — I’d be happy to write a follow-up post!

How to Use AI in Go with LangChainGo (Very Easy!)

Asharib Ahmed — Sun, 04 May 2025 05:50:29 +0000

Have you ever wanted to use AI in your Go (Golang) programs? It may sound hard, but with LangChainGo, it’s actually very easy. In this post, I will show you a simple example to get started.

What is LangChainGo?

LangChainGo is a Go library that helps you use language models (like Google AI, OpenAI, etc.) in your Go programs. You can give it a prompt (a question or a message), and it will give you an answer using AI.

What We’ll Build

We will write a small Go program that asks AI to explain something in simple terms. In this case, we ask:

"Explain the concept of quantum entanglement in simple terms"

The AI will give us an answer we can print.

The Code

Here is the full code:

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/tmc/langchaingo/llms"
    "github.com/tmc/langchaingo/llms/googleai"
)

func main() {
    ctx := context.Background()
    apiKey := os.Getenv("API_KEY")
    llm, err := googleai.New(ctx, googleai.WithAPIKey(apiKey))
    if err != nil {
        log.Fatal(err)
    }
    prompt := "Explain the concept of quantum entanglement in simple terms"
    answer, err := llms.GenerateFromSinglePrompt(ctx, llm, prompt)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(answer)
}

What This Code Does

First, it sets up a context.
It gets your Google AI API key from the environment (API_KEY).
Then it creates a connection to the AI using the LangChainGo library.
It sends a prompt to the AI.
The AI gives an answer.
We print the answer.

Example Output

When I run the code, I get something like:

"Quantum entanglement is when two tiny particles are connected in a special way, so if you do something to one, the other changes instantly, no matter how far apart they are."

Amazing, right? With just a few lines of code, you can use the power of AI!

Final Thoughts

LangChainGo makes it very easy to use AI in Go. You don’t need to be an expert in machine learning or AI. If you know some Go, you can get started right away.

Let me know if you try it out or if you have any questions!

Docker Desktop's Global Search Capability: The Quest for the Lost Container🕵🏻‍♂️

Asharib Ahmed — Mon, 18 Sep 2023 12:39:17 +0000

Finding Docker Resources Just Got Easier 🔭

In the vast and mysterious realm of containerization, Docker users have often embarked on epic quests, akin to seeking hidden treasures. These quests, however, were less like swashbuckling adventures and more like trying to find that missing sock in your laundry – frustrating and time-consuming.

The Problem 🤦🏻

Picture this: You're a developer, DevOps guru, or an IT administrator. Your Docker environment is like a bustling metropolis, filled with containers, images, volumes, and extensions. You've just received a call that the production server is acting up, and your mission, should you choose to accept it, is to find and fix the rogue container causing chaos.

You think to yourself, "No problem, I've got this." You fire up Docker Desktop, and suddenly, you find yourself in a labyrinthine maze of menus, sub-menus, and windows. "Where on Earth is that container?" you mumble, as you navigate through an endless maze of clicks and scrolls.

The "Eureka" Moment 🎯

But behold, dear Docker user, the winds of change have blown your way. Docker Desktop introduces its latest hero: the Global Search Capability! This feature is like the treasure map you've always needed but never knew existed.

With a flourish of your keyboard and a confident click of your mouse, you invoke the Global Search. You type in the name of the container you seek, and voilà! It appears before you, like a mythical creature summoned by your Docker-wizardry.

You can't help but chuckle at the irony – all those hours spent searching for containers, and now it's as easy as finding your favorite cat meme on the internet. You might even imagine Docker Desktop whispering in your ear, "Why didn't you summon me earlier, oh seeker of containers?"

Global Search: Your Trusty Sidekick 🤝🏻

Global Search in Docker Desktop is more than just a feature; it's your trusty sidekick, your secret weapon, your ticket to a world where finding resources doesn't require a treasure map or a Sherlock Holmes hat.

This ingenious capability allows you to search for not only images and containers but also the Extensions Marketplace and Community Extensions, as well as volumes. It's like having a super-powered search engine that understands the language of Docker.

Who's This For?

Developers
DevOps
IT Administrators

Global Search in Docker Desktop is a feature that can benefit anyone who works with containers and images. It can be particularly useful for developers, DevOps engineers, and IT administrators who work with complex Docker environments and need to manage multiple resources simultaneously.

In Conclusion 🔥

As you bask in the glory of finding the rogue container in record time, you realize that Docker Desktop's Global Search Capability is your trusty sidekick, your secret weapon, your ticket to a world where finding resources doesn't require a treasure map or a Sherlock Holmes hat.

So, dear Docker enthusiasts, next time you're faced with a container conundrum, remember that with Docker Desktop's Global Search, you're not just finding containers – you're finding precious moments of time, sanity, and perhaps, a good laugh along the way. Happy Docker-ing!

Getting Started 🚴🏻

Prerequisite:

Docker Desktop 4.23.0 and above

Step 1:

Click on the “whale” icon and choose “Dashboard”.

Step 2:

Click on “Search for images,containers, volumes, extensions and more…”

Step 3:

Start typing a Docker Image name and select the Images

Start typing "Mongo," and you will see search results appearing on the screen. It shows that there are 50 images and 1 extension. I don't have a Mongo image on my local machine; this is why it's showing me the list on Hub Images.

Step 4:

Click "Run" the MongoDB container

It will start downloading this image if you are running this app for the first time

Step 5:

Configuring the settings & environment variable

You can setup environment variables like username and password as shown in the following way

Step 6:

Click "Run" the MongoDB container

Step 7:

Viewing the log

Step 8:

Accessing MogoDB Server via Mac Terminal

To achieve this, you will need to install Mongosh(Mongo Shell) software on your Mac system

brew install mongosh

Next, Run mongosh without any command-line options to connect to a MongoDB instance running on your localhost with default port 27017:

mongosh 
Current Mongosh Log ID: 637857e4560a50a9c0df827c
Connecting to:      mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+1.6.0
Using MongoDB:      6.0.3
Using Mongosh:      1.6.0
For mongosh info see: https://docs.mongodb.com/mongodb-shell/
To help improve our products, anonymous usage data is collected and sent to MongoDB periodically (https://www.mongodb.com/legal/privacy-policy).
You can opt-out by running the disableTelemetry() command.

test>

Connecting to Remote MongoDB Server

To connect to a MongoDB instance running on a remote host on port 27017 with authentication in place

mongosh "mongodb://localhost:27017" --username root -p

Enter password: ********
Current Mongosh Log ID: 6378743da440589326e2c8a2
Connecting to:      mongodb://<credentials>@localhost:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+1.6.0
Using MongoDB:      6.0.3
Using Mongosh:      1.6.0

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

------
   The server generated these startup warnings when booting
   2022-11-19T05:05:35.135+00:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
   2022-11-19T05:05:36.020+00:00: vm.max_map_count is too low
------

------
   Enable MongoDB's free cloud-based monitoring service, which will then receive and display
   metrics about your deployment (disk utilization, CPU, operation statistics, etc).

   The monitoring data will be available on a MongoDB website with a unique URL accessible to you
   and anyone you share the URL with. MongoDB may use this information to make product
   improvements and to suggest MongoDB products and deployment options to you.

   To enable free monitoring, run the following command: db.enableFreeMonitoring()
   To permanently disable this reminder, run the following command: db.disableFreeMonitoring()
------
test>

Now that you've entered the MongoDB shell, you're equipped to embark on your data journey. You can begin by crafting a new collection and orchestrating an intricate symphony of CRUD operations to shape your data universe

Thanks for reading this! If you enjoyed this article, give it a virtual high-five with a 💖! If you need more info or have a burning desire for a topic I should tackle (preferably not "How to Train Your Pet Rock"), drop a comment below, and I'll try not to respond with a knock-knock joke. You can also follow me on LinkedIn, where I promise to post only the most dignified cat videos and coffee mishaps.

Automated Updates Made Easy: Unveiling Docker Compose File Watch 🐳

Asharib Ahmed — Wed, 23 Aug 2023 21:34:51 +0000

Introduction 🚀

Overview of Docker Compose File

Containerized development has revolutionized the way software is built and deployed, offering unparalleled flexibility and scalability. However, this progress hasn't come without its challenges. Docker Compose File Watch emerges as a promising solution to one of the most persistent obstacles faced by developers in this realm - the need for seamless and automatic updates to service containers during the development process.

In essence, Docker Compose File Watch aims to bridge the gap between coding and deployment by introducing a dynamic mechanism that ensures your service containers stay in sync with your evolving codebase. It promises to eliminate the tedium of manual container updates, freeing developers to focus on what truly matters - writing code and crafting innovative solutions.

Importance of Automated Updates in Development:

The modern development landscape is marked by agility and rapid iteration. Developers continuously refine their code, responding to changing requirements and addressing bugs. However, in the containerized world, every code modification often necessitates a corresponding container update, disrupting the flow and impeding productivity.

Picture this: you're feverishly coding, bringing your brilliant ideas to life. Suddenly, you need to modify a configuration file, triggering a series of manual steps to synchronize your changes with the container. The rhythm is lost, and your focus shifts from innovation to maintenance. This is where Docker Compose File Watch steps in, promising to liberate developers from these shackles of manual synchronization and container management.

Benefits of Streamlining Containerized Development:

At the heart of Docker Compose File Watch lies the aspiration to optimize the development process. By automating the synchronization of code changes with container instances, developers gain the luxury of uninterrupted focus on their codebase. This newfound efficiency translates into faster development cycles, quicker bug fixes, and a more responsive development environment.

Beyond individual productivity gains, Docker Compose File Watch holds the potential to foster collaboration within development teams. With manual synchronization largely relegated to the past, teams can work harmoniously on shared projects without constant disruptions. This collaborative synergy can lead to enhanced creativity, improved code quality, and accelerated project timelines.

Understanding the Problem 🌪

Challenges Faced by Developers in Containerized Development:

While containerization offers a plethora of advantages, it isn't without its challenges, especially when it comes to maintaining a fluid development experience.

Time Complexity in Manually Updating Containers:

Iterative Code-Test-Update Cycles:

In the realm of software development, iteration is key. Developers constantly iterate through a cycle of coding, testing, and refining. However, in a containerized environment, the iteration process is often hampered by the need to manually update containers. This introduces a significant time overhead, disrupting the seamless flow of development.

Consider a scenario where you're working on a microservice architecture. Each tweak to your codebase necessitates an update to the respective container. The manual nature of this process introduces a time complexity that accumulates with each iteration. The result? Valuable time and energy diverted from coding to administrative tasks.

Cumbersome Restart Processes:

Containerized applications thrive on their ability to be lightweight and nimble. Containers can be started, stopped, and scaled with remarkable speed. However, this agility often contrasts with the manual steps required to restart containers after code changes. The need to halt, modify, and restart services introduces friction into the development process.

Imagine you're collaborating with team members, each working on different parts of the application. As code changes are integrated and services are updated, the constant need to restart containers can create a disjointed development experience. The more complex your architecture becomes, the more pronounced this challenge becomes.

Shift in Focus from Development to Maintenance:

Impact on Creativity and Innovation:

Software development is a creative endeavor, requiring unfettered focus and imagination. Yet, the burden of manual container updates can derail this creative flow. Developers find themselves pulled away from the art of coding and into the realm of maintenance, stifling the very creativity that drives innovation.

In the midst of crafting elegant algorithms or designing intuitive user interfaces, the interruption caused by manual updates can lead to loss of context, fragmented thoughts, and a reduced capacity for innovation. The cognitive shift from development to maintenance is a disruption that hampers the very essence of what developers do best - innovate.

Mitigating Development Momentum:

Momentum is a powerful force in development. When you're deeply engaged in coding, you ride a wave of inspiration and insight. However, the need to frequently pause this momentum to attend to container updates can be jarring. The mental shift required to transition from coding to container management disrupts the development rhythm.

Imagine a scenario where you're meticulously crafting intricate logic for a complex feature. Suddenly, you're required to switch gears, update containers, and ensure everything is in sync. The mental context-switching introduces a cognitive load that erodes the fluidity of the development process. As a developer, your energy is best spent on coding, not on managing container states.

Balancing Act: Development vs. Maintenance 🧘🏼

Balancing development with maintenance is a delicate act. While maintenance is an essential part of software engineering, it should not overshadow the creative process of coding. Docker Compose File Watch aspires to recalibrate this balance, enabling developers to focus on development while the tool handles the intricate task of container synchronization.

In the sections that follow, we'll delve into the mechanics of Docker Compose File Watch, exploring how it tackles these challenges head-on. We'll uncover the inner workings of this experimental feature, delve into real-world scenarios, and equip you with the knowledge to integrate it seamlessly into your development workflow.

Introducing the Solution 🔥

How Docker Compose File Watch Addresses the Developer Problem:

Docker Compose File Watch emerges as a beacon of hope for developers grappling with the complexities of manual container updates. At its core, this experimental feature embodies the principle of automation - the art of simplifying and streamlining tasks that were once labor-intensive.

When you integrate Docker Compose File Watch into your development workflow, the arduous process of manual container updates becomes a thing of the past. Instead of toggling between your code editor and terminal, initiating container restarts, and meticulously synchronizing changes, you can trust Docker Compose to handle these intricacies seamlessly.

This feature introduces an x-develop section in your Compose.yaml file, acting as a command center for orchestrating automatic updates. By configuring watch paths and associated actions, you empower Docker Compose to monitor specific files or directories for changes and trigger predefined actions accordingly. The result? A development environment that remains in lockstep with your codebase, freeing you to channel your energy into coding rather than container management.

Getting Started 👀

Installation and Setup of Docker Compose:

Before we embark on our exploration of Docker Compose File Watch, it's imperative to ensure that you have the necessary tools at your disposal.

Installing Docker and Docker Compose: If you're new to Docker, fear not. The installation process is straightforward and well-documented. Head over to the official Docker website and follow the installation instructions tailored to your operating system. Additionally, Docker Compose, an essential companion, must be installed to orchestrate multi-container applications effortlessly.
Ensuring Compatibility with Your Project: As with any new tool, compatibility is key. Take a moment to assess whether your project aligns with the prerequisites of Docker Compose File Watch. While the feature promises a smoother development experience, confirming compatibility upfront ensures a seamless integration.

Basics of Compose.yaml Configuration:

Docker Compose operates on the premise of declarative configuration. At its core is the Compose.yaml file - a blueprint that outlines the composition and behavior of your containerized application.

Defining Services, Networks, and Volumes: The Compose.yaml file provides a canvas to define your services, networks, and volumes. Services encapsulate the individual components of your application, while networks facilitate communication between services. Volumes, on the other hand, enable data persistence and sharing between containers.
Building the Foundation for Automated Updates: To harness the power of Docker Compose File Watch, it's essential to establish a strong foundation. The Compose.yaml file serves as the canvas on which we'll introduce the x-develop extension, transforming it into a dynamic control center for automated updates.

Enabling the x-develop Section for Watch:

The key to unlocking the potential of Docker Compose File Watch lies in the introduction of the x-develop section within your Compose.yaml file.

Introducing the x-develop Extension: The x-develop extension is a mechanism to extend the capabilities of Compose.yaml. It empowers you to define watch paths and associated actions, laying the groundwork for automatic container updates. Understanding the structure and syntax of this extension is crucial as we venture into the heart of automated updates.
Integrating File Watch in Your Project Setup: Armed with the knowledge of the x-develop extension, you'll seamlessly integrate Docker Compose File Watch into your project. By strategically configuring watch paths and actions, you'll orchestrate a symphony of automated updates, ensuring your containers are always in sync with your code.

Configuring Watch Paths and Actions 🛠

Exploring the x-develop Configuration Options:

At the heart of Docker Compose File Watch lies the power to configure watch paths and define corresponding actions. This intricate dance between watching and acting is what enables the seamless synchronization of code changes and container updates.

Understanding Watch Paths and Glob Patterns:
Watch paths define the locations in your project's file structure that Docker Compose will monitor for changes. By specifying these paths, you dictate which components of your codebase trigger automated updates. The use of glob patterns offers flexibility in selecting files and directories, allowing you to be as granular or comprehensive as necessary.
Defining Actions: Sync, Rebuild, and More:
Actions define how Docker Compose responds to changes detected in the specified watch paths. The two primary actions at your disposal are synchronization and rebuild. Synchronization ensures that modified files are copied into the corresponding container paths, ensuring real-time consistency. Rebuild, on the other hand, triggers the rebuilding of container images and subsequent service updates.

Specifying Paths to Watch for Changes:

The art of configuring watch paths is rooted in strategic selection. While the temptation might be to monitor every corner of your project, a more refined approach yields greater efficiency.

Selecting Relevant Project Files and Folders:
Begin by identifying the files and folders that hold the greatest impact on your application's behavior. These could include source code files, configuration files, or data assets. By focusing on the critical components, you ensure that Docker Compose File Watch expends its resources judiciously.
Optimizing Path Selection for Development Needs:
Customization is key. Consider tailoring your watch paths to suit your development needs. For instance, if a specific feature module undergoes frequent changes, targeting its directory for watch can enhance responsiveness. The goal is to strike a balance between comprehensive coverage and targeted efficiency.

Working of Docker Compose File Watch 👨🏻‍💻

Behind the Scenes: How File Watch Mechanism Operates:

The allure of Docker Compose File Watch lies not only in its results but also in its elegant inner workings. To truly grasp its power, let's venture behind the scenes and understand how this dynamic mechanism operates.

Monitoring File System Events:
At its core, Docker Compose File Watch acts as a vigilant sentry, monitoring file system events with precision. It keeps a watchful eye on the paths you've configured, detecting changes such as file creations, modifications, or deletions.
Communication Between Host and Containers:
When a file system event is detected, Docker Compose orchestrates a seamless communication dance between the host and the relevant containers. This dance ensures that changes are propagated swiftly, maintaining a real-time synchronization that mirrors your development efforts.

Handling Synchronization and Image Rebuilds:

Docker Compose File Watch's prowess extends beyond mere synchronization. It has the ability to orchestrate intricate image rebuilds, ensuring your services encapsulate the latest updates.

Understanding the Synchronization Workflow:
When a file is modified in a watched path, Docker Compose swings into action. It orchestrates the transfer of the updated file into the corresponding container, ensuring that your changes are seamlessly integrated.
Rebuilding Images Efficiently with Cached Layers:
Certain changes, such as modifications to package dependency files, warrant more than just synchronization. In such cases, Docker Compose can trigger a systematic image rebuild. Leveraging its understanding of cached layers, Docker Compose optimizes the rebuild process, minimizing unnecessary overhead.

Benefits and Considerations 🎉

Developer Productivity and Time Savings:

The most tangible benefit of Docker Compose File Watch lies in its ability to amplify developer productivity. By eliminating the need for manual container updates, you're free to invest your time and energy where it matters most: writing code. The resulting acceleration in development cycles translates to quicker feature delivery, faster bug fixes, and an overall smoother development experience.

Potential Impact on Build and Deployment Pipelines:

The integration of Docker Compose File Watch extends its influence beyond development. It can potentially impact your build and deployment pipelines by streamlining the synchronization between development, testing, and deployment stages. Containers that remain in sync with your codebase from the outset are more likely to exhibit consistent behavior, reducing discrepancies between development and production environments.

Known Issues and Limitations of the Experimental Feature:

While Docker Compose File Watch holds immense promise, it's important to acknowledge its experimental nature. Like any technology in its infancy, there may be bugs, limitations, or scenarios that require manual intervention. Keeping abreast of Docker's official documentation and community discussions is crucial to understanding potential pitfalls and workarounds.

Balancing Automation with Manual Control:

Docker Compose File Watch is a powerful ally, but it's not the sole commander of your development landscape. Striking a balance between automation and manual control is key. There might be instances where nuanced adjustments or specific requirements demand a more hands-on approach. As you harness the power of Docker Compose File Watch, ensure that you retain the flexibility to intervene when necessary.

Future Enhancements ⌛️

Roadmap for Docker Compose File Watch Improvements:

The world of technology is ever-evolving, and Docker Compose File Watch is no exception. The Docker Compose team is actively engaged in refining the feature based on user feedback and evolving development paradigms. As you embark on your journey with Docker Compose File Watch, keep an eye on the official roadmap to anticipate upcoming enhancements and refinements.

Community Feedback and Collaboration:

The strength of any tool lies in its community. Docker Compose File Watch thrives on user feedback, suggestions, and collaborative efforts. Engaging with the Docker community, participating in discussions, and sharing your experiences can contribute to the feature's evolution. Your insights could potentially shape the direction of future updates and improvements.

Upcoming Features and Integrations:

The beauty of the software ecosystem is its relentless pursuit of improvement. Docker Compose File Watch is likely to evolve in tandem with the broader container landscape. Anticipate updates that might enhance its capabilities, introduce new features, or facilitate integrations with complementary tools. Staying informed about upcoming features equips you to make informed decisions about its integration into your workflow.

Getting Started with Docker Compose File Watch

Step-by-Step Integration Guide:

Now that you've gained a comprehensive understanding of Docker Compose File Watch, it's time to embark on your journey of integration. Follow this step-by-step guide to get started:

Install Docker and Docker Compose:
If you haven't already, ensure that Docker and Docker Compose are installed on your development environment. Head to the official Docker website and follow the installation instructions for your specific operating system.
Create or Navigate to Your Project Directory:
Whether you're starting a new project or integrating Docker Compose File Watch into an existing one, navigate to the root directory of your project in your terminal.
Compose.yaml Configuration:
Open your project's Compose.yaml file. If you don't have one, create a new file and define your services, networks, and volumes following Docker Compose's declarative syntax.
Introduce the x-develop Extension:
Within your Compose.yaml file, introduce the x-develop extension under the service for which you want to enable automated updates. Define the watch paths and associated actions within this extension.
Configure Watch Paths and Actions:
Specify the paths you want Docker Compose to watch for changes. These paths can encompass critical code files, configuration files, or other components that require synchronization. Determine the appropriate actions to take upon changes, whether it's synchronization or triggering image rebuilds.
Save and Validate:
Save your Compose.yaml file and validate its syntax using the docker-compose config command. Ensure that your configuration is error-free and ready for deployment.
Launch Your Services:
Run docker-compose up to launch your services. Docker Compose will now monitor the specified watch paths and execute the defined actions when changes occur.
Observe Automatic Updates:
As you make changes to the watched paths, observe how Docker Compose File Watch springs into action. It will synchronize changes or trigger image rebuilds as configured, maintaining a real-time connection between your code and containers.
Iterate and Enhance:
With Docker Compose File Watch seamlessly integrated into your workflow, iterate on your development process with newfound efficiency. Focus on coding, testing, and refining, knowing that container updates are no longer a manual burden.

Congratulations! You've successfully integrated Docker Compose File Watch into your development workflow. Embrace the enhanced productivity, streamlined collaboration, and accelerated iterations that this powerful feature brings to your containerized projects.

In the realm of software development, time is of the essence. By harnessing the capabilities of Docker Compose File Watch, you've unlocked a valuable tool that empowers you to devote more time to innovation and less to administrative tasks. As you continue your journey, explore additional nuances, experiment with various configurations, and share your experiences with the thriving Docker community.

Demo Projects ☃️

Embarking on our journey, we present a captivating demo project that breathes life into the concept of file watch. This hands-on demonstration offers a vivid showcase of Docker Compose File Watch in action, allowing you to witness firsthand how it transforms the development landscape. Through this engaging demo, you'll unlock the potential of automated updates and seamless synchronization, breathing new life into your coding endeavors. So, without further ado, let's delve into the world of file watch and unveil the magic it brings to your development process.

Demo Project : Todo List Application

Step 1. Clone the repository

Begin your journey by cloning the repository for our Todo List Application. In your terminal, execute the following command:



git clone https://github.com/ajeetraina/todolist-node-xdevelop

Step 2. Examining the Compose file

Dive into the heart of the Compose file that powers our Todo List Application. The Compose.yaml file orchestrates the interplay between services and introduces the magic of Docker Compose File Watch.



services:
  app:
    build: .
    x-develop:
      watch:
        - action: rebuild
          path: .
    command: sh -c "yarn install && yarn run dev"
    ports:
      - 3000:3000
    working_dir: /app
    volumes:
      - ./:/app
    environment:
      MYSQL_HOST: mysql
      MYSQL_USER: root
      MYSQL_PASSWORD: secret
      MYSQL_DB: todos

  mysql:
    image: mysql:8.0
    ports:
      - 3306:3306
    volumes:
      - todo-mysql-data:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: secret
      MYSQL_DATABASE: todos

volumes:
  todo-mysql-data:

This compose file defines two services, web and mysql, and a volume named todo-mysql-data, similar to the original file. However, the web service now includes an x-develop section, which enables the experimental "watch" mode for this service.

The watch section contains two actions: sync and rebuild. The "sync" action specifies a path to watch for changes in the host file system, and a corresponding target path inside the container to synchronize changes to. The "rebuild" action specifies a path to watch for changes in the host file system, and triggers a rebuild of the container when changes are detected.

The web service maps port 3000 of the container to port 3000 of the host, sets the working directory inside the container to /app, and mounts the current directory on the host to /app inside the container. The "mysql" service uses the official MySQL 8.0 Docker image, maps port 3306 of the container to port 3306 of the host, and creates a volume named todo-mysql-data to persist the MySQL data.

Step 3. Starting the container services



docker compose ps
NAME                IMAGE               COMMAND                  SERVICE             CREATED             STATUS              PORTS
app-app-1           app-app             "docker-entrypoint.s…"   app                 7 seconds ago       Up 7 seconds        0.0.0.0:3000->3000/tcp
app-mysql-1         mysql:8.0           "docker-entrypoint.s…"   mysql               5 days ago          Up 7 seconds        0.0.0.0:3306->3306/tcp, 33060/tcp

Step 4. Accessing the app

Open http://localhost:8080 to access the app

Step 5. Testing the Compose `Watch` Feature

To test the watch mode in the Docker Compose file, you can make some changes to the source code files that are being watched and see if the changes are automatically synchronized and/or trigger a rebuild of the container.

Run the below command to start monitoring for file edits within your project and keep the terminal open:



docker compose alpha watch

In the /src/index.js file, update the line 18 to use the new empty text



-   app.listen(3000, () => console.log('Listening on port 3000'));
+   app.listen(3000, () => console.log('Listen on port 3000'));

Step 6. Verifying the effect



change detected on /src/index.js
change detected on /src/index.js

If you make changes to the index.js under the app directory, the changes should be automatically synchronized to the corresponding files inside the container, and you should see the changes in your results.

Note that the watch mode is still an experimental feature, so there may be some issues or limitations that you encounter during testing.

Compose Watch also allows you to specify the name of directories. For example, this Docker Compose file defines a service called web which is built from the current directory (".") and includes an experimental feature called x-develop. The x-develop section includes a list of actions to be taken when changes are detected in certain directories or files.

In this case, there are two actions defined:

sync: This action will synchronize any changes made to the ./web directory on the host machine to the /app/web directory inside the container running the web service. This ensures that any changes made to the web application code are immediately available inside the container.
rebuild: This action will trigger a rebuild of the web service container if changes are detected in the .package.json file. This ensures that any changes to the application's dependencies are automatically installed and available inside the container.



services:
  web:
    build: .
    x-develop:
      watch:
        - action: sync
          path: ./web
          target: /app/web
        - action: rebuild
          path: package.json

In nutshell, if you modify package.json (such as by installing a new npm package), Compose will rebuild the image and replace the existing service with an updated version. Refer to the next section to see it in action.

Conclusion 🥁

In the dynamic landscape of containerized development, Docker Compose File Watch emerges as a beacon of efficiency and innovation. This experimental feature liberates developers from the chore of manual container updates, unleashing a new era of productivity and collaboration. By seamlessly synchronizing code changes with container instances, Docker Compose File Watch empowers developers to channel their energy into coding, refining, and creating, fostering an environment where ideas flourish. As you embark on your containerized development journey, remember that while technology propels progress, it's your insights and creativity that shape the future of software. Embrace Docker Compose File Watch, enhance your workflow, and embark on a seamless development journey like never before.

Thanks for reading this! If you enjoyed this article make sure to leave a 💖, and if you need any other information or want to request a topic I should cover, feel free to drop a comment below!
You can also follow me on LinkedIn.

Adopt 10x approach in Computer Science Degree…!🔥

Asharib Ahmed — Sat, 04 Mar 2023 16:24:04 +0000

Key Reason of writing this Article

I’m pursuing my bachelors in Computer Science from last 2 and a half year, what I have seen in my fellows that there are numerous students who end up with lower job positions or having less skills after their degree because they didn’t got the proper counseling regarding their field or market required skills!

So, I will share 10x approach with y’all how you folks can pursue your degree in a way that will make you ready for the interview in Google, Facebook type companies and what are the key courses that you have to most focus on and some tips and tricks for the better skills development :)

Discussion 💬

My end goal is to make you comprehend that CS has whole universe in it, there is nothing impossible to do, you just desire a proper path way. so, we’ll be talking over following things which you can follow to become a master in Computer Science 😎

Most worth full Concepts
Projects you have to build
How to become better programmer
How to get hired in tech giants
Soft Skills

Let’s get Started 🤩

🕯 Beginning of your 4 years journey

In very first semester mostly universities will teach you the course of Introduction to programming fundamental, Applied physics, programming language like C or C++ and Ms Office. They are just giving you an synopsis regarding these concepts, they never took you to the deeper concepts like the main reason of having a course of Applied physics is to implementation of physics principles in computer science but they teach you just momentum, force and newtons laws. so don’t just rely on your university, do learn about gravity equations, Navier stoke equation by your own which is gonna enable you build simulation. In fact Microsoft, Google have their own simulation system in which they test computer science design principle and their underlying principle which is completely based on applied physics. More over when you play any game you see Air, water, motions and movements they all are develop by inverse and forward cymatics and you can see it by your own if you download the standard assets or character controller of unity and see its script written on C#, so you’ll find the gravity equation there. This is why applied physics is crucial in CS and so you have to comprehend these concepts.

⚒️ Project Idea: Build your own 2D cylindrical game engine on C++ in which you can render object and change their shapes.

📐 Single and multi variable Calculus
If you have any interest in Artificial Intelligence so you have to consider this course extremely significant because machine learning is nothing but math and if you go in a bit deeper so you’ll find calculus concept’s like derivatives, integration etc. like we can’t do back propagation in neural network without chain rule. In CS you'll see calculus principles on and off in many places.

💪🏻 Power of C++
C++ is versatile language, you can build really amazing stuff by using C++. Our world wide web is completely written on C++ but still our universities asked you to create simple console base read and write tool which can read an employee name, age etc and write it on a .txt file. but for God sake go for something creative which is based on GUI, not go for console based tool because this habit will stuck with you till the end of your degree. In universities they will just teach you C++ up to functions and classes but you have to discover about GPU programming, Directx programming, Open GL programming, Web GL programming type thing by your own because if you gonna apply for a internship at google after 3rd or 4th semester so they will asked you for you semester projects and if you gonna exhibit them console based application, they will definitely kick you out but on the other hand if you have something like TCP/IP socket server as your semester project then they will consider you as a potential candidate.

🛠️ Project Ideas :

Develop game using Simple and Fast Multimedia Library.
First person shooter game on unreal engine.

📏 Probability and Statistics
This course is the essential for Artificial Intelligence developer. Entire Machine Learning works on probability and statistics principles’ like K nearest neighbors, Linear regression, Random Forest etc. No one can survive in AI without having a understanding of this course. You can initiate python library like Pstats as a semester project , which can implement stats function mean, mode and Standard Deviation.

🧰 Project Idea :

Create your own Algorithm (with team).
Solve real world problem related to Fintech Market

🎯 Digital Logic and Design (DLD)
This course is lovely and bit easier as compare to others. You have tones of amazing projects on which you can work on. You can build keyloggers in hardware, signal jammers , WiFi authors etc. These are the projects which can teach you real world material ground truth like how signal jammers work, how WiFi get disabled, how WiFi access point stable and how WiFi connects with the help of access points. these mini project can help you to get command on hardware programming.

🧮 Linear Algebra
This is also a prerequisite of Artificial Intelligence. Egin values and Egin vectors implementation in any programming language is the primary concept that you have to discover. Coordinators transformation is also vital if you wanna go for robotics including rotation matrix, rotation vectors etc.

🖱️ Object Oriented Programming (OOP)
Universities mostly prefer JAVA for OOP but you are in good university so they will teach you in C# otherwise. You need to learn multi-threading in this, which use to run single code on a multiple machines. Do try to learn about GPU programming, if you have NVIDIA graphic card then download Compute Unified Device Architecture (CUDA) and learn its programming. Because if you know GPU programming so you can increase any device speed, you can decrease their run-time etc and almost every tech giant required GPU programming because they are using handling large scale traffic every day.

🔧 Project Idea : GUI App management by using (Java/Visual Basic)

📊 Discrete Mathematics
In this course you have to learn about inductive and deductive logic because this is the time when you are suppose to showcase yourself to the world by Competitive Programming. CP is the only way by which you can prove yourself to the world. Gennady Korotkevich is amazing example of this, who is the world best competitive programmer, the guy who rejected Microsoft, Google and Facebook type companies’ offer. And this course is a prerequisite for competitive programming so you have to take this seriously.

Following are the platforms from where you can polish your competitive programming skills.

🔥 Platforms :

Hacker Rank
Leetcode

following are the competitions that you can be a part of.

⚔️ Competitions :

Google hash code and code jam
Facebook Hacker Cup
International Collegiate Programming Contest

💾 Database Administration
So, data structure is the only concept what you will deal with in every IT related job. If you are a developer so I guaranteed you that one day time will be come when you have to deal with Databases. So you have to be prepared for it. Do try to create your own database with few features as a semester project rather than just using pre-build database.

🗣️ Soft Skills
We have been discussing about the concepts and project that you to focus on but there is main key on which you have to work on and that key is SOFT SKILLS. Search Results. Soft skills are attributes that enable you to engage in meaningful interactions with others. Since most jobs require teamwork, it’s important to possess soft skills to enhance your employability and achieve your dream job.

Yooooo!!! its to much to digest hmmm???

No worries you have four years for this so just stay concentrated on what you are doing and if you gain good understanding of all these concepts and build likewise projects then congratulation now you are ready to join GOOGLE, FACEBOOK and MICROSOFT.

Resources

For any Book
For DLD Projects
For system Design

Weeyy Haaa!! 🤠 We are done and you are a completely ready to be a part of Google, Facebook and Microsoft!

Congratulations!! 🥳

That’s all from my side, I hope anything from above trash would help you. Good luck for your future endeavor. And Yeah one thing I forgot:

Please leave some comments!! 👏 Please..!! AaaaHAHA0HHAHA! 😭
HAHAH! Just kidding :)