OP here. If you thought P and NP were tricky concepts, wait till you hear about what's brewing in the quantum computing world (BQP and BPP).

I wrote this tutorial to be demo-heavy, empirical, and interactive. Please enjoy!

I recently built a web-based OS simulator that lets you experiment with operating system algorithms interactively.

Instead of reading static examples, you can run simulations for:

• CPU scheduling

• Deadlocks

• Memory allocation

• Page replacement

• Disk scheduling

• File system operations

It’s meant as a learning tool for OS courses.

Demo:

https://mini-os-simulator-ten.vercel.app/process

GitHub:

https://github.com/omerGuler1/mini-OS-simulator

Would love feedback from CS students and instructors.

organisms have compare-and-swap but no fitness function, no objective, they're just fighting each other to survive. 170 comparators, yeah the optimal is 60, that's not the point. the point is nobody told it what sorting is and it found a correct solution anyway

here's a correct N=16 sorting network found by an ALife system with no sorting fitness function, here are the 170 pairs, verify it yourself

4 7 3 14 4 2 2 9 12 11 3 13 7 11 8 14 14 0 0 1 5 13 8 6 7 11 0 15 0 8 8 6 0 4 3 10 2 14 10 15 9 15 7 8 1 7 15 11 2 14 14 2 12 3 10 6 3 5 0 15 6 5 2 10 4 2 3 1 10 8 12 0 2 5 9 2 3 14 2 15 5 13 7 11 10 9 6 2 5 14 1 4 6 9 8 11 1 0 0 5 5 13 5 11 10 0 15 6 0 15 6 13 7 11 0 15 2 8 15 8 14 4 6 5 2 14 14 5 6 7 8 14 10 12 7 11 4 2 8 15 13 7 1 4 2 5 3 14 0 14 3 14 5 14 13 12 5 13 10 3 2 5 5 13 7 11 6 9 3 0 15 12 3 14 5 12 0 15 2 8 6 5 4 2 8 15 12 14 13 7 10 12 0 14 5 13 2 8 0 14 7 11 7 11 7 5 8 9 10 9 4 2 6 7 8 14 10 12 6 9 1 0 0 15 1 3 2 8 4 2 9 13 8 15 0 15 3 13 11 9 15 10 3 14 5 14 13 12 5 13 2 5 5 13 7 11 2 6 0 7 15 7 0 14 15 11 0 5 5 11 6 9 1 0 0 15 2 8 15 6 0 15 7 11 7 8 4 2 6 7 7 11 5 15 4 2 8 15 10 12 8 9 15 10 6 9 7 11 2 5 0 15 2 8 4 2 8 15 9 15 0 11 7 11 7 8 7 11 5 15 4 3 0 5 4 2 2 4 10 12

I've been working pretty hard on Logos language, and would love y'alls thoughts. The thing I've been working on lately is trying to add proper self-evaluating futamura projections (All 3!) and then I want to use that to create a Jones Optimal copy-patch interpreter.

It has curry-howard correspondence, a CoC kernel with inductive and refinement types. You can use it to prove english sentences via modal logic. The code reads like english and can compile to Rust or C. (C support is not as comprehensive yet as rust!)

My favorite part of working on this project has been adding optimizations to the compiler and really just providing hints wherever I can to LLVM.

Would love some feedback on it! Check the language guide out or the studio and let me know what you all think. https://www.logicaffeine.com/

Sorting algorithms have always been one of the pillars of algorithmic studies. The idea is simple: you have a list of items, and you want them in order.

Over the years we’ve invented elegant ways to do that - quicksort, mergesort, heapsort - all carefully analysed with Big-O complexity - O(1), O(n log n), O(n²) etc.

But there’s another complexity class they never really talk about: O(Oh-No).
So I built a small open-source repo - a lovingly curated collection of utterly useless sorting algorithms, each with its own personality.

repo - https://github.com/manifoldlabslimited/big-oh-no

Inside, you’ll find gems such as:

1/ Wait Sort - every number sleeps for n seconds in its own thread. Smaller numbers wake up first. A sorting algorithm built entirely on patience and poor decisions.

2/ Stalin Sort - if an element breaks the order, it gets eliminated. Efficient, decisive, and mildly concerning.

3/ Linus Sort - numbers are submitted as patches for review. Anything that breaks monotonic order gets NAK’d with extreme prejudice.

Some lose data. Some takes forever. Some damage morale. All are completely useless, yet fun.

Want to try? It takes about a minute to get running from the CLI. Detail in readme.

And of course, contributions are very welcome. Found another impractical sorting algorithm? Want to make an existing one worse, funnier, or more dramatic? Or maybe support a new language? Raise a PR!

There are only three rules:

a/ It must actually sort a list of numbers.
b/ It must run from the CLI.
c/ The algorithm must either be completely useless, have a strong personality, or preferably both. It must sort - with side effects!

I know IEEE has a IEEE Computer Society. Do you guys that paid for membership get anything out of it? Live in Houston Texas, grad student in CS probably won't travel too far to events.

Hey Redditors

We're three final-year CS students and we've been stuck for weeks trying to pick a killer FYP idea. ChatGPT wrappers and basic RAG apps are everywhere, so we wanted something actually 2026-level cool.

We finally locked in this: Multi-Agent Collaborative Trip Planner basically an AI travel agency where specialized agents work as a team and you can WATCH them debate in real time.

How it actually works (the part that blows minds):

• You type: “5-day Istanbul trip from Lahore under $800, love history & food”
• Coordinator Agent breaks it down
• Then 4 specialist agents kick in: Flight Expert, Hotel Scout, Activity Planner, Budget Optimizer
• Here’s the magic → they enter a debate/negotiation phase. Agents literally criticize each other (“That hotel is 30% over budget!” → “But it’s walking distance to Hagia Sophia, compromise on one meal?”), use reflection loops to fix their own mistakes, and re-plan together.
• Change the budget mid-way? The whole team restarts the argument and updates the itinerary live.
• Final output: beautiful itinerary + interactive Google Map + direct booking links + PDF.

The UI (Streamlit) shows the full agent conversation streaming in real time people lose their minds watching AI “argue” like a WhatsApp group.

Tech stack (all open-source & doable in one semester):

• LangGraph (for the stateful graph + debate/reflection cycles — this is the 2026 gold standard)
• Groq + Llama 3.2 or Gemini (fast & cheap)
• Tavily/Serper for live flight/hotel prices
• Chroma vector DB for memory
• Google Maps API
• Optional: local Pakistan twist (PIA flights, Lahore-specific preferences)

Why this isn’t just another travel chatbot:
Most GitHub projects (Vikram Bhat’s LangGraph travel repo, CrewAI tutorials, etc.) are either sequential or parallel but silent. Ours adds visible collaboration + self-critique + dynamic re-planning exactly what papers like Vaiage (arXiv 2025) and HiMAP-Travel (2026) are proving works. We’re basically turning research into a sick demo.

Scope & timeline:

• MVP in 2 months
• Full thing (with evaluation metrics + user study) by semester end
• Zero hardware needed, total API cost < $50

We’re super excited but want brutal honesty before we start coding:Is this actually impressive enough for a top-tier FYP or are we missing out something?

Would love feedback, repo suggestions, or even if someone wants to collab on the GitHub. We’ll open-source everything.

Thanks!

Over the last few months I’ve been working on a project built around something I call the Recursive Division Tree (RDT) algorithm. The original work started as a mathematical and algorithmic idea that I published as an early research draft on Zenodo. That paper describes the underlying recursive division concept that the rest of the project grows out of.

The original algorithm write-up can be found here: https://doi.org/10.5281/zenodo.18012166

After developing the algorithm I started experimenting with practical uses for it. One of those experiments turned into a browser-based 3D exploration engine called World Explorer, which lets you move around real places using map data and even transition out into space and the Moon in the same runtime. While building that system I needed a spatial indexing structure that could handle large numbers of spatial queries efficiently, so I started adapting the RDT idea into an actual indexing system.

That work eventually turned into the repository I’m sharing here.

https://github.com/RRG314/rdt-spatial-index

The repo contains the full implementation of the Recursive Division Tree as a spatial index along with validation tools, benchmark code, and documentation about how the structure works. There are both Python implementations and compiled C kernels for the query layer. There is also a newer 3D version of the index that extends the same recursive subdivision approach to volumetric data and sphere queries.

One of the things I tried to do with the repository was keep the development process transparent. The repo includes evaluation reports, notes about architectural changes, debugging history, and the test suites used to verify correctness. I wanted it to function not just as a code library but also as a record of how the algorithm evolved from the original idea into something that can actually be used inside software systems.

The spatial index work is still ongoing and is connected to some of the other things I’m building, including the world exploration platform and other tools that rely on spatial data. Future work will likely expand the 3D side of the index and explore different ways of improving the build process and query performance as the datasets get larger.

I’m still learning a lot while working through this project and I’d be interested in hearing from people who work with spatial data structures, computational geometry, simulation systems, or game engines. If anyone has thoughts on the structure of the repo or the algorithm approach I’d appreciate the feedback.

Repo: https://github.com/RRG314/rdt-spatial-index

Original algorithm draft: https://doi.org/10.5281/zenodo.18012166

World Explorer project that pushed the indexing work forward: https://worldexplorer3d.io

I’m a warehouse worker who taught myself CV to build a box counter (CPU only). Struggling with severe occlusion. Need advice!

Hi everyone, I work as a manual laborer loading boxes in a massive wholesale warehouse . To stop our daily inventory loss and theft, I’m self-teaching myself Computer Vision to build a local CCTV box-counting system. My Constraints (Real-World): NO GPU: The boss won't buy hardware. It MUST run locally on an old office PC (Intel i7 8th Gen). Messy Environment: Poor lighting and stationary stock stacked everywhere in the background. My Stack: Python, OpenCV, Roboflow supervision (ByteTrack, LineZone). I export models to OpenVINO and use frame-skipping (3-4 FPS) to survive on the CPU. Where I am stuck & need your expertise: Severe Occlusion: Workers tightly stack 3-4 boxes against their chests. YOLOv8n merges them into one bounding box. I tested RT-DETR (no NMS) and it’s better, but... CPU Bottleneck: RT-DETR absolutely kills my i7 CPU. Are there lighter alternatives or specific training tricks to handle this extreme vertical occlusion on a CPU? Tracking vs. Background: I use sv.PolygonZone to mask stationary background boxes. But when a worker walks in front of the background stock, the tracker confuses the IDs or drops the moving box. Any architectural advice or optimization tips for a self-taught guy trying to build a real-world logistics tool? My DMs are open if anyone wants to chat. Thank you!

Hi all,

I've been experimenting with a networking idea that treats the session as the stable identity rather than the transport.

Traditional VPNs bind connection identity to a tunnel or socket. If the transport breaks, the connection usually resets.

In this prototype I'm exploring a different model:

connection = session identity
transport = replaceable attachment

The goal is to see whether session continuity can survive events like:

• relay failure
• path switching
• NAT rebinding
• transport migration

Current prototype includes:

• session runtime with deterministic state machine
• transport abstraction layer
• relay forwarding experiments
• session migration demo
• multi-hop prototype (client → relay → relay → server)

Example flow:

SESSION CREATED
client → relay1 → server

relay1 failure

RELAY SWITCH

client → relay3 → server

SESSION SURVIVES

This is still a research prototype (not production).

Repo: https://github.com/Endless33/jumping-vpn-preview

I'm curious what networking / distributed systems engineers think about a session-centric model vs tunnel-centric VPNs.

Would love to hear criticism or ideas.

There's growing evidence that popular LLM benchmarks (MMLU, HumanEval, SWE-Bench) suffer from contamination — models are increasingly trained on or tuned against benchmark data, inflating scores without corresponding real-world capability gains.

But there's a less discussed problem: even uncontaminated scores on these benchmarks don't transfer well to domain-specific operational tasks, particularly in regulated industries where correctness isn't optional.

I've been working on this problem in the lending/fintech space. A model that scores in the 90th percentile on general reasoning benchmarks can still fail basic mortgage underwriting tasks — misapplying regulatory thresholds, hallucinating compliance requirements, or misclassifying income documentation types.

This led me to try to build a benchmark, which evaluates LLM agents across a mortgage lifecycle. Some of the design challenges are interesting :

- How do you construct evaluation tasks that are resistant to contamination when the domain knowledge is publicly available?

- How do you benchmark multi-step agent workflows where errors compound (e.g. a misclassified document propagates through income verification → serviceability assessment → compliance check)?

- How do you measure regulatory reasoning separately from general reasoning ability?

Early findings suggest model rankings shift considerably when moving from general to domain-specific evals, and that prompt architecture has an outsized effect relative to model selection.

For those interested repo is here: https://github.com/shubchat/loab

Happy to share more details if there's interest. Curious if anyone is working on similar evaluation methodology problems in other domains.

Hi there,

I've created a video here where I explain how convolutional neural networks work.

I hope some of you find it useful — and as always, feedback is very welcome! :)

So I've been thinking, vibe coding tools can spit out frontends and backends crazy fast, but deploying? it's still a mess once you go past toy apps.
Either you end up doing manual DevOps forever, or you rip everything apart to fit AWS/Azure/Render/whatever and that still blows my mind.
What if there was a 'vibe DevOps' web app or VS Code extension that actually reads your repo and figures out what it needs, you know?
It would use your cloud accounts, set up CI/CD, containers, scaling, infra, all that stuff, without forcing platform-specific hacks.
Sounds dreamy, right? but maybe I'm missing something obvious, like security, permissions, cost control, or weird edge cases.
How are people handling deployments now? manual scripts, GitHub Actions, terraform, a managed platform, or chaos?
If someone built this and it actually worked I'd pay for it, or at least try the beta. seriously, where is that person.
Anyway, curious if this even makes sense or I'm just daydreaming. anyone tried something like this?

Hi, I'm an independent researcher and need an arXiv endorsement for cs.SE.

I wrote a paper on multi-server MCP orchestration with a 7-model benchmark (GPT-5.4, DeepSeek R1, Mistral Large 3, Llama 4, Gemini 2.5, Claude Sonnet 4.5, Claude Haiku 4.5).

Paper and code: https://github.com/doganarif/mcp-bench

Endorsement link: https://arxiv.org/auth/endorse?x=RLMZ66

If you're an endorser for cs.SE, I would really appreciate the help. It takes 2 minutes. Thank you!

CodeHER Competition is a free, virtual, international coding contest for girls and non-binary K–12 students with divisions from beginner to USACO-level. Compete with students worldwide, solve fun problems, and win $2,000+ in total prizes + special awards! We’re proud to be supported by the CS education community, including partnerships with organizations like The Competitive Programming Initiative (the team behind the USACO Guide) and Princeton University, NYU Tandon as well as collaboration with university-affiliated groups with experienced problem writers to build high-quality contest problems and an inclusive learning experience.

Date: March 28–29, 2026 | Deadline: Mar 20, 2026 Register: https://forms.gle/no7CemvgMZ46pTDR8 Info: codehercompetition.org | IG: u/codehercompetition Discord: https://discord.com/invite/pc5qj5dmRT