标签：#programming

submitted by /u/mtlynch [link] [留言]

Sometimes, the best ideas come when you least expect them — like at 2 AM, scrolling through social media with nothing exciting to do. That’s exactly how IGram, my latest side project, came to life. No grand plans, no investors, no pressure — just a spark of curiosity and a desire to build something fun. In this post, I’ll share the story of how IGram started, what it is, the challenges I faced, and what I learned along the way. If you’ve ever wondered what it’s like to build a messaging app from scratch or are just curious about side projects, this one’s for you. HOW IT BEGAN _**A few days ago, stuck in an endless social media scroll loop, I suddenly thought, “Why not build my own messaging app?” Not to compete with the giants like Telegram or WhatsApp, and certainly not because I had a startup idea or funding. Simply because I wanted to see how far I could take it. That spontaneous idea turned into IGram, a project born purely out of boredom and a hunger to learn. What Is IGram? IGram is a modern messaging app inspired by platforms like Telegram and Discord. But it’s not a clone. Instead, it’s designed to feel fast, smooth, and enjoyable—an experience I wanted to craft from the ground up. It’s my personal challenge and learning experiment, built solo and fueled by the excitement of creating something new. Features You’ll Find in IGram Even though it started as a simple idea, IGram has grown to include a solid set of features: One-to-one messaging Group conversations Channel support Message reactions, editing, and deletion Reply and message forwarding Search functionality Dark and light themes Responsive design and mobile-friendly layout User profiles and modern UI animations Every feature is designed to keep the app feeling smooth and responsive, because the user experience matters just as much as the functionality. The Biggest Challenge: User Experience Surprisingly, writing the code wasn’t the toughest part—it was designing how everything flows and feels. Modern

Introduction Most developers today are learning how to “use AI APIs.” But that’s not enough anymore. The real shift happening in software engineering is this: We are moving from building APIs → to building AI-powered systems. And that requires a completely different mindset. The Problem with Most AI Tutorials Most tutorials show this: Call OpenAI API Get response Print output That’s it. But in production systems, this approach fails because it ignores: Context management State handling Reliability Tool integration System design In real applications, AI is not a function call — it is an orchestrated system. What an AI System Actually Looks Like A production AI system usually includes: 1. Input Layer Validation Preprocessing Safety checks 2. Reasoning Layer (LLM) Prompt engineering Context injection Model selection 3. Tool Layer APIs Databases Search engines Internal services 4. Memory Layer Conversation history Vector DB / embeddings User context 5. Output Layer Formatting Validation Response filtering Simple Example: From API Call → AI Agent Thinking Instead of this: response = client . chat . completions . create (...) We design something like this: class AIAgent : def __init__ ( self , llm , tools ): self . llm = llm self . tools = tools def run ( self , user_input : str ): context = self . build_context ( user_input ) response = self . llm . chat . completions . create ( model = " gpt-4o-mini " , messages = context , temperature = 0.2 ) return self . post_process ( response ) Now AI becomes: ✔ structured ✔ extendable ✔ production-ready Key Shift in Thinking Old mindset: “How do I call the model?” New mindset: “How do I design the system around the model?” That’s the difference between: ❌ AI script ✅ AI product system Why Tools Matter More Than Prompts Modern AI systems are not just text generators. They are tool-using systems . Examples: Search APIs (RAG systems) Databases (SQL, NoSQL) External APIs Internal business logic This turns AI from “chatbot” into “agent

If you've ever watched a hacker movie and seen someone plug in a USB and own a machine in seconds — that's not Hollywood magic. That's a Rubber Ducky. And I built one for under ₹150. Here's exactly how I did it, what it taught me, and why every security student should build one. What Even Is a Rubber Ducky? A Rubber Ducky is a USB device that pretends to be a keyboard. The moment you plug it in, the operating system trusts it completely — because keyboards don't need driver approvals or admin permissions. Once trusted, it starts "typing" pre-programmed commands at superhuman speed. We're talking 1000 keystrokes per second. By the time you blink, it's already opened PowerShell, run a script, and closed the window. The original Hak5 Rubber Ducky costs around $80. I built mine for ₹150. What I Used DigiSpark ATtiny85 — ₹120–150 on Amazon India Arduino IDE — free A Windows test machine (my own laptop) 15 minutes That's it. No soldering. No special skills. Just a tiny microcontroller the size of a thumb. Setting It Up Step 1 — Install Arduino IDE Download from arduino.cc and install normally. Step 2 — Add DigiSpark Board Support Go to File → Preferences and paste this into Additional Board Manager URLs: http://digistump.com/package_digistump_index.json Then go to Tools → Board → Board Manager, search Digistump and install. Step 3 — Install Drivers DigiSpark needs Micronucleus drivers on Windows. Download from the official Digistump GitHub and run the installer. Step 4 — Write Your First Payload This opens Notepad and types a message — my first ever "attack": cpp#include "DigiKeyboard.h" void setup() { DigiKeyboard.delay(2000); DigiKeyboard.sendKeyStroke(KEY_R, MOD_GUI_LEFT); // Win+R DigiKeyboard.delay(500); DigiKeyboard.print("notepad"); DigiKeyboard.sendKeyStroke(KEY_ENTER); DigiKeyboard.delay(1000); DigiKeyboard.print("Hello. Your keyboard is now mine."); } void loop() {} Upload it, plug in the DigiSpark, and watch it type on its own. That moment hits different when y

Introduction In the early 2000s, email spam was rampant, cluttering inboxes with unsolicited messages promising quick riches or promoting dubious products. Fast forward to today, and a similar phenomenon is occurring in the world of open-source software: Pull Request (PR) spam. Much like its email predecessor, PR spam is becoming a major nuisance for developers and maintainers, disrupting workflows and compromising the integrity of collaborative software projects. This blog post explores the parallels between early 2000s email spam and contemporary PR spam, examines the motivations behind this new wave of digital clutter, and discusses potential solutions to mitigate its impact. The Rise of PR Spam The Allure of Contribution Metrics One of the primary drivers behind PR spam is the increasing emphasis on contribution metrics in the open-source community. Platforms like GitHub have made contributing to projects more accessible, and many developers are eager to showcase their activity through public repositories. However, this focus on quantity over quality can lead to an influx of low-effort or irrelevant PRs. An example of this is Hacktoberfest, an annual event encouraging contributions to open-source projects. While well-intentioned, it has, in some instances, resulted in a deluge of superficial PRs. Contributors seeking to meet participation thresholds often submit changes that are trivial or unnecessary, much like the spam emails of old that inundated our inboxes with irrelevant or nonsensical content. Automated PR Generators Another factor contributing to the rise of PR spam is the use of automated tools that generate pull requests. These tools can be beneficial for routine tasks such as dependency updates or code formatting. However, when misused, they can lead to a flood of PRs that lack genuine human oversight or consideration, akin to the automated email spam generators that once plagued communication networks. For instance, a tool might automatically submit

submitted by /u/henk53 [link] [留言]

submitted by /u/madnirua [link] [留言]

Open Graph images are the single biggest factor in whether your shared links look credible or broken. Yet most sites ship one generic image on every page because making a unique one by hand is tedious. Here is a more sustainable approach: treat preview images as generated data, not hand-made design. The problem, concretely When you share a link, the receiving platform reads your page's og:image meta tag and renders a card. If that tag is missing, points to a low-res logo, or is the same image on all 200 pages, your links look generic in every feed, Slack channel, and group chat. Studies of social sharing consistently show that posts with a clear, relevant preview image get meaningfully more engagement than those without. The reason teams skip it is not ignorance. It is friction. Opening a design tool, duplicating a template, swapping the title text, exporting at the right dimensions, and uploading the file takes 10 to 20 minutes per page. Nobody keeps that up across a real publishing schedule. So the back catalog stays bare and new posts get whatever the default is. The insight: it is template work Look at a typical preview card and ask what actually changes between pages. Usually just the title, maybe the author and a category tag. The layout, background, logo, and fonts are constant. That is the textbook definition of a job you should template once and generate programmatically, not redo by hand each time. How to solve it The cleanest pattern is to generate the image at build time or on first request, then cache it. Conceptually: // During your build or in an API route async function getOgImage ( post ) { const params = new URLSearchParams ({ title : post . title , author : post . author , tag : post . category , }); // Returns a ready Open Graph image URL return `https://getcardforge.dev/api/card? ${ params } ` ; } // In your page head // <meta property="og:image" content={getOgImage(post)} /> You can build this yourself with a headless browser plus an HTML templ

Every serious AI workflow eventually runs into the same failure. The agent does useful work in one session. It learns the shape of the project. It figures out which assumptions were wrong. It follows a correction, makes a decision, and gets closer to the real work. Then the session changes. The next run starts too cold. Old context comes back without the correction that changed it. The agent asks for the same setup again. It repeats an assumption that was already fixed yesterday. You end up managing the memory of the work instead of moving the work forward. That is the problem Pith is built for. Pith gives AI agents durable project memory they can trust when facts change. It is not trying to make an agent remember everything. That would be the wrong goal. Real projects are messy. Facts change. Decisions get reversed. A note that was useful last week can become stale after a release, a migration, a new customer constraint, or one correction from the human operator. The harder problem is not recall. The harder problem is knowing which memory is still useful. Why Longer Context Is Not Enough Longer context helps, but it does not solve continuity by itself. A long prompt can carry more text into a single run. It cannot automatically decide which prior facts survived a correction, which decision is now superseded, or which evidence should come back when the project resumes three days later. Developers working with agents already feel this. The friction shows up as small taxes: repeating project background that the agent should already know; re-explaining decisions that were already made; correcting stale assumptions that were already corrected; losing the reason behind a prior choice; restarting from a cold state after every meaningful break. Those taxes compound. The more serious the workflow, the more expensive the memory gap becomes. If an agent is helping with a toy task, forgetting is annoying. If an agent is helping with a codebase, a release, a customer workflow,

One of the most important blogs I have written in the last 25 years that most devs struggle with. submitted by /u/watson_full_scale [link] [留言]

submitted by /u/debba_ [link] [留言]

I just completed my bachelor’s last month and I have realised basic programming knowledge about different languages won’t get me any job. So I have decided to pursue Mern stack + Ai integration path. However I don’t have any money to buy courses. Lucky I have an internet connection and a laptop. I’m already familiar with basic javascript and I want to dive into the intermediate level at the least ASAP! Are there any free courses online for Mern ?? I’m already looking into freecodecamp. However if there are other unpopular options available, help would be appreciated. Thanks!! PS :- I attached google link cuz didn’t know what else to do. submitted by /u/Mental-Parsnip-8026 [link] [留言]

I couldn't find many resources online that showed how to see cache misses on macOS. I thought I'd learn a bit about Instruments, throw some toy problems at it, and write about the experience in a blog post. These toy examples - iterating sequentially then randomly, summing elements in a matrix, naive vs tiled matmul and iterating AoS vs SoA - are great to see some real numbers from L1 data cache misses, but they're far away from real programming problems. What's your experience using tools like Instruments/perf/cachegrind to actually optimize an algorithm? Is it ever needed to measure this at the hardware counter level or can you get away with intuition about the size of your data structure, how it's been accessed and using basic timers? submitted by /u/markuzo1 [link] [留言]

Every generation gets a new interface: ⌨️ Keyboard 🖱️ Mouse 📱 Touchscreen What's next? submitted by /u/goto-con [link] [留言]

submitted by /u/cekrem [link] [留言]

I spent some time reading Grafana Alloy’s source code to understand how it loads configuration, builds a dependency graph, evaluates components, and runs them. I wrote a short breakdown of what I learned, mainly focused on the runtime/controller, loader, scheduler, services, and component lifecycle. It is not a complete deep dive into the whole project, but more of a source-code reading note from exploring a real production Go codebase. Feedback is welcome, especially from people familiar with observability systems or large Go codebases. submitted by /u/am0123 [link] [留言]

submitted by /u/sommukhopadhyay [link] [留言]

submitted by /u/fagnerbrack [link] [留言]

submitted by /u/nephrenka [link] [留言]

submitted by /u/lucian-12 [link] [留言]