标签：#tor

Home theater projectors are getting better and better, and have quickly become my favorite way to enjoy movies.

How to get a photo below a strict KB limit Many government portals, job forms, school applications, and support websites reject an otherwise valid photo because it is larger than a fixed limit such as 100 KB or 200 KB. Standard gallery apps usually offer cropping or a quality percentage, but they do not tell you whether the final file will meet a specific upload limit. That is the problem I built FormFit to solve on Android. Why exact-KB compression is tricky File size depends on more than width and height. Image detail, color variation, output format, and compression quality all affect the result. A quality setting that works for one photo may leave another photo far above the required size. FormFit works toward a maximum KB target and adjusts the generated copy for you. The practical goal is to create a file at or below the limit while keeping it as clear as possible. Compress a photo on Android Install FormFit from Google Play . Open the photo-compression tool and select the image you need to upload. Enter the maximum file size required by the website or form. Optionally resize the image dimensions or choose JPG, PNG, or WebP for the generated copy. Run the compression, review the result, and save or share the new file. The original photo is not replaced. FormFit creates a separate output copy, so you can compare the result before uploading it. Remove metadata from generated copies Photos can contain metadata such as device or capture information. When you only need to submit the visible image, FormFit can remove metadata from the generated copy. This does not change the original file. Turn several photos into one PDF Some forms ask for a single PDF instead of multiple image files. FormFit can combine up to 20 selected photos into one PDF directly on the phone. This is useful for receipts, scanned notes, application documents, and other small document sets. On-device processing The selected photos and PDFs are processed on the Android device. FormFit does not req

Ask a team how their RAG pipeline works and they will tell you about the embedding model, the vector database, and maybe the reranker. Ask them how they chunk their documents and you will usually get "uh, 500 tokens with some overlap? Whatever the default was." That default is quietly deciding the quality of every answer the system gives. Chunking is the highest-leverage, least-discussed decision in a RAG pipeline , and I want to convince you of that with concrete examples rather than hand-waving. The refund policy that got sliced mid-sentence Say your docs contain this refund policy: ## Refund policy Customers may return items within 30 days of delivery for a full refund. Items must be unopened and in original packaging. Opened electronics are subject to a 15% restocking fee. Sale items are final and cannot be returned unless defective. Defective items can be returned within 90 days regardless of sale status. Now run it through a fixed-size chunker, the kind that cuts every N characters. Depending on where the boundary lands, you can get a chunk like this: original packaging. Opened electronics are subject to a 15% restocking fee. Sale items are final and cannot be returned unless A user asks "can I return a sale item?" The retriever finds this chunk (it literally contains "Sale items are final and cannot be returned unless") and hands it to the model. The model reads it and answers "sale items are final and cannot be returned." The critical exception, "unless defective," was decapitated by a character boundary. The 90-day defective window lives in a different chunk that scored lower and never made it into the prompt. Nothing in your stack is broken. The embedding model is fine, the vector database is fine, the LLM did exactly what the context told it to. The answer is still wrong, and it is wrong because of an off-by-one in a splitting function nobody has looked at since the prototype. A heading-aware chunker would have kept the whole "Refund policy" section toget

The Evolution of Web Forms Part-1 — From Plain HTML to AJAX Modern React forms can feel unnecessarily complicated when you first encounter tools such as React Hook Form, Zod, resolvers, controlled inputs, refs, formState , and server-error handling. Why do we need all of that? Why not simply read the value from an input and send it to the server? To understand why modern form libraries exist, we need to understand the problems developers faced before those libraries were created. In this series, we will evolve the same idea step by step: Plain HTML ↓ Native HTML validation ↓ JavaScript validation ↓ AJAX submission ↓ React controlled forms ↓ Form libraries ↓ React Hook Form ↓ React Hook Form + Zod ↓ Production form architecture This first part covers the first four stages: Plain HTML forms Native HTML validation Vanilla JavaScript validation AJAX form submission By the end, you will understand how forms worked before React and why each new approach became necessary. Stage 1: Plain HTML Forms Before React, AJAX, or even large amounts of client-side JavaScript, browsers already knew how to submit forms. HTML forms are not just visual containers. They are a built-in browser mechanism for collecting data and sending an HTTP request. A basic registration form <!DOCTYPE html> <html lang= "en" > <head> <meta charset= "UTF-8" /> <meta name= "viewport" content= "width=device-width, initial-scale=1.0" /> <title> Registration Form </title> </head> <body> <h1> Create an account </h1> <form action= "/register" method= "POST" > <div> <label for= "username" > Username </label> <input id= "username" name= "username" type= "text" /> </div> <div> <label for= "email" > Email </label> <input id= "email" name= "email" type= "email" /> </div> <div> <label for= "password" > Password </label> <input id= "password" name= "password" type= "password" /> </div> <button type= "submit" > Register </button> </form> </body> </html> There is no JavaScript in this example. The browser handles the ent

A frozen desktop window is a state, not a diagnosis. Windows adds Not Responding when the UI thread stops processing messages for long enough. That can happen because the application is doing legitimate work, waiting for disk or network I/O, blocked by another process, stuck behind a modal dialog, or caught in a real deadlock. Reinstalling may replace files, but it does not tell you what the process was waiting for. Preserve a few minutes of evidence first. Define the symptom precisely Keep these cases separate: Slow: the window still repaints and eventually accepts input. Not responding: the frame is visible, but Windows reports that the app is not processing messages. Blank: the frame appears while the content surface fails to render. Invisible: the process runs without a visible main window. Crash: the process exits and may create an application error event. This distinction matters. A blank WebView surface and a blocked UI thread can look similar to a user, but they leave different evidence. Use one repeatable action Restart the application once and perform the smallest action that reproduces the freeze. Record: the exact click or file that triggers it; the time the action starts; how long the window remains responsive; whether CPU, disk, or network activity changes; whether the process recovers without being terminated. Avoid opening several test files or clicking repeatedly. Extra input can queue more work and hide the original transition. Watch the process before ending it Open Task Manager and identify the correct process ID. Expand child processes if the application uses helpers or a web-rendering runtime. Useful observations include: High sustained CPU: a loop, intensive parsing, OCR, compression, or rendering work is plausible. Near-zero CPU with disk activity: the process may be waiting for storage. Near-zero CPU with network activity: an online request, proxy, DNS, or TLS operation may be blocking progress. Near-zero activity everywhere: look for a hidd

How to Extract Colors From an Image Using JavaScript and Canvas Have you ever looked at an image and wanted to know the exact HEX color of a particular pixel? Designers often need to extract colors from photographs, screenshots, logos, UI designs, and illustrations. You can do this directly in the browser without uploading the image to a server. The browser Canvas API gives us everything we need. Reading pixels with Canvas The basic process is: Load an image. Draw it onto a canvas. Read the pixel data. Convert the RGBA values into a color format such as HEX or RGB. The important API is getImageData() . javascript const imageData = ctx.getImageData(x, y, 1, 1); const pixel = imageData.data; const r = pixel[0]; const g = pixel[1]; const b = pixel[2]; const a = pixel[3];

Google is introducing HEIR (Homomorphic Encryption Intermediate Representation), an open-source compiler and development toolchain designed to make encrypted computation easier to deploy. In particular, HEIR can compile pre-trained AI models built for conventional, unencrypted inputs so they can instead operate on encrypted data. By Sergio De Simone

Introduction Managing files locally or manually in your own pc gets out of hand very fast. You might find that you have a file named project_final_1 and project_final_2 which are about the same project but named differently depending on the day the projects were updated or modified. Git Bash is a command line tool that records detailed history of your code as it changes over time GitHub is an online tool where the changes in your code are stored remotely. GitHub does not use folders instead it uses repositories. The repositories make it easier for you to store your work, have a back-up of your work and also showcase your portfolio. Step 1:Installing Git First you have to install git depending on your operating system. Once installed open git bash and you have to tell Git who you are. The code below will help you set up git for the very first time git config --global user.name "put your name here" git config --global user.email "put your email here" After configuration you have to verify your installation with the code below git --version Adding SSH Key For your git to be connected to git hub you have to genarate an ssh key. The key allows your git to access your github without much stress. First you open your terminal or git bash terminal and run the code below to generate the SSH key. ssh-keygen -t ed25519 -C "enter your email here" This code will prompt you on your terminal to save the key on its default location, press enter. Next you will be prompted to enter a passphrase, for easy access and to elimate the chances of forgetting the passphrase you entered just press enter twice. Now you have a public key saved in your pc, use the command below to copy the key. cat ~/.ssh/id_ed25519.pub Adding the Key to GitHub Login into github, click on your profile picture in the top left corner and select settings . in the left navigation bar click SSH and GPG keys . Click the New SSH key button. Give a description of your key (eg .my work laptop), in the drop down menu make

A podcast host recently told me that he prepares questions from the guest’s bio using ChatGPT. That works for the basics, but a bio does not show which stories the guest has repeated across other interviews or which questions they have already answered many times. I’m helping Audiogram test a different workflow. It connects to Claude through MCP, searches Apple Podcasts, retrieves available episode transcripts, and lets Claude compare the guest’s previous answers before drafting new questions. For one test, I used two published Sam Altman interviews. The workflow pulled both available transcripts, separated recurring themes from open gaps, and produced follow-up questions around measurable evidence, privacy limits, and independent review—rather than repeating another general “will AI be good or bad?” question. The prompt is simple: Prepare an interview brief for [guest] about [interview angle]. Find podcast episodes where the guest is actually interviewed, retrieve the available transcripts, and compare them. Show recurring themes, changes in position, questions already answered, and five follow-up questions based on gaps or unsupported claims. Cite the podcast and episode for every finding. Separate transcript evidence from inference, and say what is missing when the available material is not enough. This is for research across published Apple Podcasts episodes. It is not a raw-audio editor, and transcript availability and speaker labels still need to be checked. You can see the complete recipe and tested example here: Podcast guest interview preparation with Audiogram If you prepare podcast interviews, would previous-interview comparison improve your questions, or is another part of guest research still the bigger problem? Disclosure: I’m helping Audiogram with early-user growth and used AI to help edit this post.

AI agents can look reliable after one impressive demo and still fail the moment real users, messy repositories, and conflicting instructions enter the room. The dangerous part is not that an agent makes mistakes. The dangerous part is that teams often change agent rules based on vibes, not evidence. If you are building an AI feature, internal coding agent, support assistant, research workflow, or automation layer, your standards need tests. Not just model evals. Not just unit tests. You need a way to answer a practical question: Did this new rule, skill, prompt, or tool instruction actually make the agent better? This guide shows a lightweight experiment system for AI agent standards. You can use it before rolling out new agent instructions across a product, engineering team, customer workflow, or multi-tenant AI application. No vendor pitch. No magic framework. Just a repeatable way to stop guessing. Why Agent Standards Need Experiments Most teams already have standards for human developers: code review rules security policies testing expectations deployment checklists naming conventions observability requirements AI agents need the same kind of guidance, but they behave differently from humans and traditional software. A human may read a coding standard once and remember the intent. An agent may load the wrong instruction file, ignore a rule buried deep in context, over-follow a stale example, or select no skill at all. That means the main risk is not only bad instructions. It is unreliable instruction delivery. Recent practitioner discussion around agentic development points to the same pattern: teams are moving from simple prompts toward skills, rules files, context packs, tool registries, desktop agents, and workflow harnesses. At the same time, developers are asking harder questions about governance, cost, reliability, and whether agents can be trusted with production work. What Counts as an AI Agent Standard? An AI agent standard is any reusable instruction t

How a tiny little electronic switch sparked the computer revolution.

My First GitHub Project: From a Local Folder to GitHub Using Git and SSH Introduction This week I learned how to use Git, Git Bash, GitHub and setting up SSH Keys . Before this, I knew about GitHub but I did not really understand how a project moves from a folder on my computer to GitHub. A simple way I now understand the relationship is: Git manages the history of my project while GitHub provides an online home for the project. In this article, I will explain the steps I followed to create a simple project locally and push it to GitHub. Creating My Project I started by creating a folder for my project using Git Bash. mkdir Kenya-Hospital-Records-Analysis cd Kenya-Hospital-Records-Analysis Inside the folder, I created a README.md file and a folder called data . My project looked like this: Kenya-Hospital-Records-Analysis/ ├── README.md └── data/ The README.md file is where I can explain what my project is about while the data folder can be used to store datasets. In the data folder i uploaded an excel file called Kenyan_Hospital_Health_Records How to use Git The next step was to make Git start tracking my project. I did this using: git init I then used: git status This helped me see which files Git was tracking and which files had not yet been added. To add my files, I used: git add . I then saved the changes to Git using a commit: git commit -m "Initial commit" One thing I learned is that a commit is like saving a checkpoint of my project. The commit message helps explain what changes I made. Connecting Git to GitHub while generating SSH Keys To push my local project to GitHub, I needed a secure way for my computer to communicate with my GitHub account. I used SSH (Secure Shell). I first generated an SSH key on my computer and then added the public key to my GitHub account. An SSH key normally consists of two parts: Private key – stays securely on my computer. Public key – can be added to GitHub. One important lesson was that the private key should never be shared.

OVHcloud will raise prices from September, with 2026-edition gaming servers up 87 percent and other recent servers 40 to 59 percent. Founder Octave Klaba says memory cost six times more in June than a year earlier, as RAM suppliers shifted capacity toward high-bandwidth memory for AI. AWS, buying years ahead, has repriced one reserved GPU product. By Steef-Jan Wiggers

Buildroot builds a cross-compiler, a Linux kernel and a complete root filesystem from source, driven by one Kconfig-style configuration file. Starting from the qemu_arm_vexpress_defconfig that ships with Buildroot 2026.05.1, two commands produce a bootable ARM system you can run under QEMU. The images you ship are the ones in output/images/ ; output/target/ looks like a root filesystem but must never be copied to a device. This post starts a new hands-on series on Buildroot for embedded Linux. By the end of this part you will have built a working Buildroot root filesystem for an ARM target, booted it under QEMU, and understood which generated directories are safe to ship. Later parts add your own packages, a BR2_EXTERNAL tree, kernel and bootloader integration, and reproducible image output. If the choice between build systems is still open, our earlier Yocto vs Buildroot comparison covers it; this series assumes the decision is made. What you need A Linux host, several gigabytes of free disk space, and a network connection. No development board is needed for this part; QEMU stands in for the hardware. On a Debian or Ubuntu host, this covers the mandatory packages the manual lists, plus the ncurses development files that menuconfig needs: raghu@techveda.org:~$ sudo apt install build-essential diffutils patch gzip bzip2 perl tar cpio unzip rsync file bc findutils gawk wget libncurses-dev One rule from the manual is worth stating plainly: build everything as a normal user. Buildroot never needs root, and running it as root exposes your host to any package that misbehaves during installation. The command above is the only one in this post that uses sudo . Getting Buildroot and choosing a target Download and unpack the current stable release — 2026.05.1 at the time of writing — from buildroot.org/downloads , and work from that directory. Buildroot ships ready-made configurations for many boards and emulated machines, one file each in configs/ , and make list-defconfigs

Bluesky starter packs look like a single thing in the app — a shareable page that lets a new user follow a curated group in one tap. At the protocol level they are three separate records glued together by references, and if you create them from code (we do, as part of an automated outreach pipeline), the decomposition matters: it decides what you can update later, what you can only create once, and where a naive script will quietly make a mess. The three records Everything below is plain com.atproto.repo.createRecord / putRecord calls against your own PDS — no special API surface. 1. The list — app.bsky.graph.list . A starter pack is backed by an ordinary Bluesky list with purpose: app.bsky.graph.defs#referencelist . The list record itself holds metadata — name, purpose, createdAt, plus optional description and avatar. Members live elsewhere. 2. The memberships — app.bsky.graph.listitem . One record per member, each holding the member's DID and the list's AT-URI. There is no "add 20 members" batch call in the record layer: twenty members means twenty listitem creates. Plan for partial failure in the middle of that loop — more below. 3. The pack — app.bsky.graph.starterpack . The record that makes the share page exist. Per the lexicon, name , list , and createdAt are required; list is the AT-URI of the referencelist from step 1, the name is capped at 50 graphemes, and optional feeds can attach custom feeds. The official limits: up to 150 people, up to 3 feeds. The share URL is derivable, not returned: https://bsky.app/starter-pack/{your-handle}/{rkey} where {rkey} is the tail of the starterpack record's AT-URI. The trap: creation is not idempotent Every createRecord mints a fresh rkey. Run your create-starter-pack script twice and you have two packs with two URLs, both live, both indexed — and the one you already shared is not the one your script now reports. There is no natural key (like a title) that the protocol dedupes on. Our rules after learning this: Creation

Working through a practical reference to moving a change through Git took me through the process of taking a single change from my local computer, committing it in Git, and pushing it to GitHub where others would be able to see it. This was written for complete Git Novices and so I approached it without any prior experience of using Git. By the end, you will be able to move a change through all four Git stages and confirm it's visible on GitHub with a clear commit history. Who This Is For Anyone that want to work with Git in the terminal Users who find git add , git commit , and git push unclear No prior Git experience required Prerequisites Git installed ( git --version to check) A terminal or command-line application A GitHub account (create one if needed) We'll use a small sales data project as a running example. You do not need Python or Pandas installeda as we will be only tracking files, not running code. The Four-Stage Flow Every change travels in one direction: Working Directory → Staging Area → Local Repository → Remote Repository Working directory : where everything is worked on Staging area : choosing what goes in Commit : your historical record for everything worked on Push : share it so collaborators can see it Setup: Initialize a Repository Create a project folder and make it a Git repository: mkdir monthly-sales cd monthly-sales git init Expected output: Initialized empty Git repository in /path/to/monthly-sales/.git/ git init creates a hidden .git folder where Git stores the entire history. From now on, Git watches this folder. Usage 1. Working Directory (Untracked Files) Create a raw data file: echo "date,region,revenue" > sales_data.csv echo "2026-01-01,East,1200" >> sales_data.csv Check its status: git status Expected output: On branch main No commits yet Untracked files: (use "git add <file>..." to include in what will be committed) sales_data.csv Untracked means Git can see the file but isn't following it yet. This is the default for new files.

Introduction People, especially beginners, face challenges when making changes to their projects and pushing those changes to Github. Some of the challenges faced include Git command, authentification, configuration etc. This article aims to explain the process of building a Github project, from creating local directories/folders to uploading the project to Github using Git and secure shell(ssh). I will use a project titled Poor Performance in 2025 National Exams as a case example to illustrate the steps involved in creating a project. The process is outlined in the following steps: STEP 1: Creating directories The first step of a project is to establish a well organized directory structure. This helps keep project files organized logically, making them easier to manage, access and maintain throughout the development process. We create our project directories within Desktop and OneDrive. Desktop is basically a special directory used by windows to store files and shortcuts while OneDrive is a microsoft's storage store. In our case we start by navigating to the desktop directory using Git. For example, cd desktop means 'go to desktop' Next, Use ls to list all the directories and files in desktop. Once you have navigated the desktop directory, Proceed to making your first project directory. We use mkdir commandto create a new directory. For example, mkdir "Poor-performance-in-2025-National Exam" . Next, we create additional directories within our newly created project directory. In this case we will create a directory called Data, which will store the datasets required for the analysis. For example, mkdir data STEP 2: Creating Files Files are essential part of building a project. In this step, we will create a README.md file. A README.md gives an overview of the project and describes its purpose, structure and usage in a clear and understandable way. README.md is written using Markdown language. we use touch to create files. For example, touch README.md STEP 3: Printin

You have probably written HTML forms before, and so the structure below resonates with you. Perhaps you even smile because, this one, you understand. <form> <input type= "text" /> <button> Submit </button> </form> If you have done this, you know what happens when you click the button. The whole form reloads, the changes or inputs are cleared. This is the default behavior of forms in HTML. In React, we handle every step and every stage so that we have control over the data and the behavior of the form and data. The above signature represents what we call UNCONTROLLED INPUT . This means that there isn't a single source of truth to the value of this field, hence it can change to anything, and any value In addition to the above attributes, we will add value and onChange props to the input element as below: <input type= "text" value= {} onChange= {}/ > value represents the content of the input field e.g. the name text that the user enters in a Name field. onChange is the function that will be triggered everytime the input changes. Whenever a key is pressed within this field, this function will be invoked. Controlled inputs have their values set and manipulated by states, as we saw in Part 1 of the series. Uncontrolled inputs on the other hand do not have a manager that will dictate what goes into the field and when. Now let's write our first React Input, we'll keep it simple. import { useState } from " react " function Form (){ const [ name , setName ] = useState ( "" ) return ( < input type = " text " value = { name } onChange = {( event ) => setName ( event . target . value )} / > ) Let's look at what happens in the above. We have declared a state [name,setName] . name is the state variable setName is a function used to update the variable We then initialized an input element with properties value and onChange Note that, when the value of an input is set, that will always be the value even if you type something into the box. That is the essence of controlled input. The

Introduction In this article I will explain my practical experience of creating Git repository,connecting it to GitHub using SSH,commiting my files and pushing the project to a remote repository. Step 1 :Creating My Local Project The first step is to create a folder through file explorer which as the best option for me and name it (my-project) Next step was to open GitBash and run the command cd my- project To open the file directory Step 2 : Initializing Git This is to tell Git that my my-project folder should become a Git repository. To initialize Git I ran the command: git init Step 3:Repository Status Check After initializing Git, I used : git status This command is very useful as it can be used throughout the process it tells what's happening inside my repository. At some point people may encounter: On branch main Nothing to commit, working on a tree clean It could seem like an error,however I learned that this means Git has checked my project and found no changes that need to be committed. Another situation that I encountered is where Git told me that the older my project was already initialized .This taught me to use the command: git status To understand the current status of my project. Step 4:Connecting GitHub Using SSH The next thing I learnt was on how to generate SSH key which will be used to connect my computer securely to GitHub. To generate an SSH key I ran the command: ssh-keygen -t ed25519 -C "your_email@example.com" Under the double quotes use the email used for your GitHub account. Then press entre to save it on the default location. You'll then be told to enter passphrase which is simply a password,create a simple one which you can memorize easily like 1234.Then entre it again when asked. You then start the SSH agent Run; eval "$(ssh-agent -s)" Then add your SSH keyy Run: ssh-add ~/ .ssh/id_ed2559 It will ask you to entre the passphrase you created. Copy your public key y running the command: cat ~ .ssh/id_ed25519 .pub Add the entire line generat

A free model quota is a budget, not a gift. You should treat it like one if you plan to build anything on top of it. I learned this the hard way when my prototype stopped responding in the middle of a demo. I had silently burned through the monthly allowance, and the provider cut me off without warning. This article shows how I built a small token budget alarm on a free server. It watches a free model's usage and warns me before the quota runs out. Most developers track their cloud spend religiously but ignore the token consumption of free models. The free tier feels like a gift, so we assume it will last forever. Then the provider cuts us off at the worst moment, and we scramble to find the cause. A token budget alarm removes that uncertainty by measuring your actual burn rate. It projects the exhaustion date and alerts you before you hit the wall. The design is deliberately small: a reverse proxy sits in front of the model endpoint. It records the token usage from every response and stores it in a local database. A background thread then computes the average consumption over a sliding window. It compares that rate against the remaining allowance and fires a webhook when the projection looks dangerous. You can run this entire stack on a free server, which is exactly what I did with MonkeyCode's free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The proxy itself is a tiny Flask application that forwards requests to the model. It extracts the usage field from each response and records the token count. If your provider does not return a usage object, you can estimate the token count with a simple heuristic. Dividing the character count by four is a rough but workable approximation. The important part is that every request is accounted for, because a single long prompt can consume more than a hundred small ones. from flask import Flask , request , Response import requests import sqlite3 import time app = Flask ( __name__