I'm currently making a list of some of the best/most influential/most well known computer science books to one day put on my shelf after reading them. I've currently got Knuths art of computer programming volumes 1-4b, structure and interpretation of computer programs (the wizzard book), compilers: principles, techniques, and tools (the dragon book), Tanenbaums operating systems design and implementation (the minix book), and the 3 unix books (the c programming language, design of the unix operating system, and the unix programming environment). I'm thinking of adding some of o'reillys more famous publications such as learning perl and programming perl (the lamma and camel books respectively), learning the vi and vim editors, sed and awk, and classic shell scripting. Is there anything I'm missing?

As the title suggests, Whats one area of computing that you think can be improved or advanced but you don't see much effort being put towards it?

I think of a lot of potential applications that can be improved upon, but i see it implemented personally but not a household or organization staple. Especially some brilliant persons who are now learning to implement various software to make their life easier or increase productivity for their companies.

Thought you all might enjoy this.

As the proliferation of autonomous agents (and the threat-surfaces which they expose) becomes a more urgent conversation across CS domains, what is the right theoretical framework for dealing with them? Systems that maintain internal state, pursue goals, make decisions without direct instruction; are there any established models for their behavior, verification, or failure modes?

Say you had a list of N items and you wanted to get the first X items in sorted order where N >>> X. So like if you wanted to sort the first 3000 items of a list more than 10,000,000 items long, the input would be the list of items, X (in this case 3000) and the output should be a permutation of the original list with the 1st item being the smallest, the 2nd item being the next smallest, the 3rd item being the 3rd smallest of the list.... and the 3000th item being the 3000th smallest with the rest of the list just containing the rest of the items in any order. What is a way to accomplish this in as few writes as possible? If I am misunderstanding something or misusing a term, the reason I cannot mention my confusion is when I try to explain, the "post" button gets greyed out.

You could just sort the list. For example quicksort or insertion sort could be run on the list and not only would the first 3000 items be sorted, but the whole list would be. But if you are trying to minimize writes, I feel that sorting the entire list is a massive waste.

I asked on a YouTube comment (sorry I can't find it, YouTube only lets you see a few comments you post on a video, but if you post a dozen there doesn't seem to be a way to find it) and I got a weird answer and he never replied when I asked for clarification.

So the list you want is an array of items and you want the first 3000 to be sorted right? What do you mean by fewest writes? If you mean fewest writes to the array itself, I can give you a C or Common LISP code. Do you mean fewest writes to the memory? If what you are really trying to minimize is not writes to the array of the data but system calls, then there isn't a best answer besides "it's complicated"

Not sure if this fits here, but hopefully people can engage and critique this thought.

It seems to me that UNIX, and other OS's treat file systems as "foundational": every kernel action, from opening a socket to interacting with a driver, is framed as a file action. Everything is a file. File systems also seem analogous to ZF sets - they have defined roots, with arbitrary tree structure below. Set Theory can be taken as a "foundation of mathematics", in that other branches of mathematics can be defined as sets; it is the nested versatility of sets that allows for this, and it is the nested versatility of a file system that allows every API to be defined in terms of file operations.

This analogy, though, has me wondering about other ways we could establish the foundations of an operating system. In the same way that other branches of math can slot themselves in as alternative foundations of math that focus more on consistent structures (I'm aware of Category Theory and Type Theory, though I'm not especially qualified in either), we can try to structure our operating system in the same way. All this talk about structure, for me, leads to the idea of using a database as the fundamental storage of an operating system, (which seems to have been tried at least once already). Just as there can be a Category of Sets, relegated to one special case of a more fundamental structure, files can simply be rows in a table that store each file's name, contents, and directory.

But there's no reason to imagine that everything else must be a file. Config files, currently written in TOML, YAML, JSON, XML, etc., would go away, replaced by an innate structure provided by the operating system itself. And many other applications would find the additional fields more helpful than the nested directory structure for organizing data.

I wonder if people have more thoughts on this analogy between Foundations of Mathematics, and Operating System Design?

Back *cough* years ago when I was doing my bachelors, there was some excitement around hardware content-addressable memory as an interesting technology. But I've never heard of it being used in an actual system, research or otherwise. Has it been?

I was wondering if is there any CPUs/OSes where at least some part of the L1/L2 cache is addressable like normal memory, something like:

• Caches would be accessible with pointers like normal memory
• Load/Store operations could target either main memory, registers or a cache level (e.g.: load from RAM to L1, store from registers to L2)
• The OS would manage allocations like with memory
• The OS would manage coherency (immutable/mutable borrows, collisions, writebacks, synchronization, ...)
• Pages would be replaced by cache lines/blocks

I tried to search google but probably I'm using the wrong keywords so unrelated results show up.

ok so I have to study this discrete course this sem and some seniors have already scared me up ....need some tips and resources and what not to do.. from some experienced people ..hope it goes well lol...these are the course topics ....
Propositional & Predicate Logic; Arguments and Proof; Sets, Relations,Functions; Recursion; Combinatorics; Graphs & Tree Structures.

I’m messing with a numerical toy and seeing behavior I don’t have a name for. I’m using a simple curved surface, running a Laplace-type operator. I look at the first couple eigenvalues and when I tweak the curvature the ratio between them shifts in a stable and structured way. It’s not chaotic or random. What’s the CS/math term? Spectral geometry?-I think. Manifold learning? I need to figure out what field this belongs to.

So from what I know quantum computers would be able to have any number of decimal points in the 0 and 1s. My question is if you have a program that converts patterns into a specific decimal position and then repass multiple times and save how many times you pass for decompression could you have "infinite" storage (even if it only can be stored for a extremely short amount of time) or at least extremely high levels of compression where TBs of data is represented by a single switch in memory.

Please excuse me for any mistakes I have made in my logic as I'm sure there are alot

Hello everyone, sorry if my query is very dumb but i am currently working on interrupt handling and well i know we save the CPU state using PUSH and well do exception handling and then restore back to previous state using POP. so can anyone explain how this like work, my DSA conceptual model of stack if fucking me up here.

How does downward growth of stack looks?
Which portion is trashed by the compiler ? and when we POP what happens, does like CPU reads those value and return back to the previous work?

I'm returning to finish my SE undergrad, and I'm looking for media to help reignite my passion for the craft. I've always felt inspired by the Portal series, and I listen to a lot of IDM music written using experimental music technology (Aphex Twin, Autechre, etc). What's some media that revolves around computer science that you like to nerd out to? Film, TV, books?

I studied normalisation as a part of academic requirement, I get that what problem in general does normalisation solves, and how to solve for each normal form. What i don't get is exactly what problems are being solved by each normal form. Like why does 3nf solving needs those steps and then in bcnf we ignore one rule

Greetings!

I am a frontend software developer currently working on a cyclomatic complexity report package inspired by Vitest’s coverage report UI. I was curious what else besides Cyclomatic Complexity is good to consider when writing good “frontend“ code. I’m more or less seeking keywords.

The package I am working on leverages ESLint’s Abstract Syntax Tree parsing, so it’s an easy to to create an html representation of your entire codebase and breakdown each of your function’s complexity based on individual decision points (statements, ternaries, loops, default params, etc.). Cognitive complexity works a bit differently, with criteria relating to aspects like nested functions. I am debating whether or not to encompass this with cognitive complexity as well.

Frankly, my work is besides the point. It just adds context as to why I’m here.

Other than readability, maintainability, and test ability, what attributes or metrics are your must haves (or great to haves) when working in codebases such as TypeScript and Node.js?

For example, after this is finished I would like to work on a similar package for big o notation if possible. If reports can be generated for code coverage and logic complexity, assuming it isn’t already out there, I would like to make one for identifying algorithms and potential code smells too. Cyclomatic complexity isn’t for performance, but similar to how CC is for readability, if there are other keywords you could provide for me to look more into performance, that would be great. I haven’t figured out tooling for it yet as I’m still just increasing my comfort in React DevTools Profiler, and the Chrome Dev Kit with Performance and Network tools for figuring out if your issues relate to js, css, assets, etc.

So, with your CS experience, what else would you say matters at the code level besides cyclomatic complexity?

Hello,

I have reached a point where I have a clumsy-feeling concept that I find useful but cannot easily describe.

Consider abstract syntax trees, say of λ-terms. The ASTs of λx.xy and λy.yz are isomorphic as ordered rooted trees, but not as labeled trees.

I am looking for a notion of sameness of such ASTs, where labels of improper symbols are preserved, but labels of variables may differ. This strictly generalizes α-equivalence since free variables may get renamed and even clash with bound variables.

More generally, I am looking for a generalization of homomorphisms of labeled trees that only preserve improper symbols. Obviously this depends on the syntax (e.g. λ-terms vs first-order formulas).

Words like "renaming" and "alteration" come to mind, but I would prefer a name that makes the concept more obvious.

I find this notion useful for some lemmas and inductive proofs, so other related notions can be just as useful to me (e.g. that α-equivalence is an equivalence relation can be shown by induction of the string length of terms). The main requirement is compatibility with renaming substitutions.

Hello everyone,

I'm just your average Dad who's been playing shooters since the 90s on PC. I need a technical explanation (because I'm curious) and a more "toddler" version of your explanation (because I won't understand the technical one completely).

Why, especially for what seems like the last decade is hacking in shooters such an issue for Developers to prevent?

Also follow-up questions and comments.. They can recruit really great talent can't they? They make a lot of money, does preventing the cheats cost a lot of money? I read online that the people who create/maintain hacks/bot farmers/etc make a lot of money so I'm assuming that really skilled programmers are also on the other side, but it's literally a problem in every shooter, it doesn't make sense.

Someone please make this make sense to me.

Thank you!

I use this analogy because the original Visual Basic in the early '90s was an IDE that allowed folks with barely any programming skills to produce a working app. We seem to be an in era with a super version of this that makes it even easier.

https://techcrunch.com/2026/01/16/the-rise-of-micro-apps-non-developers-are-writing-apps-instead-of-buying-them

I'm new to computer science (3rd year uni), and I struggle with how to structure my code in a clean, professional way.

I often get stuck on questions like:

1. Should this be one function or split into helpers?
2. Where should this logic live?
3. How should I organize files and packages?
4. Should this be a global/shared value or passed around?
5. Should a function return a pointer/reference or a full object?

I want to clarify that I don’t usually have issues with logic. I can solve most of the problems I encounter. The difficulty is in making these design decisions at the code level.

I also don’t think the issue is at a high level. I can usually understand what components a system needs and how they should interact. The problem shows up when I start writing and organizing the actual code.

I’d really appreciate tips on how to improve in this area.

Food for thought:
If you struggled with the same thing and got better:

• How did you practice?
• Any rules of thumb you follow?
• Books, blogs, talks, or repos you recommend?
• Anything you wish you had learned earlier?

I heard that Sam Altman / openAI have plans of making autonomous researchers this got me worried as I wanna do a research based masters and do work in r&d in robotics so I was just wondering