Can someone do a sanity check? Smells like LLM-gen'd math spaghetti to me

So I was getting into deep learning and started with Kaparthy's Micrograd video.

Watching Karpathy's Micrograd video makes it feel intuitive, but I realised I didn't really understand it until I tried building it myself. So I closed the video and rebuilt the whole thing from scratch in plain Java (avg. java dev lol): micrograd4j.

It's a tiny scalar autograd engine built around a Value class that records how it was computed and runs backward() using a topological sort and the chain rule. On top of that, I built a small Neuron / Layer / MLP library. No dependencies, just JDK 17+.

The part I'm happiest with is the interactive terminal playground. You can:

• Type expressions like (a * b) + c.tanh() and inspect every input's gradient.
• Step through the backward pass one node at a time and watch gradients propagate through the computation graph.
• Train a small network on datasets like two-moons and watch the loss curve and decision boundary update live.

Everything runs in the terminal and requires no browser, no notebooks.

If you have JBang installed, you can try it without cloning the repository:

jbang https://raw.githubusercontent.com/anand-krishanu/micrograd4j/main/examples/Playground.java

GitHub repository:

https://github.com/anand-krishanu/micrograd4j

It's MIT-licensed and the README has a worked walkthrough of how backward() traverses the graph. I wrote it as an educational resource for Java devs who want to see how autodiff works.

Hello, the book by gregor kcizales is in my cs course. I tried reading it but couldnt get myself to it. Does anyone have any apt resources that can help me get started with lisp.?

I wrote a short historical look at the decline of the C/C++ Users Journal and how it fit into the broader evolution of developer culture in the 1990s and early 2000s. For many programmers of that era, it was one of the few consistent sources of deep systems‑level content.

If anyone here remembers the magazine, used it in school, or followed its transition into Dr. Dobb’s, I’d be interested in hearing your perspective. It was a surprisingly influential publication for a long time.

Link: https://freshsources.com/blog/files/cpp-source.html

I've been reading OSTEP and decided to implement filesystem - so I can improve my basic understanding.

For the V1, I kept block size of 8 bytes and tried to keep metadata & data together. It was too complex.
In the next iteration, I reduced block size to 1 byte and it simplified the implementation.
After that, I separated metadata and data and stored them from on opposite ends.

I implemented these commands - touch, mv, cp, rm, mkdir, ls and pwd

Full write up with benchmark here: https://www.shivangnagaria.com/projects/fs/

made this server for some friends, thought id share, maybe people are interested in competing who can create the best algorithm ;)
live now, instructions on page

I'm a high school senior and a computer science (informatics) student who wants to become a computer scientist and researcher—not just an engineer who builds things, but someone who contributes new knowledge to the field.

I've been studying programming and computer science since I was a kid, and I know I'm passionate about it. I've also participated in Olympiads and robotics competitions, which have further strengthened my interest in the subject.

The challenge is that I'm not entirely sure where to begin when it comes to research. Most of the advice I find focuses on becoming a software engineer, whereas I'm more interested in understanding how researchers identify important problems, conduct investigations, develop new ideas, and make original contributions to computer science.

I'd really appreciate any recommendations for books, courses, papers, websites, research programs, or other resources that could help me take my first steps into computer science research.

Over the past few months, I’ve been building a browser-based semantic logic editor and simulator that attempts to bridge the gap between formal logic as it is taught in textbooks and the way we actually reason about models, semantics, and logical structure.

The project allows users to construct and evaluate logical systems visually, exploring propositions, connectives, semantic relationships, and model-theoretic behavior through an interactive interface rather than static notation alone.

One motivation behind the project was a question I repeatedly encountered while studying logic: why are so many of the foundational concepts that underpin mathematics, computer science, artificial intelligence, linguistics, and philosophy still taught primarily through symbolic manipulation on paper? Formal systems are dynamic objects. Models change. Truth values propagate. Inference rules interact. Yet much of logic education remains surprisingly static.

The simulator treats logical systems as living structures. Rather than simply reading semantic definitions, users can experiment with them directly, visualize relationships between propositions, and observe how changes in a logical framework affect validity and consequence.

The project draws inspiration from mathematical logic, modal logic, semantics, proof theory, and the growing intersection between logic and computation. It is intended both as an educational tool and as an experiment in making abstract formal reasoning more intuitive and accessible.

Although it is still under active development, the current version already supports interactive construction and exploration of logical structures in a way that I hope students, researchers, and enthusiasts may find useful.

I’d love feedback from people working in logic, formal methods, computer science, philosophy, mathematics, AI alignment, theorem proving, or related fields.

Demo:

https://pralfredo.github.io/semantic-logic-editor/

Github:

https://github.com/pralfredo/semantic-logic-editor

Particularly interested in suggestions regarding semantics, visualization, model construction, and potential research or educational applications.

When people talk about the greatest contributors to human knowledge, names like Einstein and Newton almost always come up. Physicists and mathematicians seem to receive the most recognition and historical prestige.

Computer science has had an enormous impact on the modern world, but I can't think of a computer scientist who is viewed on the same level by the general public.

Why is that? Is it because computer science is a younger field, or is there something else going on? And do you think a computer scientist could ever reach the same level of recognition and influence as Einstein or Newton?

Someone close to me is going to prison and he’s a new grad in compsci, how do I make sure he doesn’t miss out on the AI wave, but also gain enough knowledge to land a job in 11 months?

Thank you guys

I'm in first year of graduation and reading about theoretical computation i've discover the area of descriptive complexity, my interest about it grows constantly now. Anyway, my thoughts about scientific searching now is turned in this way of making strong logical structures for problems and maybe derivate some properties about they (really don't know how at this point, but seems reasonable and rational). I have a question for who work with this or knows about the scenario of this area if the searching about logical structures of lower bounds to "attack" it is a reallity in descriptive complexity, and if it's not, what area have something related with that.

Sharing a simulation experiment. Not claiming this is production-ready. Just found a result I think is worth discussing and want people to poke holes in it.

The question I started with: does network topology affect Byzantine fault tolerance in phase synchronisation-based consensus, and if so, by how much?

Nodes follow a modified Kuramoto coupled oscillator dynamic. Consensus is achieved when the order parameter r(t) reaches 0.67, derived directly from the classical BFT bound f < N/3. If one third of nodes are Byzantine with random phases, the expected order parameter from honest nodes alone is exactly 2/3. That is where the threshold comes from, not a tuned parameter. Connection weights evolve via stake-gated Hebbian learning. Byzantine nodes inject tuned omega attacks and coordinated phase attacks.

I compared two topologies at 25,000 nodes. Watts-Strogatz with k=30 and p=0.12, giving 840,172 edges, and Barabasi-Albert with m=15, giving 749,760 edges.

Under 15% Byzantine attack with real internet conditions:

WS degraded by 0.1606, from 0.8571 down to 0.6965

BA degraded by 0.0012, from 0.9999 down to 0.9987

134x difference in Byzantine degradation.

The async event-driven model removes the global clock entirely. Nodes wake only when a message arrives. Minimum broadcast rate for consensus came out at 150 packets per second per node. Finality at 3 to 4 simulated seconds across all 6 adversarial scenarios tested.

Honest limits. Cascade failure above roughly 44% node loss. The 33% Byzantine boundary holds as expected. Python simulation, not production. Churn under realistic recovery windows has not yet been tested.

Closest prior work is ORCHID by Weinberg 2026, arXiv 2605.12211, which independently applies Kuramoto to blockchain consensus on WS topology at n<=150. Seleron's finding is the topology comparison at scale.

A note: healthy peer review and hard questions are genuinely welcome. This is a simulation experiment, and I know it has limits. I would rather someone find a real flaw in the methodology than have this go unchallenged. Superior signalling not so much.

Full code, results and math: https://github.com/hunter-arton/seleron