标签：#web

Making a personal website and trying to showcase projects I've worked on and trying to make it filterable. But I can not for the life of me figure out how the javascript part works? W3schools has been amazing and digestible up until this point. Using this as my base but what do I replace in the java part to make it filterable???? https://preview.redd.it/a35guno7yt3h1.png?width=1990&format=png&auto=webp&s=169b5610856995b84e1cee0881dac68dbc8be32d submitted by /u/ToxicGhostJuice [link] [留言]

I’m a big fan of PostgreSQL and recently started thinking about building a new database system as a side project. I know creating a database is a huge challenge, and I’m still learning, but I really like the idea. If a few passionate people team up together, I believe we can build something interesting. I’d love to know: What struggles do you face with current databases? What features are missing in existing systems? What problems do you wish databases solved better? Performance? Scaling? RAM usage? Replication? Developer experience? Your feedback and ideas would really help. Or shorter and more Reddit-style: Title What problems do you face with existing databases? Content I’m thinking about creating a new database project because I really enjoy working with PostgreSQL. I know it’s a huge challenge, but I like the idea and want to learn deeply by building something. If a few passionate developers team up, maybe we can create something interesting. What problems or frustrations do you currently face with databases? What would you improve if you could design your own database? I’m deeply interested in backend architecture, distributed systems, and database engineering. Previously, I built a backend framework in Go called KVolt, which gave me strong experience in scalability, API architecture, performance optimization, and system design. Recently, I started exploring a bigger challenge: I’m a big fan of PostgreSQL, but I believe there’s still room for innovation in areas like: Performance Scalability Distributed systems Replication Memory optimization Developer experience Modern architecture design I know database engineering is one of the hardest areas in software development, and that’s exactly why it interests me. I’m also looking for a few passionate developers, backend engineers, and system-level programmers who genuinely enjoy solving hard engineering problems and would like to team up on this open-source journey. I’d love to hear from the community: What struggl

I was playing around with antigravity/claude last weekend and put together a 2026 rendition of a project I did almost 15 years ago. Basically it's an app that lets you watch videos with friends. Back in the day it was a great way to share and discover music, especially stuff you normally wouldn't listen to. I'm not quite sure it would work in today's age but maybe there's something there. Either way it's pretty awesome that you can prototype something so quick by just chatting with an LLM. submitted by /u/Zenpher [link] [留言]

give some suggestion in that my company two partner and one partner has no knowledge of development and he will do the busineess related things submitted by /u/Party-Tension-2053 [link] [留言]

We let AI agents loose on a payment platform. They crushed the boring stuff. Then they silently broke the stuff that matters. A survey came out last week. 54% of all code is now AI-generated. Up from 28% last year. I read that number and thought: yeah, that tracks. We're probably in that range too. But here's the thing nobody's asking — which 54%? Not all code carries equal weight. A CRUD endpoint for fetching merchant details? Low risk. The webhook handler that transitions a payment from pending to complete ? That's someone's rent. Someone's payroll. Get that wrong and money moves where it shouldn't, or worse, money doesn't move at all. I'm the CTO of a payment platform. FCA-authorised, processing real money, real merchants, real consequences. We run NestJS microservices, Docker, Traefik — the usual stack. And we've been using AI agents aggressively for over a year now. I'm not here to tell you AI is dangerous. It's not. I'm here to tell you it's dangerous when you forget what it's actually good at. The 80% Where AI Agents Are Genuinely Brilliant Let me give credit where it's due. AI agents have made our team faster in ways that would have seemed absurd two years ago. API scaffolding. Generating service boilerplate. Writing Zod validation schemas. Spinning up new endpoints. Creating test stubs. Refactoring imports. Migrating patterns across repos. We run multiple microservices. When we need a new service, an agent can scaffold the entire thing — module structure, base configuration, Docker setup, Traefik labels — in minutes. What used to be a half-day of copy-paste-and-tweak is now a conversation. When we overhauled our env management across all repos, AI agents did the grunt work. They mapped every .env file, found naming conflicts, identified common variables, and generated a unified Zod schema. What would have taken a team days of grep-and-spreadsheet work took hours. For this 80% of the codebase — the predictable, pattern-following, structurally repetitive code

The Problem We Were Actually Solving During load testing at 50k concurrent hunters hitting the hunt endpoints, p99 latencies stayed under 200ms. But at 270k concurrent users in production, the hunt page suddenly took 1.8 seconds to load, triggering cascading 502s from our CDN. The error surfaced in Datadog as hunt_page_render_time_bucket{le=2.0} = 42% while le=0.5 dropped to 18%. The fingerprints were identical across three regions: high latency correlated exactly with Redis cache miss rate spiking from 12% to 48% during the hunt start window. Our cache-aside pattern with a 30-second TTL was amplifying miss storms. We discovered that the treasure hunt start time was synchronised by marketing campaigns. When the clock struck 10:00:00 UTC, 270k users hit the endpoint within 30 seconds. Each request would check the cache (miss), fetch from PostgreSQL, render the page, and write the cache entry. But PostgreSQL couldnt keep up with 9k queries per second during that window, causing query queueing and connection exhaustion. The Redis layer, designed for 150k ops/sec, was not the bottleneck. The database was. What We Tried First (And Why It Failed) Our first attempt was to increase Redis TTL from 30 seconds to 5 minutes. This reduced cache misses from 48% to 24%, and p99 latency improved to 650ms. But at 320k concurrent users, the latency still spiked to 1.4s because the underlying database queries were still hitting the same table with the same indexes. The Redis layer was masking symptoms, not solving the root cause. Next, we tried database read replicas. We spun up three read replicas and routed hunt queries to them using a weighted service mesh. This worked for a few minutes, but then we hit replication lag. The replicas fell 800ms behind primary, causing hunt pages to display stale treasure locations. Our operators started getting customer complaints about seeing the wrong treasure coordinates. We rolled back within 15 minutes. We even tried increasing PostgreSQL share

Just starting a discussion on breakpoints. Not like this hasn't been beaten to death before :D (͡(¬‿¬)) Tailwind sm: 40rem - roughtly 640px xs: is commonly set to 30rem or 320px for the smallest iphone width folding phones might be a use case for even smaller viewports.. idk, i cnat afford one so mauybe that's not how they work? supposedly they can be 280px there's smart glasses. no idea. VR. no idea. windows on desktop, people like me get really annoyed when some content of a window goes off screen or it transforms into a mobile version of the site just because i shrunk the window when i wanted to keep using the desktop site. (oh you and your tiling window manager, lol) submitted by /u/xThomas [link] [留言]

Maybe I’m just getting older, but frontend tooling changes so fast now that sometimes it feels harder keeping up with the ecosystem than actually building products. Feels like every few months there’s a new framework, rendering strategy, state management pattern or deployment workflow people suddenly expect you to know. submitted by /u/Bladerunner_7_ [link] [留言]

I’m working on a school Design & Technology major project and need help finding a subreddit to choose the best tool. The project is a browser-based low-poly 3D educational prototype about Greek mythology. It has a small Mount Olympus hub which is basically a decorated hub area with the one portal to the one playable myth scene: Theseus and the Minotaur in Daedalus’ Labyrinth which is essentially like a maze where you can explore/follow the myth through some mediums like cutscenes and some small puzzles. My constraints are: needs to run in a browser should work on normal school laptops/devices low-poly/simple 3D style minimal coding experience must be realistic for a student prototype ideally easy to share with a link More context is that essentially I have my whole design planned out with multiple eventualities based on the constraints on the tool I end up using and so I essentially just need a medium to construct my project in which is why I have left it so late to ask for advice on what tool to use to construct this prototype. I am confident with my extensive designs and a decently functioning prototype of this one playable scene and hub area along with potential future designs that I will show the design process adequately for a band 6 hopefully. submitted by /u/Bigbrainmc [link] [留言]

I opened v0, typed "a settings page with profile editing, notification preferences, and a connected accounts section," and watched it generate a fully functional three-tab settings interface in under 40 seconds. The component used shadcn/ui primitives, Tailwind utility classes, and TypeScript types — the exact stack I would have chosen if I had written it from scratch. I copied the code, pasted it into my Next.js project, changed two import paths, and it rendered correctly on the first try. This is the v0 value proposition distilled: generate UI components that look like a senior frontend developer wrote them, then paste them into your real project without rewriting half the output. After generating 15 components across two weeks of real product work, I can confirm that v0 delivers on this promise more reliably than any general-purpose AI coding tool I have tested. But its scope is narrower than the marketing suggests, and understanding where v0 stops being useful is as important as knowing where it excels. The shadcn/ui Advantage v0 is built on top of shadcn/ui, and this is the single most important fact about how it works. shadcn/ui is not a component library in the traditional sense — it is a collection of copy-pasteable React components built on Radix UI primitives with Tailwind styling. When v0 generates a component, it uses these primitives directly, which means the output is consistent, accessible, and composable. The practical benefit is that v0-generated components integrate with your existing project without introducing a new design system. If you already use shadcn/ui — and a large and growing percentage of Next.js projects do — the generated components reuse your existing Button, Card, Dialog, and Input primitives. v0 just assumes you have them installed and generates code that expects them. If you do not have shadcn/ui in your project, v0 prompts you to run the initialization command before generating anything, which takes about 30 seconds. This archite

I tested GitHub Copilot Workspace on 12 real tasks across three repositories in May 2026 — a mix of bug fixes, feature additions, and documentation updates. My goal was to figure out whether the spec-first, browser-based workflow actually produces useful code, or whether it is a demo that falls apart when you ask it to do real work. The answer sits somewhere between impressive and frustrating, with the tool's success rate varying dramatically based on task size, repository maturity, and how well you write the initial specification. The Spec-First Workflow Forces Better Communication Copilot Workspace changes the AI coding interaction in one fundamental way that I have not seen elsewhere: you do not start with code, you start with a specification. When I opened Workspace on a Next.js project and typed "add rate limiting to the API routes using the existing rate-limit.ts utility," the system did not immediately generate code. It spent roughly 15 seconds reading my repository, then produced a three-step implementation plan: (1) import the rate-limit utility in each route, (2) wrap the route handler with the rate limiter, (3) add a test for the rate-limited behavior. I could approve the plan as-is, reject individual steps, or add revision notes before any code was written. On this particular task, the plan was correct and I approved it. Workspace then executed each step, modified five route files, and produced a draft pull request with a clear description and a summary of what changed. The entire process — from typing the specification to having a reviewable PR — took 4 minutes and 12 seconds. This planning phase is not window dressing. On a different task where I asked Workspace to "add WebSocket support to the chat feature," it read the repository and surfaced during planning that the project was deployed on Vercel's serverless functions, which do not support persistent WebSocket connections. It suggested using Vercel's Edge Functions with a third-party real-time serv

🚀 The Golden Age of “Just Ship It” A few months ago, I started building side projects differently. Instead of: Planning architecture Reading documentation Writing every function manually I started doing this: “Build me a responsive dashboard with authentication, dark mode, PostgreSQL integration, and Stripe payments.” And somehow… It worked. AI tools can now generate: APIs UI components Database schemas Docker configs Tests Documentation We’ve entered the era of vibe coding . And honestly? It feels amazing. What Is “Vibe Coding”? Vibe coding is when you: Describe what you want Let AI generate most of the implementation Keep iterating through prompts Instead of engineering every detail manually, you steer the vibe of the application. Tools making this popular: Cursor GitHub Copilot Claude Windsurf ChatGPT Replit AI You become less of a code writer and more of a: reviewer editor product thinker debugger At least in theory. The First Few Days Feel Like Magic The productivity boost is unreal. You can build in hours what used to take days. Things that once required: Stack Overflow endless documentation tabs debugging sessions at 2 AM …now happen through prompts. You feel unstoppable. Then Production Arrives And production is where the vibes end. Because production doesn’t care if the demo looked cool. Production cares about: edge cases reliability security scalability maintainability observability This is where AI-generated code starts exposing cracks. Problem #1: The Code Looks Right This is the dangerous part. AI code is often: clean formatted nicely modern-looking confident But hidden underneath: unnecessary complexity duplicated logic subtle bugs bad abstractions Problem #2: Hallucinated Architecture AI is very good at generating: components snippets isolated features It is much worse at: long-term architecture consistency scaling systems over time You start noticing: 4 different API patterns duplicated utilities random folder structures inconsistent state management

If you've trained a transformer in the last three years, your GPU spent most of its wall-clock time inside a matrix multiplication. The kernels doing that work were probably written by cuBLAS, generated by a compiler stack like Triton, or hand-assembled on top of NVIDIA's CUTLASS templates. CUTLASS is the one most people don't see directly, but it sits underneath a surprising amount of modern AI infrastructure — from FlashAttention to vLLM to several internal kernels inside PyTorch. What CUTLASS actually is CUTLASS — CUDA Templates for Linear Algebra Subroutines — is a header-only C++ template library NVIDIA publishes on GitHub under Apache 2.0. It is not a drop-in replacement for cuBLAS. cuBLAS gives you a closed-source binary with a stable API: you call cublasGemmEx and you get a tuned kernel. CUTLASS gives you the building blocks to write your own kernel, with control over tile sizes, data layouts, epilogues, and how the kernel decomposes work across the GPU's memory hierarchy. That control is the point. If you're building a custom inference engine and your projection layer needs to fuse a GEMM with a SiLU activation and a residual add, cuBLAS can't fuse the epilogue for you — you'd launch the GEMM, then a separate elementwise kernel, paying twice for global memory traffic. With CUTLASS, the epilogue is a template parameter. You write the fusion once, instantiate the template, and the compiler emits a single kernel. This is why CUTLASS shows up wherever standard cuBLAS shapes don't fit — unusual data types like FP8, custom epilogues, sparse or grouped GEMMs, attention-shaped matrix products. Anywhere the stock library doesn't have what someone needs and the performance ceiling matters, you tend to find a CUTLASS kernel. CUTLASS is not a productivity library. It is a kernel-author's library. If you're writing PyTorch model code, you'll never import cutlass directly — you'll consume kernels that were built on top of it. The audience here is people who write the ker

The advice was correct. That's what makes it interesting. A creator with a large audience recently described the problem precisely: unused project ideas atrophy. They gave the prescription: externalize the idea, commit to a 30-60-90 day sprint, get into a community that holds you accountable, treat a deployed URL as the only real milestone. The audience listened. The ideas stayed unshipped. Not because the advice was wrong. Because advice is not a mechanism. The gap between diagnosis and structure There's a category of knowledge that's completely useless without enforcement. "You should exercise consistently." Correct. Also irrelevant for the 80% of people paying for gym memberships they don't use. "You should ship your side project in 30 days instead of perfecting it." Also correct. Developers have been hearing this for years. The projects that were "almost done" last year are still almost done. The advice identifies the problem. The problem persists. The gap between them is not information. It's structure. Discipline is the tax on misalignment One phrase from the transcript stayed with me: "Discipline is the tax on misalignment." The insight is sharper than it sounds. When what you're building doesn't connect to why you're building it, every work session requires a new act of will. You're not building forward momentum — you're paying an interest payment on a debt you haven't quite defined. This is why most sprint systems fail. They give you the structure (30 days, daily tasks, accountability partner) but skip the alignment check. The structure holds for two weeks. Then it becomes another system you're "almost following." What the AI makes worse Here's where it gets specific for developers using AI tools on side projects. The AI is genuinely useful. It generates architectures, writes boilerplate, outlines features, summarizes where you are. The output looks like forward motion. But the AI has no ground truth about your actual progress. It has your files and your pr

I switched my primary editor to Cursor in January of 2026 after spending three years on VS Code with GitHub Copilot. The reason was not the chatbot sidebar — every editor has one of those now — but the tab completion model that felt qualitatively different the first time I used it. After six months of daily use across TypeScript, Python, and Go projects, I have a clear picture of what Cursor actually changes about the coding experience and where the marketing outpaces the product. The Tab Completion Model Changed How I Write Code The first thing I noticed with Cursor was that I was pressing Tab instead of thinking about what to type next. That sounds minor, but after tracking my usage over a two-week comparison period, I found that Cursor's tab model correctly predicted my next edit 73 times out of 100 attempts in TypeScript files — measured by counting how often I accepted the ghost text suggestion versus how often I ignored it and typed manually. The mechanism behind this is Cursor's speculative continuation engine. It does not wait for you to stop typing before offering a suggestion. As you modify a function signature at the top of a file, the model silently recalculates the impact on every call site below. I tested this explicitly on a 340-line TypeScript service file where I renamed a parameter from userId to accountId . Before I could scroll to line 180 where the first call site appeared, Cursor had already ghost-written the updated argument. By the time I reached line 310, all six call sites had correct suggestions waiting. That multi-location awareness is what I have not seen any other editor replicate consistently. Not every language gets the same treatment. I ran the same completion acceptance test across three languages I work in regularly. TypeScript came in at the 73 percent acceptance rate I mentioned. Python was close behind at 68 percent. Go was noticeably worse at 51 percent, and the Go suggestions that I did accept frequently required minor correct

After finishing the app I've been working on, I decided to use Paddle to handle monthly and yearly subscriptions. I followed their documentation and getting started page and did almost everything they say, yet I got this error as in the screenshot. That happens after I generate a checkout link in the server side, and navigating to it. If you've encountered such issue before and somehow fixed it, or at least you know a little better in this field, any helpful hints or advices will be truly appreciated https://preview.redd.it/1y9muysics3h1.png?width=1209&format=png&auto=webp&s=baebc208c65540d0a2cc8be24c0e90110b3ceefd submitted by /u/WadieZN [link] [留言]

The Problem We Were Actually Solving Treasure hunts in Hytale arent just about generating loot. Theyre about generating simultaneous loot across thousands of players while keeping the world state consistent. We started with the assumption that events are stateless notifications: a hunt starts, we fire an event, clients react. That model worked fine when we had 200 concurrent players. At 2,000 players, the event bus turned into a 40 MB/s firehose of JSON blobs. Each loot drop required serializing the entire chunk state—blocks, entities, metadata—so clients could render the drop in real time. The JVMs G1GC couldnt handle the allocation rate. Every 47 minutes, a GC cycle would pause for 4.2 seconds, the chunk cache would fragment, and the server would hard crash with an OutOfMemoryError in net.minecraft.server.MinecraftServer#processQueue. The real problem wasnt the hunt logic. It was the architectural laziness of treating events as a catch-all glue layer instead of a boundary layer with explicit interfaces. What We Tried First (And Why It Failed) We tried Kafka as the event bus. The plan was to shard hunts by region and stream loot drops as compacted topics. The first run worked for about 6 hours before the compacted topics started to bloat. Each hunt was generating 700 KB of serialized chunk state per drop. At 30 drops per hunt per minute, thats 21 MB per hunt per minute. With 400 active hunts, the brokers couldnt keep up. The lag grew to 12 seconds, clients started rubber-banding, and we got a flood of Discord reports: You sank my boat! The event stream was now the bottleneck, not the event source. Next, we tried Redis Streams with a Lua script to aggregate loot drops per chunk. Within 30 minutes, we hit the 4 GB maxmemory limit because Lua scripts were stacking dropped items in memory while waiting for the next batch. The script was elegant—O(1) per drop—but the memory footprint made it unusable in production. Finally, we tried a sidecar service: a small Go process

Disclosure: I work on Passlens, a browser-first passport and ID photo maker. This post is about the product decisions behind that workflow, not a neutral review of every tool in the space. A passport photo looks simple until you try to make one that an upload form will actually accept. It is a headshot, yes, but it is also a small chain of constraints: physical size, pixel size, background, head position, print scale, and whatever the destination country's portal decides to reject that week. That is why generic photo editors feel slightly wrong for this job. They can crop. They can resize. They can export. The hard part is not any one of those actions. The hard part is keeping all of them tied to the document rule the user picked. The unit problem For developers, document photos are awkward because two units matter at the same time. A user may need a 2x2 inch passport photo. A visa portal may ask for 600x600 pixels. A print sheet may need 35x45 mm photos at 300 DPI. These are not the same request, but people often treat them as if they are. If the app only thinks in pixels, the print can come out the wrong physical size. If it only thinks in millimetres or inches, the digital upload can be rejected for the wrong pixel dimensions. A good workflow has to keep both ideas alive: the document size and the export target. That is the main reason Passlens keeps presets and print layouts as first-class pieces of the workflow instead of treating them as labels on a crop box. The crop is not the output Another small trap: the crop the user sees is not always the final output. For a digital upload, the crop usually becomes one image file. For printing, the same crop may become several photos arranged on 4x6, A4, or Letter paper with spacing, margins, and optional cut marks. If that print sheet is scaled by the browser or printer dialog, the whole thing is wrong. So the editor needs to separate three things: the face and shoulder crop the finished document-photo size the print s

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

Calculate and track FPS on the web page yourself to track performance issues and regressions. submitted by /u/jssmash [link] [留言]