DEV Community: Abanoub Hanna

Links on the web: blind click vs. transparency

Abanoub Hanna — Wed, 18 Mar 2026 09:54:55 +0000

The "Blind Click" is one of the most significant, yet overlooked, security gaps in the modern mobile experience. While we have spent decades training desktop users to "hover before they click", the transition to smartphones has effectively stripped away this essential safety habit.

Here is an exploration of why this matters, the security risks involved, and how a simple UI change can restore user trust.

The Hidden Luxury of the "Hover"

On a desktop or laptop, the web browser acts as a silent guardian. Whenever your cursor moves over a link or a button, a small strip of text appears in the bottom-left corner of the window. This is the URL preview. It allows you to verify that a button labeled "Login to Bank" actually leads to bank.com and not shady secure-login-verify-72.xyz.

On a smartphone, this layer of transparency vanishes. There is no cursor, and therefore, no "hover" state. To see where a link goes, a mobile user typically has to:

Long-press the link.
Wait for a context menu.
Read the URL in small print.

In reality, almost no one does this. We simply tap and hope for the best.

Why the "Blind Click" is a Security Nightmare

The lack of URL visibility on mobile isn't just a minor inconvenience; it is a primary vector for Phishing and Social Engineering.

Cybercriminals rely on the fact that mobile users are often distracted and unable to verify destinations easily. According to security research, mobile users are significantly more likely to fall for phishing attacks than desktop users, largely because the technical cues we rely on to spot fraud are hidden behind the glass.

"The mobile interface inherently prioritizes aesthetics and screen real estate over technical transparency. This "clean" design often comes at the cost of user security, as it masks the underlying architecture of the web."

By hiding the URL, the interface forces the user to trust the Link Text (what the button says) rather than the Link Destination (where the button actually goes).

The Solution: Explicit Transparency

The fix is logically simple but rarely implemented: Show the URL directly under the button text.

By displaying the destination domain—or at least the verified handle—directly in the UI, we remove the guesswork. This approach turns a "leap of faith" into an informed decision.

Benefits of Visible URLs:

Instant Verification: Users can see immediately if a "Facebook" button leads to facebook.com or a malicious clone.
Reduced Cognitive Load: Users don’t have to wonder or "long-press" to feel safe; the information is already there.
Building Brand Authority: For legitimate businesses, showing your official domain reinforces that you have nothing to hide.

Setting a New Standard: KartBusiness.com

This philosophy of "Security through Transparency" is exactly why KartBusiness.com has integrated visible URLs into its digital business cards.

Every social media link and external contact button on a KartBusiness profile is designed to show the underlying destination. When a client or lead views your digital card, they don't just see a "LinkedIn" icon; they see the direct path to your professional profile.

In an era where digital identity theft is at an all-time high, this feature serves as a digital "seal of authenticity", ensuring that every interaction on the platform is grounded in trust and technical honesty.

Conclusion: Transparency is the Best Policy

Design should never come at the expense of safety. As we move toward an increasingly mobile-first world, the responsibility falls on developers and platform owners to provide users with the tools they need to stay safe. Showing the URL isn't just a design choice—it’s a commitment to user security.

Take Control of Your Digital Identity

Don't leave your professional links to chance. Provide your clients with a secure, transparent, and professional way to connect with you.

Create and publish your FREE digital business card now at KartBusiness.com.

RegExp vs String Manipulation in Go language

Abanoub Hanna — Fri, 19 Dec 2025 13:47:15 +0000

I wrote a tool to abstract all package managers such as apt, snap, and flatpak, so I can use it as the interface instead of dealing with the specific package manager of the Linux distribution currently in use.

What is wrong?

In i, the tool, I wrote this function to replace the letter x from a command (if it has) with the package the user specified.

func executeCommand(template string, pkgName string) {
    if template == "" {
        fmt.Println("Command not defined for this package manager.")
        return
    }

    re := regexp.MustCompile(`\bx\b`)
    cmdStr := re.ReplaceAllStringFunc(template, func(s string) string {
        return pkgName
    })

    if verbose {
        fmt.Printf("Executing: %s\n", cmdStr)
    }

    parts := strings.Fields(cmdStr)
    if len(parts) == 0 {
        return
    }

    head := parts[0]
    args := parts[1:]

    cmd := exec.Command(head, args...)
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    err := cmd.Run()
    if err != nil {
        if verbose {
            fmt.Printf("Error executing command: %v\n", err)
        }
        os.Exit(1)
    }
}

But using regular expressions for a simple task like this is a horrible choice.

getting rid of regular expression

The task is to remove the letter x from the command and put the package name instead.

The commands always had that x letter at the end which made it a good case to use strings.TrimSuffic():

sudo apt install x
sudo apt remove x
sudo apt install --only-upgrade x
apt search x
apt show x
brew install x
brew uninstall x
brew upgrade x
brew search x
brew info x
sudo port install x
sudo port uninstall x
sudo port upgrade x
port search x
port info x
sudo flatpak install x
sudo flatpak uninstall x
sudo flatpak update x
flatpak search x
flatpak info x
sudo snap install --classic x
sudo snap remove x
sudo snap refresh x
snap find x
snap info x
sudo dnf install -y x
sudo dnf remove -y x
sudo dnf upgrade -y x
dnf search x
dnf info x
sudo pacman -S --noconfirm x
sudo pacman -Rs --noconfirm x
sudo pacman -Syu --noconfirm x
pacman -Ss x
pacman -Qi x

But there is a case that the command ends with x as a part of the package manager's name (guix), I don't want to replace this x.

guix

So, I can use a letter preceded with a space like this " x". But nix package manager has dot before the package name like this nix-env -iA nixpkgs.x, so, I need to handle this case too.

nix-env -iA nixpkgs.x

After taking all of these cases into consideration, If the command ends with ".x" or " x", I will remove the end x and put the package name.

Here is the function after using string manipulation instead of RegExp:

func executeCommand(template string, pkgName string) {
    if template == "" {
        fmt.Println("Command not defined for this package manager.")
        return
    }

    cmdStr := template
    // if template ends with ".x" or " x" remove "x" and add pkgName
    if strings.HasSuffix(template, ".x") || strings.HasSuffix(template, " x") {
        cmdStr = strings.TrimSuffix(template, "x") + pkgName
    }

    if verbose {
        fmt.Printf("Executing: %s\n", cmdStr)
    }

    parts := strings.Fields(cmdStr)
    if len(parts) == 0 {
        return
    }

    head := parts[0]
    args := parts[1:]

    cmd := exec.Command(head, args...)
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    err := cmd.Run()
    if err != nil {
        if verbose {
            fmt.Printf("Error executing command: %v\n", err)
        }
        os.Exit(1)
    }
}

I was wondering how much speed this will make!

Benchmarking RegExp vs string replacement

I wrote a benchmark to test the performance and it turns out it is super faaaaaaaaaaaaast!

$ go test -bench=. -run=NONE -benchmem
goos: linux
goarch: amd64
pkg: github.com/abanoubha/i
cpu: Intel(R) Core(TM) i5-1035G1 CPU @ 1.00GHz
BenchmarkRegexpReplacement-8             541910    2207 ns/op    1609 B/op  21 allocs/op
BenchmarkRegexpPrecompiledReplacement-8  1986163   609.2 ns/op   88 B/op    4 allocs/op
BenchmarkStringReplacement-8             23621672  50.48 ns/op   24 B/op    1 allocs/op
PASS
ok      github.com/abanoubha/i  3.608s

That means:

String Manipulation: ~50 ns/op
Regexp (Pre-compiled): ~609 ns/op (~12x slower)
Regexp (Compiled on-the-fly): ~2207 ns/op (~44x slower)

If you are curious to see the performance benchmark code, I left it on github inside the i project codebase.

takeaways

Use string functions whenever and wherever you can. Keep your code free of
regular expression as much as you can. Using strings functions in Go programming language is simpler and easier to understand and reason about and performs better.

I hope you enjoyed reading this post as much as I enjoyed writing it. If you know a person who can benefit from this information, send them a link of this post. If you want to get notified about new posts, follow me on YouTube, Twitter (x), LinkedIn, and GitHub.

Predictions for the Future of Programming Future in 2030

Abanoub Hanna — Tue, 08 Apr 2025 15:18:44 +0000

On May 2019, I wrote my predictions for the future of programming in 2025. Let's evaluate my predictions now before talking about my predictions for programming in 2030.

evaluation of my 2025 predictions for programming

Today is the last day of 2024, and tomorrow is the 1st day of the year 2025, Happy New Year to you ALL. I know, there is almost a year for my predictions to become true but I choose not to wait. I'd like to add a paragraph update to show my state of my predictions at the end of year 2025 too.

predicted the increase of Go language usage as an alternative to NodeJS

I predict that software developers will use Go language instead of Node JS for backend engineering.

This prediction came true. You'll watch too many companies and popular tech youtubers using Go and talking about it. For example:

Too many reasons why Go language is getting popular in the backend space. For example, Go is winning in popular benchmarks like these:

Go winning against Python : Go (Golang) vs Python Performance Benchmark
Go winning against FastAPI (a Python web framework) : Python (FastAPI) vs Go (Golang) Performance Benchmark
Go wins despite the optimizations to the FastAPI application codebase: Python (FastAPI) vs Go (Golang) (Round 2) Performance Benchmark
Go wins against Django (a Python framework) : Django (Python) vs Go (Golang) : Performance (Latency - Throughput - Saturation - Availability)
Go wins against Node JS : Node.js vs Go (Golang) : Performance (Latency - Throughput - Saturation - Availability)
Go wins despite the optimization in the Node app code : Go (Golang) vs Node.js: Performance (Latency - Throughput - Saturation - Availability)
Fiber (a Go web framework) wins against C# .NET : .NET (C#) vs. Fiber (Go) : Performance (Latency - Throughput - Saturation - Availability)
Go does NOT win against Bun JS (a JS runtime written in Zig) : Go (Golang) vs. Bun: Performance (Latency - Throughput - Saturation - Availability)

predicted that PHP will still be used in small projects and blogs

Yes. PHP, Laravel the web framework, and WordPress the CMS are being used vastly by small to medium projects, and especially for blogs. But other CMSes and SSGs are increasing in popularity especially among software engineers. For example, many tech blogs are written in Hugo the famous static site generator.

predicted the use of design after automatically being converted into code

No. Frontend developers still need to write the webpages in frontend technologies such as React JS and Vue JS. No mass use of automatic conversion of UI design into code reached till now (Dec 31, 2024). But there are some plugins/extensions for Figma to export the design as webpage code. I think it needs more time to get good enough for mass/public use to be the common practice.

predicted that Flutter will compete against PHP in web space

No. Flutter framework usage to create web apps is too little. It does not reach the level of competition of PHP web world. PHP has Laravel and WordPress, and they're huge.

predicted the presence of many complex web apps using WebAssembly like Photoshop

In the near future, We'll see web apps that are strong and complex like Photoshop run as a web app by leveraging WebAssembly (WAsm), likely using languages like Go or Rust.

Yes. Many web apps are created leveraging WebAssembly. Here are some examples:

photopea: the alternative to Photoshop.
SVG OMG: SVG image editor and compressor.
Squoosh app: the image converter and compressor created by Google.
photoshop: the Photoshop itself.
Figma: the famous UI / UX designing tool.
Photon is a high-performance image processing library in WebAssembly that runs both natively and on the web.
Discourse: Faster (and smaller) uploads in Discourse with Rust, WebAssembly and MozJPEG.
Zoom on Web : WebAssembly SIMD, WebTransport, and WebCodecs.
Google Meet: Background Features in Google Meet, Powered by Web ML.
In-browser transcoding of video files with FFmpeg and WebAssembly
MasterShot: in-browser video editor.
Speeding Up Webamp's Music Visualizer with WebAssembly
Speeding Up the Webcola Graph Viz Library with Rust + WebAssembly
Realtime Audio Analyzer Demo

You can find an up-to-date list of web apps leveraing WebAssembly in this awesome list on Github.

predicted that Rust will be used instead of C++ for device drivers

Software engineers will use Rust language instead of C++ to write device drivers.

Yes. Many popular projects switched from C++ to Rust, or written in Rust instead of C++ programming language. These projects prefered Rust for its ownership model which ensure no data races.

Examples of projects using Rust instead of C++ :

fish shell: from 100% C++ into 100% Rust.
WalletCore's Migration from C++ to Rust
DropBox: Rewriting our sync engine in Rust
Rust in Linux kernel

.. and many more projects, but above them all the contribution in building device drivers in the Linux kernel.

predicted the increase of Flutter usage in mobile app development

Mobile app developers will build their apps in Flutter using Dart language instead of the native languages. But the complex apps will be written in native languages which are Kotlin for Android, and Swift for iOS and iPadOS.

Yes. That is happening. 28% of the iOS apps in the app store is written in Flutter according to this FlutterInProduction Live stream.

predicted that most programming languages to develop for AI / ML

Most programming languages will contribute and develop for AI / ML as a means to develop and contribute to the AI evolution and increase of capabilities and merits of the language, but Python will stand as the defacto standard for AI / ML development. Python will face a competition against languages such as Go and Swift, but will stand as the top language for artificial intelligence and machine learning.

That didn't happen. Most programming languages integrated the tools and platforms of AI / ML for consuming not development.

Go language did not compete in AI / ML development yet.

On the contrary, Swift language support in Tensorflow project is deprecated. Currently, tensorflow supports Python, in addition to bindings to C, Java, and Go languages according to the official website.

An unexpected thing happened. New programming languages targeting Python lovers, Rust enthusiasts, and AI/ML at the same time. Mojo language is written in Pythonic syntax, with a backend better optimized than LLVM, by LLVM creators, with techniques to eliminate data races similar to Rust, as a superset of Python. It seems too good to be true, and it is. There is a catch, of course, but I am not interested enough to try and find it.

My predictions for programming in 2030

Predicting the future is one of the hardest things in life. But I am trying my best, relying on two basic heuristics to maintain sane predictions. Here are the two heuristics:

Laws of nature, and common heuristics: for example; the easiest will be popular among people because humans are lazy by heuristic nature.
What happened will happen again: assume that nothing will radically change, because the change is hard for people.

I try to predict the future because that will help me decide which way I'll go in work. Predicting the future makes your decisions easier to make. If the predictions are right, your decisions will be beneficial. That's why I spend some time to follow up with tech events and analyze the scientific laws that rule these changes in the software development field. This helps me understand the potential of each new idea, concept, and technology. Detecting the vision and direction of evolution in the tech space is a great asset in your predictions and decision making. This is me trying to analyze and predict the future, to help myself make better decisions.

Here is what I predict will happen in the software development in 2030.

Go will be as fast as C and Rust in code execution time

There are two indicators which help me predict that the code written in Go will be as fast as C and Rust in execution. They are:

Go development team is focusing on evolving the standard library into a better v2.
Google developed V8 engine for Chrome browser that made javascript run faster then ever; which made javascript a viable language for server-side / backend later.

Thinking of those 2 indicators made me predict that Go code will execute faster in the near future, as the Go team perfecting the codebase of Go and its stdlib. Go is already fast enough, but that push will make its performance greater.

Go will be the defacto standard in backend development in entreprise and medium-size companies

After all the enhancements and evolution that will occur in the next few years, Go will reach a level that makes it the defacto standard to develop backend, cloud, and server-side projects in medium and large companies.

Android apps will be written in Flutter more than Kotlin or Java

I predict that Flutter will be used significantly more than Kotlin and Java to develop Android apps in 2030. That's because Flutter development team is focusing on perfecting the framework. They announced that they'll experiment with making it possible to use Android native ABIs directly from Dart code in this FlutterInProduction live stream. After they already developed Impeller engine which is used instead of Skia rendering engine on iOS and Vulkan enabled Android devices (modern Android phones). Impeller makes apps run smoother and faster.

If the experiment of calling Android native ABIs directly from Flutter succeed or not, it still is a good thing as it is the vision and direction of the Flutter leaders. Their vision is great and will make Flutter live and prosper more and more. Fixing the common pain points in Flutter will guide its success. I see Flutter as defacto standard in Android app development thanks to the vision of the Flutter team I see.

Use UI design after automatic conversion into code

This prediction is one of my 2025 predictions which were not come true. I predict it again for 2030 but with a fundamental difference. I am not predicting a Figma plugin/extension to convert design into code. I predict a system similar to low-code solutions that has two-way transparent abstraction over code. I may try to accomplish this myself.

Web apps built on WebAssembly will increase more

Building complex web apps on WebAssembly instead of creating for Windows, Mac, or Linux will be the direction for big software companies. The web will have useful creative complex apps instead of just landing pages, posts, videos, and images.

Zig language will get more popular and usage more than Rust

Zig language will compete against Rust in developing device drivers; which is the place Rust got in the Linux kernel. Zig will succeed in the performance critical areas and security critical areas.

In fact, I predicted that Zig will succeed, in general, without specifying a date. I predicted that on June 17th 2022 in a post titled "Zig will succeed".

Rust will continue to get more popular despite the hot competition

Rust will continue to rise and be used because of its ability to stimulate the mind, show programmer's ego, get developers excited to work and show off.

Why I created Deeper Dark Color Theme for VS Code ?

Abanoub Hanna — Wed, 12 Mar 2025 20:09:41 +0000

I am using Visual Studio Code as one of my most used source code editors on MacOS, Ubuntu Linux, and Windows. I love dark mode with good contrast colors, so, I tried several color themes but not satisfied with anyone.

Color themes I tried

I tried some popular dark themes, but they did not fit for me.

Visual Studio Dark Theme

This is the default dark color theme for VS Code. This color theme is great but I need more contrast between background and text colors. I'd like for the lighter gray colors of the background of the left menu, and the colorful status bar to go away and only get deep dark background.

Dark High Contrast color theme

So, I tried this high contrast dark color theme. I thought it would be great to have extreme contrasty colors, but it is actually horrible. I can not use VS Code comfortably with these popping borders and contrasty outlines. So, I switched right away.

Default Dark Modern color theme

I thought, what about another dark theme with a darker backgrounds. So, Default Dark Modern came handy, but it was switched around! the editor's background is lighter and the sidebar's background.. this is horrible for me! I moved away.

Material Theme Darker High Contrast color theme

I thought of Material Design as I am an Android app developer, so, the Material Theme High Contrast caught my eyes. But when I installed it, it was not that bad, but not great. It is dimmer and less contrasty! the editor's background is not DARK enough for me.

Decision to create my own color theme

After testing all these popular dark color themes, I decided to create my own dark color theme with my criteria to fit my needs. Here are the rules I thought of.

backgrounds are absolutely DARK!
text colors are light more than enough to be sharp and contrasty.
dim colors for borders and outlines.

So, the theme is just the default dark theme with no colorful backgrounds, or it is just the Default Dark Modern theme with deeper dark backgrounds.

Deeper Dark color theme

This is my color theme. Deeper Dark is the name I chose for the color theme as the most important job for it is changing the backgrounds to be the absolute dark color. That's it. It is similar to Default Dark Modern and Material Theme Darker High Contrast but not close enough. So, I created this simple theme that fits my needs and shared it on Github.

If you'd like to try it, here is how to.

How to install it on your VS Code

Search for deeper dark in Visual Studio Code extensions sidebar, choose the extension that provided by Abanoub Hanna, and install it.

Or install it via commandline, using this command:

code ext install abanoubha.deeper-dark

Or find the extension on VS Marketplace: https://marketplace.visualstudio.com/items?itemName=abanoubha.deeper-dark

The Siren Song of Representative Samples: Why Telemetry Still Reigns Supreme in Software Development

Abanoub Hanna — Wed, 12 Mar 2025 20:02:39 +0000

The idea is seductive: if you could perfectly capture the essence of your user base with a meticulously crafted representative sample, wouldn't that eliminate the need for vast, intrusive telemetry? After all, why track every single user action when a smaller, carefully selected group could provide the same insights? While compelling in theory, this notion falls apart under the harsh realities of software development in the modern era.

Let's dissect why, across programming languages, operating systems, mobile apps, desktop apps, and the broader software ecosystem, telemetry remains indispensable, even when representative samples are theoretically possible.

The Illusion of Perfect Representation

The core problem lies in the inherent difficulty of creating a truly "representative" sample. Human behavior is complex, nuanced, and often unpredictable. Consider:

Diverse User Demographics: Software caters to a global audience with varying demographics, technical proficiencies, and usage patterns. Accurately reflecting this diversity in a manageable sample is a Herculean task.
Edge Cases and Unforeseen Scenarios: Even with the most comprehensive sampling strategy, rare but critical edge cases can be missed. These edge cases, often triggered by specific hardware configurations, network conditions, or user workflows, can have a disproportionate impact on software stability and user experience.
Evolving User Behavior: User behavior is not static. It evolves with new software releases, emerging technologies, and changing market trends. A sample that was representative yesterday might be obsolete tomorrow.
The "Unknown Unknowns": The most dangerous issues are the ones you don't know to look for. A pre-defined sample, no matter how well-crafted, can't anticipate unforeseen problems that emerge in the wild.

The Limitations of Sample-Based Insights

Even if a near-perfect sample could be created, the insights derived from it would still be limited compared to telemetry:

Scale and Statistical Significance: Telemetry provides data on a massive scale, enabling statistically significant conclusions. Sample-based insights, while valuable, may lack the statistical power to detect subtle but important trends.
Granularity and Context: Telemetry can capture granular data on user interactions, performance metrics, and system events. This level of detail is crucial for diagnosing complex issues and optimizing software performance. Samples often lack the depth of this contextual data.
Real-Time Monitoring and Alerting: Telemetry enables real-time monitoring of software performance and user behavior. This allows developers to quickly identify and address critical issues before they impact a large number of users. Samples, by their nature, provide a snapshot in time, not a continuous stream of data.
A/B Testing and Feature Experimentation: Telemetry is essential for A/B testing and feature experimentation. It allows developers to measure the impact of different software variations on user behavior and performance. Samples can be used for initial user studies, but they lack the scale and granularity required for robust A/B testing.

Specific Examples Across Software Domains

Let's illustrate these points with concrete examples:

Programming Languages:
- While surveys can gauge general language popularity, telemetry from package managers or IDEs reveals actual usage patterns, library dependencies, and performance bottlenecks across diverse projects.
- Edge case compiler issues that only appear on specific hardware configurations or with complex code structures are almost impossible to catch without widespread telemetry.
Operating Systems:
- Driver compatibility issues, hardware conflicts, and performance regressions across a vast array of hardware configurations are only detectable through comprehensive telemetry.
- User behavior patterns, such as application usage and system settings, are essential for optimizing OS features and resource management.
Mobile Apps:
- Network latency, battery drain, and app crashes across a multitude of devices and network conditions require detailed telemetry.
- User engagement metrics, such as screen time, feature usage, and in-app purchases, are crucial for optimizing app design and monetization strategies.
Web Applications:
- Browser compatibility issues, performance bottlenecks, and security vulnerabilities across a wide range of browsers and devices necessitate robust telemetry.
- User flow analysis, and funnel analysis are critical to understand where users are having issues, or leaving the site.
Cloud Services:
- Monitoring the health and performance of distributed systems, and detecting outages across globally distributed data centers is impossible without telemetry.
- Security threat detection, and anomaly detection relies on massive amounts of telemetry data.

The Ethical Considerations of Telemetry

It's crucial to acknowledge the ethical considerations surrounding telemetry. User privacy must be paramount. Developers should:

Be transparent about the data they collect and how it's used.
Provide users with clear and easy-to-use controls over their data.
Anonymize and aggregate data whenever possible.
Comply with all relevant data privacy regulations.

Good example of telemetry and representative samples

Go toolchain telemetry is entirely voluntary, and disabled by default. Go toolchain telemetry is only in Go toolchain programs, not yours. To enable it, you should run go telemetry on.

Watch the keynote of Russ Cox about "Go Telemetry Wins" here.

The Go language ecosystem effectively utilizes opt-in OpenTelemetry instrumentation, earching a representative sampling number of opted-in developers, to enhance its toolchain.

Conclusion: Telemetry as a Necessary Evil (or a Necessary Good?)

While the allure of representative samples is undeniable, the realities of software development demand comprehensive telemetry. It's the only way to gain the deep, granular, and real-time insights needed to build robust, reliable, and user-friendly software. By prioritizing user privacy and implementing responsible data collection practices, we can harness the power of telemetry to create a better software ecosystem for everyone. In short, while sampling has it's place, it does not replace the need for good telemetry.

How to set Win+V shortcut for Clipboard History in Ubuntu Linux ?

Abanoub Hanna — Wed, 12 Mar 2025 19:55:21 +0000

I liked the new-ish Windows 10 and 11 style of clipboard management. It has a shortcut to copy (CTRL+C) and to paste (CTRL+V), but they added another incredible one, which is Windows Key + V. This shortcut will show a list of the last 10 copied items (or so ..).

There are many clipboard managers for Linux operating systems but they does not have that seamless elegant user experience. So, I'll try to re-create a similar workflow for my convenience.

Installing a clipboard manager

I installed Diodon clipboard manager using these commands on my Ubuntu Linux laptop.

sudo add-apt-repository ppa:diodon-team/stable
sudo apt-get update
sudo apt-get install -y diodon

After that I will use a custom shortcut to trigger the paste menu to show up.

Custom shortcut to show clipboard history

I am using Ubuntu 24.04.1 LTS which comes with GNOME desktop environment, so I can customize keyboard shortcuts using the settings app.

Open settings app, then select keyboard from the side panel, then click on view and customize shortcuts at the end of the page.

Keyboard shortcuts will show up. Click on custom shortcuts at the end of the page/screen/window.

Custom Shortcuts window will appear. Click on the button that has a plus sign.

Write a name as you like.

Write this specific path for the Diodon executable /usr/bin/diodon which I got from Diodon program in its tab HotKeys.

Click on the button next to shortcut and click the shortcut which is Windows key and V (also known generally as Super key + V).

After doing all of that, click on the orange button that says Replace.

Customizing Diodon clipboard manager

I enable these settings in the preferences of Diodon app.

use clipboard (CTRL+C)
add images to clipboard history
keep clipboard content
synchronize clipboards
automatically paste selected item

And I increase the number of recent items to 30 which makes Diodon save the latest 30 copied items.

Super+V experience with Diodon

Here is the dropdown menu that shows up when I click the shortcut Super + V in any input field.

The menu has two main sections:

a list of the last 30 copied items.
clear (to clear all saved clipboard history)
preferences (to open preferences of Diodon app)
quit (to close this dropdown menu)

Linux awareness, Distrohopping, Ricing, and Growing up

Abanoub Hanna — Wed, 12 Mar 2025 18:49:51 +0000

I have a rich long history with Linux distributions, and I wanna share that history and the evolution of my thought process of operating systems with you all in this post.

Linux awareness

I was using Windows 7 on my HP 250 laptop. I was happy with the operating system I have. Sometimes I face a problem with WiFi connection, or bluetooth, and I search Google and YouTube and fix it myself. I was satisfied with Windows 7 in a general sense.

I started to learn Visual Basic 6 on Visual Studio on Windows 7 and it was a fun experience with graphical user interface that uses forms and drag-n-drop widgets (I don't recall the exact name of them).

After learning Visual Basic 6.0 for a few months, I decided to learn web development. I started to learn front end web technologies and languages starting with the obvious HTML, then CSS, then CSS3. I was learning from W3schools and some other forum I can't recall right now. I used Notepad, Atom code editor, and Notepad++. I prefered Atom editor at that time.

I learned Javascript and focused on the DOM manipulation as I was thinking of the browser and frontend. My thinking was graphically, client-side, visually oriented. I have not been able to grasp the concept of backend yet.

Android's shiny apps caught my eyes and made me pivot my learning path into Android app development in Java. I started to learn Java and it was a hard (almost horrible) experience but I passed it successfully. Java was the first programming language I learned deeply. I downloaded Android Studio on my humble laptop and it sucked big time.

I used my big enough skills in googling and I learned how to decide what are the problems in the computer which affects its performance, and what is the bottlenick. I used Task Manager to watch my laptop performance while I code, save, and run Android app on emulator. It was my hard disk drive. my HDD read/write speed is the bottlenick as it is almost always at 100%. I replaced my DVD with another storage unit with proper housing, so, my laptop then had 2 storage disks; one is SSD with faster writing and reading speed, and the older one is HDD.

My laptop became usable after fixing its bottlenick. So, I could continue to learn and build Android apps for businesses and myself.

I faced too much viruses, trojans, shortcut worms/viruses, .. etc, and I was searching too much about these things on Google. I was reading too many articles, forum posts, and documentation on viruses, security, and hacking (offensive and defensive security).

Kali Linux

I saw security experts using Linux operating systems such as Kali Linux when they talk about hacking, pentesting, cracking hashes, .. etc. I started to search with related words, my search keywords became more informed. After a while I decided to try Kali Linux in Virtualbox.

It was a horrible experience on my poor laptop. But I learned too much about the terminal, security, and simple hacking programs and tools.

After that, I started to read about Linux, open source, libre software, and operating systems in general starting with UNIX and MINIX.

Ubuntu

After a while, I decided to dualboot Windows 7 and Ubuntu for better performance and to gain more hands-on experience. I loved Ubuntu Linux.

After getting mature in software development in general and gaining more knowledge about Linux and opensource, I decided to go all in.

I moved all my personal files and other important files on a USB pendrive and some uploaded to Google Drive and some other files are kept on the hard disk inside my laptop. I wiped everything on the SSD and installed Ubuntu. I was so happy I could achieve that.

distrohopping

I faced issues from time to time on Ubuntu, so I started to think about better Linux distributions. I installed Kali Linux on bare metal instead of Ubuntu, and it was a horrible 2 day experience, so I reinstalled Ubuntu.

Linux Mint

After a few days, I was reading about Linux mint. I started to think of trying it. I installed it on the weekend. It was good enough, but it was sluggish and laggy compared to Ubuntu. I didn't know why at that time.

I use Arch btw

After about a week, I decided to try another distribution that everyone talks about. So I decided to install Arch itself!

On my 15-day long holiday, I started it with installing Arch. It was the most stressful learning experience. I consumed days and nights to install and figure out things. searching, doing, and re-searching. More than a week later, I decided it was enough. No more time for Arch. I gained more knowledge in various low-level software architecture and apps, but it is enough. Let's go back to business.

Back to Ubuntu

I installed Ubuntu again.

Kubuntu : Ubuntu with KDE Plasma

After about a month, the experience of hopping from distro to distro was giving me suspense, amusement, satisfaction, .. some fealing of fear and success, like trying to explore a wild new world. So, I kept thinking of trying KDE (later named Plasma desktop). I installed Kubuntu which is Ubuntu with KDE desktop environment. I had too much choices and customization options, but I was lost. It was a vast crowded wild world.

I kept customizing, changing things around, hiding, adding, installing apps, and even redesigning the desktop look and feel to be like Ubuntu, then to be like Windows 7 interface, then I stumbled up on a video that showing how to customize KDE to be like MacOS (OS X) interface, so I did it.

Back to Ubuntu, again

After 10 nights of geeking around, I quit this redesign loop. And I went back to Ubuntu with GNOME desktop environment. I kept Ubuntu for a while as I was focusing on software development (web and mobile).

Clear Linux OS

One night, I was reading some article about a performance beast created and maintained by Intel, specially optimized for Intel CPUs. So, I was hooked. On the next weekend, I installed Clear Linux OS on my laptop. I was thrilled with its performance. It felt like a breeze of fresh air with its performance and GNOME DE. Clear Linux OS has a package manager that has too few packages but it includes Flathub, so, it has popular Linux programs there. It was a quiet experience with little worries and issues at first. But after about I month, I faced an issue, and almost all webpages I read on Google search says update via swupd (its package manager), so I did. It broke! There were some issues in updating too. After a long night I figured out how to fix the problem. It was a horrible rolling release issue with packages older than expected for its "smart" package manager.

Back to my beloved Ubuntu

I went back to Ubuntu with my mind full of gratefulness and satisfaction. I saw Ubuntu as valuable, stable, productive as it can be.

Elementary OS

But someday, I watched a YouTube video about a new Linux distribution that has a MacOS look and feel with a focus on user experience. I thought it was a novelty thing.. a shiny broken glass.. but too many youtubers tried it and recommended it! I started to think and search about Elementry OS. I knew it is based on Ubuntu with a new Pantheon desktop environment and a back-to-basics app store with a great pay-what-you-can policy. I loved the concept and bought the premise.

I downloaded the ISO file. A few busy days in my college passed, and I forgot about Elementary OS. I watched more youtubers talking about Elementary OS, so I came back to it, and installed it.

My out of the box experience of it was good. It was somewhat slower than Ubuntu and Clear Linux OS. But it gave me a clean user interface with good user experience. Installing apps was not bad for me as I was used to the terminal. But for everyone else, it was horrible as it has dozen apps in its innovative app store (called "App Center").

I tried its code editor, it was basic but good. I saw it was a promising distribution but I face too many errors and issues down the road with updates and installed programs.

Debian

So, I thought I should come back to my belove Ubuntu. But another thing caught my attention. Ubuntu is based on Debian. Why not Debian?

So I installed Debian. It was not good enough as it started with issues with device drivers, then with playing videos and proprietary codecs, and its performance was worse than Ubuntu. It broke my heart as I see it as the wise grandfather of Linux distribution. At that time, I appreciated Ubuntu more and more.

Pop!_OS

Should I go back to Ubuntu? but I need more than Ubuntu ? What about the new distribution that is based on Ubuntu and maintained by System76 (a Linux-powered hardware company). It'd be it. I installed Pop!_OS (that weird name).

It was a stable distribution for the most part, but after a few days of usage its user interface started to freeze randomly. A program interface freezes, and at the same time the whole system and other programs works fine. The dock/panel freezes, but all other things and programs work properly. It was a chaos experience of great experience and horrible experience. I love the concept, but I hated the product. Their vision is good though. I follow their progress until now while they're creating COSMOS desktop environment in Rust. COSMOS DE is in alpha stage right now (the time of writing).

Manjaro

I thought I should visit other friends to get my hands-on experience to make an informed decision about my Linux distribution of choice. So, I tried Manjaro. I liked its user interface, especially its colors and the prompt theme of the terminal. But it was deeply horrible distro with ducktaped parts which fail all the time.

Fedora

I tried Fedora. People are talking high about Fedora, but it was not that good. I faced too many device drivers' issues and more issues with updating and installing programs.

Zorin OS

I tried Zorin OS, that shiny thing. It was not that good as a daily driver. It has the look and feel but not much in the functionality and stability.

Parrot OS

I tried Parrot OS, that security focused distro, similar to Kali Linux. It was not good at all. I thought of the next distro after less than 2 days.

Settle on Ubuntu

After trying all these Linux distros, I decided to settle on Ubuntu once and for all. I installed the good old friend on my laptop. I started to use it as usual. That stability and quitting distrohopping helped me focusing on my college and software development career.

But another behavior came along. I started to see a better user experience for every behavior in Ubuntu w/ GNOME.

the ricer

So, I started to customize GNOME with extensions. I did too many customization. I redesign its user interface to be similar to Pantheon interface but with a left side mounted dock. I added the menu to the left top corner like Elementary OS and Mate (good old Unity desktop environment). I redesign it to look like MacOS. I even changed program icons. The day after that day, I redesigned it to look minimal with less clutter and more of a tiling window manager.

I was constantly trying to optimize the user experience and my workflow, but I was literally lost in customization and ricing.

I was always ricing. I installed too many desktop environments on the same Ubuntu distribution. It was too much ricing.. too much customization.. too much change.. too much issues including "not booting to Ubuntu"!

After a crazy 2 month, I came to realize what I want! and I thought why?

That's the great word. WHY?

Why should I customize that much?

why all of these changes?

Why KDE ?

Why GNOME ?

Why not GNOME ?

What I want? What is the purpose? Why I choose this or that?

Recovering and growing up

I started to think more clear utilizing my rich experience with different Linux distros. I put some rules, guidelines, goals, specifications, or points that should be in my chosen Linux distro.

I wrote this list:

passed the test of time with at least 10 years.
used by millions of people to make sure it is tested on various PC / laptop configurations.
left mounted dock of apps.
top bar.
touchpad gestures like MacOS, Elementary OS, and Pop!_OS.
performant and efficient as a daily driver not in synthetic benchmarks.
preferably has APT package manager (Debian based, or Ubuntu based).
not a rolling release, not cutting edge, I need stability more.

So, I decided to go with GNOME as a desktop environment as I need too minimal customization. I just need to put the app dock on the left. Then I compared Elementary OS, Pop!_OS, Ubuntu, NixOS. I landing on the orange Ubuntu land. I still using Ubuntu and I love it. I am writing this post on Ubuntu 24.04.1 LTS operating system of choice.

That was the chosen operating system for me. Ubuntu is great with its default GNOME desktop environment. Ubuntu passed the test of time, and used by millions of users around the world. Its performance and efficiency is great for me. GNOME DE has a topbar, and an apps dock which Ubuntu left mounted it for me. Its package manager is APT with their new Snap package manager. It has a famous long-term support release every two years (LTS). I daily drive Ubuntu and it is great and familiar and easy to use for me.

I now focus on programs I run, software tools I create, my time management, .. etc. I am feeling I grown up. I learnt more than enough about GNU Linux and its distros.

Why Microsoft is porting Typescript Compiler into Go ?

Abanoub Hanna — Wed, 12 Mar 2025 18:44:01 +0000

On March 11, 2025 Anders Hejlsberg, technical fellow at Microsoft, announced porting Typescript Compiler in Go programming language on the official YouTube channel of Microsoft Developers.

Why moving to another language? Why not self-hosting?

Self-hosting is writing the language compiler it the language itself. The TSC is self-hosted right now, but the team is porting it into Go.

The Typescript team saw an increase of latency with the grow of the codebases in Microsoft, so, they think tsc needs to get faster and scalable. So, it needs to be more concurrent for better scalability, and more native to get as much performance from the hardware as possible.

They thought of Go, Rust, C#, .. and other languages.

Why Go ?

Anders said Go is similar to Typescript in syntax so tsc can be ported (rewritten in exact same way) not rewritten from scratch reasoning from first principles in a new language.

Typescript team members can pick Go language in a week or so, because Go is an easy to learn programming language.

Why not C# ?

Typescript Compiler codebase relies heavily on functions and structs not OOP, so it is easier to port the codebase into Go than porting it into C# as C sharp is more object oriented.

Why not Rust ?

Rust language is too different than Typescript, so it needs a complete rewrite reasoning from first principles using "the Rust way". It is a multi-year job with too much complexity.

Developers and engineers working on the Typescript compiler team need months to learn Rust.

the codebase is written on a way that is relying on a garbage collector. So, if we rewrite it in Rust, its code layout will be so different. It will be a harder to get done in a timely manner.

Gains of porting tsc into Go

10X more speed
half memory usage
more scalable as a benefit of Go concurrency

My opinion on porting tsc into Go

I see it as a mature decision that weighs the benefits and moves forward into a better performant efficient yet easily maintainable future.

The faster compile time of Go language is beneficial as it helps developers focus on iterating in their code not waiting for compiling or testing. It is similar to dynamic typed language in its compile time, yet it is static typed and native. It is the best of both worlds.

Cross platform compatibility of Go language made it a better choice for tsc as it needs to be available on Linux operating systems, Windows (of course), and MacOS.

As Anders put it on his interview on Michigan Typescript channel: "Go is the lowest level language we can get to and still have automatic garbage collector, it's the most native-first language we can get to and still have automatic GC". (at 19:29 time mark).

Choosing my distro: Ubuntu, NixOS, Elementary OS or Pop!_OS

Abanoub Hanna — Mon, 23 Sep 2024 14:29:35 +0000

I used Ubuntu for more than 8 years now. I tried Elementary OS, Pop!_OS, Kali Linux, Parrot OS, Linux Mint, Manjaro, .. and too many other distros. But today, I wanna decide what to use in my journey as a software developer and tech geek.

I eliminated all other Linux distributions, and the list of choice is as follows with my reasons.

Ubuntu: wholesome.
Elementary OS: the great user experience (UX) of Pantheon desktop environment.
Pop!_OS: The new efficient desktop environment called COSMIC desktop.
Nix OS: the declarative approach, immutability and reproducibility.

I can try cosmic desktop once it reaches production (now, in early alpha) on Nix OS. So, no real need to use Pop!_OS (for me).

I can try Pantheon desktop on Nix OS, too. So, no real need (for me) to install Elementary OS.

So the distro list is now became.

Ubuntu
Nix OS

Now, I use Ubuntu as my daily driver Linux distribution of choice. So, I will install Nix OS besides Ubuntu as a dual boot.

But for now, I will try Nix OS in GNOME boxes first. After getting more familiar with it, I will install it besides Ubuntu.

How to improve OCR accuracy ? | my 5-year experience

Abanoub Hanna — Fri, 12 Jul 2024 09:06:48 +0000

my experience with OCR technologies

I created my 1st image to text converting app on Oct 6th 2018, so it was 5+ years ago. I have been improving, learning, rewriting, iterating, experimenting on OCR technology since then.

I created all of these apps to extract text from images/photos:

IMG2TXT: Image To Text OCR (opensource)
IMG2TXT OCR App (discontinued)
IMG2TXT Hindi / Indian OCR App (will be discontinued after the 1st app supports Hindi/Indian)
IMG2TXT : Persian OCR App (will be discontinued after the 1st app supports Persian)

After all these years, I have a simple thing to say "What is measured, improves". This quote is from "The Effective Executive" book by Peter F. Drucker.

ideas to improve OCR accuracy

Improving OCR accuracy of extracted text is not a small task. The obvious answer to how to improve text extraction from images is:

improve "traineddata" models
use auto correct; for example correct boxmg into boxing
use High DPI photo

I used to focus on all of these bullet points and more of them, such as:

pre-processing images/photo with
- black and white filter
- binarization with adaptive threshold
increase the DPI of the image artificially to be around 300 dpi
use the best models from tesseract OCR despite their large size

These ideas led me to improve performance and text accuracy to certain extent. Don't get me wrong! these tips and tricks me my apps run fast enough with good enough accuracy. But I see more accurate apps! for example, Google ML kit produces almost 99% accuracy in text extraction from clear images.

how to measure OCR accuracy improvement/progress ?

My measurements are not good enough. I need to follow "What is measured, improves" concept. I need to have a set of photos of papers to measure my app's accuracy against. I need a sample of photos that represents the real world use cases. Then I need to refactor and enhance the text extraction accuracy against this sample of images. So, people get the improvements in their daily tasks of typing a paper into digital document.

specifications of the image sample

I need to collect that image sample with the real world use cases in mind. So I need these images.

a photo of an old book, the paper is perfectly laid out on an even surface
a photo of an old book, the paper is warped as the book is open
a photo of a modern book with clear white background
a photo of a modern book with some image/illustration between paragraphs
a photo of an article written in Arabic with some words in English
a photo of an old yellowish book paper with a cursive font

This is the initial set of image specification of the collected photos. If you have a specific use case, send some photo samples to me on Twitter (x) or LinkedIn.

Go or Python ? Which language is used more in production software?

Abanoub Hanna — Mon, 01 Jul 2024 06:36:04 +0000

I think that Go is better than Python. And that's my own opinion. But I was wondering if people are using Go or Python for their production software in the real world. I want to get statistics of production software to compare and understand the real world.

Source of statistics

In a previous post, I used Homebrew as the source of statistics about apps written in each programming language. Homebrew is a package manager for MacOS and Linux distros.

Homebrew provides a json file of the index of all packages and apps in Homebrew Core Formulae.

So I created a simple CLI application written in Go to use that updated JSON file to count the apps using a specific programming language.

Statistics by gobrew

language	June 2	July 1
Go	988	998
Python	777	783
Cython	11	11

According to statistics, Go is used for more production software than Python.

Why Go is used more than Python ?

comparison	Go	Python / Cython
compilation speed	very fast	Python: not compiled, Cython: very slow
runtime performance	very fast	Python: slow, Cython: good
concurrency support	great	bad
libraries & frameworks	good enough	huge
readability	good	good

As you can see, Go checks all factors mentioned, but Python is great at things and bad at other things. Programming languages are just tools, so, overall, I personally choose Go every time as the better tool to get the job done. Most software developers choose Go over Python as you can conclude from the statistics above.

Is Go Used in Production more than Rust ?

Abanoub Hanna — Fri, 26 Apr 2024 08:37:16 +0000

I was wondering if programs used in the real world are mostly written/built in Rust or Go? How to create a real world statistic to compare ?

Homebrew package manager

I found that Homebrew lists the dependencies of the package like this.

$ brew info eza
==> eza: stable 0.18.13 (bottled)
Modern, maintained replacement for ls
https://github.com/eza-community/eza
Not installed
From: https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/e/eza.rb
License: MIT
==> Dependencies
Build: pandoc ✘, pkg-config ✔, rust ✘
Required: libgit2 ✘
==> Analytics
install: 12,792 (30 days), 38,295 (90 days), 68,375 (365 days)
install-on-request: 12,790 (30 days), 38,293 (90 days), 68,375 (365 days)
build-error: 0 (30 days)

The dependencies of eza to build are pandoc, pkg-config and Rust. So, I can get all software packages in Homebrew and query every package to get its dependencies, then calculate the number of packages which depends on Go and others on Rust.

I was wondering if I should execute system commands of brew list and brew info <pkg-name>, but fortunately, Homebrew has a json file containing all Homebrew Core Formulae.

gobrew

So, I created a simple Go program named it "gobrew" to get the JSON API, then parse it, and count all Go-based software packages.

I made gobrew more general, so, you can use it to get the number of packages written in Ruby by this command gobrew -l ruby. You can specify any programming language or library or build system or runtime.

Statistics on April 26, 2024

The number of packages written in Go is 957. The number of packages written in Rust is 524. That means Go is the most used in software distributed by Homebrew package manager for production by far.

$ ./gobrew -l go
957

$ ./gobrew -l rust
524

You can try it yourself via gobrew on GitHub.

Here is a chart to help distinguish the difference in the count of packages.

other programming languages

I used this command to count packages written in these programming languages for me.

$ ./gobrew -l zig
6

Here is a table of programming languages (I thought of) and their packages count.

Language	pkg count
python\@3.12	718
python\@3.11	67
lua	47
ruby	27
ocaml	26
perl	25
php	20
cython	12
Zig	6

build systems & libraries & runtimes

I used the following command to count packages which use the build system or runtime to get build or run.

$ ./gobrew -l cmake
1011

Here is a table of build systems, libraries and runtimes (I thought of) and their packages count.

build system or runtime	pkg count
pkg-config	1447
cmake	1011
autoconf	455
automake	435
libtool	366
ninja	253
meson	213
node	189
gcc	75
python-setuptools	75
llvm	30
luajit	22

my opinion

I think of Rust as a great language for low level programming such as operating system modules and device drivers. And I think of Go as the perfect backend programming language and CLI apps. I think that's why Go is almost 2x more used to create apps distributed via Homebrew compared to Rust.

I think Go is more useful for most cases, but there are other specific cases suitable more for Rust and Zig (which I think will succeed and get popular).