DEV Community: Viorel PETCU

PDF Scan File Size: What To Do About It.

Viorel PETCU — Sat, 14 Sep 2024 22:25:03 +0000

In today's digital age, we're constantly creating, sharing, and storing documents and media. While the cost of storage has dropped and internet speeds have skyrocketed, there's a hidden cost we often overlook—our environmental impact. A wonderful resource for insights on how our digital activities affect the environment is The Green Web Foundation, particularly their calculators.

The Environmental Cost of Large Files

It might not be immediately obvious, but the size of the files we share and store contributes to global energy consumption. Data centers, which store everything from photos to PDFs, use massive amounts of electricity. Smaller files mean less data transferred, processed, and stored—leading to a direct reduction in energy usage and, ultimately, CO₂ emissions.

The 'Ubuntools' Docker Image

This is where my project, the ubuntools Docker image, comes in handy. Initially created as a basic toolkit for probing APIs and aggregating data, I expanded the project to include tools for compressing PDFs and media files. Why? Because reducing file size doesn’t just save space—it helps reduce the environmental impact of our digital lives.

Why Document and Media Compression Matters

Even though cloud storage seems limitless and fiber internet offers instant downloads, the carbon footprint of transferring large files still matters. Every megabyte of data requires energy to transmit and store. By compressing documents and media, we can make a small but meaningful contribution to minimizing our environmental impact. Here's an example of how I incorporated this idea into ubuntools:

I planned to send an article from a magazine to a contact of mine as an email attachment since there was no online version to simply share the link. So, I fired up my flatbed scanner and scanned the three pages:

To my surprise, for a 300 dpi resolution, the result was a 1.77 MB PDF file. That would not even fit on a standard floppy disk back in the day—unacceptable!

I planned to do some editing of the files anyway, using GIMP (for image corrections, cropping, fine rotation, etc.), so I told myself, "Once the shading is gone and the colors are uniform, the PDF size will surely reduce."

BTW, if you're interested in a tutorial on editing PDFs with GIMP (all free and open source software), leave a comment. If there's enough interest, I'll write up a tutorial on the top 10 things you need and how to accomplish them using GIMP.

But then I got an even bigger surprise. After rotation, color correction, and exporting the layers as pages of the PDF, I felt like this:

Well... 💩 The file was now 11.4 MB—kind of going in the wrong direction!

So, I taught ubuntools some new tricks. Under the pdf-processing tag, you'll find a base Ubuntu Docker image with the following tools:

ghostscript
pdftk-java
poppler-utils

# start ubuntools in the directory where your big PDF file are
docker run -it --rm -v $(pwd):/work --workdir /work viorelpe/ubuntools:pdf-processing /bin/bash

# execute the following command
gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dQUIET -dBATCH -sOutputFile=compressed.pdf original.pdf

This command reduces the scanned document's size while maintaining high quality—perfect for email attachments or archiving. How much did it reduce the size? It came down to 0.71 MB, which is a considerable improvement.

Here’s the finished product and the original side-by-side:

Check the difference for yourself on GitHub.

Expanding with Media Compression

From here, it's easy to integrate other media compression utilities, such as FFmpeg, to reduce the size of videos and images. These tools, combined with ubuntools, make it real easy for you, because all you have to do, is to run two commands:

Start ubuntools with the appropriate tools (via tag).

Run a command and feed it your files.

Conclusion: Think Small, Act Big

File size might seem trivial in an era of "unlimited" storage and bandwidth, but it's the small, cumulative actions that matter. Compress your files, shrink your media, and contribute to a greener future.

I Built ubun🔨ools, So You Don’t Have To

Viorel PETCU — Sun, 08 Sep 2024 09:59:21 +0000

Not sure how often this happens to others, but whenever I start a new project, I like to start with a blank slate. I do this to avoid unconsciously dragging in tools or methods from other projects that might not fit into the current tech stack.

So, typically, I check out the project and mount the directory into a fresh Ubuntu container like this:

git clone https://github.com/realvorl/ubuntools.git
cd ubuntools

docker run -it --rm -v $(pwd):/work --workdir /work ubuntu:24.04 /bin/bash

All set, right? Well, not quite. Let’s say I want to check the weather quickly:

root@20fb3c8cf2eb:/work# curl wttr.in
bash: curl: command not found # <--- and this is what I am talking about
root@20fb3c8cf2eb:/work#

I don’t always check the weather, but you get the point. I’ve already set everything up, but now I’m in a container where tools like curl, wget, jq, or even a simple editor like nano are missing. And if the container crashes, whatever I install now is gone. Frustrating, right?

The Solution: Ubun🔨ools

So, I built ubunTools—a lightweight Docker image generator that packages the tools I need in these situations. No more fumbling with missing dependencies or reinstalling them every time. With ubunTools, you pull the image, and boom—you’re ready to go.

Let me show you how this works:

1 add your list of tools to the workflow input form:

2 put that list into an ENV variable:

3 build the parameterized image:

4 push to docker hub:

Here’s the same workflow, but this time using an image generated by ubunTools:

# Swapping ubuntu:24.04 with viorelpe/ubuntools:useful_REST_tools
docker run -it --rm -v $(pwd):/work --workdir /work viorelpe/ubuntools:useful_REST_tools /bin/bash

root@0325311145e2:/work# curl wttr.in
Weather report: 

      \   /     Clear 
       .-.      11 °C          
    ― (   ) ―   ↑ 6 km/h       
       `-’      10 km          
      /   \     0.0 mm          ...
                                ...
┌────────────────────────────── ...
│            Morning            ...
├────────────────────────────── ...
│    \  /       Partly Cloudy   ...
│  _ /"".-.     +22(21) °C      ...
│    \_(   ).   ↖ 5 km/h        ...
│    /(___(__)  10 km           ...
│               0.0 mm | 0%     ...
└────────────────────────────── ...

Easy, right? Now, I’m good to go with all the tools I need.

Principle 1: Adding More Tools Shouldn’t Be Hard

One of my favorite things about ubunTools is how simple it is to expand. Need a new tool for a specific project? No problem! Just name it in the GitHub workflow inputs, trigger it, and the image will automatically update with the new tool(s). Minimal effort, maximum flexibility. It’s like a toolkit that grows with you as your needs evolve.

Principle 2: Keeping It Secure and Up-to-Date

Security matters, especially when dealing with Docker images. That’s why ubunTools includes a mechanism that keeps it in sync with the latest Ubuntu image. If the Ubuntu image changes (like when there’s a security fix), ubunTools rebuilds the image (at midnight) and pushes it to Docker Hub under the appropriate tag - overriding the previous one. You don’t have to worry about manual updates—it keeps everything secure and fresh.

Conclusion: A Toolkit That Works for You

Ubun🔨ools started as a personal solution to a common onboarding headache, and it’s already grown beyond what I imagined. Whether you’re probing APIs, aggregating data, or just needing a basic toolkit, ubunTools has you covered—and it’s easy to build on.

Check out ubunTools on GitHub 🚀. Don’t want to deal with creating your own Docker Hub account? No worries! Just create an issue on GitHub, and I’ll build the image for you. It’s just a few text fields and a click—no biggie.

Final Thoughts

I wanted to make my life easier, and now, with ubunTools, I hope it makes yours easier too. Whether you’re a developer who likes starting projects with a clean slate, or you just need a reliable, customizable toolkit, ubunTools is there for you. Let me know if you give it a spin!

I built a Free Badge Generator for Everyone

Viorel PETCU — Sat, 31 Aug 2024 21:27:02 +0000

It all started with a simple sticker. On a business trip to Hamburg, my colleagues and I came across a promotional sticker from the German county of Baden-Württemberg, which humorously boasted, "nett hier, aber waren Sie schon mal in Baden-Württemberg?" ("Nice here, but have you ever been to Baden-Württemberg?").

Have a look at the promotion if you ever taught about moving to or within Germany, Baden-Württemberg is a great destination.

Since my team is based in Stuttgart, this little joke hit home, and we all had a good laugh. But it also sparked an idea—what if I could create similar badges or "stickers" digitally and easily share them in README files, CI/CD pipelines, or anywhere else they might bring a bit of humor or information?

That idea grew into the Badge Maker Lite, a simple yet powerful tool that anyone can use to create custom badges with personalized text, colors, and layouts.

The Concept: A Tool for Everyone

The Badge Maker Lite is designed to be a free and accessible service. It’s hosted on GitHub Pages, ensuring that anyone can use it without cost or the need for a personal account. The service is straightforward: you customize your badge, preview it in real-time, and get the SVG code to use wherever you need it. The goal was to make it as easy as possible to create these badges, without requiring any complicated setup or installation.

However, for those who want a bit more control, the app has some special features. When run locally with a GitHub Personal Access Token (PAT) that has the appropriate scope, you can save and load your badges using GitHub Gists. This feature adds a layer of persistence to your badges, allowing you to easily share or reuse them later.

My Badge Gallery

the joke	other work link	approved link	nice touch link	future ideas
				...

Special Features: Gists and Short URLs

One of the standout features of the Badge Maker Lite is its ability to save badge configurations as GitHub Gists. This is only enabled when the tool is run locally with a PAT, making it both secure and optional. By saving a badge as a Gist, you receive a unique UUID that you can later use to reload your configuration.

But the fun doesn’t stop there. I’ve also been using Bitly to create short, memorable URLs that link directly to these SVGs. This makes it incredibly easy to embed badges in Markdown documents, project READMEs, or even CI/CD pipeline statuses. Here’s how it works:

Generate Your Badge: Customize your badge using the Badge Maker Lite.
Save It as a Gist: If running locally with a PAT, save the badge and get a UUID.
Create a Bitly Link: Use Bitly to shorten the URL of your public raw SVG hosted on GitHub. Now, you have a neat, memorable URL that can be shared or embedded wherever you like.

This process not only makes it easier to share your badges but also adds a layer of professionalism to your documentation.

A Tech Test for Something Bigger

While the Badge Maker Lite is a fun and useful tool, it’s also a tech test for a larger project I’m planning. This project has allowed me to experiment with different technologies, workflows, and user interactions, all of which will inform the development of my next big idea. Stay tuned for more on that front—exciting things are coming!

Call for Contributions

The Badge Maker Lite is open to contributions, and I’d love to see what the community can bring to the table. While I’m content with the HTML, DIVs, and CSS approach for the UI, I’m fully aware that there’s room for improvement, especially when it comes to responsiveness and modern design. If you have ideas for enhancing the UI, or if you want to contribute new features or improvements, I encourage you to jump in.

I’ve intentionally kept the project open-ended, so there’s plenty of scope for innovation. And if there’s something you’d like to see but don’t have the time or skills to implement, feel free to open an issue. I’ll prioritize the ones that get the most upvotes.

Conclusion

What started as a joke sticker on a business trip has evolved into a fully-fledged tool that anyone can use to create custom SVG badges. Whether you’re adding a bit of humor to your documentation or displaying important status updates in your CI/CD pipelines, the Badge Maker Lite makes it easy and fun.

I’m excited to see how others use this tool and where the community takes it. If you’re interested in trying it out or contributing, check out the GitHub repository. Let’s build something awesome together!

I built a Free Badge Generator for Everyone

Viorel PETCU — Sat, 31 Aug 2024 21:27:01 +0000

Have a look at the promotion if you ever taught about moving to or within Germany, Baden-Württemberg is a great destination.

That idea grew into the SVG Badge Generator, a simple yet powerful tool that anyone can use to create custom badges with personalized text, colors, and layouts.

The Concept: A Tool for Everyone

The SVG Badge Generator is designed to be a free and accessible service. It’s hosted on GitHub Pages, ensuring that anyone can use it without cost or the need for a personal account. The service is straightforward: you customize your badge, preview it in real-time, and get the SVG code to use wherever you need it. The goal was to make it as easy as possible to create these badges, without requiring any complicated setup or installation.

My Badge Gallery

the joke	other work link	approved link	nice touch link	future ideas
				...

Special Features: Gists and Short URLs

One of the standout features of the SVG Badge Generator is its ability to save badge configurations as GitHub Gists. This is only enabled when the tool is run locally with a PAT, making it both secure and optional. By saving a badge as a Gist, you receive a unique UUID that you can later use to reload your configuration.

Generate Your Badge: Customize your badge using the SVG Badge Generator.
Save It as a Gist: If running locally with a PAT, save the badge and get a UUID.
Create a Bitly Link: Use Bitly to shorten the URL of your public raw SVG hosted on GitHub. Now, you have a neat, memorable URL that can be shared or embedded wherever you like.

This process not only makes it easier to share your badges but also adds a layer of professionalism to your documentation.

A Tech Test for Something Bigger

While the SVG Badge Generator is a fun and useful tool, it’s also a tech test for a larger project I’m planning. This project has allowed me to experiment with different technologies, workflows, and user interactions, all of which will inform the development of my next big idea. Stay tuned for more on that front—exciting things are coming!

Call for Contributions

The SVG Badge Generator is open to contributions, and I’d love to see what the community can bring to the table. While I’m content with the HTML, DIVs, and CSS approach for the UI, I’m fully aware that there’s room for improvement, especially when it comes to responsiveness and modern design. If you have ideas for enhancing the UI, or if you want to contribute new features or improvements, I encourage you to jump in.

Conclusion

GitHub Actions for Secret Management

Viorel PETCU — Sun, 10 Mar 2024 12:54:25 +0000

Navigating the complexities of managing projects, especially those inherited with little documentation on API keys and secrets, presents a formidable challenge. My journey began with an urgent need to identify and securely document the secrets dispersed across repositories—a challenge compounded by frequent personnel changes and a lack of previous accountability. To tackle these issues and avert potential downtime risks associated with indiscriminately replacing tokens, I devised two GitHub Actions:

Initially born out of necessity, these tools have evolved to assist developers facing similar challenges more broadly.

Download Secret Text

(Encrypted Documentation & Secure Sharing)

Download Secret Text offers a secure method for encrypting and documenting sensitive information. By using a GPG public key for encryption, it enables the safe sharing of secrets among team members or for archival purposes. This action stands as a testament to the critical importance of maintaining the confidentiality and integrity of project secrets.

Using the action is quite intuitive:

    steps:
    - uses: vosos/download-secret-text@v1
      with:
        gpg_public_key: ${{ vars.GPG_PUBLIC_KEY }}
      # gpg_public_key: ${{ secrets.GPG_PUBLIC_KEY }}
        plain_text: |
            SOME_API_KEY=${{ secrets.SOME_API_KEY }}
            FYE_SECRET_ONE=${{ secrets.FYE_SECRET_ONE }}
            FYE_SECRET_TWO=${{ secrets.FYE_SECRET_TWO }}
            SOME_TOKEN=${{ secrets.SOME_TOKEN }}

such a step in your workflow will produce this kind of result in your run summary:

For setting up a GPG key pair, GitHub's own TUTORIAL provides an excellent starting point. The tutorial walks you through generating the necessary public and private keys—the former for this action and the latter, combined with your passphrase, for decryption.

Mystery Token Explorer

(Shedding Light on the Shadows)

Mystery Token Explorer illuminates the obscured tokens within a project by leveraging the GitHub API to fetch information about their ownership. This insight is invaluable for developers tasked with navigating projects riddled with undocumented secrets. Plans for future enhancements include expanding the use of the GitHub API to uncover additional token details (I'll get around to this soon—meanwhile, contributions via PRs and issues are encouraged).

Using this action is also intuitive:

    - name: Identify GitHub User
      uses: vosos/mystery-token-explorer@v1
      with:
        token: ${{ secrets.GITHUB_TOKEN }}
        jq_filter: '{name: .name, login: .login, id: .id}'

such a step in your workflow will produce this kind of result in your run summary:

Bridging GitHub's Secret Management Gap

GitHub's "write-only" policy for secrets safeguards security by preventing direct viewing or retrieval post-addition. Download Secret Text cleverly circumvents this limitation, providing a "read" capability akin to GitLab's more flexible secret management approach. This functionality is particularly beneficial for teams migrating to GitHub or managing projects across different platforms, offering a unified and secure secret management solution.

Expanding Utility Beyond Initial Needs

Though these GitHub Actions were created to ease project transitions, their utility extends into broader contexts:

Streamlining Security Audits & CI/CD Pipelines

Incorporating Mystery Token Explorer into security audits or CI/CD pipelines facilitates the automated identification and cataloging of tokens. Used alongside Download Secret Text, it ensures secure updates to secrets, minimizing exposure risks and maintaining uninterrupted operations.

Advancing Secure Documentation Practices

Download Secret Text is invaluable for teams committed to securely documenting their infrastructure, ensuring sensitive details remain accessible only to those authorized.

In Closing

Inheriting projects laden with undocumented secrets need not be overwhelming. Mystery Token Explorer and Download Secret Text equip developers with robust tools for discovering, understanding, and securely managing digital secrets. These GitHub Actions smooth project transitions and bolster security and operational efficiency, demonstrating a proactive secret management strategy that maximizes GitHub's strengths while mitigating its constraints. As these tools progress, they highlight the potential for community-driven enhancements to forge more secure and efficient development workflows.

A Zero-Cost Monitoring Solution

Viorel PETCU — Tue, 26 Dec 2023 23:31:58 +0000

Introduction

In the data-driven domain of content creation, having a real-time pulse on audience engagement is invaluable. My quest was to construct a tool that epitomizes both efficiency and elegance—a solution where a simple URL would serve as a portal to the metrics of my Dev.to articles.

The Challenge

Manual monitoring was out of the question. The goal was to create an automated system that provides live updates on comments and reactions without the hassle of repeatedly checking each article. And importantly, this system had to be cost-free.

The Solution

My resolution took the form of a memorable URL: bit.ly/dev-mon, a nod to both its daemon-like operation and ease of recall. The choice of hosting fell on the sturdy shoulders of GitHub Pages, a free platform that became the stage for my engagement dashboard.

TL;DR: Quick Start Guide

Eager to see a dashboard like this?

Follow these steps:

Clone the Repository: Visit InteractoGraph and clone the repo.
Customize for Your Profile: Navigate to ./cypress/e2e/0-mine/all_in_one.cy.js#L4 in your cloned repo and replace realvorl in https://dev.to/realvorl with your DEV.TO username.
Commit and Push: Commit the changes with a message like "Update username in Cypress test" and push to main.

Voilà! Post workflow, visit:

https://<YOUR-GITHUB-USERNAME>.github.io/InteractoGraph/

for your very own engagement dashboard. Of course, you can now extend it to include anything that you can think of and are able to scrape using the Cypress API.

For a deeper understanding of the setup, let's dive into the subsequent sections.

Automating Data Collection with Cypress

The Cypress test below scrapes engagement data from my Dev.to profile, illustrating the ease of automation:

describe('Article Metrics on dev.to', () => {
  it('captures comments and reactions for multiple articles', () => {
    // Visit the user's main page
    cy.visit('https://dev.to/realvorl');

    // Define an array to hold our article metrics
    let articleMetrics = [];

    // Wait for the articles to load
    cy.get('.crayons-story__body').each(($body, index, $bodies) => {
      // Extract the article title, comments, and reactions
      const title = $body[0].getElementsByTagName('h2')[0].textContent.trim();
      const links = $body[0].getElementsByTagName('a');
      const reactionsCount = links[links.length - 2].innerText.trim();
      const commentsCount = links[links.length - 1].innerText.trim();

      // Add the metrics to our array
      articleMetrics.push({
        title,
        'commentNo': parseInt(commentsCount, 10) || 0,
        'reactionNo': parseInt(reactionsCount, 10) || 0
      });

      // After the last article, write the metrics to a JSON file
      if (index === $bodies.length - 1) {
        cy.writeFile('./cypress/e2e/0-mine/data.json', {
          'dateISO': new Date().toISOString(),
          'articles': articleMetrics
        }, { flag: 'w+' });
      }
    });
  });
});

It captures titles, comments, and reactions and consolidates them into a JSON file, timestamped for traceability.

Integrating Data with Visualization

Using a Node.js script, updateHtml.js, the data from Cypress is dynamically injected into a Google Chart within an HTML template, chart.tmpl.

const fs = require('fs');

const tmplFilePath = 'chart.tmpl'; // Template file path
const htmlFilePath = 'index.html'; // The final HTML file path
const jsonFilePath = 'data.json';  // The JSON data file path

// Read the template HTML content and the JSON data
const htmlContent = fs.readFileSync(tmplFilePath, 'utf8');
const jsonData = fs.readFileSync(jsonFilePath, 'utf8');

// Replace the placeholder in the template with the actual JSON data
const updatedHtmlContent = htmlContent.replace('// JSON_PLACEHOLDER',
`var json = ${jsonData}`);

// Write the updated HTML content to the final file
fs.writeFileSync(htmlFilePath, updatedHtmlContent);

This transforms the JSON data into an interactive chart, ready for publishing.

Continuous Integration and Deployment with GitHub Actions

The workflow I've established with GitHub Actions automates data scraping, chart updating, and deployment to GitHub Pages. Here's the workflow:

name: CI
on:
  push:
    branches: [ "main" ]
  pull_request:
    branches: [ "main" ]
  workflow_dispatch:
  schedule:
    # Runs at minute 0 past every 6th hour
    - cron: '0 */6 * * *'

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3

      - name: Install and Run Cypress
        run: | 
          # Set up Git credentials
          git config --global user.email "6973263+realvorl@users.noreply.github.com"
          git config --global user.name "(Vorl)-Bot"
          # Install dependencies and run tests
          yarn 
          yarn cy-all
          # Commit and push the results
          git add .
          git commit -am "chore (ci): update e2e test results $(date +%s)"
          git push
          # Branching strategy for GitHub Pages
          git checkout -b gh-pages
          git push --set-upstream origin gh-pages --force

      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_branch: gh-pages
          publish_dir: ./cypress/e2e/0-mine

      - name: Upload a Build Artifact
        uses: actions/upload-artifact@v4.0.0
        with:
          name: chart
          path: ./cypress/e2e/0-mine/index.html
          retention-days: 14

The branching strategy for GitHub Pages involves force-pushing to a gh-pages branch, using the peaceiris/actions-gh-pages action to deploy the updated chart, and uploading the chart as a build artifact for quick access.

The first unintended consequence, but actually my favorite feature of this implementation, is the diff that you can get when you look at the git history:

You can just click on the parent link and you can navigate, in this view, through the history of the changes.

Another unintended feature is the possibility to declutter the notifications on your phone. Because this can be used for virtually anything that you want to monitor, you can disable the annoying push notifications, and just do an hourly / daily digest of the engagement you get online.

Conclusion

This automated system scrapes new data and refreshes the dashboard every 6 hours, eliminating manual effort and providing a continuously updated view of article engagement. Of course, it is not limited to DEV.TO, basically anything that you are interested in (LinkedIn), you can set up a Cypress Test, enrich the JSON with that information and follow the pattern laid out in this article.

The "Censorship Brush" - GIMP enabled Invoice Redaction

Viorel PETCU — Wed, 20 Dec 2023 17:59:38 +0000

Introduction: A Holiday Challenge Turned Innovation

This holiday season brought more than just cheer to my doorstep; it brought a mountain of delivery invoices. As I sorted through this paper avalanche, I realized that I needed to redact some sensitive information before recycling. But there was a catch – my trusty redaction roller had run out of ink. "No problem," I thought, and hopped online to order a replacement. However, the estimated delivery time was way past the city's pre-Christmas recycling pickup schedule.

In a moment of what I thought was brilliance, I decided to use my printer. Why not print something over the sensitive parts? And what better than the seemingly endless digits of Pi? After all, 6766 decimal places of Pi on an invoice seemed like a foolproof plan. It was a joyous moment of geeky triumph until I proudly presented my creation to my wife. She was less than impressed. "Isn't that a bit... wasteful?" she pointed out, both in terms of toner and recycling efficiency.

Her comment got me thinking. There had to be a smarter way to do this, a way that was economical yet effective. Because this is a lot of toner that you just waste, when in fact you only want a few lines or sections redacted

Then it hit me – GIMP, the versatile image manipulation program, had all the tools I needed. I recalled a YouTube video about creating custom brushes in GIMP. With a spark of inspiration, I scanned an old, redacted page to capture the pattern left by the roller. From there, it was a matter of putting those GIMP skills to work and crafting a custom censorship brush.

What followed was an interesting journey of digital DIY and a testament to the power of open-source software. In this article, I'll guide you through the steps to create your own censorship brush in GIMP, turning a simple software tool into a powerful ally for maintaining your privacy.

Getting Started: GIMP Setup and Initial Preparations

⚠️ Disclaimer ⚠️ While this method has worked well for me, please be aware that using crumpled or improperly aligned invoices in your printer could cause damage. I share my experience for informational purposes and cannot guarantee the same results for everyone. Always use caution and at your own risk.

First things first, you will need GIMP, a scanner, or a very good lighting setup for your smartphone. I used my Brother DCP-1610 wireless printer and scanner.

The only other thing you will need is an image of random letters (here you can customize to your liking)

For example:



KVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQ
VAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQK
AMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKV
MQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVA
QKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAM
KVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQKVAMQ

OR:



REDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDRE
EREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDR
TEREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDACTED
CTEREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDACTE
ACTEREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDACT
DACTEREDACTEDREDACTEDREDACTEDREDACTEDREDACTEDREDAC

This you can screenshot for later use in the creation of the censorship brush.

Creating the Tool: Crafting a Custom Censorship Brush in GIMP

For anything, you might ever need to implement using GIMP, there is no better resource than Logos by Nick on YouTube.

The following is the exact tutorial I used to implement the brush

Towards the end of the tutorial, you are shown how to install the brush, but Nick is using Windows, if you are on Linux (like me) you would need to install the new brush at a location similar to:

/usr/share/gimp/2.0/brushes

The Redaction Process: Preparing and Censoring Your Invoice

Now that your GIMP has a new superpower, you are only a couple of steps away from perfectly censoring any invoice that is compatible with your printer!

Now you can scan the invoice(s) and get to work.

Step 1: Scan the invoice

This step is self-explanatory.

Step 2: Mark the places you want to redact

Start by adding a new layer fill it with white and reduce the opacity to 50%

Make sure the new top layer is selected, choose the rectangle select tool, and, with the shift key pressed start selecting areas you would like to redact.

Now that you have multiple areas selected, you can choose your new censorship brush, select the appropriate size and start stamping (do not click and drag) click, reposition and click again.

When all is done, you will end up with something like this

Step 3: The Finish

All that is now left to do is to delete the invoice layer and restore the opacity to 100% for the redaction layer.

Now put the invoice in your printer on top of your paper stack (facing the right way) and PRINT, make sure to Ignore Page Margins

Congratulations 🎉 you have now perfectly censored an invoice, so you can throw it in the recycle bin free of any remorse, both from a privacy point of view and also for the amount of wasteful toner.

Conclusion: Towards a More Automated and Efficient Future

As we've seen, GIMP is not just an image manipulation tool; it's also a powerful ally in maintaining privacy and reducing waste. This DIY approach to invoice censorship showcases the versatility and potential of open-source software in everyday tasks.

Looking ahead, there are exciting possibilities to further streamline and automate this process. Imagine leveraging GIMP's API to integrate with an automated system that detects and redacts sensitive information on invoices. This could be integrated with hardware solutions, enabling a seamless scan, censor, and print workflow.

I'm also considering creating a repository of censorship masks tailored for different types of invoices, making it even easier for others to adopt this method without starting from scratch.

WOW you are still reading !?

👀

Respect!

Did this guide help you create your own censorship brush in GIMP? Do you have other innovative ideas for hacking one thing to do another unintended thing? Share your thoughts, experiences, or any questions in the comments below.

🌱 Introducing the Climate Positive Public License! 🌱

Viorel PETCU — Mon, 16 Oct 2023 23:09:52 +0000

Hello everyone out there using open-source licenses,

I'm working on a new kind of license I'd like to present: the Climate Positive Public License (CPPL). It's still in its early stages, much like the weather outside, unpredictable and ever-changing. However, I believe it holds a lot of promise.

Why another license, you might ask? Well, the goal isn't just to create software, but to do so with a climate-positive footprint. The CPPL is designed to promote climate-friendly software practices, CO2 neutrality, carbon capturing, and more. It's an endeavor that's not just for me; it's for our planet.

The license is very much influenced by the GPL, and the core idea is simple:

Use this license for your software, and in return, make sure your software or project actively contributes to the betterment of the environment.

If not, support the cause in another manner, through environmental funds or other means.

In essence, it's a license with a conscience.

I won't claim the CPPL to be the solution to all our environmental concerns. I'm not even sure if it will gain traction, but I'm hopeful. What I do know is that it's another tool in the toolbox for developers who are conscious about the environment and wish to make a positive impact through their work.

I'd appreciate any feedback, ideas, or contributions. The project is open-source and is very much a collaborative effort. If you're curious or want to contribute, the repo is available on GitHub.

Would love to hear what you think!

Maybe take a look on GitHub.

Overcoming the "PIGDOG" thanks to good design

Viorel PETCU — Sun, 23 Apr 2023 19:44:50 +0000

This is a story of how I stumbled upon a sleek analog solution to a problem I initially thought could only be solved with software.

After a global pandemic that led to a significant amount of self-reflection, it's no secret that:

"physical exercise can have many benefits for software engineers, it's important for maintaining a healthy and active lifestyle"

- all the studies, ever.

The reasons for having an established fitness routine could not be more clear-cut, just see any study ever done on this subject.

About the inner "PIGDOG"

"Innere Schweinehund" is a German term that refers to the inner voice or impulse that tells a person to avoid doing something that is difficult, uncomfortable or unpleasant. It can be loosely translated to "inner PIGDOG" or "inner lazy-bones". The term is often used in the context of self-discipline or motivation, encouraging individuals to overcome their inner resistance and push themselves to achieve their goals.

Enter ChatGPT: as "personal trainer"

My inner PIGDOG will always find a way to sabotage my attempts at a healthier lifestyle, and lastly it became apparent, that even when I am in the gym, the PIGDOG will find things to throw in my way.

So I decided to ask ChatGPT for an optimized routine that would work out all muscle groups in the span of a week, would take between 45 and 60 minutes to complete, and include all the recovery time needed between workout days.

This is what I got:

Day 1:
===
Squats - 3 sets of 8-12 reps
Barbell Bench Press - 3 sets of 8-12 reps
Pull-Ups or Lat Pulldowns - 3 sets of 8-12 reps
Standing Dumbbell Shoulder Press - 3 sets of 8-12 reps
Plank - hold for 30-60 seconds

Day 2:
===
Deadlifts - 3 sets of 8-12 reps
Incline Dumbbell Press - 3 sets of 8-12 reps
Bent Over Barbell Rows - 3 sets of 8-12 reps
Lateral Raises - 3 sets of 10-15 reps
Bicycle Crunches - 3 sets of 10-15 reps

Day 3:
===
Lunges - 3 sets of 8-12 reps per leg
Military Press - 3 sets of 8-12 reps
Chin-Ups or Cable Rows - 3 sets of 8-12 reps
Push-Ups - 3 sets of 10-15 reps
Russian Twists - 3 sets of 10-15 reps

Even after having this plan, the inner PIGDOG was still bugging me about how I will forget the routine and will always have to look it up on my phone... waste time... get distracted...

The initial implementation

So I decided to set out to build some sort of APP that would only serve this purpose:

track my sessions
track my progress during the week
have the exercises for the day
have the sets for the exercises
have an indicator for when I am exhausted
have a purpose built UI
no distractions
no "smart" features

Well, naturally, as a software developer I immediately pulled out my go-to programming language and framework and was using ChatGPT to knock out the boilerplate code.

I don't know about you, but I usually put on a podcast or some documentary in the background when I code, this time I decided to put on some Science without the gobbledygook by Dr. Sabine Hosenfelder and for some reason after the video, the YouTube algorithm served me something completely different, it was a video about the Venus Project

The final implementation

(inspired by the Venus Project)

I was obviously was not deep in the flow, because what I was hearing in the background caught my attention, and I started looking up all sorts of things about this project.

If you don't know what the Venus Project is, do yourself a favor and visit their project page

One thing they teach, with their design philosophy, is: make the thing that you want to build, have everything built-in, and not rely on manuals and rules that people have to follow.

So I scrapped the software solution and pivoted to a pure hardware, analog, "no batteries required" solution:

the humble T-Shirt!

This is the design I came up with:

front	back

The gallery

I hope this little project inspires you to come up with novel ways to achieve a goal without consuming cloud services, build servers and generate hosting fees, sometimes there are far simpler alternatives.

One single thing I think of improving: make the text mirrored so that when you are looking in the mirror, you can read the text and also to make other gym goers put in a little more effort into reading my AI generated training program.

In the end, I was happy with my decision to go analog. I learned that sometimes the simplest solutions are the best, and that technology is not always the answer. It was an eye-opening experience.

So, the next time you are faced with a problem, take a step back, and think outside the box. You might be surprised by what you can come up with.

Stay healthy and have a nice day!

Dyslexic DEV? No problem!

Viorel PETCU — Sun, 31 Oct 2021 22:06:33 +0000

Given

that I am dyslexic and also suffer from aphantasia, which is a fascinating quirk of the brain, one can imagine I have sort of a love / hate relationship with reading.

On the one hand, I must keep up with the news and trends of the software engineering industry but the serious and useful information I require, is in written form and that always drains my reading battery because of the above average amount of concentration I have to put forward.

When

daylight saving Weekend rolled around, I decided to do something useful with the "additional" hour, so I set out to improve this situation for people like me.

I decided to build something that allows us to take the text from any article in any language (English, German, Romanian in my case) and convert it to an mp3 file so that we can "listen to the article" and not drain our weak reading battery.

Then

I remembered one of the most important UNIX principles:

"DO ONE THING AND DO IT WELL"

so I challenged myself to:

use WELL DONE existing THINGS
write only a shell script
have less than 31 lines (today is halloween 🎃 )
uses only cli tools,pipes, shell commands
time box of 1h.

🤪

I did it! But this was only possible because so many wonderful people have developed so many great projects and shared them with the rest of us. There exists a multitude of software out there and any UNIX based OS allows us to interconnect it seamlessly, simply amazing 🤩

Result

The script:

#!/bin/sh
# this script does some text editing for the:
#   $1 - input file
# and stores it into the:
#   out-$1 - output file
# which it then later utilises to CURL to http://localhost:5002/api/tts running:
#   docker run -it -p 5002:5002 synesthesiam/mozillatts:en
# you can replace the TAG at the end with any language supported by TTS
# it will:
#  - produce a .wav file for each sentance in the outputfile
#  - join the wav files into a single one
#  - turn it into a .mp3 file named audio-$1.mp3

cat "$1" | awk -F'\.' '{ for (i=1; i<NF; i++) print $i ".\n" }' | tr "'" "´" |tr "\"" "´" > out-"$1"

input="out-$1"
while IFS= read -r line
do
  curl --location --request POST 'http://localhost:5002/api/tts' --header 'Content-Type: text/plain' --data-raw "$line" -o "audio_$(date +%s).wav"
done < "$input"

ls audio*wav |awk '{print "file " $0}' > wav-list.txt

ffmpeg -f concat -safe 0 -i wav-list.txt -vn -ar 44100 -ac 2 -b:a 128k audio-$1.mp3

rm out-$1
rm *wav
rm wav-list.txt

open "audio-$1.mp3"

The list of ingredients:

Mozilla/TTS
FFMPEG cli this thing went to Mars 🔴
UNIX based OS
docker cli
the above script

The "recipe":

 # in your terminal run: 
 docker run -it -p 5002:5002 synesthesiam/mozillatts:en
 # replace the 'en' tag with 'de', 'fr', 'ro' etc.
 # select and copy the text you want to listen to 
 # paste it into a file: `article.txt`
 # save the script as `audiofy.sh` next to the text file
 # in the terminal run:
 sh audiofy.sh article.txt

Demo

I used a snippet from the README file of the fantastic Mozilla/TTS for my demo i.e:

Have a listen to the output on soundcloud. (use the open in new tab function so you can see the text and marvel at the natural sounding synthetic voice)

Conclusion

Even tough I set only 1h for this project, I do love the result and will return to it for improvements. Implementing this was way too much fun.

Also in the time I wrote this post I listend to most of the news articles that popped up on my Google News feed, because I had converted them as a test for my script.

Synergy: achieved!
Productivity: increased!
Reading battery: protected!

✌️

Can you focus on work when owning Bitcoin?

Viorel PETCU — Fri, 02 Apr 2021 17:21:42 +0000

If you are here I am guessing that you too jumped on the bitcoin train and that's why you consume anything you can find on the subject, including this article. Yeah, you and me too, I got roped in after seeing this tweet from Elon Musk:

Because bitcoin is so volatile and valuable (for the moment) you can have huge swings within hours and if you want to do some trading during those peaks and valleys you inevitably get into constantly checking websites or some live ticker app, or worse, you might even have push notifications enabled ... so you end up in distraction hell, just ask Elon.

TL;DR version

Can you focus on work when owning Bitcoin?

YES you can!

Just take away all the unnecessary convoluted, distracting and time consuming steps.

OK, so what did I do to remove this distraction?

I made the conversion rate between BTC and EUR visible in my BASH prompt because, of course I did, I always have at least one instance open ( and probably so do you ):

This allows me to have the information in the corner of my eye, bare bones with no distraction. I don't have any cognitive effort and I don't switch the context.

To do this, I wrote a few lines of SHELL script and with it I can configure my prompt to display whatever I need:

how much is my current portfolio worth?
how much is X amount worth? (when buying / selling)
it's extensible to other crypto currencies
it's easy to setup
anyone can pick up where I left off

The long(er) version

I tagged this article ( at least the hands on part ) as intermediate, assuming that you know the concepts used to build this:

what the .bashrc file is
how the $PS1 environment variable is constructed
how to use the curl command
how to use the bc command
shell scripring

Step 1 - teaching BASH a new trick

Extend the .bashrc file (or any other file that your BASH consumes when starting up):

mbtc () 
{
    KEUR=$(curl -s 'https://blockchain.info/tobtc?currency=EUR&value=1000')
    MINE="${1}" # amount of BTC you want to monitor
    CALC=$(echo "scale=3; $MINE/$KEUR" | bc -q)
    echo "${CALC}k €"
}

Now your linux knows a new "command" called mbtc that accepts a parameter, this is the amount of BTC you want converted into KILO EUROS or k €

By adjusting the value parameter from the curl GET call to the public blockchain.info API you can transform other quantities, just be careful to adjust the calculation string that is later passed to bc

Step 2 - start BTC/EUR monitoring

Check your current $PS1 variable value:

echo $PS1

Create a file with the amount of BTC you want to monitor in your prompt:

echo "0.1234" > ~/btc.count

Now redefine the PS1 variable also by editing the ~/.bashrc file, by adding a subshell call inside of the existing prompt:

($(mbtc $(cat ~/btc.count)))

What next ?

Now you can rest assured, you will always know the up to date value of a Bitcoin or any other amount you want to monitor, just write the value in the ~/btc.count

Of course these concepts work just as well with any other shell implementation, you just need to edit the corresponding equivalent files.

All that is left for me to do is to wish you happy monitoring! Let me know if you were able to use this or if you were able to enhance or build something completely new on top of this.

#staysafe #peace #coderforever

Vio.

Browser Extensions: if you liked it, don't forget to 👍 it.

Viorel PETCU — Mon, 17 Feb 2020 00:16:16 +0000

Full disclosure, I am a slow reader and needless to say that I compensate a lot by consuming multi media content like Audiobooks, Podcasts, Documentaries and Streaming services.

Ever since the inception of YouTUBE I saw it's potential, and lately it's gotten crazy good, due to the growing competition brought on by the advances in technology: everything is a camera and high-speed internet is spanning almost the entire globe.

Of course these advances also make it easier for mediocre, bad or even controversial content to make it on the platform, that is exactly why voting is important.

Given that.

If you subscribe to a creator or channel and "like" the content, you provide a valuable information for the algorithm that will tailor future suggestions to your liking (pun intended).

Additionally it's a great help for the creators, as they can use the feedback to refine their content or for their revenue from sponsorships and outreach. The entire thing becomes a massive positive feedback loop.

It's such a simple action, but still, when I am in fullscreen mode, inside a playlist...

Be it a blender tutorial:

(this will help with my indie game)

or try to really understand calculus:

(this will help with my indie game)

or just want to learn some survival skills:

(this is awesome to know in an emergency)

I simply forget to give the 👍 although I watched the entire videos and got the knowledge I was seeking in a very entertaining manner, simply because I am watching a playlist. I think that is unfair.

No wonder that the number of LIKES represent somewhere between 3% and 6% of the number of VIEWS. This is a problem for me, because I want to show my appreciation and reward good work.

What to do?

Well, we can do something about that, right?
Let's see, we'll need:

something that runs in the browser
can be activated / deactivated / configured.
reacts only to the YouTUBE URL
checks the running videos runtime
checks your subscription to the channel / creator
likes the video from the creator if the set threshold is reached
works in fullscreen mode & background

Automate it!

So I created a Chrome Extension that keeps all the logic in the client, so that I don't need a server side component. I also didn't want to mess around with YouTUBE API and tokens or API Keys. My most important requirement: NO AUTHORISATION or USER DATA required.

This is what I came up with

You need to press the button "AutoLIKE ON" so that the code starts monitoring the video progress bar.

You need to select a threshold for when to trigger the 👍 between 10% and 90%.

You need to be subscribed to the creator / channel.

You need to have them added to your list manually using (+)

All configurations, in my implementation, get stored in the localStorage of your browser:

The extension is available in the Chrome Web Store

When you click the 💚 icon to show / hide it expands or collapses but the whole time it is embedded in the DOM of the YouTUBE page, looking like this:

Conclusion

I started out writing this post in order to show the little journey that led me to develop my first Browser Extension, but what I am hoping to achieve, is to maybe motivate you to just try out stuff and solve some "problems" you had for a long time and solve it with software!

If you decide to look into Chrome or Browser Extensions, you can use my little project as a starting point:

realvorl / furry-guacamole

show some love when you got 80% ^-^

YouTUBE Auto Like, Level 2

With this extension you can show your support for your favourite creators by adding their channel to your locally (in localStorage) managed list.

Never again, will you forget to like a video that you enjoyed over a certain percentage of its runtime. The creator list and like threshold are configurable.

The idea is simple, a little effort on your behalf makes a big difference for the creators on YouTUBE, because engagement is something that matters for them in monetizing their work.

Here is how to start

Install the extension fom the Chrome Store: http://bit.ly/auto-like-level2

check for this icon:

( a 32 x 32 pixel version of the image above - the desert fox)

Set it up

Well, no need, just open YouTUBE and you will be greeted with a little heart icon in the upper left corner:

by clicking on the heart icon, you…

View on GitHub

PS:

during the writing of this post I had "PBS SpaceTime"
in the background and as I was nearing the end of the Post
I caught the short notification, on my second monitor

I love it when a DEV plan comes together 🙃