标签：#ux

1. How this project started? I'm going to be honest, it's been ages since I have written something without the use of AI to fix my writing. English is not my first language so please bear with me! With the rapid rise of AI, I felt that I have been losing passion for what I used to love at some point: learning . Nowadays, we can quickly solve most of our problems with the use of AI, often times, not even reviewing if it correct or not. That's why I decided to take some time daily to learn something new without or minimal use of AI. The first step is deciding, what should I try to learn first? Well, it was quiet easy to find out what. If you are into Linux, you have probably heard of Omarchy at this point. Like it or not, there's no deny that it's getting more popular among developers. So, why not try to build a decent looking Arch workspace? Before continuing, I would like to mention that this is not a guide. There are lot of resources online that teaches you how to install Archlinux and other packages. 2. Why Archlinux? Archlinux has -or had- the reputation of being difficult to get started with. Most of us are used to booting into a nice-looking, functional operating system. Although I have some Linux knowledge, I wanted to have a better understanding of what it takes to have a decent workspace. 3. Installing Archlinux The first step is actually installing Arch on my device. The device I'm going to use is my trusty built PC that I currently use exclusively for gaming. There are a few things to consider before jumping into installing Arch: My PC has an Nvidia RTX 5050 and AMD Ryzen 5 CPU. Need dual boot to switch between Windows 11 and Archlinux. I don't want to change the BIOS options repeatively. With this in mind, I quickly created a bootable USB using RUFUS . 3.1. Booting the USB If you are a Windows 11 user and have dual boot, you may know that Windows requires Windows Secure Boot. In order to boot another operation system, you'll need to change your Secure Boo

A syndication job noticed before I did A scheduled task publishes one blog post a day to a developer community. It fetches the article from my own site, converts it, and posts it. At 10:00 it failed four times with this: Server error '521 <none>' for url 'https://neuragrowth.co/blog/schema-grammar-ceiling/' 521 is Cloudflare saying the origin server did not answer. So the interesting failure was not in the syndication job at all. My whole site was down, and had been for over three hours by then. The server itself was fine: four days of uptime, load under 0.2, disk at eight percent. But systemctl is-active nginx said failed , and nothing was listening on 80 or 443. nginx resolves your upstreams before it starts The journal had the whole thing in three lines: 06:49:54 systemd[1]: Stopping nginx.service... 06:49:54 nginx[36027]: [emerg] host not found in upstream "example-backend.tld" in /etc/nginx/sites-enabled/site:104 06:49:54 nginx[36027]: nginx: configuration file test failed Line 104 was a small proxy I had added months earlier so the public site could forward one form endpoint to a backend on a different host without revealing its name: location = /api/lead-capture { proxy_pass https://example-backend.tld/api/lead-capture ; proxy_ssl_server_name on ; proxy_set_header Host example-backend.tld ; } When proxy_pass contains a literal hostname, nginx resolves it while parsing the configuration , and treats failure as a fatal config error. That resolution happens inside ExecStartPre=/usr/sbin/nginx -t , so a name it cannot look up means the unit never starts. The config was not wrong. It was valid before the restart and valid after, and nginx -t passed by hand seven hours later. It was invalid for about one second. Why DNS was gone for exactly that instant Ten seconds of journal, reconstructed: 06:49:44 apt-daily-upgrade.service starts 06:49:53 "Reexecution requested ... (unit apt-daily-upgrade.service)" 06:49:53 systemd reexecuting (it had just upgraded itself) 06:49

Debian voted to allow developers to use AI tools in their contributions to the Linux distribution's "development, maintenance, [and] documentation." The new policy on AI acknowledges that "responsible" use of AI can improve developers' productivity, and goes on to say, "generative AI is neither exempt from nor subject to special rules beyond the standards already […]

In this episode, Scott Jenson, a veteran UX designer known for his work on the Macintosh, Google Maps, and Chrome examines the long-term stagnation of desktop operating systems and the limitations of current mobile and cloud-centric models. By Scott Jenson

Every self-hosted project I run starts the same way: a brand new VPS and about twenty minutes of setup before I install a single application. That twenty minutes is what separates "my server" from "someone else's crypto miner." A fresh box with a public IP starts getting probed within minutes, and the default configuration on most images is built for convenience, not safety. This is the secure baseline I set up on every new server, before Docker, before n8n, before anything else. It is also the starting point our production n8n guide assumes you already have. Every command below was checked against current Ubuntu LTS documentation, and I flag the parts that genuinely need a real server to verify. Key takeaways Never do daily work as root. Create a sudo user and log in as that instead. Use an SSH key and turn password login off, but only after you confirm the key works. Deny everything at the firewall by default, then open only the ports you actually use. Turn on automatic security updates so patches land while you sleep. If you plan to run Docker, remember that published ports skip UFW. Bind them to 127.0.0.1 . Prerequisites A VPS running a current Ubuntu LTS. Both 24.04 "Noble Numbat" and 26.04 "Resolute Raccoon" work well. I run long-lived boxes on Hostinger VPS hosting , which is also what powers the n8n guide. An SSH key pair on your own machine. If you do not have one yet, Step 3 creates it. A terminal, and a note of your provider's recovery console. Most hosts, Hostinger included, give you a browser based console in their control panel. That is your way back in if you ever lock yourself out, so find it before you start. Disclosure: some links in this guide, including the Hostinger link above, are referral or affiliate links. If you sign up through them we may earn account credit or a commission, at no extra cost to you. We only point at tools we actually run. Step 1: Log in and update the system Right after the server boots, log in with the credentials your pr

Hey all 👋 Last episode a power cut exposed an uncomfortable fact: my cluster's entire memory lived in one SQLite-flavored database, on one laptop, bound to one Wi-Fi address, guarded by one aging battery. Four single points of failure in a trench coat. The fix isn't making that database unkillable. The fix is making it unimportant . If every manifest lives in git and something reconciles the cluster against git continuously, then "the datastore died" stops being a tragedy and becomes a reboot with extra steps. So: Flux . Here's the setup, and the four ways I face-planted installing it. 🗂️ The Shape of the Repo clusters/homelab/ flux-system/ <- Flux writes this at bootstrap; hands off infrastructure.yaml <- points at infrastructure/ apps.yaml <- points at apps/ infrastructure/ controllers/ <- Longhorn + Envoy Gateway HelmReleases configs/ <- GatewayClass, Gateway, StorageClasses apps/homelab/ airflow/ <- the actual point of all this Three Flux Kustomizations, chained: infra-controllers → infra-configs → apps , via dependsOn . That chaining is not decoration. My GatewayClass can't exist until Envoy Gateway's CRDs exist, and the CRDs arrive with the controller's Helm chart. Without dependsOn , Flux sprints ahead, tries to create a GatewayClass into a cluster that's never heard of GatewayClasses, and fails with the enthusiasm of a golden retriever running into a glass door. dependsOn plus wait: true turns that into: install controllers, wait until healthy , then configs, then apps. Boring. Sequential. Correct. The three great virtues. 🔑 Sidequest 1: The Token Bureaucracy flux bootstrap github needs a GitHub token, and the docs-diving summary is: Classic PAT: repo scope. Needed if Flux should create the repo. Fine-grained PAT (pre-created repo): Contents read/write, Metadata read, and — the one everyone misses — Administration read/write , because Flux installs an SSH deploy key on the repo, and deploy keys are an admin operation. Here's the nice part: the deploy key is

If you use Claude Code for both work and personal projects, you've probably hit this: switching accounts means logging out, logging back in, and losing whatever session state you had. It's a small friction that adds up fast if you're context-switching several times a day. The fix is one environment variable: CLAUDE_CONFIG_DIR for both work and personal projects, you've probably hit this: switching accounts means logging out, logging back in, and losing whatever session state you had. It's a small friction that adds up fast if you're context-switching several times a day. Running Multiple Claude Code Accounts on Linux - Writing Run separate Claude Code accounts on Linux with CLAUDE_CONFIG_DIR — manual setup, an automation script, direnv auto-switching, and VS Code integration. sakibullah.me

Every AI redesign of my portfolio looked different and was the same filing cabinet underneath. What a style guide couldn't fix — and the one instruction that did.

In alignment with security compliance standards, the Nautilus project team has opted to impose restrictions on crontab access. Specifically, only designated users will be permitted to create or update cron jobs. Configure crontab access on App Server 3 as follows: Allow crontab access to rose user while denying access to the rod user. Solution Step 1: Connect to App Server 3 (stapp03) ssh banner@stapp03 # Password: BigGr33n Step 2: Switch to root or use sudo sudo su - # Password: BigGr33n Step 3: Create the cron.allow file with user rose echo "rose" > /etc/cron.allow Step 4: Add rod to cron.deny file (optional but ensures denial) echo "rod" >> /etc/cron.deny Note: If cron.allow exists, cron.deny is ignored. However, it's good practice to maintain both. Step 5: Verify the configuration # Check cron.allow file cat /etc/cron.allow # Check cron.deny file cat /etc/cron.deny # Test rose user access su - rose -c "crontab -l" 2>&1 # Test rod user access su - rod -c "crontab -l" 2>&1 Complete One-Line Commands From jump host with password: echo 'BigGr33n' | ssh banner@stapp03 "sudo -S bash -c 'echo rose > /etc/cron.allow && echo rod > /etc/cron.deny && echo \" === cron.allow === \" && cat /etc/cron.allow && echo \" === cron.deny === \" && cat /etc/cron.deny'" From jump host using heredoc: ssh banner@stapp03 << ' EOF ' echo 'BigGr33n' | sudo -S bash -c ' echo "Creating cron.allow with rose..." echo "rose" > /etc/cron.allow echo "Creating cron.deny with rod..." echo "rod" > /etc/cron.deny echo "" echo "=== Verification ===" echo "cron.allow contents:" cat /etc/cron.allow echo "" echo "cron.deny contents:" cat /etc/cron.deny echo "" echo "Testing rose user (should have access):" su - rose -c "crontab -l" 2>&1 || echo "No crontab for rose (expected)" echo "" echo "Testing rod user (should be denied):" su - rod -c "crontab -l" 2>&1 ' EOF Step-by-Step Interactive Commands # Connect to stapp03 ssh banner@stapp03 # Enter password: BigGr33n # Become root sudo su - # Enter password: B

At xFusionCorp Industries, the Stratos Datacenter houses a jump host server that stores template XML files essential for the Nautilus application. Prior to their use, these files need to be populated with valid data. As part of regular maintenance, the system administration team utilizes various string and file manipulation commands to prepare these templates. Your task is to substitute all occurrences of the string Text with Echo-Location within the XML file located at /root/nautilus.xml on the jump host server. Solution Step 1: Connect to the Jump Host Server ssh thor@jump-host # Password: mjolnir123 Step 2: Switch to root sudo su - # Password: mjolnir123 Step 3: Verify the file exists and check its content # Check if file exists ls -la /root/nautilus.xml # View the file content (optional) cat /root/nautilus.xml Step 4: Substitute all occurrences of "Text" with "Echo-Location" Method 1: Using sed (Recommended) sed -i 's/Text/Echo-Location/g' /root/nautilus.xml Command breakdown: sed : Stream editor for filtering and transforming text -i : Edit files in-place (without backup) s/Text/Echo-Location/g : Substitute all occurrences s : Substitute command Text : Pattern to search for Echo-Location : Replacement string g : Global (replace all occurrences, not just the first) Method 2: Using sed with backup (Safer) sed -i .bak 's/Text/Echo-Location/g' /root/nautilus.xml This creates a backup file nautilus.xml.bak before making changes. Step 5: Verify the changes # View the modified file cat /root/nautilus.xml # Check for any remaining "Text" strings grep -n "Text" /root/nautilus.xml # Check for "Echo-Location" strings grep -n "Echo-Location" /root/nautilus.xml # Count occurrences replaced grep -o "Echo-Location" /root/nautilus.xml | wc -l Complete One-Line Commands From jump host directly (as root): sed -i 's/Text/Echo-Location/g' /root/nautilus.xml && echo "✓ Substitution complete" && grep -c "Echo-Location" /root/nautilus.xml From jump host with sudo: sudo sed -i 's/Text

If you searched for a klogg alternative , you probably already know klogg is good. It is fast, it is free, it is open source, and it runs on Windows, macOS and Linux. Most people who go looking for something else are not unhappy with klogg as a viewer. They are unhappy with one specific moment in their day: Opening the file again. You investigated a 48GB log yesterday. You closed it. This morning your colleague asks about a different error, and you have to wait through the whole index build a second time. On a USB HDD that is nine minutes of staring at a progress bar — and while it builds, klogg only shows you the beginning of the file. That is the problem this article is about. Below is a measured comparison on a real 47.73GB file, including the rows where klogg wins . The test File OpenStreetMap Japan japan-latest.osm — 47.73 GB, 892,239,125 lines Machine MacBook Air / Apple M4 (10 cores) / 32GB RAM Storage (measured with dd ) USB HDD 0.10 GB/s ／ USB SSD 0.41 GB/s ／ Internal SSD 3.29 GB/s Versions klogg 24.11.0 ／ UwView Pro Search hit counts were verified to match exactly across klogg, UwView Pro, and a direct search of the raw file — so we know both tools are answering the same question. The numbers klogg 24.11.0 UwView Pro Ratio First open HDD ~9 min ／ USB SSD ~110 s ／ Internal SSD ~15 s — every time HDD 10.6 min ／ USB SSD 138.5 s ／ Internal SSD 23.3 s — first time only klogg wins Reopening Same as the first open (re-indexes every time) 0.01–0.07 s ~1,250–50,000x Search, literal "Tokyo" ~585 s ／ 120–135 s ／ 15–20 s 74.8 s ／ 14.3 s ／ 5.1 s ~7.8x ／ ~9x ／ 3–4x Search, regex "Tok[yi]o" ≈ literal (I/O bound, pattern-independent) 29.8 s (USB SSD) ／ 11.0 s (Internal SSD) ~4.4x ／ ~1.5x Disk used to keep the file 48 GB (original required) 5.3 GB (original can be deleted) 1/9 Two things are worth saying plainly. klogg opens the file faster the first time. UwView Pro is slower on the first open because it is building a compressed cache while it reads. That is a real cost a

I’m setting up a local AI development environment on Windows + WSL2 and I’m trying to decide between two architectures. Option 1 — Ollama/Models on Windows WSL2 ┌───────────────────┐ │ Application │ │ ├── Python │ │ ├── .venv │ │ └── Source code │ └───────┬───────────┘ │ HTTP localhost:11434 │ ▼ Windows ┌───────────────┐ │ Ollama │ │ ↓ │ │ Models │ │ ↓ │ │ GPU │ └───────────────┘ Option 2 — Ollama/Models inside WSL2 WSL2 ┌─────────────────────────┐ │ Application │ │ ↓ │ │ Ollama │ │ ↓ │ │ Models │ └────────────┬────────────┘ │ GPU access │ ▼ Windows ┌─────────────────────────┐ │ GPU / Driver │ └─────────────────────────┘ My current setup is Option 1 , and it works: WSL2 can access the Windows Ollama API through localhost:11434. But I’m wondering if Option 2 is a better long-term architecture for local AI/LLM development. I’m especially interested in: 🚀 Performance 🎮 GPU utilization 🧠 Model management 💾 Disk usage 🔧 Setup and maintenance 🐧 Linux/ML tooling 🐳 Docker integration 🌐 Networking 📈 Future scalability If you use Ollama with Windows + WSL2, which architecture would you choose and why? And if you've actually used both setups, I'd especially like to hear about your experience. 👇 Option 1 or Option 2?

In remote software demos, the biggest problem is not always the product itself. Sometimes the audience simply doesn’t know where to look. A button may be visible. A setting may already be on screen. The presenter may be explaining everything correctly. But if attention isn’t directed clearly, people can still get lost. After doing a lot of screen sharing and software demos, I kept noticing the same small UX problems. 1. The cursor is visible, but not necessarily noticeable When you're presenting your own screen, you always know where your pointer is. The audience doesn’t. On a large monitor, a compressed video call, or a busy application UI, the pointer can easily disappear visually even though it is technically visible. This becomes especially obvious when you say something like: “If you look over here…” You know exactly what “here” means. The audience may need another second or two to find it. That delay sounds minor, but during a demo it can happen again and again. A presenter moves on to the next step while part of the audience is still trying to locate the previous one. 2. Moving the pointer is not the same as directing attention A common workaround is to move the mouse around whatever you want people to notice. I’ve done this many times myself. Circle the button with the cursor. Move back and forth over a chart. Quickly point between two settings. It works, but it also adds visual noise. Eventually I realized there are really two different actions happening: Navigation — using the mouse to operate the software. Attention — telling the audience where to look. During a demo, those aren’t always the same thing. Sometimes I don’t want to click anything or change the interface. I just want to say: Look here. 3. Highlighting something can interrupt the demo There are plenty of powerful screen annotation tools available. They make sense when you want to draw arrows, write notes, add shapes, or explain something in detail. But during a live product demo, switching int

📝 Originally published (in Japanese) at forge.workstyle.tech . The Challenge of "Silence" in Unmanned AI Avatar Live Streams When creating a live stream where an AI avatar operates autonomously, the first major hurdle you encounter is the issue of "silence." It’s not that there are no viewers—quite the opposite. Yet the avatar falls silent for long stretches, or ignores comments for tens of seconds. What human streamers do unconsciously—creating "space" in the conversation—is entirely missing from AI behavior. In this article, I’ll summarize two key challenges we tackled to prevent unmanned streams from becoming boring. The first: how to fill the silence when no comments arrive. The second: how to handle response delays when comments do arrive. The former deals with behavior during "no input," while the latter concerns the time between input and reaction. Both are two sides of the same coin in live streaming, and neither worked with a straightforward implementation. What they had in common was that brute-force attempts to "make it faster" or "make it smarter" missed the mark. We had to observe long-running streams, measure breakdowns, and redesign priorities—mundane but essential work. Reactive Alone Doesn’t Make a Stream Our initial implementation was straightforward: "Respond when a comment arrives." Functionally, it worked correctly and passed tests. The problem was what happens when no comments arrive. In an unmanned stream, the avatar stands frozen on screen for tens of seconds—blinking, but doing nothing. This is nearly an accident for a live stream. And for newly launched channels, this is the default state. Comments come only after the stream has grown; until then, silence is the norm. This was a design philosophy issue. If built as a chatbot, the AI only outputs in response to input —just like a web request/response model. But a streamer is different. Their job is to keep talking even when no one says anything. So we needed a mechanism that generates speech

When testing opinionated Linux distributions, the ultimate benchmark isn't how smoothly they run on a workstation with 16 cores and a high-end GPU—it's how gracefully they perform on budget, resource-constrained hardware. Enter Omarchy , the "omakase" Arch-based distribution created by David Heinemeier Hansson (DHH) . Built around the Hyprland tiling window manager and explicitly tailored for modern developer productivity, Omarchy proves that a curated desktop environment doesn't require a heavy computing footprint. Running Omarchy 4.0.0 on an entry-level laptop built around an Intel Celeron N4020 CPU demonstrates how deliberate software curation turns modest hardware into a fast, highly capable development machine. 💻 Hardware & System Overview Below is the environment breakdown from our test run: Category Specification / Details Hardware / PC Model ASUS C204M Processor Intel® Celeron® N4020 (2 cores / 2 threads) @ 2.80 GHz Graphics Integrated Intel UHD Graphics 600 Display 11" Built-in Display (1366x768 @ 60 Hz) RAM Utilization 2.69 GiB / 3.68 GiB (~73% load) Storage / Root 15.66 GiB / 27.10 GiB (~58% used) on Btrfs OS & Kernel Omarchy 4.0.0-1 (Linux Kernel 7.1.8-arch1-3) Compositor Hyprland 0.56.2 (Wayland) 🚀 The Developer Experience: What Makes Omarchy Special Omarchy isn't just an Arch installer with custom dots; it's an opinionated operating system designed to eliminate setup friction and let you write code immediately. 1. Zero-Friction Language Setup via Menus Setting up language runtimes on a fresh Linux install often involves hunting down version managers (like asdf , nvm , or pyenv ), configuring shell initialization scripts, and managing system paths. Omarchy streamlines this entirely. Through its integrated menu system, installing a programming language or developer stack is as simple as launching the system menu, picking a language (Node.js, Ruby, Python, Go, Rust), and hitting Enter. The system automatically installs the necessary version managers, conf

I am the Arthur of this blog, and I want to tell you about something I have been exploring recently: how a VPS can become more than just a place to host a website . When people hear the word VPS, they usually think about web hosting, servers, domains, or websites. But a VPS can actually be a useful environment for developers who want to learn Python, automation, AI tools, Linux, APIs, and practical server management . You don't need to start with a huge cloud infrastructure or an expensive dedicated server. Sometimes, a simple VPS with Linux, Python, and a few useful tools is enough to start learning by building real projects. In this article, I will show you how these pieces fit together and how you can create a small practical project on a VPS. What Is a VPS? A VPS (Virtual Private Server) is a virtual server that gives you your own allocated environment inside a physical server. Compared with traditional shared hosting, a VPS gives you much more control. You can usually: Install your own software Run Python applications Configure Linux packages Create databases Run background scripts Host APIs Deploy websites Manage services with SSH Automate repetitive tasks For developers, this control is one of the biggest advantages of VPS hosting. Instead of only uploading website files, you can actually use the server as a small development and deployment environment. Why VPS Is Useful for Learning New Skills One thing I have learned while working with technology is that reading about a skill is very different from actually using it. For example, you can read ten tutorials about Python automation, but running your own Python script on a Linux server teaches you something completely different. You start understanding: Python ↓ Application ↓ Linux Server ↓ VPS ↓ Internet This is where a VPS becomes interesting. You can build a small application locally, move it to the VPS, configure the environment, and make it available online. That single process teaches several skills at o

Linux server running out of memory? Learn how to diagnose and fix high memory usage with real commands — before it takes down your app. Your app starts slowing down, the OOM killer fires, or your monitoring page turns red — and the culprit is memory. High memory usage on a Linux server is one of the most common production crises for small teams, and it's easy to misread. Linux intentionally uses most of your RAM for caching, so a server showing 95% memory used isn't necessarily in trouble. But one that's exhausting real working memory and swapping is. Here's how to tell the difference and actually fix it. Step 1: Get a Clear Picture of What's Using Memory Start with the basics. Run 'free -h' to see total, used, free, and available memory. Focus on the 'available' column — that's the real number. It accounts for reclaimable cache and is far more useful than 'free'. free -h — quick overview of RAM and swap usage vmstat 1 5 — five one-second snapshots; watch the 'si' and 'so' columns for swap-in and swap-out activity cat /proc/meminfo — full breakdown including Slab, PageTables, and AnonPages If swap is actively being used (si/so values above zero consistently), your server is genuinely memory-constrained. That's different from swap space existing but sitting idle. Step 2: Find the Processes Eating Your RAM Once you know memory is tight, you need to know what's consuming it. Run 'ps aux --sort=-%mem | head -20' to list the top 20 processes by memory percentage. For more detail on actual RSS (resident set size) in human-readable form: ps -eo pid,ppid,cmd,%mem,rss --sort=-%mem | head -20 RSS is the memory a process actually holds in RAM — not virtual memory, which is often misleadingly large. Another useful tool is 'smem', which calculates PSS (proportional set size) and gives a fairer view when processes share memory libraries. Install it with 'apt install smem' or 'yum install smem', then run 'smem -r -k | head -20'. Look for processes with unexpectedly high RSS. A Nod

Disclosure up front: I'm Vitalii, founder of PDFik , a hosted URL/HTML-to-PDF API. It shows up once near the end, clearly marked. The rest of this is the debugging guide I wish existed the last three times someone hit these errors. If you run wkhtmltopdf in containers, you have probably met at least one of these three errors: sh: /usr/local/bin/wkhtmltopdf: not found # Alpine wkhtmltox : Depends: libssl1.1 but it is not installable E: Unable to locate package wkhtmltopdf # Ubuntu 24.04 / Debian 13 All three have the same root cause: the project is archived (January 2023, repository read-only ) and the last official packages were built in May 2023 — release 0.12.6.1-3 , whose newest targets are Debian 12 (bookworm) and Ubuntu 22.04 (jammy). The distros kept moving; the binaries stopped. Here is what each error actually means, the recipe that still works in 2026, and the honest exits. Error 1: not found on Alpine — it's not about PATH The confusing part: the file is there, ls sees it, and the shell still says not found . That message comes from the kernel failing to load the binary's interpreter: official wkhtmltopdf builds link against glibc , Alpine ships musl , and the referenced dynamic loader ( /lib64/ld-linux-x86-64.so.2 ) does not exist on Alpine. ldd /usr/local/bin/wkhtmltopdf shows it immediately. There is no supported way around it on Alpine today: the distro dropped its wkhtmltopdf package years ago (nothing in current stable), and gcompat shims are a lottery with a binary this large. If the container must run wkhtmltopdf, don't build it on Alpine — that fight is not worth the ~50 MB you save. Error 2: Depends: libssl1.1 — you're installing a 2020 build on a 2023+ distro The widely-copied Dockerfiles fetch wkhtmltox_0.12.6-1.*.deb , which links OpenSSL 1.1. Debian 12, Ubuntu 22.04+ and everything after ship OpenSSL 3 and removed libssl1.1 from the archives, so the dependency is unresolvable. (Pinning an EOL base image or hand-installing an EOL libssl to wor

From Termux to a Freestyle VM: My Osintgram and HikerAPI Experiment After experimenting with Osintgram directly in Termux, I wanted to see how the same project behaved inside a Linux environment running through a Freestyle VM. The idea was not simply to reproduce the installation. I wanted to understand whether moving the project into the VM would make the HikerAPI troubleshooting any clearer. Why use a VM? Termux is capable of running many command-line tools directly on Android, but a VM provides a more conventional Linux environment. I connected to the Freestyle VM from Termux and worked with Osintgram from there. The project could start, but the API side still required investigation. The dependency confusion One of the first things I noticed was that there were multiple API-related components involved. I initially looked at the installed "hikerapi" package and its "Client" class. That alone wasn't enough to explain what Osintgram was doing. So I switched from inspecting only the Python environment to inspecting the project's source code. The HikerAPI-related code pointed me toward: src/hikercli.py This was much more informative because it showed where the client was being configured and how the access token entered the application. Checking the installed library I also checked the installed HikerAPI package rather than assuming I had the expected version. For example: python3 -m pip show hikerapi This let me verify the package that was actually installed in the VM. The important point here is that checking a package version and understanding how the application uses that package are two different troubleshooting steps. Separating authentication from Osintgram I found it useful to test the API independently instead of using Osintgram as the only diagnostic tool. For example: import requests headers = { "x-access-key": "YOUR_KEY" } r = requests.get( " https://api.hikerapi.com/v2/user/by/username?username=natgeo ", headers=headers ) print(r.json()) Again, "YOUR_KEY"

1. Retomando: o que é o Fzf Na primeira parte desta série vimos o que é o fzf, como instalá-lo e como usá-lo direto no shell com Ctrl+R , Ctrl+T e Alt+C . Quem também usa tmux no dia a dia ganha um segundo nível de integração: o fzf pode rodar dentro de janelas flutuantes (pop-ups) do próprio tmux, sem interferir no layout de painéis já aberto, e servir de seletor para operações do próprio tmux — trocar de sessão, de janela, de painel, matar processos em outro painel etc. 2. Por que integrar Fzf com Tmux Sem integração, usar o fzf dentro de uma sessão tmux funciona normalmente, mas cada busca ocupa o painel inteiro: se o objetivo é só escolher um arquivo ou trocar de branch rapidamente, o conteúdo do painel (um editor, um servidor rodando) é temporariamente coberto e é preciso "voltar" depois. Além disso, o tmux tem sua própria lista de coisas que fazem sentido filtrar de forma fuzzy — sessões, janelas, painéis — e não há um binding nativo do tmux para isso. O fzf-tmux , incluído na instalação do fzf, resolve o primeiro problema: roda o fzf em uma janela sobreposta (pop-up ou split temporário) que desaparece assim que a seleção é feita, sem afetar o conteúdo do painel original. Combinado com bindings customizados no tmux.conf , também resolve o segundo. 3. fzf-tmux: pop-ups nativos fzf-tmux é um wrapper de shell em torno do fzf que aceita as mesmas opções, mais flags de posicionamento e tamanho da janela sobreposta: # pop-up centralizado, 80% da largura e 60% da altura do terminal fzf-tmux -p 80%,60% # split na parte de baixo do painel atual, ocupando 40% da altura fzf-tmux -d 40% # split lateral à direita, ocupando 50% da largura fzf-tmux -d 50% -r A flag -p (disponível a partir do tmux 3.2, que suporta display-popup ) é a mais usada hoje: cria uma janela verdadeiramente flutuante, sobreposta ao conteúdo do painel, que não reorganiza o layout existente — diferente do -d , que faz um split real e temporariamente redistribui o espaço entre painéis. # substitui o Ctrl