标签：#RAM

This one is bit math heavy. I started of building a small timeseries compression library, and ended up digging through some numerical algorithms, linear algebra. I learnt through a hose during last week and found something genuinely beautiful. If you stick through it I suppose you can see what I saw. submitted by /u/ennamo_po_madhava [link] [留言]

How I replaced all the ugly S3 URLs on my Laravel blog with clean /storage/media/... and /storage/og-images/... paths. The setup: Laravel + Octane + Traefik + Cloudflare. Two buckets -- a private one for uploaded media and a public one for auto-generated OG images. What's in the post: - MediaUrlBusiness helper class that centralizes URL generation (replaced 6+ blade templates of raw Storage::url() calls) - ObjectProxyController that streams files directly from S3 using readStream() + response()->stream() -- no memory buffering - Cache-Control: public, max-age=86400, immutable so Cloudflare caches aggressively - Route setup in routes/static.php with a middleware tweak that doesn't overwrite the proxy's own cache headers One gotcha: Storage::download() and streamDownload() buffer the whole file into memory. Switching to readStream() sends it directly from S3 to the client. submitted by /u/HolyPad [link] [留言]

Originally published on the Prufa blog . Five days ago we audited 49 Show HN launches and found that 78% had a critical bug on day one. This week we pointed the same free audit at a different cohort: 14 products freshly posted to r/SideProject. We expected more of the same. We got the opposite — and it turned out to be more interesting. Not one of the 14 had a critical finding. No broken signup flow, no canonical pointing at the wrong domain, no analytics tag silently swallowing every event. By the measure that matters most on launch day — does the core thing work — these builders shipped clean. And yet every single site had findings. They just all live one tier down, in a layer so consistent it reads like a shared checklist nobody handed out: 11 of 14 sent no analytics events at all. 11 of 14 shipped with no Content-Security-Policy and could be framed by any site (no X-Frame-Options ). 11 of 14 had serious accessibility violations . 12 of 14 had tap targets smaller than 24px on mobile. 9 of 14 took over four seconds to paint their largest element on mobile. 8 of 14 had no canonical link on the entry page. No site is named in this post. The point isn't to embarrass anyone — these are good builders who got a real product live. The point is that the same common side-project launch mistakes show up again and again, and if 11 of 14 strangers have them, you probably have a few too. Methodology, briefly We pulled 20 URLs from recent r/SideProject posts and ran each through the same audit a free Prufa run does: a real browser loads the public pages and captures network traffic, console output, response codes, headers, and the rendered DOM, then a fixed suite of deterministic checks grades the evidence. Same input, same verdict. Of the 20: 14 completed cleanly , 4 were blocked by bot protection before our runner could load them, and 2 didn't finish inside our polling window. The numbers below are from the 14 that completed. Two honest caveats. First, 14 is a small sample —

Here's a question most businesses never think to ask when they're building a website: can everyone actually use this? Not just the people on a fast laptop with perfect vision and a reliable internet connection. Everyone. The person navigating your site with a screen reader because they're visually impaired. The user who can't use a mouse and relies entirely on a keyboard. The individual with a cognitive disability who needs clear, consistent layouts to make sense of what they're looking at. If your website doesn't work for these people, it doesn't work full stop. And yet, accessibility is almost always the last thing discussed in a web development project, usually buried somewhere at the bottom of a checklist, treated as a nice-to-have instead of a requirement. That needs to change. Not because of legal compliance (though that's a real consideration too), but because accessibility-first web development simply produces better websites. Faster load times, cleaner code, better SEO, higher user retention accessible design delivers all of that. The framework isn't complicated. It just requires thinking about it from the start instead of trying to bolt it on at the end. This is that framework. What Accessibility-First Web Development Actually Means Accessibility-first is a mindset, not a checklist. It means building with the full range of human experience in mind from day one not auditing for compliance after the site is already live. It's Not the Same as Compliance WCAG (Web Content Accessibility Guidelines) is the global standard for web accessibility. Most businesses know it exists. Very few understand what it actually requires or that meeting WCAG 2.1 AA standards isn't a ceiling, it's a floor. Compliance means you passed the audit. Accessibility-first means you thought about disabled users during architecture decisions, during design reviews, during content writing, and during QA. Compliance is a document. Accessibility-first is a process. The gap between the two mat

I use a form validation problem as a technical interview question. It's deceptively simple — and the solutions people reach for reveal a lot about how they think. Then I tried it on Claude, ChatGPT, and Gemini. The results were illuminating, but not for the reasons I expected. The Problem Many form libraries share a common convention: form data is represented as a plain nested object, and the validation function returns an object of the same shape containing the errors. You'll find this pattern in Formik and React Final Form in React, and — full disclosure — in Inglorious Web , my own framework, which ships form handling built in without any extra dependencies. const values = { productName : ' VR Visor ' , quantity : 1 , homeAddress : { street : ' Long St ' , zip : ' 00666 ' }, shippingAddress : { street : ' Short St ' , zip : ' 00777 ' , co : ' Inglorious Coderz ' }, billingAddress : { street : ' Wide Plaza ' , zip : ' 00888 ' , vat : ' 1142042 ' }, } The validation function should return an object containing all errors found. A starting example: function validate ( values ) { const errors = {} if ( ! values . productName ) { errors . productName = ' required ' } return errors } The ask: extend this to validate every field . Notice that the three address types aren't identical. shippingAddress requires a co field. billingAddress requires a vat . These differences matter — and how you handle them reveals a lot. Four Solutions, Four Instincts 1. The Flag — the average human The most common approach I see in interviews is a single validateAddress function with a type parameter: function validateAddress ( values = {}, type ) { const errors = {} if ( ! values . street ) errors . street = ' required ' if ( ! values . zip ) errors . zip = ' required ' if ( type === ' shipping ' && ! values . co ) errors . co = ' required ' if ( type === ' billing ' && ! values . vat ) errors . vat = ' required ' return errors } It works. But every new address type, every new special rule,

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

The restrictions include a nationwide ban on Telegram until June 22 and a requirement to disable the app's message editing feature.

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

We Built Korexbase: A Lead Generation Platform for Finding Business Leads by City and Niche Building software is exciting. Building software that solves a real problem is even better. Over the past few months, we've been working on Korexbase , a lead generation platform designed to help businesses discover targeted leads faster. The Problem Many agencies, sales teams, freelancers, and startups spend hours manually searching for potential customers. The process usually looks something like this: Search for businesses online Collect contact information Copy everything into spreadsheets Repeat the process every day It's slow, repetitive, and difficult to scale. We wanted to simplify that workflow. The Idea Korexbase allows users to search for business leads by: City Industry Business category Instead of manually collecting data, users can generate leads and manage them through a clean dashboard. The goal isn't to replace sales. The goal is to help businesses spend less time searching and more time closing deals. Building the Platform A major focus during development was creating a dashboard that feels simple and easy to navigate. Some areas we focused heavily on included: Responsive layouts User-friendly navigation Clear data presentation Fast loading interfaces Consistent design patterns Challenges Like most projects, we faced a number of challenges: Designing for Simplicity One of the biggest lessons was that adding more features doesn't automatically create a better product. We spent a lot of time simplifying interfaces and removing unnecessary complexity. Creating a Better Dashboard Experience Presenting lead generation data in a way that is useful without overwhelming users required multiple design iterations. We focused on: Better spacing Better visual hierarchy Cleaner cards and tables Improved responsiveness Product Positioning An interesting challenge was refining the product's positioning. As development progressed, we learned more about what users actually w

This module built one thing, from many angles: the container — the part of Spring that creates your objects, wires them together, and hands them out. Eight articles each zoomed in on a different corner of it. This recap zooms back out. The goal here is not to re-explain each topic, but to show how they are all the same idea seen from different sides, so the whole module collapses into a picture you can hold in your head at once. So before the details, here is the single sentence the entire module hangs on: the container is a factory that runs at startup, and almost every feature you met is just that factory doing a little extra work while it builds a bean. Keep that sentence close. Everything below is a way of filling it in. The factory, in one picture Picture an assembly line that runs exactly once, when your application boots. You hand it a list of what to build and how the pieces fit. It builds every object your app is made of, connects them, sets them on a shelf, and hands them out on request for the rest of the program's life. That assembly line is the container. The objects it builds and manages are beans . An object you create yourself with new is not a bean — Spring never touched it — and that distinction is the thread running through every trap in this module. The factory does four things at startup, and the order matters: it reads recipes, works out who needs whom, builds from the bottom up, and caches each result. ApplicationContext ctx = SpringApplication . run ( App . class , args ); OrderService svc = ctx . getBean ( OrderService . class ); // already built and wired By the time run returns, the work is done. Asking for a bean is instant because the building already happened. Every other topic in the module is a detail about how that one startup pass works. Why we hand the work over at all The module opened with a question of control. Left alone, a class builds its own collaborators with new — and in doing so it welds together two unrelated decisions:

I'm not here to trash Sololearn. Sololearn taught millions of people how to code. It was one of the first apps to make programming education feel mobile-native. That's a real achievement. I respect it. But I'm building Codino — a Python learning app — and I'd be lying if I said I didn't study Sololearn carefully before writing a single line of code. I looked at what they got right. I looked at where users complained. And I made decisions based on both. This is that honest breakdown. What Sololearn Got Right 1. The Community Feel Sololearn built a genuine community. The code playground where users share their projects, comment on each other's code, and get likes — that was smart. Learning feels less lonely when other people are doing it alongside you. It created a social loop that kept people coming back even when they weren't actively doing lessons. I haven't built this yet in Codino. The leaderboard is a start, but a full community layer is something I'm thinking about for a future update. 2. Multi-Language Support Sololearn didn't bet on just one language. Python, JavaScript, C++, SQL, HTML — they covered everything. That gave them a massive addressable audience. Codino is Python-only right now. That's intentional — going deep on one language is better than going shallow on ten. But I understand why multi-language eventually matters for scale. 3. The Code Playground The ability to write and run real code inside the app — without going to a browser — was ahead of its time when Sololearn launched it. That feature alone brought back users who had finished all the lessons. Codino has a full offline IDE powered by Sora Editor. I'd argue ours is actually more capable — real syntax highlighting, autocompletion, offline Python execution — but Sololearn deserves credit for proving this feature matters. 4. Bite-Sized Lessons That Actually Work Sololearn understood that people learn on the bus, in bed, waiting in line. Their lessons are short, digestible, and don't demand 45

AI coding assistants have fundamentally changed the way we write software. Today it's perfectly normal to ask ChatGPT, Claude, Cursor, or Copilot to explain an API, generate a React component, review a pull request, or help debug a problem. For many developers, these tools have become part of the daily workflow. Yet there's one area where they still struggle more than we'd like to admit: understanding the current state of the web platform. Mozilla recently demonstrated this problem in a surprisingly direct way. While evaluating Claude Code on recently released Firefox features, the team discovered that the model confidently claimed Firefox didn't support the Web Serial API and that Mozilla had no plans to implement it. The answer sounded plausible, detailed, and authoritative. There was just one issue. Firefox had already shipped support for the API. That experiment became one of the motivations behind Mozilla's new MDN MCP Server , a tool designed to give AI assistants direct access to MDN documentation and browser compatibility data. More importantly, Mozilla didn't just launch the service—they tested whether it actually improves the quality of AI-generated answers. The results are worth paying attention to. The Real Problem Isn't Hallucination When discussions about AI reliability come up, the conversation usually focuses on hallucinations. But browser compatibility is a slightly different problem. The web platform evolves continuously. Browsers ship new APIs, CSS features, HTML capabilities, and compatibility updates every few weeks. Specifications change, Baseline statuses evolve, and features that were experimental yesterday can become production-ready tomorrow. Large language models, on the other hand, are trained on snapshots of information. Even highly capable models can only know what was available when they were trained. When they're asked about something that appeared later—or something that wasn't widely represented in their training data—they often hav

Tools like Claude Code and Codex have completely reshaped how software engineering is done. This new tooling allows for much faster development and iteration, but it's important to keep the code maintainable and scalable to make sure the project can continue evolving over the long term. A template project with an initial structure using all of the technologies described here is available on GitHub: https://github.com/MartinXPN/nextjs-firebase-mui-starter When working on a startup, the speed of iteration is key. The requirements change quickly, features are added daily, and code gets modified rapidly. In those conditions, picking technologies that enable fast iteration, while ensuring your users get the best experience possible, is crucial. During the last four years or so, we have experimented with many modern technologies while building Profound Academy . So, in this blog post, I'd like to present the whole tech stack that enables building quickly, while having a highly maintainable codebase, scalable infrastructure, and a great user experience. We'll cover everything from Authentication to UI, we'll talk about the backend, hosting, testing, and much more! AI Agents, Skills, and MCP servers AI Agents enable quick iteration and rapid improvement, including bug fixes, the addition of new features, and performance improvements. Yet, it's important to keep the code maintainable for the long run. AI tools make it really easy to overengineer things and add thousands of lines of code to a project. It's important to resist the urge to solve problems that don't exist yet, and keep things simple (both in terms of the code, the infrastructure, and the user experience). Even in the Agentic Software Development Era, having a small and simple setup helps. Agents coordinate better, features are added faster, bugs are fixed more easily, and the code is maintainable by humans, too. So, we have chosen to take a balanced/nuanced approach to how we use AI Agents when it comes to worki

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

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

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

I wanted to see how far an autonomous coding agent could get unattended. The constraint that makes this hard isn't code generation — it's that each session starts with zero memory of the last. So the design problem is state, not prompting. Setup A cron-scheduled task fires hourly, 11pm–7am (~8 runs). Each run is a fresh agent session. No shared context, no carryover. State lives entirely on disk: the working tree, the git history, and two files — BUILD_SPEC.md (the immutable goal/architecture) and PROGRESS.md (an append-only decision + status log). The run loop Every session does the same thing: Read BUILD_SPEC.md, then PROGRESS.md, then git log --oneline. Reconstruct "where are we" from the files themselves (the code is the source of truth, not the narrative). Do one unit of work. Commit. Append to PROGRESS.md: what changed, why (chosen X over Y because Z), and the exact next step. Commit granularity = checkpoint granularity. Worst case on an interrupted session is losing one unit, and the next run re-derives it. The "why" lines matter as much as the diffs — without them a later session re-litigates settled decisions. Guardrails The agent was allowed to build, test, and commit locally. It was explicitly not allowed to deploy, push to a remote, or touch secrets — those get written into PROGRESS.md as "needs human" items instead. This boundary is what makes unattended runs safe to leave alone. What came out A working full-stack monorepo: a pure TS scheduling engine (with property tests), multi-tenant auth, a Drizzle/Postgres schema, server-side re-validation, and publish/share/export flows. Across the runs it cleared its own stale git lock, and one session caught and fixed an off-by-one in a labeling layer that spanned five files. The takeaway The leverage wasn't the model writing code. It was designing a process where progress is durable across total context loss — externalize state, checkpoint constantly, log decisions not just actions, and fence off irreversible o

Is FAANG Becoming MANGO in the AI Era? For years, FAANG was the gold standard for innovation and engineering excellence. If you were a developer, working at companies like Facebook (Meta), Apple, Amazon, Netflix, or Google was often seen as the ultimate career goal. But the AI revolution is changing the conversation. Today, some of the most influential companies aren't just building products—they're building intelligence. The spotlight is increasingly shifting toward AI-native organizations such as OpenAI , Anthropic , NVIDIA , and others that are shaping the future of software. The Bigger Shift This isn't really about replacing FAANG with another acronym. It's about a fundamental shift in technology: Search → Answers Automation → Agents Software → Intelligence Features → Capabilities As developers, we're entering an era where understanding AI is becoming as important as understanding frameworks, databases, and system design. What This Means for Engineers The most valuable engineers of the next decade will likely combine: Strong software engineering fundamentals AI-assisted development skills Prompt engineering LLM and agent integration AI-powered product thinking The goal isn't to compete with AI. The goal is to learn how to build with it. Read the Full Article This post was inspired by a thought-provoking article that explores the FAANG-to-MANGO idea in much greater detail. 👉 Read the complete article here: https://www.saurabhsharma.dev/blogs/mangos-vs-faang-ai-era/ What do you think? Are we witnessing the rise of a new generation of AI-first companies, or will traditional tech giants continue to lead the next wave of innovation?

A story about an AI content moderation system that flagged 347 posts since launch — and what...

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