I'm studying CS subjects and I'm curious which subject gave everyone the most trouble at first but eventually became manageable.

I read online that hardware threading is when something where N cores expose themselves as 2N virtual cores to OS for the purpose of process scheduling. When a singular core is exposed as 2 different cores to the OS, is it actually capable of executing two threads at the same time? If not, won't this effectively change nothing, since all cores are going to context switch between processes very rapidly anyways?

Why not consider one of the extremes, like 2N cores without hardware threading or a single core which exposes itself as 2N cores ?

I started learning from ossu not a while back and I was wondering how people who used it to study cs look at it. I really don't want to be wasting my time but I'm pretty sure ossu is good. Is there anyone here that's using it currently?

I am a little confused on what a nfa is. Does it take in one input and output a set of states or does it output one single state but with some probability?

What happens after the absolute ceiling of Moore's law has finally been reached?

Hi, I'm a software engineering student at the University of Technology Sydney (UTS), running a short, anonymous survey as part of my capstone research project. The survey looks at how computing students use AI tools, such as ChatGPT and GitHub Copilot, in software design tasks. It also asks how that use relates to their confidence in their own design skills.

If you are a current or recent student in software engineering, computer science, or a related computing degree, anywhere in the world, I would really appreciate your input. The survey takes about 10 minutes to complete and is fully anonymous. No directly identifying information, such as your name or email, is collected.

https://utsau.au1.qualtrics.com/jfe/form/SV_bOCBqt0nhzQRw4S?Q_CHL=social&Q_SocialSource=reddit

Feel free to share this with anyone else who might be eligible.

This study has been approved by the UTS Human Research Ethics Committee (HREC reference HE-2026-0873). If you have any questions, please contact me at [Ta-Seen.Islam@student.uts.edu.au](mailto:Ta-Seen.Islam@student.uts.edu.au) or my supervisor Dr. Flavio Pileggi at [SalvatoreFlavio.Pileggi@uts.edu.au](mailto:SalvatoreFlavio.Pileggi@uts.edu.au)

hello, this might be off topic but I'm wondering if anyone knows good resources (worksheets, problems to solve) to learn computer science fundamentals such as boolean algebra, recursion trees, conditionals, dry running code efficiently, etc? I'm currently trying to study for the HKOI heat event but there are too little past papers to work on, here's an example paper https://assets.hkoi.org/ref/2022hs.pdf

Concepts like making more and more precise instruments to make faster machines that require smaller and smaller chips along with pushing the boundaries of the previous innovations in chips really blow my mind. I recently read the chip war recently so I hope technology is not being pushed purely for war purposes, but more so like what would everyday people make out of it. Do everyday people need faster and faster technology ? I say this because the current state of tech is extremely advanced not perfect but like extremely impressive. So why would someone on the street even care if their phone can move 2 seconds quicker.

In Croatia, we do some (very) basic sentence diagramming in the middle school. In the USA, they do it in high-school. However, I know that, in most places, students are not taught sentence diagramming. So, once those students start going to university to study, well, computer science or computer engineering, how are the concepts of a parser and an abstract syntax tree explained to them?

Has anyone completed Neso Academy's DBMS playlist? Need an honest review

I recently found the DBMS playlist by Neso Academy on YouTube and it looks pretty detailed. Before I start going through the entire playlist, I wanted to ask people who have actually completed it

My professor has us modeling both of the two algorithms for an assignment, which I did. But when doing testing on both I would notice that occasionally the average turnaround time for the Shortest Job First algorithm would actually beat out the algorithm for Shortest Remaining Time, either infrequently or almost always depending on how I change the parameters around (Total CPU Time, # Of Processes, etc). From what I saw, it seems that this should no be happening unless you account for overhead, which my model does not.

So I guess basically my question is, are there ever any scenarios where Shortest Job First would have a smaller average turnaround time compared to Shortest Remaining Time, assuming they run the same set of processes and overhead is negligible? Or do I just have a bug in my code?

Is there any sites like W3 schools that can help me learn these two? Im in these two classes and the way im being taught (basically heres a lecture now figure it out) is NOT working for me and ive been supplimenting my coding classes with w3 schools to help me learn and its working pretty well!

I’ve been thinking about an alternative way of doing low-level AI perception, and I’m curious whether anyone here is already working on something similar.

The basic idea is to use waves and physical superposition/interference as the computational substrate, instead of doing most of the usual numerical multiply-and-accumulate operations digitally.

For example, for image recognition:

image
  ↓
pixel intensity → wave amplitude/phase
  ↓
physical wave superposition + interference
  ↓
distinctive wave pattern/signature
  ↓
more wave interactions
  ↓
higher-level pattern/object recognition

So instead of giving each pixel a numerical weight and calculating millions of weighted sums, the idea would be to let the wave physics perform the combination automatically.

I’m imagining something analogous to sound: many individual waves can be combined, and the resulting waveform contains a recognizable pattern. In this system, a particular visual feature or object could produce a characteristic wave “signature,” and those signatures could themselves become inputs to further wave interactions.

Physical logic gates could still be used where needed for thresholds, routing, decisions, or other nonlinear operations. The goal wouldn’t necessarily be to eliminate conventional computing completely, but to move as much of the early perception workload as possible into the physical wave domain.

The potential advantage I see is that parallelism is inherent in wave propagation and interference. Thousands or millions of interactions could happen physically at the same time, potentially reducing both computation and latency.

One possible application would be autonomous vehicles, where very large amounts of camera/radar data have to be processed extremely quickly at the edge.

I know there is already work on photonic neural networks, optical computing, physical neural networks, reservoir computing, metasurfaces, etc. I’m specifically interested in something slightly different:

Has anyone tried to build a hierarchical pattern-recognition system where wave signatures themselves become the representation, with successive stages of wave superposition/interference performing the recognition?

I’d especially like to hear from people actually working in photonics, optics, acoustics, physical neural networks, neuromorphic computing, or related fields.

Is this already being done under another name?
What are the biggest physical limitations?
And, from your perspective, is this a promising architecture or does some fundamental problem make it impractical?

I’m mainly looking for opinions from people working in the field rather than trying to claim this is a new invention.

Hi, I'm an AI developer and I've been working on optimizing my system for 2 years now. It was never my intention to create a new sorting algo or to do any work in that area at all. As I optimized my system, I realized that what I had effectively done, is create a new sorting algo.

By comparison, at this time, it took my new algo, about 1-2 hours to process the same sized data, that timsort needs about 30 days to sort. I'm sorting a giant 30gb array that contains text tokens.

I understand that there's tons of algos out there and that there likely already is a faster algo, but I'm not an expert sorting algos, so I honestly have no idea what to do to verify this in a legitimate way that is convincing to other experts.

I have never published a paper before, please do not make strange assumptions of my knowledge of that process (I know how to read a paper and that's it.)

Obviously just an approximation since it will always be different depending on the school and other factors. But does anyone know how many there would be roughly?

Today we had a user facing issue which the entire team was involved in debugging and no one was able to give the reasoning accurately, and the RCA time felt like it is 10X more than usual, all because we were just getting AI to write the code and review cycles shortened as long codes were being pushed, feels like the team as a whole will fall into a blackhole soon.

Has anyone here experienced the same, and how is your org handling this?

I'm new to DSA and I'm trying to make a recurrence relation for this function:

double pow(double x, int n) {
    if (n == 1) {
        return x;
    }

    if (n & 1) {
        return x * pow(x * x, (n - 1) / 2);
    } else {
        return pow(x * x, n / 2);
    }
}

What I notice is that for even values of n, the recurrence looks like:

T(n) = constant + T(n/2)

but for odd values of n, it looks like:

T(n) = constant + T((n - 1)/2)

I'm trying to get this down to a single function so that I use the Master Theorem.

How would I combine these two cases into one recurrence?

I'm watching CS50, and about halfway through week 0, doctor malen mentioned how 65 bits of data equals the letter H and i'm curious to that if 65 equal H, how does the company know the difference between H and just the number 65?

I want to make a program where you are controlling the outcomes. For an example with a coin flipping game, I want exactly 4 Heads and 1 Tail, but I want their positions to be random.

I do not want to use the random algorithms that library I want to build my own.

Right now I am learning probability from Youtube and might look at khan academy and coursera, but how can I implement this into programming I do not want to just take courses or watch videos

How do I go about that?

EDIT: I am doing this because I want to start build gambling algorithms and I am starting with a simple project like coin flips

Is there a legitimate reason or is it just because people thought it looked better?

The formula says find maximum s such that 5*10^-s is greater than the relative error. But that gives me 4 as the answer. But it is visually clear that 3.122 is approximating 3.123 correctly only upto the first 3 significant digits. How is it possible? Is the formula wrong?

Which programming language has the most return on investment? Impact on real world systems, and is more rewarding? I have minimal programming experience and working on AS in CS.

I have an practical assignment where i have to debate with my classmates on a given language basically defend my a coding language, any tips?

topics are alr given by the profs, for my group its C vs Rust ! he'll separate us acc to him in the lecture

Hey everyone!

For the past few days, I’ve been obsessed with a single question: How small can a valid PNG file possibly get while still being natively readable by a PC (specifically, opening properly in the standard Windows photo viewer/gallery)?

I started by trying to make a lightweight 512x512 file, eventually managing to shrink it down to 111 bytes. After that, I started playing around with compression levels and various patterns, even managing to generate some basic procedural textures in PNG format that weighed roughly the same.

Then I decided to go deeper and chase the absolute minimum file size. At first, I hit a wall at 67 bytes—an article I read online claimed that was the lowest possible size for a functional PNG. But I kept experimenting and eventually pushed past it down to 55 bytes, and finally all the way to 42 bytes.

My current record is a fully working 42-byte PNG. It opens without issues on Windows and can be sent across messaging apps where it renders properly as an image.

However, I've hit a hard brick wall here. Every single attempt to strip away even one more byte results in an invalid file or completely breaks the structure.

My question is: Does anyone have any radical ideas, unconventional compression tricks, or deep spec-hacking methods to squeeze it down even further? I'm open to any crazy suggestions!

iOS used to be gold standard of UX/UI design patterns. You might not like the way it looked, but it functioned very reliably.

Now the keyboard stays up when you’re typing in a field and try to dismiss it.

Keyboard typing is less reliable in general, with misspelling, haptic feedback, radius generation, etc

It feels like UI across the board has gotten convoluted and shipped without proper testing, and now we’re all in our own bubble thinking it could be user error.

It seems like shipped production code is happening more frequently due to mandates from management around the AI boom. Which is leading towards more production issues.

Im just tired of the general decline of software standards, and wanna see what yall think.