{"id":391,"date":"2026-10-31T08:00:00","date_gmt":"2026-10-31T16:00:00","guid":{"rendered":"https:\/\/www.tonybhimani.com\/programming-blog\/?p=391"},"modified":"2026-10-30T10:19:11","modified_gmt":"2026-10-30T18:19:11","slug":"docker-for-developers-an-old-school-programmers-take-on-containers","status":"publish","type":"post","link":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/","title":{"rendered":"Docker for Developers: An Old-School Programmer’s Take on Containers"},"content":{"rendered":"

I’ve been developing software and managing IT infrastructure for a long time. Back in the day, getting an application running on a server often meant installing the required software, configuring the environment, sorting out dependencies, and hoping everything played nicely together.<\/p>\n

If you were lucky, the development environment closely resembled production. If you weren’t, you could spend hours tracking down a problem that only appeared on the server.<\/p>\n

Then came Docker.<\/p>\n

Containers aren’t a magic solution to every deployment problem, but they offer a practical way to package an application with much of what it needs to run. For developers who work across different machines and environments, that can make life considerably easier.<\/p>\n

In this article, I’ll explain what Docker brings to the development process, why I started using it, and why containers still require a little old-fashioned troubleshooting now and then.<\/p>\n

Why I Started Using Docker<\/h2>\n

One of the challenges of software development is keeping environments consistent.<\/p>\n

An application might run perfectly on your development machine but behave differently after you deploy it to a server. The operating system may differ. Software libraries might be different versions. Environment variables, filesystem permissions, network configuration, and other settings can all affect how an application behaves.<\/p>\n

Traditionally, developers dealt with these differences by installing and configuring the required software on each machine.<\/p>\n

That approach works, but it can become cumbersome when you’re managing multiple applications or switching between development and production environments.<\/p>\n

Docker provides another option. Instead of manually reproducing an application’s environment on every machine, you can define an environment that Docker can build and run in a consistent, repeatable way.<\/p>\n

I didn’t start using Docker because I wanted to adopt the latest development trend. I started using it because I wanted a more manageable way to run software and its dependencies without having to install and maintain everything directly on every machine.<\/p>\n

For a developer working on multiple projects, that distinction matters.<\/p>\n

What Is a Docker Container?<\/h2>\n

A Docker container is an isolated environment in which an application runs. It uses the host operating system’s kernel while providing the application with its own configured filesystem, processes, networking, and other resources.<\/p>\n

A container is created from an image. The image describes the filesystem and software environment used to start the container.<\/p>\n

For example, imagine you have a Python application that requires a particular Python version and several third-party packages.<\/p>\n

You could install Python on your computer, install the packages, configure the application, and repeat some version of that process on your server.<\/p>\n

Or you could create a Docker image that specifies the Python environment, copies in your application, installs its dependencies, and defines how the application starts.<\/p>\n

You can then build and run a container from that image wherever a compatible Docker environment is available.<\/p>\n

The details still matter, of course. You need to configure things such as environment variables, network access, persistent storage, and secrets appropriately. Docker doesn’t automatically solve those problems for you.<\/p>\n

But it gives you a repeatable foundation.<\/p>\n

Images and Containers Are Not the Same Thing<\/h3>\n

It’s worth understanding one distinction early.<\/p>\n

A Docker image is the packaged template. A container is a running instance created from that image.<\/p>\n

You can use the same image to create multiple containers. You can also stop and remove a container without necessarily removing the image from your machine.<\/p>\n

This becomes particularly important when working with databases and other applications that maintain persistent data. The container’s writable filesystem is not a substitute for properly configured persistent storage.<\/p>\n

We’ll explore that in a future article when I look at running PostgreSQL in Docker.<\/p>\n

Containers Versus Virtual Machines<\/h2>\n

If you’ve worked with virtual machines, some of this might sound familiar.<\/p>\n

Virtual machines allow you to run an operating system inside another operating system using virtualization software. Each virtual machine typically has its own operating system kernel and requires its own allocation of resources.<\/p>\n

Containers work differently.<\/p>\n

A container shares the host’s operating system kernel while isolating the application and its environment. Because you aren’t running a separate guest operating system for every container, containers generally require less overhead than full virtual machines.<\/p>\n

That makes them useful when you want to run several applications or services on a single server without maintaining a separate virtual machine for each one.<\/p>\n

However, containers and virtual machines aren’t interchangeable in every situation.<\/p>\n

A virtual machine can provide a separate operating system kernel, which is useful when you need stronger operating-system separation or a different kernel from the host. Containers are often a better fit when you want to package and run applications efficiently.<\/p>\n

Docker Desktop on Windows and macOS adds another layer to this picture. Because Linux containers need a Linux kernel, Docker Desktop generally uses a lightweight Linux virtual machine behind the scenes.<\/p>\n

You don’t need to understand every detail of that architecture to use Docker, but it’s useful to know that running a Linux container on a Windows or macOS development machine isn’t necessarily the same thing as running it directly on a Linux server.<\/p>\n

That distinction can matter when troubleshooting environment-specific problems.<\/p>\n

Why Developers Use Docker<\/h2>\n

For me, the biggest advantage of Docker is repeatability.<\/p>\n

Once you’ve defined an application’s environment, you have a starting point that can be reused rather than recreated manually on every machine.<\/p>\n

Here are a few practical benefits.<\/p>\n

1. Fewer Dependencies Installed on Your Development Machine<\/h3>\n

Not every project needs to install its runtime or supporting services directly on your computer.<\/p>\n

You can run a Python application in one container, a database in another, and supporting services in additional containers.<\/p>\n

This can help keep projects separated and reduce conflicts between dependencies.<\/p>\n

It also means you can work on different projects that require different software versions without having to manage every version directly on your host operating system.<\/p>\n

There are still things to configure, and containers don’t eliminate every host dependency. But they can simplify the overall setup.<\/p>\n

2. Repeatable Development Environments<\/h3>\n

Imagine handing a project to another developer.<\/p>\n

Without a defined environment, you might need to explain which runtime to install, which packages to download, which services to configure, and which settings need to be changed.<\/p>\n

With Docker, you can provide the application code and the files needed to build its environment.<\/p>\n

The other developer still needs Docker and any required configuration, but you have a much clearer starting point.<\/p>\n

Instead of relying entirely on a set of setup instructions, you can define much of the environment in version-controlled files.<\/p>\n

3. Easier Movement Between Development and Deployment<\/h3>\n

Docker makes it possible to build an application image in one environment and run that image in another compatible environment.<\/p>\n

For example, you might develop on a Mac, build a Linux container image, and deploy it to a Linux server.<\/p>\n

This reduces the number of differences you have to manage manually.<\/p>\n

It doesn’t mean that every deployment will behave identically. Hardware architecture, operating-system behavior, networking, permissions, runtime configuration, and external services can still introduce differences.<\/p>\n

But using the same image gives you a more consistent starting point than separately installing and configuring the application’s dependencies on each machine.<\/p>\n

4. Easier Service Separation<\/h3>\n

Applications often depend on more than one service.<\/p>\n

A typical project might need an application runtime, a database, and a connection pooler. You could install all of those directly on one server, but then you would have to manage their versions, configuration, and dependencies on that machine.<\/p>\n

Docker allows you to run those services in separate containers.<\/p>\n

This separation can make it easier to update, replace, or troubleshoot individual components.<\/p>\n

It also encourages you to think about each service as a distinct part of the overall system rather than treating the server as one large collection of installed software.<\/p>\n

Of course, putting everything into separate containers doesn’t automatically make an architecture better. You still need to consider resource usage, networking, security, backups, and how the services depend on one another.<\/p>\n

The goal is to simplify management, not add complexity for its own sake.<\/p>\n

A Real-World Example: Dependency Hell in Lureesa<\/h3>\n

I ran into a good example of dependency hell while developing Lureesa, my AI-powered companion application<\/a>.<\/p>\n

The problem involved two Google libraries I needed in the backend: Google’s generative AI libraries and Firebase Cloud Messaging (FCM), which I use to send push notifications.<\/p>\n

Neither library was something I could simply remove. Both served an important purpose in the application. The problem was how their underlying dependencies were defined.<\/p>\n

The Google Gen AI libraries required an older version of the Google Cloud Storage Python library, while the Firebase Cloud Messaging libraries depended on a newer version of that same library.<\/p>\n

I wasn’t necessarily using Google Cloud Storage directly for this particular functionality. It was a dependency that these libraries brought into the environment behind the scenes.<\/p>\n

When I tried adding the Firebase Cloud Messaging packages to my existing Lureesa backend, the installation failed because the older Cloud Storage version was already installed to satisfy the Gen AI libraries. The FCM dependencies required a different version, and the package requirements couldn’t be satisfied together in that environment.<\/p>\n

In other words, I had two libraries from the same broader ecosystem that wanted different versions of an underlying dependency. Welcome to dependency hell.<\/p>\n

I needed a solution that would let both parts of the application work without forcing one library’s requirements onto the other.<\/p>\n

My solution was to separate Firebase Cloud Messaging into its own dedicated service with its own codebase and Python environment.<\/p>\n

That service has one responsibility: sending FCM notifications. It installs the Firebase-related packages and their dependencies independently of the main Lureesa backend, so it no longer has to share a Python environment with the Gen AI libraries.<\/p>\n

The main application continues to use its own dependencies, while the FCM service maintains the versions it needs.<\/p>\n

I also deliberately kept the notification service narrowly focused. Its purpose is to send notifications, not to become another general-purpose backend. By avoiding unrelated functionality and unnecessary new dependencies, I reduce the chances of introducing another version conflict down the road.<\/p>\n

This is where containerization becomes particularly useful. Each service can have its own image, dependency definitions, and runtime environment. A conflict in one environment doesn’t automatically become a conflict in another.<\/p>\n

To be clear, Docker doesn’t fix incompatible dependencies inside a single environment. If two libraries require incompatible versions of the same package, putting them into one container won’t magically resolve the problem.<\/p>\n

Instead, Docker gives you a way to isolate those requirements. The main application can use one dependency set, while the notification service uses another.<\/p>\n

There is a trade-off, of course. Separating a service means maintaining another codebase and deployment, and the services need a way to communicate. You shouldn’t split every application into multiple services just because a package installation fails. Sometimes a compatible set of package versions is all you need.<\/p>\n

In my case, though, separating FCM provided a clean solution to a real dependency conflict. It also gave the notification functionality a clear boundary that I can maintain independently.<\/p>\n

That’s one of the practical benefits of containerized development. You’re not just packaging software so it runs on a server. You’re also creating independent environments for components that have different technical requirements.<\/p>\n

Development Versus Production: Consistency Isn’t Perfection<\/h2>\n

This is where I think developers need to be realistic about Docker.<\/p>\n

One of the selling points of containers is that you can build an environment and run it in different places. That’s useful, but it doesn’t mean the underlying platforms become identical.<\/p>\n

I’ve encountered situations where a Python application behaved one way when running through Docker in a Windows development environment and then required changes when deployed to a Debian Bookworm server.<\/p>\n

I don’t want to claim that one particular Docker setting was responsible without being certain of the underlying cause. The important lesson is broader: <\/strong>Docker can make environments more consistent, but it doesn’t guarantee identical behavior everywhere.<\/strong><\/p>\n

There are several reasons for this.<\/p>\n

The host operating system and kernel can affect application behavior. Filesystem permissions and path handling can differ. Networking and process management may be configured differently. CPU architecture can matter when images contain architecture-specific components. Runtime settings, environment variables, and external services can also introduce differences.<\/p>\n

Even when the container image is the same, the environment surrounding it might not be.<\/p>\n

This is why I recommend testing applications in an environment that resembles the intended production environment as closely as practical.<\/p>\n

If you’re deploying to a Linux server, test your application in a Linux container and verify its behavior under the conditions it will encounter after deployment.<\/p>\n

Pay attention to logs, configuration, permissions, and the way the application starts and shuts down.<\/p>\n

Docker reduces some classes of environmental problems. It doesn’t eliminate the need to understand your application or troubleshoot it when something goes wrong.<\/p>\n

And honestly, that’s fine. Containers are another tool in the developer’s toolbox, not a replacement for knowing how your software works.<\/p>\n

Where I’m Using Docker<\/h2>\n

One of my practical uses for Docker is running the services needed by my own development projects.<\/p>\n

A good example is PostgreSQL.<\/p>\n

Managed database services can be convenient, but their cost can be difficult to justify when you’re a solo developer working on a small application or an early-stage product.<\/p>\n

Depending on the project’s requirements, running PostgreSQL on a virtual private server can be a more affordable option. Docker provides a way to package the database environment and manage it separately from the host operating system.<\/p>\n

I can use a similar container-based setup on my local Mac and on a remote Linux server without installing PostgreSQL directly on either machine.<\/p>\n

There is an important detail here: <\/strong>Docker itself doesn’t replace the server.<\/strong> The remote virtual machine still provides the CPU, memory, disk space, operating system, and network connection. Docker runs the services on that infrastructure.<\/p>\n

I also use a separate container for PgBouncer, a connection pooler that sits between applications and PostgreSQL.<\/p>\n

That arrangement allows my applications to connect to PgBouncer rather than opening their database connections directly to PostgreSQL. PgBouncer then manages connections to the database according to its configuration.<\/p>\n

Database storage requires special attention, too. I use persistent storage so the database’s data isn’t tied solely to the lifecycle of a particular container.<\/p>\n

If I remove and recreate the database container, the data should remain available in the persistent volume, provided I preserve and correctly configure that volume.<\/p>\n

That doesn’t replace backups. Persistent storage can still be lost or damaged, and it doesn’t protect against every failure scenario.<\/p>\n

I also have a backup process that uses pg_dump<\/code> and pipes the output through GPG encryption. This allows the backup data to be encrypted as it is generated rather than deliberately writing an unencrypted SQL dump to a temporary file on the server first.<\/p>\n

Encryption is one part of protecting database backups. Key management, access controls, retention, and testing the restoration process are important, too.<\/p>\n

I’ll cover these details in a separate article about running PostgreSQL in Docker, including why I use a separate PgBouncer container and how I approach database persistence and backups.<\/p>\n

For now, the point is that Docker isn’t just useful for deploying web applications. It can also help developers manage the supporting services their applications depend on.<\/p>\n

Containers Are a Tool, Not a Silver Bullet<\/h2>\n

Docker has changed how I approach certain development and deployment tasks, particularly when a project depends on several services or needs a consistent environment across machines.<\/p>\n

It can reduce setup work, help isolate dependencies, and make applications easier to move between compatible environments.<\/p>\n

But it doesn’t remove the need to understand operating systems, networking, filesystems, application configuration, or the services you’re running.<\/p>\n

You still need to secure your containers, manage secrets, configure persistent storage, monitor resource usage, maintain images, and plan for backups and recovery.<\/p>\n

You also need to decide whether containers make sense for the project in the first place.<\/p>\n

For a small script with few dependencies, installing and running it directly might be perfectly reasonable. Introducing Docker adds another layer that you need to understand and maintain.<\/p>\n

For an application with multiple services, conflicting dependencies, or a need for repeatable environments, that extra layer can be worth it.<\/p>\n

As an old-school developer, I don’t think the goal is to use a technology simply because it’s popular. The goal is to understand what problem it solves and decide whether it makes your work easier to maintain.<\/p>\n

For me, Docker has earned a place in that toolbox.<\/p>\n

In the next article, I’ll get more practical and look at how I’m using Docker to run PostgreSQL and PgBouncer on a remote virtual machine, with persistent database storage and encrypted backups.<\/p>\n

Because sometimes the best way to learn a tool isn’t to build an elaborate demonstration. It’s to use it to solve a problem you actually have.<\/p>\n","protected":false},"excerpt":{"rendered":"

I’ve been developing software and managing IT infrastructure for a long time. Back in the day, getting an application running on a server often meant installing the required software, configuring the environment, sorting out dependencies, and hoping everything played nicely together. If you were lucky, the development environment closely resembled production. If you weren’t, you […]<\/p>\n","protected":false},"author":1,"featured_media":394,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[108,109],"tags":[111,114,113,110,112],"class_list":["post-391","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-docker","category-programming-tools","tag-containers","tag-dependency-management","tag-devops","tag-docker","tag-virtual-machines"],"yoast_head":"\nDocker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Docker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal\" \/>\n<meta property=\"og:description\" content=\"I’ve been developing software and managing IT infrastructure for a long time. Back in the day, getting an application running on a server often meant installing the required software, configuring the environment, sorting out dependencies, and hoping everything played nicely together. If you were lucky, the development environment closely resembled production. If you weren’t, you […]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/\" \/>\n<meta property=\"og:site_name\" content=\"Tony's Programming Blog and Development Journal\" \/>\n<meta property=\"article:published_time\" content=\"2026-10-31T16:00:00+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1376\" \/>\n\t<meta property=\"og:image:height\" content=\"768\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"Tony\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@TonyBhimani\" \/>\n<meta name=\"twitter:site\" content=\"@TonyBhimani\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Tony\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/\"},\"author\":{\"name\":\"Tony\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#\\\/schema\\\/person\\\/036db10e4bc2069453a60f580f91ab88\"},\"headline\":\"Docker for Developers: An Old-School Programmer’s Take on Containers\",\"datePublished\":\"2026-10-31T16:00:00+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/\"},\"wordCount\":2876,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#\\\/schema\\\/person\\\/036db10e4bc2069453a60f580f91ab88\"},\"image\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/DockerForDevelopers_20261030094218.jpg\",\"keywords\":[\"containers\",\"dependency management\",\"devops\",\"docker\",\"virtual machines\"],\"articleSection\":[\"Docker\",\"Programming Tools\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/\",\"url\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/\",\"name\":\"Docker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/DockerForDevelopers_20261030094218.jpg\",\"datePublished\":\"2026-10-31T16:00:00+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/DockerForDevelopers_20261030094218.jpg\",\"contentUrl\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/wp-content\\\/uploads\\\/2026\\\/10\\\/DockerForDevelopers_20261030094218.jpg\",\"width\":1376,\"height\":768,\"caption\":\"Docker For Developers\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/docker-for-developers-an-old-school-programmers-take-on-containers\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Docker for Developers: An Old-School Programmer’s Take on Containers\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#website\",\"url\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/\",\"name\":\"Tony's Programming Blog and Development Journal\",\"description\":\"Sharing is caring... Especially with code\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#\\\/schema\\\/person\\\/036db10e4bc2069453a60f580f91ab88\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/#\\\/schema\\\/person\\\/036db10e4bc2069453a60f580f91ab88\",\"name\":\"Tony\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g\",\"caption\":\"Tony\"},\"logo\":{\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g\"},\"sameAs\":[\"https:\\\/\\\/tonybhimani.com\\\/programming-blog\",\"https:\\\/\\\/x.com\\\/TonyBhimani\",\"https:\\\/\\\/www.youtube.com\\\/tonybhimani\"],\"url\":\"https:\\\/\\\/www.tonybhimani.com\\\/programming-blog\\\/author\\\/coding_magik\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Docker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/","og_locale":"en_US","og_type":"article","og_title":"Docker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal","og_description":"I’ve been developing software and managing IT infrastructure for a long time. Back in the day, getting an application running on a server often meant installing the required software, configuring the environment, sorting out dependencies, and hoping everything played nicely together. If you were lucky, the development environment closely resembled production. If you weren’t, you […]","og_url":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/","og_site_name":"Tony's Programming Blog and Development Journal","article_published_time":"2026-10-31T16:00:00+00:00","og_image":[{"width":1376,"height":768,"url":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg","type":"image\/jpeg"}],"author":"Tony","twitter_card":"summary_large_image","twitter_creator":"@TonyBhimani","twitter_site":"@TonyBhimani","twitter_misc":{"Written by":"Tony","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#article","isPartOf":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/"},"author":{"name":"Tony","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#\/schema\/person\/036db10e4bc2069453a60f580f91ab88"},"headline":"Docker for Developers: An Old-School Programmer’s Take on Containers","datePublished":"2026-10-31T16:00:00+00:00","mainEntityOfPage":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/"},"wordCount":2876,"commentCount":0,"publisher":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#\/schema\/person\/036db10e4bc2069453a60f580f91ab88"},"image":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#primaryimage"},"thumbnailUrl":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg","keywords":["containers","dependency management","devops","docker","virtual machines"],"articleSection":["Docker","Programming Tools"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/","url":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/","name":"Docker for Developers: An Old-School Programmer's Take on Containers - Tony's Programming Blog and Development Journal","isPartOf":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#primaryimage"},"image":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#primaryimage"},"thumbnailUrl":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg","datePublished":"2026-10-31T16:00:00+00:00","breadcrumb":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#primaryimage","url":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg","contentUrl":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-content\/uploads\/2026\/10\/DockerForDevelopers_20261030094218.jpg","width":1376,"height":768,"caption":"Docker For Developers"},{"@type":"BreadcrumbList","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/docker-for-developers-an-old-school-programmers-take-on-containers\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.tonybhimani.com\/programming-blog\/"},{"@type":"ListItem","position":2,"name":"Docker for Developers: An Old-School Programmer’s Take on Containers"}]},{"@type":"WebSite","@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#website","url":"https:\/\/www.tonybhimani.com\/programming-blog\/","name":"Tony's Programming Blog and Development Journal","description":"Sharing is caring... Especially with code","publisher":{"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#\/schema\/person\/036db10e4bc2069453a60f580f91ab88"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.tonybhimani.com\/programming-blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.tonybhimani.com\/programming-blog\/#\/schema\/person\/036db10e4bc2069453a60f580f91ab88","name":"Tony","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g","caption":"Tony"},"logo":{"@id":"https:\/\/secure.gravatar.com\/avatar\/ed5a2a00dc5d9679e1fd2f29f60ca885a8e0f9d2c1aa2b5dabf05af02663b46c?s=96&r=g"},"sameAs":["https:\/\/tonybhimani.com\/programming-blog","https:\/\/x.com\/TonyBhimani","https:\/\/www.youtube.com\/tonybhimani"],"url":"https:\/\/www.tonybhimani.com\/programming-blog\/author\/coding_magik\/"}]}},"_links":{"self":[{"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/posts\/391","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/comments?post=391"}],"version-history":[{"count":5,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/posts\/391\/revisions"}],"predecessor-version":[{"id":397,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/posts\/391\/revisions\/397"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/media\/394"}],"wp:attachment":[{"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/media?parent=391"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/categories?post=391"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.tonybhimani.com\/programming-blog\/wp-json\/wp\/v2\/tags?post=391"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}