标签：#programming

A few months ago, if someone had asked me to build a mobile app, I would've had absolutely no idea where to start. Today, an app I built is on the Google Play Store. It's called Stulo, and it's currently in closed testing. The funny part? I'm not a software engineer. I'm just a college student who got tired of missing opportunities. Internships were on LinkedIn, hackathons were buried somewhere on Instagram, college events lived inside WhatsApp groups, and competitions were scattered across random websites. If the algorithm didn't like you that day, you simply never found them. That felt... ridiculous. So I asked myself, "Why isn't there one place where students can find everything?" That simple question eventually became Stulo. Today, students can discover internships, hackathons, competitions, campus events, connect with other students, and share updates through a campus feed—all in one app. The biggest lie I believed was that building the app would be the hard part. It wasn't. Understanding why it wasn't working was. I built the first version using Emergent because, honestly, I didn't know enough to start from scratch. It got me surprisingly far. As the project became more serious, I moved development to Google AI Studio (Antigravity). That's when I learned something every AI-generated YouTube thumbnail forgets to mention: AI doesn't build products. It generates code. There's a huge difference. AI happily writes hundreds of lines of code, but it doesn't explain why your images randomly stop rendering after ten minutes, why scrolling suddenly feels like you're using a phone from 2013, or why fixing one bug somehow creates three completely unrelated bugs. Most days followed the exact same routine: generate code, run the app, watch something break, Google the error, ask AI, read Stack Overflow, realize the problem was my own code, and repeat. Some bugs took ten minutes to fix, while others stole an entire weekend. Looking back, one of the biggest things I learned wa

C is over 50 years old. Yet it still powers: Linux Embedded Systems Compilers Databases Device Drivers Why? Because it offers something very few languages do: Speed + Control + Portability 1. Fast Execution C compiles directly into machine code. That means very little runtime overhead and excellent performance. 2. Portability Well-written C code can be recompiled on Windows, Linux, and macOS with minimal changes. 3. Direct Memory Access Pointers allow precise control over memory. That's one reason C is used for operating systems and embedded software. 4. Structured Programming Functions and modular design make large programs easier to organize. 5. Small Language Core The language itself is relatively small, making it easier to learn the fundamentals. 6. Standard Library Useful libraries exist for: Input/Output Strings Files Memory Mathematics 7. Hardware Interaction Few languages communicate with hardware as naturally as C. That's why C remains the dominant language for firmware and drivers. What About the Downsides? C also has limitations. Manual memory management No garbage collection No built-in OOP Limited runtime safety These make C harder to master but also teach concepts that many higher-level languages hide. Simple Example #include <stdio.h> int main () { printf ( "Hello, World! \n " ); return 0 ; } Even this tiny program demonstrates: Header files The main() function Standard library usage Program execution Final Thoughts Learning C isn't about writing every future application in C. It's about understanding how software works beneath modern frameworks. Once you understand C, many other programming languages become much easier to learn. Full beginner guide with diagrams and explanations: [Feature and Application C Programming](# 7 Features of C Programming Every Developer Should Know C is over 50 years old. Yet it still powers: Linux Embedded Systems Compilers Databases Device Drivers Why? Because it offers something very few languages do: Speed + Control +

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

So for learning purposes I was reading a few research papers on the topic of databases. I read through a few papers like gfs, cockroachdb, dynamodb, raft etc.. DynamoDb uses consistent hashing for the key distribution. It also uses virtual nodes for reducing the rebalancing problem when a node dies. So I had an idea of using the resource(disk, cpu, ram, network) of server to determine how much data/load it should handle. We can't determine the capacity of a server just with its hardware specs like ram & disk, if the latency is high or has frequent network issue then it makes that particular node not very reliable to hold the data. So incorporating the network details will help us get better resource scores of a node. Keys are mapped to slot using CRC16 and there will be a fixed number of slots 16384. Since I used a storage engine called pebble(similar to rocksdb) I was able to avoid the headache of writing the storage layer. I greatly underestimated the process of writing a database. So coming back to the topic I want to know if this resource based ranging splitting is already implemented and more information on it. I developed a architecture on this topic called irisdb and it implements this resource scores mechanism to determine which node to take the slot range to split. this is a learning project and I gladly accept any feedback I could get submitted by /u/wizard_zen [link] [留言]

AgentJr — The AI Junior Developer That Manages Your Entire Freelance Business While You Sleep Most "AI developer tools" do one thing: write code. AgentJr does everything a real junior developer does. Code. Clients. Communication. Deployment. Testing. Invoices. Social media. All of it. Automatically. While you sleep. The Real Problem With AI Coding Tools Today Claude Code writes code. Devin writes code. Copilot writes code. But writing code is maybe 40% of what a freelance developer actually does. The other 60%? Talking to clients. Understanding what they actually want. Managing git properly. Branches, commits, PRs. Running tests. Catching bugs before the client sees them. Deploying to the right environment. Not accidentally pushing dev code to production. Sending updates. "Hey, your feature is live." Tracking costs. How much did this project actually cost me in API calls? Following up. Drafting invoices. Scheduling calls. Posting on LinkedIn about the work you just shipped. No AI tool today handles all of that together. They give you a coding assistant and leave the rest to you. AgentJr is different. AgentJr is not a coding assistant. It's a complete AI junior developer that manages your entire workflow — from the moment a client messages you, to the moment the project is deployed, tested, and the invoice is sent. You Are the CEO. AgentJr Is the Manager. Here's the architecture that makes AgentJr unique: You — give direction. Set priorities. Approve plans. That's it. AgentJr (Manager) — understands requirements, asks smart questions, builds plans, manages git, monitors work, handles client communication, runs tests, manages deployments, tracks costs, drafts invoices, posts social media updates. Claude Code / Codex / Gemini CLI (Worker) — writes the actual code. Spawned by AgentJr on your terminal. Per project. You choose which one. AgentJr never writes code itself. It orchestrates the worker that does. This separation is intentional — and it's what makes the whole s

I am looking for a permanent solution to streamline my business communications - sending bulk messages, handling customer chats, creating tickets like in any crm and possibly to integrate calling option as well. I have found gupshup.ai but they are not catering to small businesses. submitted by /u/Recent_River_7934 [link] [留言]

Open your browser DevTools and run this: const user = { name : " Bob " } console . log ( user ) user . name = " Alice " You would expect the log to show { name: "Bob" } , the value at the time of the console.log call. The collapsed line is what you expect: ▶ Object { name: "Bob" } But expand it, and you will see: name: "Alice" Oops. So what's going on? console.log() is the most-used debugging tool in JavaScript, but it can be subtly unreliable. Not because it is broken, but because it optimizes for speed and interactivity rather than for accuracy . It was built for fast exploration in a live, interactive environment, and those priorities come with tradeoffs that can genuinely mislead you during debugging. Over the next sections, we'll look at a few ways the console can mislead you - and, more importantly, why each one exists. Objects Aren't Snapshots When you pass an object to console.log() in browser DevTools, the browser does not immediately serialize it into a string. Instead, it stores a live reference to that object and defers the actual rendering until you expand the entry. This is called lazy evaluation, and it is what caused the surprise. The collapsed ▶ Object you see is essentially a placeholder: the properties shown inside it are evaluated at the moment you click the arrow, not at the moment you called console.log() . By then, your code has already continued running. That means what you're seeing is not a frozen record of the object at the time of logging, but a live view into whatever the object happens to look like when DevTools renders it. In the example: You log { name: "Bob" } DevTools stores a reference to the user object The code continues executing user.name is mutated to "Alice" You expand the logged object later and see the current state This behavior can feel unintuitive at first, because most developers mentally model console.log() as "print this value right now", but in browser DevTools, it is closer to "show me this object as it exists when

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

Hello again, DEV Community!I recently shared my project, Jesse Math Rock Star, and the feedback from this community has been incredibly supportive.For those who don't know me, I am 11 years old. I started coding with Scratch when I was 8, and I built this production web app using self-explored vibe coding, Google's Gemini models (via AI Studio), and Vercel!Looking at my analytics, 61% of my visitors are using mobile phones, mostly Android. I want to make sure the app feels perfect and fun for kids my age to use on small touchscreens.Could you do me a quick favour?Open the app on your phone: https://jesse-math-rockstar-app.vercel.app/ a quick round of math.Leave a comment below with your advice on the user interface (UI) and layout!Thank you all for being such a safe and helpful community for early-career builders! ( https://jesse-math-rockstar-app.vercel.app/ )

I’ve always been fascinated by PDFs. They look simple on the surface. Just a document you can open anywhere but underneath they’re a full layout engine, object graph, drawing model, and archival format all at once. I enjoy that mix of precision and complexity and that is exactly what led me to build PDF::Make (and yes I had some help from Claude LLM). I wanted a fully featured toolkit that could both generate PDFs and let me inspect/edit them programmatically. At the low level, PDF::Make exposes the raw building blocks of the format: PDF objects, pages, the drawing canvas, a parser/reader, and import/merge primitives. This is the layer you reach for when you need fine grained control or want to work with the structure of a document directly. For everyday document creation, PDF::Make::Builder sits on top of that foundation and provides a higher level API. It handles the boilerplate of page setup, fonts, text flow, and layout so you can produce a polished PDF in just a few lines of Perl. The same toolkit is also designed for post-processing. You can open an existing PDF, extract structured text along with its coordinates, and then draw annotations or overlays back onto the page, making it straightforward to build review, QA, or markup workflows on top of documents you didn’t originally generate. This post shows a practical two-step flow: Create a PDF Re-open it, extract text coordinates, and draw border highlights around matched words 1) Create a PDF with PDF::Make::Builder Script: #!/usr/bin/perl use strict ; use warnings ; use PDF::Make:: Builder ; my $pdf = PDF::Make:: Builder -> new ( file_name => ' source_demo.pdf ', configure => { text => { font => { family => ' Helvetica ', size => 12 , colour => ' #222222 ' }, }, }, ); $pdf -> add_page ( page_size => ' Letter ') -> add_h1 ( text => ' PDF::Make blog demo ') -> add_text ( text => ' PDF::Make builds and edits PDF files directly from Perl. ') -> add_text ( text => ' In the next step we extract text coordinates and

Currently available as a beta in Xcode 27, Swift 6.4 introduces a range of enhancements: better C interoperability, simplified OS availability check, fine-grained warning control, async support in defer, efficient iteration for non-noncopyable types, up to 4x faster URL parsing, and improved interoperability between Swift Testing and XCTest. By Sergio De Simone

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

submitted by /u/Adventurous-Salt8514 [link] [留言]

I've been working on Churo, an open-source voice assistant built entirely in Python. It features high-quality speech-to-text and text-to-speech, web search, image understanding, and agentic capabilities. It runs with Ollama models and is designed to be easy to modify and extend. The goal is to provide a capable, local-first voice assistant that developers can actually inspect, customize, and build on. Repository: https://github.com/MathObsession/Churo-assistant or run it with(You need Ollama): pip install churovoice churovoice --voice male Feedback, issues, and contributions are welcome.

For the last two years, one skill dominated every AI conversation: Prompt engineering. People spent hours crafting the "perfect" prompt. They built prompt libraries. They sold prompt templates. They believed that better prompts meant better AI. But AI has evolved. The bottleneck is no longer the prompt. It's the context . The Prompt Was Never the Problem Imagine asking an AI: "Build me a secure authentication system." A perfect prompt isn't enough. The AI also needs to know: Which programming language you're using Your existing codebase Your framework Your database schema Your security requirements Your coding standards Your deployment environment Your team's conventions Without that information, even the best model is forced to guess. And AI is terrible at guessing. What Is Context Engineering? Context engineering is the practice of giving AI everything it needs to solve a task—not just instructions. It's about designing the right environment for the model to think. Context includes: Source code Documentation Project architecture Previous conversations Git history APIs Logs Tool outputs User preferences Business requirements Memory Constraints The prompt tells AI what to do. The context tells AI how to do it correctly. Why Prompt Engineering Is Reaching Its Limits A prompt is static. Real work isn't. Projects change. Requirements evolve. Files get updated. Tests fail. New bugs appear. The AI must continuously receive fresh information. That's impossible with a single prompt. Instead, modern AI systems constantly rebuild their context as they work. Think About AI Coding Agents Why do AI coding agents feel dramatically smarter than a normal chatbot? Not because they have better prompts. Because they constantly gather context. They can: Read your repository Search across files Run terminal commands Execute tests Inspect logs Read documentation Fix errors Verify changes Remember previous actions Every step adds more context. Every iteration makes better decisions. Cont

Disclosure: I'm Aditya Kachave, co-founder of Be10x. We sell AI training, so read this knowing I have skin in the game. I've tried to write the version I'd want even if I weren't selling anything. There's a lot of noise telling professionals they'll be "left behind" if they don't master AI immediately. Most of it is fear used as a sales lever — and I say that as someone in the business. Here's a calmer framework I actually believe in. Four levels, not a cliff You don't go from zero to "AI expert." You move through levels, and most people only ever need the first two. Level 1 — Aware. You understand roughly what these tools can and can't do. You know they predict plausible text, which is why they sometimes make things up. This alone protects you from both the panic and the over-trust. Level 2 — Applied. You use a tool to do one or two real tasks in your job — drafting, summarizing, reformatting. This is where the actual productivity lives, and where 90% of professionals should aim to land. Level 3 — Integrated. You've built repeatable workflows and you reach for AI reflexively on the right kinds of tasks. Useful, not urgent. Level 4 — Building. You're chaining tools, using APIs, automating across systems. This is genuinely technical and most people don't need it. (The dev.to crowd is the exception — many of you live here.) The one mental model that matters most Think of current AI as a fast, confident, occasionally-unreliable assistant. That single framing tells you how to use it correctly: You delegate first drafts, not final decisions. You verify anything that matters. You never hand it confidential data without checking where that data goes. If you internalize only that, you're ahead of most people throwing money at courses. What's actually worth your time Worth it: Picking one recurring task and getting genuinely good at routing it through a tool. Worth it: Learning to write clear, constrained instructions (a transferable skill, not a tool-specific trick). Not wo

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

A few weeks back I shared some early Zen code examples. Since then, a lot has changed. We're now at v1.1.1 and the language actually has real tooling. What's new: Full CLI with package management zen publish - publish packages directly from CLI zen install - install packages from the registry zen list - browse all published packages with pagination Language improvements Struct support with literals and returns Regex with POSIX ERE ( matchRegex ) File I/O with binary support FFI bindings to C functions 162 stdlib functions across math, strings, fs, os, http, crypto, path utilities Package Registry (v1.0.0) JWT-based authentication GitHub-hosted packages Support for both runnable apps and libraries Semantic versioning The reactive variables concept from the first post is still there (that was my favorite feature), and now you can actually write real programs and share them with the community. Full docs: https://jishith-dev.github.io/zen-doc/site/ Install: curl -fsSL https://raw.githubusercontent.com/jishith-dev/Zen/main/install.sh | bash Next up: HTTP server APIs, better imports, and whatever the community asks for. Open to feedback and collaborators 💻 ✨ zen #programming #compiler #llvm #packagemanager #opensource #programminglanguage

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

Original post: tachiosports.com What we're building By the end of this guide, you'll have a Discord bot that posts live CS2 match scores to a channel, updates every 60 seconds, and shows team names, current map, and odds. No database required — everything comes straight from the API. Prerequisites You'll need Node.js installed (v18 or newer), a Discord bot token from the Discord Developer Portal, and a free Tachio Sports API key. Sign up on the homepage with GitHub to get yours. Step 1 — Create the Discord bot Go to discord.com/developers/applications and create a new application. Under the Bot tab, click Add Bot and copy the token. Invite the bot to your server with the 'bot' and 'Send Messages' permissions. Keep your token secret — it's like a password for your bot. Step 2 — Set up the project mkdir cs2-discord-bot cd cs2-discord-bot npm init -y npm install discord.js Step 3 — The complete bot code const { Client , GatewayIntentBits , EmbedBuilder } = require ( " discord.js " ); const DISCORD_TOKEN = process . env . DISCORD_TOKEN ; const API_KEY = process . env . TACHIO_API_KEY ; const CHANNEL_ID = process . env . CHANNEL_ID ; const client = new Client ({ intents : [ GatewayIntentBits . Guilds , GatewayIntentBits . GuildMessages , ], }); async function fetchLiveMatches () { const res = await fetch ( " https://api.tachiosports.com/esports/live/cs2 " , { headers : { " x-api-key " : API_KEY } }, ); if ( ! res . ok ) return []; const data = await res . json (); return data . matches ?? []; } function buildEmbed ( match ) { const home = match . teams . home . name ?? " TBD " ; const away = match . teams . away . name ?? " TBD " ; const score = match . score ?. display ?? " vs " ; const map = match . current_map ?? "" ; const format = match . match_format ?? "" ; const league = match . league . name ?? "" ; const oddsHome = match . odds . match_winner . home ?? " – " ; const oddsAway = match . odds . match_winner . away ?? " – " ; return new EmbedBuilder () . setColor (