Forem: Damilare Ajakaiye

Dockerclean — How I Learned to Stop Worrying and Love Safe Docker Cleanup

Damilare Ajakaiye — Sun, 23 Nov 2025 02:49:31 +0000

Picture this: I'm mid-project, juggling three Docker containers, testing a new microservice architecture, when suddenly… my laptop screams at me: "No disk space left!"

I check Docker. 12GB of images I don't remember downloading, stopped containers from experiments, dangling volumes… and yeah, build caches from weeks ago. My usual go-to, docker system prune, felt like defusing a bomb blindfolded. One wrong flag and I could lose hours of work.

I realized I needed a smarter, safer approach. Enter Dockerclean — my little Go CLI project that now keeps my Docker environment lean, predictable, and pain-free.

The Problem

Docker is amazing, but it hoards disk space like a dragon. Unused images, stopped containers, orphaned volumes, and leftover build cache silently pile up, slowing down builds and filling your storage.

Developers often run docker system prune or forget about it altogether, risking data loss or wasting hours cleaning manually. I wanted a solution that:

Shows exactly what's using disk space
Lets me prune safely or fully, depending on the risk I'm willing to take
Is easy to install and run anywhere

How I Built It

I went with Go because it's fast, statically typed, and perfect for CLI tools. Here's the breakdown:

Analyzer (`internal/analyzer`)

Connects to Docker using the Go SDK
Scans images, containers, volumes, and build cache
Reports disk usage in a human-friendly, color-coded format

Cleaner (`internal/cleaner`)

Wraps Docker prune commands safely
--safe mode removes only stopped or dangling resources
Full prune removes everything, but always asks for confirmation

CLI (`cmd/`)

Built with Cobra for robust command parsing. Uses fatih/color for instant visual cues — green for safe, yellow for warnings, red for critical.

Commands are intuitive:

# Analyze your Docker environment
dockerclean analyze

# Safe prune
dockerclean prune --safe

# Full prune (confirmation required)
dockerclean prune

Testing

Wrote unit tests for analyzer and cleaner packages to ensure safe operations. Coverage is 100% for the core logic, so nothing accidentally nukes my running containers.

The Result

Now, instead of wondering "What's eating my disk?", I just run:

dockerclean analyze

…and see a clean summary of total usage, per-resource breakdown, and a safety assessment.

Need to reclaim space?

dockerclean prune --safe

or, if I'm feeling bold:

dockerclean prune

Everything's logged, color-coded, and predictable. No more surprises.

Lessons Learned

Visibility first — never prune blindly
Go + Cobra + Docker SDK = a dream team for CLI tools
Tests are non-negotiable — safe operations are useless without confidence in your code
Color-coded terminal output makes a surprisingly big difference when scanning usage stats

Dockerclean started as a personal tool, but now I hope it helps others who are tired of Docker eating their storage silently.

Try it yourself: github.com/pozadkey/dockerclean

Creating and Publishing Dart Packages for Flutter

Damilare Ajakaiye — Tue, 15 Aug 2023 02:12:22 +0000

What are Dart Packages?

Dart packages are a fundamental aspect of the Flutter framework, offering pre-built functionalities and features that streamline app development. These packages are readily available on platforms like pub.dev, which acts as a central repository for Flutter packages, enabling developers to access and share resources easily.

Why Embrace Dart Packages?

Leveraging Dart packages empowers developers to concentrate on crafting distinctive features and user experiences while benefiting from the collective expertise of the community. This not only accelerates the development process but also maintains a high standard of quality and cultivates an environment of shared knowledge and innovation.

Dart Package vs Plug-in Package

Dart packages encompass a collection of related code files and assets, often disseminated through the Dart package manager (pub.dev). This package manager facilitates dependency management and code sharing, contributing to a more efficient development workflow.

In contrast, a plug-in package is designed to enhance the capabilities of specific software, frameworks, or platforms. For instance, in the context of Flutter—a Dart framework—a plug-in package might grant access to native features or third-party services, expanding the app's functionality.

Let's Dive In: Creating a Dart Package

Step 1: Setting Up the Project

Begin by initiating a project named quick_button using the following command in your terminal:

flutter create --template=package quick_button

This command creates a folder structure with the primary entry file located at lib/quick_button.

Step 2: Git Repository Setup

Initialize a Git repository for your project using the following commands in the terminal:

git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/pozadkey/quick_button.git
git push -u origin master

Ensure that you replace 'origin' with your actual remote address.

Step 3: Editing Essential Files

With your project files pushed to the GitHub repository, you can now proceed to edit the following files:

pubspec.yaml: This file contains information about the Flutter package and its dependencies. Make the following edits:
- Author: Provide details about the creator and contributors in the pattern:
```
FirstName LastName <email@example.com>
Damilare Ajakaiye <hello@pozadkey.com>
```
- Homepage: Include the URL of the package repository.
README.md: Craft a starter markdown file that succinctly outlines the purpose of the package.
CHANGELOG.md: Document changes made to the package in chronological order, including version information and explanations for each change.
License: Choose an open-source license and insert it in the proper section, replacing [year] and [fullname] with appropriate values.

Step 4: Developing the Flutter Widget

Create a custom button widget by editing the lib/quick_button file. This widget will serve as the foundation for the button's appearance and behavior.

Step 5: Building an Example

Generate an example project to test the package. Execute the following command in the root directory:

flutter create example

In the example project's pubspec.yaml file, add the package dependencies required for the example project.

...
dependencies:
  flutter:
    sdk: flutter
  custom_alert_box:
    path: ../
...

We can now import our package and use it in the example project.

import 'package:quick_button/quick_button.dart';

Writing Tests: To ensure that all the widgets are responding correctly, you can create tests in the test/quick_button_test.dart file.

Step 5: Publishing the Package

Document the Package: Create comprehensive documentation that explains the concepts and usage of your package. Generate documentation using the following command:

  dart doc .

Push Changes to GitHub: Ensure all changes are committed and pushed to your GitHub repository.
Test-Publish the Package: To verify everything is in order, perform a test-publish of your package using the command:

  flutter pub publish --dry-run

Final Publishing: Once you've confirmed the absence of errors, publish your package to pub.dev with the following command:

  flutter pub publish

Terminal will prompt you to verify your pub.dev account.

Congratulations! Your Package has been published.

Step 6: Maintaining the Package

Before updating the package, remember to:

Push all changes to your GitHub repository.
Record changes in the CHANGELOG.md file.
Update the version in the pubspec.yaml file

Package source code: quick_button
Published package: quick_button

Publishing Flutter app to Google Play Store - Part 2

Damilare Ajakaiye — Sat, 28 Jan 2023 15:27:01 +0000

In the previous article of this series, you learned how to prepare your Flutter app for Android production release. If you haven't read the article yet, Read it here. It's highly recommended that you do so before proceeding with this article.

In this article, you'll learn how to publish your app to the Google Play Store via the Developer Console.

Let's get started!

Step 1: Create a Developer Account

If you already have a Developer Account, move on to Step 2.
Visit Google Play Console to create a Developer Account.
A one-off $25 registration fee must be paid using a debit or credit card (prepaid cards are not accepted).
You'll need to verify your identity using a government-approved document.
Once approved, you can proceed to Step 2.

Step 2: Create an App

Click on the Create App button.

Fill in the required details and check all the checkboxes.

Step 3: Add Description, Logo, Screenshots, Videos, and Feature Graphics.

Go to Store presence > Main store listing.
Fill in the required details.

To add an App icon, simply drag and drop the icon.png you used to create your App Icon from the previous tutorial into the App icon box.

Add a Feature Graphics. You can either generate one using an Online Graphic Generator or use any other website you prefer.

Include at least 2 screenshots of your app in the Phone, 7' and 10' tablets Screenshot sections respectively.

Save the Main Store Listing.

Step 4: Store Settings

Go to Store Settings and select your app's category and tags, then fill in the required details.

Save it.

Step 5: Add Countries and Regions

Go to Production > Country / Region to specify the countries where you want your app to be available for download.

Step 6: App Content

Add a Privacy policy for your app. You can use a Privacy Policy Generator or provide the link to an existing one.

Select App Access.

In the Ads section, select YES if your app contains ADS, or NO if it doesn't.

Choose the appropriate Content Rating category for your app.

In the Questionnaire tab, answer the provided questions and Save.
Proceed to Target audience and content.
Select the target age groups for your app.

Click Next and provide the required information on the App Details page.

Click Next twice to reach the Store presence tab. Select appropriate options.

Click Next and Save.
Navigate to News apps.

Select YES if your app is a news app; otherwise, select NO.
Save it.

Step 7: Roll Out the App to Production

Click on Production in the sidebar.
Create a New Release.

Upload the app-release.aab app bundle file in the App Bundle section.
Add Release Notes, which will be displayed on your app's home page on Google Play.

Save it and Review the Release.
Finally, click on Start Rollout To Production.

Congratulations 🎉!! You've uploaded your app to the Google Play Store. Now you need to wait for a response from the Google team to manually review your app and add it to the Google Play Store.

Publishing Flutter app to Google Play Store - Part 1

Damilare Ajakaiye — Sat, 28 Jan 2023 15:17:19 +0000

Publishing your Flutter app to the Google Play Store might seem intimidating, but the process is actually quite straightforward! As a Flutter developer aiming to create an Android app for widespread use, understanding how to publish your Flutter application on the Google Play Store is crucial. In just a few steps, you can make your app available for download to millions of Android users worldwide.

This tutorial is divided into two parts. The first part provides a step-by-step guide on preparing your app for production release. The second part explains the process of publishing your production-ready app on the Google Play Store. If you're already familiar with preparing your app for production release and are eager to learn about publishing on the Google Play Store, you can skip ahead to Part 2 of this series.

Let’s get started!

Step 1: Change the App Name

Navigate to the folder:

android/app/src/main/AndroidManifest.xml

Find the android:label attribute and change its value to the desired name for your app.

Tip: You can also add necessary permissions required by your app. For instance, to grant internet access, add:

<uses-permission android:name="android.permission.INTERNET" />

Step 2: Change the App Icon:

In your pubspec.yaml file, add the flutter_launcher_icons package to your dev_dependencies
Add the following options below dev_dependencies

flutter_icons:
    android: true
    ios: true
    image_path: "assets/icon/icon.png"

image_path refers to the path where your app icon is located.

Run this command to generate your app icons:

flutter pub run flutter_launcher_icons:main

Now run your app to see the changes.

Step 3: Add a Splash Screen

A splash screen, also known as a launch screen, start screen, or boot screen, is a graphical control element containing the image, logo, and current software version. It's the first screen of the app that displays while the application is loading. For a detailed tutorial on creating a splash screen for your Flutter app, you can refer to this resource.

Step 4: Sign the App

Create a keystore

A keystore is the unique signature used for signing your app.

Open your terminal and paste the following commands:

On Mac/Linux:

keytool -genkey -v -keystore ~/upload-keystore.jks -keyalg RSA -keysize 2048 -validity 10000 -alias upload

On Windows:

keytool -genkey -v -keystore %userprofile%\upload-keystore.jks -storetype JKS -keyalg RSA -keysize 2048 -validity 10000 -alias upload

In case you encounter the error:
Operation couldn't be completed. Unable to locate Java Runtime.

Run flutter doctor -v and copy the path after Java binary at. Replace java with keytool in the command [add \ for Mac and " for Windows, and remove any spaces]. You should have something like this:

/Applications/Android\ Studio.app/Contents/jbr/Contents/Home/bin/keytool -genkey -v -keystore ~/upload-keystore.jks -keyalg RSA -keysize 2048 -validity 10000 -alias upload

Your keystore has been successfully created, and the file path is displayed in the terminal.
Create a key.properties file in the android folder.
Add the following lines of code:

storePassword=<password from keystore file>
keyPassword=<password from keystore file>
keyAlias=upload
storeFile=<location of the keystore file, e.g., /Users/<user name>/upload-keystore.jks>

Make sure to keep them private. Avoid sharing them on public source control platforms.

Open android/app/build.gradle and paste the following lines above the android {…} block:

def keystoreProperties = new Properties()
def keystorePropertiesFile = rootProject.file('key.properties')
if (keystorePropertiesFile.exists()) {
  keystoreProperties.load(new FileInputStream(keystorePropertiesFile))
}

Scroll down and replace the existing buildType {…} block with:

signingConfigs {
     release {
         keyAlias keystoreProperties['keyAlias']
         keyPassword keystoreProperties['keyPassword']
         storeFile keystoreProperties['storeFile'] ? file(keystoreProperties['storeFile']) : null
         storePassword keystoreProperties['storePassword']
     }
 }
 buildTypes {
     release {
         signingConfig signingConfigs.release
     }
 }

In the defaultConfig {…} section, change the value of applicationId to your preferred Id for your app. This unique Id is used to identify your app on the Google Play Store. For example:

applicationId "com.example.my_android_app"

Step 5: Create an Android App Bundle

Run flutter clean to clear the cache and previous builds.
To generate your .aab bundle, run the following command:

flutter build appbundle

The .aab build for your app is now located at build/app/outputs/bundle/release/app-release.aab
Your app is now ready for publication via the Developer Console.

In this tutorial, you've learned how to prepare a Flutter app for production release. Now, you can publish your app to the Google Play Store in Part 2 of this series.