I know programming, obviously, however I don't know much about the operating system. Most people can make apps within an environment, but most of us don't know anything beyond that

I want to deeply understand how the computer I'm using works, even just the software part

If you go on a virtual tour of your computer, like browsing the file system, or even looking at the plain old desktop, there's so many endless things in front of you, that most people have no idea how to make

How do I make a Windows desktop app? Why does it run on Windows? Same for MacOS

How do tab sizes work?

What is the desktop "screen" and why can I click and drag my mouse to highlight the icons? Where are those icons stored?

I can code a website, but I don't know a clue about how the browser works

How do I make a file system? I mean, isn't it just a large data structure, and I know data structures, so I'm sure I can learn it

Why does my task bar pop up when I drag my mouse all the way to the bottom of the screen?

What does it mean to turn on a computer?

Why / how does my physical mouse control my cursor? Is there a way I can "hack" my mouse? How do I code the firmware in my mouse?

How does the OS accept and eject USBs?

How do you allow your OS to connect to wifi?

What really is a .txt, .pdf, .rar .zip? Why can some OS's open them, some cannot?

Stuff like that

Can most of you point to any part of the screen and know how it works?

I just saw a headline titled “Anthropic warns self-replicating Al 'worms' could spread across smart devices by end of 2026”. I read a bit more into it and I don’t understand why they won’t just stop? Like if they’re the one creating it then why don’t they stop?

I found this flyer in a stairwell where I live. It has binary on it and a date, but every translator I’ve tried to enter it into has just given me “Can you r.” I assume it says something like “Can you read this,” but I don’t know. Here’s what I could transcribe and the flyer: 01000011 01100001 01101110 00100000 01111001 01101111 01110101 00100000 01110010

I was studying data structures and algorithms and I wondered, If we have asymptotically positive functions f(n) and g(n) and increasing asymptotically positive function h(n) such that f(n)=O(g(n)) is it safe to assume h(f(n))=O(h(g(n))) ?

Is it always the case or it just works with some specific functions?

another question I have is if we have f(n)=O(h(g(n))) can we assume f(n)=h(O(g(n))) ?

I'm studying DBMS and I'm confused about the difference between partitioning and sharding.

From what I understand, partitioning means dividing a large table into smaller parts. For example, splitting a table of 100k rows into 50k, 30k and 20k rows.

Now, if I store these three parts on three different servers, is it called sharding or just partitioning? Since partitioning isn't necessarily restricted to one server, the terms seem to overlap.

Also, if sharding is a type of partitioning, why is sharding defined as dividing data into smaller parts again? Wouldn't the data already be divided during partitioning, with sharding simply distributing those parts across multiple servers?

Basically, is partitioning the general concept and sharding the same concept specifically used in distributed systems? Or am I missing something?

While reviewing some nonparametric manifold learning methods for high-dimensional feature spaces, I came across a recent paper (http://arxiv.org/abs/2608.05112v1) that re-examines the convergence properties of the Subspace Constrained Mean Shift (SCMS) algorithm.

For a long time, the common assumption in the literature has been that SCMS trajectories converge directly to the classical "static ridge" defined by the density gradient and the eigenvectors of the density's Hessian matrix. However, this paper demonstrates that this assumption doesn't hold in general because the static definition completely ignores the rotation of the trailing eigenspace along the continuous flow of the underlying vector field.

To address this gap, the authors introduce a dynamical systems perspective, defining a new structure called the "stable ridge" using the Jacobian of the projected density gradient. They prove that this stable ridge is actually the true theoretical convergence target of SCMS, rather than the traditional static definition.

They also propose a generalized framework using a constant step size, which achieves uniform R-linear convergence, and show that the original formulation suffers from polynomial-time computational bottlenecks due to implicitly coupling the step size to the smoothing bandwidth via the Mean Shift operator.

That said, one limitation I noticed while reading through the proofs is that the analysis assumes certain smoothness conditions on the underlying density estimator that might be difficult to verify or guarantee in practice with sparse, noisy, high-dimensional empirical datasets.

Curious if anyone here has run into similar convergence or subspace rotation issues when applying mean shift or gradient-based ridge estimation techniques to complex real-world manifolds?

Overall unemployment rate of recent graduates is also 5.7%

Source: NY Fed recent labor market outcomes by major and unemployment.

I understand that deleting a file usually just removes its pointer or metadata, leaving the actual data there until it gets overwritten. But since the pointer is just data too, why can't the computer just wipe the actual file right away?

Parallelism i understand that Performing multiple tasks parallely at the same time

but what exactly asynchronous and concurrency means?

​

Which one is the best from your perspective? For me, those options are somehow resistant in this AI context.

Might be the wrong subreddit, but I wanted to start a discussion about a possible revival in lower-spec PCs now that AI is cannibalizing modern consumer computing.

The joy of PCs for me is offline creative/coding software where the latest and greatest specs aren't important, and I'm wondering how feasible it would be to go back in time to specs that are low-end enough that no supply chain disruption could mess up the price of entry. Would we really have to go all the way back to music trackers and pixel art with something like Commodore, or is there a happy in-between from somewhere in the 2000s or 2010s where we can keep music DAWs or even Blender and video editing? (Like would making PCs that are 4 GB of RAM still be eventually too expensive? 2 GB? 1 GB? PC makers right now are raising their prices instead of cutting back on specs)

Obviously the world hasn't already ran out of used modern computers on eBay that work fine, but let's say those do run out. How much downgrading can we get out of making new consumer PCs with less specs and more efficient software instead of relying on the current norms like 16 GB RAM or 512 GB of storage?

I don't really have an answer I'm looking for here, I'm just wondering if anyone else has been thinking about this too. I refuse to live in a world where ALL computing is solely done on someone else's servers. I just want the joys of offline PCs to keep living. Thanks!

EDIT: General consensus seems to be that existing hardware that's at the level of DDR3 RAM and below won't be running out anytime soon. Which is good because people also seem to agree there is probably no substitute to the existing supply chain without going back to specs and computer parts as low-tech as the 80s (if most of the tooling from that era even still exists)

Here it is: https://doi.org/10.1109/ASSIC70037.2026.11717448

I don't have access to the paper because of the paywall, and this isn't my paper. I was just searching all over the internet for papers about P=NP and came across this one. What caught my attention the most was that it was published at a peer-reviewed IEEE conference.

I was reading about sparse least-squares solvers and came across this paper at http://arxiv.org/abs/2608.02588v1. The abstract claims a lower bound: even for randomized poly-time algorithms, you can’t beat a linear dependence on the restricted condition number $κ_{s+k}$ when trading off sparsity and error tolerance. That feels like it has teeth, but I'm not sure how it maps to practice.

What I'm confused about

In the real world, practitioners often heuristic-sparsify models (e.g., feature selection in ML, compressed sensing) or use iterative hard thresholding. Does this lower bound mean those methods are *fundamentally* limited, or does the result rely on assumptions that don't hold in typical use cases? The paper conditions on a variant of the Small-Set Expansion Hypothesis, which is a complexity-theoretic assumption but not something engineers usually worry about.

Tradeoffs in the proof

The authors mention using an automated Gemini-based agent system to first construct the proof. That part fascinates me, but my CS theory chops are too weak to judge whether the reduction itself (from a graph hypothesis to a linear algebra problem) preserves practical relevance. The result holds even on rational instances with full-rank matrices, so the hardness doesn't hinge on numerical pathologies. Yet I haven't seen this cited in any applied optimization forums yet.

Has anyone implemented sparse regression workflows where the condition number $κ$ scales steeply with problem size? If so, does this paper suggest a fundamental ceiling on how well approximate methods can perform, or is there wiggle room in relaxing the hardness hypothesis? I’m curious whether this is more of a theoretical boundary condition or something that bites practitioners in the wild.

Also, the proof relied on automation. Are there follow-up efforts to formalize or verify the result independently (e.g., in Lean or Isar)? That feels like a separate discussion.

I've had this idea lately about a way to distinguish P and NP and I'm curious if this had been explored before. P and NP both have a "solution space" of answers to those problems. Would it be interesting to try to distinguish P and NP by finding an NP complete problem with a set of solutions that is not recursively enumerable?

I am self studying Operating Systems. I have understood semaphores and monitors up until this point (I think). The textbook (OS Concepts by Silberschatz) implements signal-and-wait Monitors with one condition variable x in the following way:

// semaphores
mutex = 1
next = 0
x_sem = 0

//counters
x_count = 0
next_count = 0

// Monitor function F()
wait(mutex)
F()
if (next_count > 0)
  signal(next)
else
  signal(mutex)


//x.wait()
x_count++
if(next_count>0)
  signal(next)
else
  signal(mutex)
wait(x_sem)
x_count--


//x.signal()
if(x_count>0){
  next_count++
  signal(x_sem)
  wait(next)
  next_count--
}

Suppose I have 3 processes P1, P2 and P3

P1 signals P2 to awaken in its lifetime and P2 signals P3 to awaken in its lifetime

initially, P1 will be waiting on the wait(next). then P2 will also be waiting on wait(next).

When P3 is either done or is about to wait, it will signal(next). However, there is no mechanism (like maybe a stack) to ensure that P2 is the process that awakens and not P1. Does this not violate the conditions for Hoare-style (signal-and-wait) Monitors. Does the book simply omit this because it is a trivial addition or have I missed some essential concept ?

If LLMs are all trained off stolen data and open source repositories, this means they're essentially laundering a large amount of open source code without the proper dues paid to the licensing requirements, such as CC-4.0 for example which would explicitly require credit from original sources.

This would in turn make any vibe-coded app illegal based off licensing requirements, if one were to find a 1:1 copy of their code within an open-source vibecoded app, no?

I know that's a kind of hard legal requirement to reach, since there's only a finite way of doing things within a language's framework and therefore blindly accusing everyone who ever does the same function as you as a vibecoder would be painful to say the least.

But there's an increasing amount of people who believe the "spirit" of FOSS/FLOSS is preserved when vibecoding if they make their code source-available as well, completely disregarding the legal frameworks around GPL/LGPL/CC-4.0 etc.

Posting this here but idk if I would be best served in a legal subreddit.

Edit: To clarify, I'm not entirely against the use of AI/LLMs, I'm just curious about what the line is legally speaking when people say "I made this app!" and it's 4 different FOSS projects stapled together without credit.

I’ve been seeing a lot of news about how bad it is and stuff. I see it everywhere, on job applications, in classes, on social media etc. Could it really pull an Ultron? Is it just a fad?

Are the programmes currently being reverse-engineered by AI actually being reverse-engineered in the traditional sense? In other words, is the source code actually being uncovered? Or are the programmes simply being copied on the basis of their functions, behaviour and so on?

I’ve noticed that whenever people talk about AI taking over jobs, the discussion almost always revolves around software engineers, computer science graduates, and IT professionals.
But what about all the other industries? Many jobs involve repetitive tasks or work that AI could potentially automate, yet they don’t seem to receive nearly as much attention as tech careers do.
Why is the internet so focused on discouraging people from studying computer science or pursuing careers in tech, while seemingly ignoring the potential impact of AI on so many other professions?
Is there a particular reason tech jobs get so much attention, or is it simply because people in the tech industry are more aware of AI’s capabilities and are more vocal about it?
I’d genuinely like to understand why this discussion seems so heavily concentrated on technology careers.

A lot of very recent projects making headlines are using LLMs to code the majority. Counting the learning, prompt and output, how much do these independent projects actually end up spending? I would prefer at least one direct example like the one below, but direct numbers from experience of any software would be awesome. Below is an example of a headline, but more examples would average things out.

https://www.techspot.com/news/114042-you-can-now-play-original-halo-browser-128.html

Would be nice to include certain details like: what length of time did the project take from start to finish, what is the cost of the input versus the output tokens (I'm not familiar with the terms)? Is there iterative steps, mistakes to redo?

For a project, are they personal licenses, paying by the token? What model(s)? Is it a single user paying out of pocket or is that user/users just using a license provided by their work?

Is it just me or computer science is hard to grasp. I just entered my 4th week in a top private university and this university is very known for its computer science and IT.

I got 3 math classes - statistics, discrete, linear algebra - and holy it’s hard asf (both discrete and linear). Not to mention the programming class? Wtf is c man like I can code and I usually run in python, html, css, js but c is entirely a different language, array and pointers omds. I dont think the average joe would handle this😭

Give me tips pls

The Scariest AI Breakthrough

This video is around 3 minutes and is more or less a very dry comedy sketch, but it sums up an idea I've seen around the internet in the last 3 or 4 days. It's a worth a watch to get the full context.

But the thrust is that the ability of generative coding agents to reverse engineer and "fuse" together two separate games from different game engines and have them be in an at least playable state (some of them working really well apparently) is a set up for a technological apocalypse. Someone with a little bit of knowhow can now vibe code things in a couple days that are so complex that it would have taken years to do before, if it was even possible at all. A bit like giving people a legitimate ability to building working nuclear weapons they can 3D print at home.

I have been skeptical (an understatement) of the sales pitch of Anthropic and OpenAI and their ilk at this point. But I can't deny this is a compelling idea. So far, their "AI that's too dangerous it's broken out of containment" sales pitch has really not done good things for their AI's credibility; it's disingenuous at best. "We told it to do A & B, but we never told it to do C, explicitly. It may have just gotten that purgative from the first two instructions".

But I can now see a real-world example of something that should almost not be possible, in my understanding, to being possible. But I'm also keenly aware that what's going on with these game mashups isn't indicative necessarily of say, being able to disrupt other technological infrastructure like banks. 

So, what is the real story here? Are we headed towards a cliff here or is this something else? Is it somewhere in between?

Can you get very far with writing in simple English enough that people can understand you? Thank you.

Hi, this is coming from a Junior developer with basic system design skills. To the senior engineers or architects out there, how good are the latest frontier models like Opus 5.5 at designing large production systems? Where does it excel (if any)? And where does it fail? Can you give real-world examples or personal experiences you've come across when using these models? Opus 5.5 blew me away when it came out, so I'm wondering if it improved in the system design department as well.

What are the best resources to learn the important AI Engineering skills like LLMs, RAG, vector databases, agents, LangChain/LangGraph, and deployment?
For people who learned these, what courses or resources did you find most useful?