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 built a Linux CLI tool that encrypts and decrypts folders using AES-256-GCM. It also hides file and folder names and stores the mapping in an encrypted file. Repo: https://github.com/sahilPadmani/ACE-files-encryption

A while ago I tried to build a local coding assistant. I downloaded Qwen3, fired it up on my MacBook with 16GB of RAM, and within a day realized the output quality was nowhere close to Claude or GPT-5. The model could fit . It just couldn't compete . So I changed the question. If I can't make the model smarter on my hardware, can I make what I feed it smarter? Where the tokens actually go I started watching where my Claude / Cursor / Copilot sessions actually spent their tokens. The surprise: most of it wasn't reasoning. It was lookup . Every fresh chat about my company's database re-discovered the same things: What does status = 3 mean? (cancelled) How does orders join to users ? ( orders.user_id → users.id ) What's that cryptic JobStatus enum? (a dozen integer codes nobody remembers) The model figured it out, the session ended, and tomorrow it figured it out again . Same tokens, same latency, every single time. The expensive part of working with an AI wasn't the thinking — it was re-teaching it things it had already learned yesterday. There's a lot of attention right now on trimming AI output tokens (talk like a caveman, strip the pleasantries, etc.). But in my workflow the bigger leak was on the input side: paying full token cost every session to re-establish context that never changed. "Memory" isn't a feature, it's an architecture question AI clients are starting to bolt on "memory" features. But they're proprietary, opaque, and locked to one tool. Claude's memory doesn't help Cursor. Cursor's doesn't help Copilot. You can't inspect it, you can't share it with a teammate, and you can't diff it. What I actually wanted was an explicit, inspectable, shareable context layer that any AI client could read deterministically — same answer every time, same file my team could hand off. I picked the highest re-learn cost in my world to start with: SQL databases. Enter amnesic amnesic is an open-source MCP server that gives any AI client persistent semantic memory of your

Most trading ideas start as vague thoughts. "Buy when RSI is oversold and price bounces from support." It sounds reasonable. But the moment you try to test or automate it, the ambiguity becomes obvious. What exactly counts as oversold? How is support defined? What qualifies as a bounce? When do you exit? Without precise answers, the idea cannot be tested, measured, or executed consistently. This gap between intuition and execution is exactly what no-code strategy builders are designed to close. Why vague trading ideas fail Most traders think in concepts rather than rules. "Buy the dip." "Trade strong momentum." "Enter when the trend looks healthy." These ideas feel intuitive, but they are unusable in practice unless translated into explicit logic. Without clear definitions, you cannot backtest a strategy, cannot repeat decisions consistently, and cannot diagnose why results change over time. Ambiguity leads to second-guessing. Second-guessing leads to inconsistent execution. Inconsistent execution makes performance impossible to evaluate. What a no-code strategy builder actually does A no-code strategy builder is a visual system that forces clarity. Instead of writing code, you select indicators, define conditions, combine logic using AND/OR rules, specify entries and exits, and then test the strategy on historical data. Conceptually, it works like assembling building blocks. Each block represents a condition such as "RSI below 30" or "price above moving average." When combined, those blocks form a complete, testable trading system. The key benefit is precision. From idea to testable strategy The transformation follows a predictable workflow. You begin with a loose idea, such as buying when a stock is oversold and starting to recover. You then break that idea into components. What defines oversold? What signals recovery? How do you enter? How do you exit? How much do you risk? Once those questions are answered, the idea becomes a set of explicit rules. For example,

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 really like NotebookLM, especially for dumping PDFs/slides/long YouTube videos into one place and asking questions about them. But I’m starting to feel like it’s very “research workspace” first, which makes sense. It’s great when I already have sources and I want to understand them. Less great when I want something more flexible for actual learning, especially on mobile. The things I’m looking for: - handles PDFs, slides, articles, and long You Tube videos - lets me chat with the material / summarize / ask follow-up questions - has more output styles than just one default format - ideally lets me change voice, tone, length, and depth - works well on mobile - can translate or help me learn across languages - good for topics beyond school research, like communication, social skills, history, humanities,career stuff, etc. - bonus if it helps plan what to learn next instead of just summarizing one source A few I’ve looked at so far: Quizzify seems good if your main use case is active recall. It’s more of a quiz/practice-test focused, which is useful because summaries can trick you into thinking you learned something. My brain absolutely falls for this. The downside is that it feels more school/study-tool specific. BeFreed for the audio learning side. It’s not really a NotebookLM clone, but that’s kind of why I like it. You can paste a PDF, article, You Tube link, or just prompt a topic, then it turns it into a personalized audio learning path. You can adjust the voice, style, depth, and length, and the mobile experience is much better for learning while walking/commuting. I’ve used it more for history, communication, social skills, and career-type topics than pure school research. Elephas looks interesting for Mac users because it can do document Q&A and writing locally. That might be helpful if connection issues are the annoying part. But from what I can tell, it’s more of a doc chat / writing assistant than a flexible learning app. Gamma / Canva / Napkin seem strong

Download: App List Sau khi Export một file .html thì bạn mở lên sẽ không thấy app icons đâu. Hãy chạy đoạn script Python dưới đây để có thể **bổ sung app icons vào Android app list *. Để tìm kiếm và bổ sung tự động icon thực tế của ứng dụng (từ Google Play Store hoặc các nguồn khác trên mạng) vào file HTML của bạn, phương pháp tối ưu nhất là sử dụng Script tự động (Python hoặc NodeJS) kết hợp với các công cụ/API cào dữ liệu (Web Scraping). Vì trong file HTML của bạn đã có sẵn mã gói ứng dụng (ví dụ: com.alibaba.aliyun ), việc tìm kiếm bằng package-name sẽ cho kết quả chính xác 100%. Dưới đây là các phương pháp phổ biến và dễ thực hiện nhất: Phương pháp 1: Sử dụng thư viện Python google-play-scraper (Khuyên dùng) Đây là cách dễ nhất, không cần đăng ký API key và tỷ lệ thành công rất cao. Thư viện này sẽ tự động tìm kiếm trên Google Play Store dựa trên package-name và trả về link icon (hình ảnh). Cách hoạt động: Đọc file HTML của bạn để lấy tất cả package-name . Dùng thư viện quét qua Play Store để lấy URL của icon. Chèn thẻ <img src="URL_ICON" /> vào trước tên ứng dụng trong HTML. Đoạn code Python mẫu để bạn chạy: (Trước khi chạy, bạn cài thư viện bằng lệnh: pip install google-play-scraper beautifulsoup4 ) Lưu file với tên tuỳ chọn và chạy trong cmd.exe: py append_applist_icons.py . from bs4 import BeautifulSoup from google_play_scraper import app as play_app import time # 1. Đọc file HTML gốc của bạn (thay tên file tương ứng) input_file = " apps_20260527232642_1.html " output_file = " apps_with_icons.html " with open ( input_file , " r " , encoding = " utf-8 " ) as f : soup = BeautifulSoup ( f . read (), " html.parser " ) # Tìm tất cả các khối ứng dụng app_items = soup . find_all ( " div " , class_ = " app-item " ) print ( f " Đang xử lý { len ( app_items ) } ứng dụng... " ) for index , item in enumerate ( app_items ): package_div = item . find ( " div " , class_ = " package-name " ) if package_div : package_name = package_div . text . strip () try : # 2. Lấy thông

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

I've been running AI workloads on Azure Container Apps for over a year. Every time I spin up a new agent backend, the ritual is the same: create an environment, configure networking, set scaling rules, wire up health probes, then deploy the actual container. For a prototype agent that might live for a week, that's too much ceremony for what you get. ACA Express, which hit public preview in May 2026, kills most of that ceremony. And a separate but related announcement, Docker Compose for Agents, brings MCP gateways and model serving to standard ACA environments. They solve different problems and run on different infrastructure, but together they cover the full spectrum of agent deployment on Azure. Let me break down both. ACA Express: What It Actually Is Express is a new environment tier within Azure Container Apps. You bring a container image. Express handles provisioning, HTTPS, scaling (including scale-from-zero with subsecond cold starts), and resource allocation. No environment to manually provision through the portal. No networking to configure. No scaling rules to write. Under the hood, Express is built on ACA Sandboxes, a platform primitive that uses prewarmed pools to deliver that subsecond startup. This isn't the standard ACA cold-start experience with a fresh coat of paint. It's a different architecture. The tradeoffs are real. Express is HTTP workloads only, consumption CPU only. No GPU. No VNet integration. No Dapr. No service discovery between apps. No managed identity at runtime. No health probes. If you need any of those, standard ACA environments are still there. But for stateless HTTP agent backends, Express is dramatically faster to deploy and cheaper to run. Here's what it takes to get a container running: # Create an express environment az containerapp env create \ --name my-express-env \ --resource-group rg-my-agents \ --environment-mode express \ --logs-destination none # Deploy your app az containerapp create \ --name my-agent-api \ --resource

🚀 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

I am responsible for a research project that is supposed to train a GPT-like model (Transformer-decoder) with 100M, 250M and 500M model variants. # params ## training dataset - 750M tokens - vocabulary is ~15k to ~100k tokens (depends on tokenizer settings) - ~3% of the vocabulary is used in ~50% of the training tokens (similar to language, where most of the vocabulary is used very sparsely) ## training hyper-params - optimizer = AdamW - lr = 1e-3 (works the best compared to 1e-2 and 1e-4) - betas = [0.9, 0.95] - effective batch size = 4M tokens - epoch = 16 - warmup steps ~200 (approx 1 epoch) ## model hyper-params - 16 layers (but variants with up to 48 layers were tested) - embedding = flexible to yield 100M, 250M and 500M model - MLP size = 4*n_embd - 16 attention heads - context window = 1000 # Issue The model seems to fail to learn the basic auto-regressive behavior. It often gets stuck on generating a single token (no repetition penalty, no sampling yet). Is training GPT-like models still a black magic? Is there some trick to this? *Disclaimer*: I will add/edit the parameters above as people ask clarifying questions. submitted by /u/gartin336 [link] [留言]

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

Introduction In my previous IAM article we learnt basics of IAM and how to create Users, Groups and attach Policies. You can refer here: https://dev.to/kadhamvj23/aws-identity-and-access-management-explained-for-beginners-cn7 After setting up secure access to our AWS account using IAM, the next question we mostly have is where do we actually run our application? The answer is Amazon EC2 - Elastic Cloud Compute. EC2 is one of the most widely used AWS services and understanding it well is essential for anyone starting their cloud journey. In this article we will cover what EC2 is, why it exists, the different types of instances, pricing models, Regions and availability Zones and finally hands-on walk through of creating your first EC2 instance. Breaking Down the Name -EC2 Let us understand what each word in the name actually means: Elastic --> In AWS you will notice many services have this prefix "Elastic". The reason is simple. Whenever AWS provides a service that can be scaled up or scaled down based on our needs, that service is called Elastic . With EC2 you can increase resources when traffic is high and decrease them when the traffic is low. So in simple terms EC2 = A virtual server on the cloud that you can resize anytime. Cloud: EC2 runs on AWS's public cloud infrastructure, meaning the servers are owned and managed by Amazon across the world. Compute: The word compute means you are asking AWS to provide you CPU, RAM and Disk - basically a virtual machine or server that can run your applications. How does EC2 actually work? When you request a Virtual server from AWS, here is what happens behind the scenes: You request a virtual machine on AWS ⬇️ request goes to a Hypervisor(a software layer sitting on top of physical servers that creates and manages VMs) ⬇️ Hypervisor creates your VM ⬇️ You get the access to your EC2 instance You never touch any physical hardware. AWS manages all of that for you. Why use EC2? Imagine your company wants to host an application. T

Why We Built JaisCloud — A Free, Single-Binary AWS Emulator in Go If you've ever tried to test AWS-dependent code locally, you've probably reached for LocalStack. It works — but it comes with baggage: Python runtime, Docker dependency, and the features most teams actually need locked behind a Pro subscription. JaisCloud is our answer to that problem. What is JaisCloud? JaisCloud is a free, open-source local AWS cloud emulator written entirely in Go. It implements the exact AWS wire protocols — Query/XML, JSON/Target, REST — so your existing SDK code points at JaisCloud and works unmodified. No shims, no proxy rewrites, no SDK patches. # Start it jaiscloud-aws start # Point your SDK at it export AWS_ENDPOINT_URL = http://localhost:4566 export AWS_ACCESS_KEY_ID = test export AWS_SECRET_ACCESS_KEY = test export AWS_REGION = us-east-1 # Your existing code works — no changes needed aws s3 mb s3://my-bucket aws sqs create-queue --queue-name my-queue The Problem With Existing Solutions JaisCloud LocalStack Community Moto Single static binary Yes No - Python + Docker No - Python library Zero runtime deps Yes No No Postgres persistence Yes Pro only No Real Spark/EMR execution Yes No No Apache Iceberg Yes No No Prometheus metrics Yes Pro only No State export / import Yes No No Deterministic time control Yes No No Written in Go Yes No No License Apache-2.0 Apache-2.0 Apache-2.0 Key Features Single Static Binary JaisCloud ships as a single Go binary per cloud. No Python, no Docker, no Node — just download and run. Works on laptop, CI runner, or Kubernetes pod. # Download and run — that is it ./jaiscloud-aws start # Or with Docker docker run --rm -p 4566:4566 rjaisval/jaiscloud-aws:latest Portable State Snapshots Export the complete emulator state — every resource, every account, every region to a single gzip tarball and restore it anywhere in milliseconds. # Capture a baseline jaiscloud-aws export -o baseline.tar.gz # Restore on a teammate's machine or CI runner jaiscloud-aws i

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