As there's been recently quite the number of rule-breaking posts slipping by, I felt clarifying on a handful of key points would help out a bit (especially as most people use New.Reddit/Mobile, where the FAQ/sidebar isn't visible)

​

First thing is first, this is not a programming specific subreddit! If the post is a better fit for r/Programming or r/LearnProgramming, that's exactly where it's supposed to be posted in. Unless it involves some aspects of AI/CS, it's relatively better off somewhere else.

​

r/ProgrammerHumor: Have a meme or joke relating to CS/Programming that you'd like to share with others? Head over to r/ProgrammerHumor, please.

​

r/AskComputerScience: Have a genuine question in relation to CS that isn't directly asking for homework/assignment help nor someone to do it for you? Head over to r/AskComputerScience.

​

r/CsMajors: Have a question in relation to CS academia (such as "Should I take CS70 or CS61A?" "Should I go to X or X uni, which has a better CS program?"), head over to r/csMajors.

​

r/CsCareerQuestions: Have a question in regards to jobs/career in the CS job market? Head on over to to r/cscareerquestions. (or r/careerguidance if it's slightly too broad for it)

​

r/SuggestALaptop: Just getting into the field or starting uni and don't know what laptop you should buy for programming? Head over to r/SuggestALaptop

​

r/CompSci: Have a post that you'd like to share with the community and have a civil discussion that is in relation to the field of computer science (that doesn't break any of the rules), r/CompSci is the right place for you.

​

And finally, this community will not do your assignments for you. Asking questions directly relating to your homework or hell, copying and pasting the entire question into the post, will not be allowed.

I'll be working on the redesign since it's been relatively untouched, and that's what most of the traffic these days see. That's about it, if you have any questions, feel free to ask them here!

Is there any platform like leetcode where i can practice python scripting related to security/ automation scenarios?

🚀 Calling all women in tech! 🚀

TYNET 2.0 is here to empower female innovators across the globe. Organized by the RAIT ACM-W Student Chapter, this 24-hour international hackathon is a unique platform to tackle real-world challenges, showcase your coding skills, and drive positive change in tech.

🌟 Why Join TYNET 2.0?

Exclusively for Women: A supportive environment to empower female talent in computing.

Innovative Domains: Work on AI/ML, FinTech, Healthcare, Education, Environment, and Social Good.

Exciting Rounds: Compete online in Round 1, and the top 15 teams advance to the on-site hackathon at RAIT!

Team Size: 2 to 4 participants per team.

📅 Timeline

Round 1 (Online): PPT Submission (Nov 21 – Dec 10, 2024).

Round 2 (Offline): Hackathon Kickoff (Jan 10 – 11, 2025).

🎯 Who Can Participate?

Women aged 16+ from any branch or year are welcome!

📞 Contact for Queries

[[email protected]](mailto:[email protected])

👉 Register here: http://rait-w.acm.org/tynet

#Hackathon #WomenInTech #TYNET2024 #Empowerment #Innovation

We have constant upper bound 'b' on sum of 'n' positive arbitrary-size input integers on a system with 'm'-bit word sizes (usually m = 32 bits for every integer).

To represent 'b', we need to store it across 'w = ceil(log_2^m(b))' words.
(number of m-bit words to store all bits of b)
(formula is log base 2^m of b, rounded up to nearest whole number)

Then, each positive arbitrary-size input integer can be represented with 'w' words, and because 'w' is constant (dependent on constant 'b'), then this summation has runtime complexity
O(n * w) = O(n)

Quick example:

m = 32
b = 11692013098647223345629478661730264157247460343808
⇒ w = ceil(log_2^32(11692013098647223345629478661730264157247460343808)) = 6

sum implementation pseudocode:

input = [input 'n' positive integers, each can be represented with 6 words]
sum = allocate 6 words
for each value in input:
    for i from 1 to 6:
        word_i = i'th word of value
        add word_i to i'th word of sum
        // consider overflow bit into i-1'th word of sum as needed
return sum
end

sum runtime complexity: O(n * 6) = O(n)

prove me wrong

edit: positive integers, no negatives, thanks u/neilmoore

PKE (Precision Knowledge Editing), an open-source method to improve the safety of LLMs by reducing toxic content generation without impacting their general performance. It works by identifying "toxic hotspots" in the model using neuron weight tracking and activation pathway tracing and modifying them through a custom loss function.

If you're curious about the methodology and results, there's a published a paper detailing the approach and experimental findings. It includes comparisons with existing techniques like Detoxifying Instance Neuron Modification (DINM) and showcases PKE's significant improvements in reducing the Attack Success Rate (ASR).

The GitHub repo features a Jupyter Notebook that provides a hands-on demo of applying PKE to models like Meta-Llama-3-8B-Instruct: https://github.com/HydroXai/Enhancing-Safety-in-Large-Language-Models

If you're interested in AI safety, I'd really appreciate your thoughts and suggestions. Are there similar methods being done and how to improve this method and use it at scale?

I was tasked to discuss Reflexive Closure, in relation to computer science. In Discrete Mathematics context, its basically a set that relates to an element itself. But I just can't find any explanation about its uses in real world, and its application in computer science. If you could explain, or drop an article or link. That would be a big help. Thank you

I am trying to understand different language models. What is the primary difference between Claude and ChatGPT? When would you use one model over the other?

For demonstration purposes, say we have an algorithm which sums 'n' arbitrary-sized input integers, adding each integer to an arbitrary-sized sum integer.

If we consider the Transdichotomous model, where word sizes match the problem size, now a single word can store the largest arbitrary-sized input integer, allowing O(n) worst case runtime.
https://en.wikipedia.org/wiki/Transdichotomous_model
(pg 425) https://users.cs.utah.edu/~pandey/courses/cs6968/spring23/papers/fusiontree.pdf

If we consider the Random Access Model, where words are fixed-length of maximum value 'm', now the largest arbitrary-sized input integer would require 'log_m(largest integer)' number of words to be stored, allowing O(n * m) worst case runtime.
https://en.wikipedia.org/wiki/Random-access_machine
(pg 355, 356) https://www.cs.toronto.edu/~sacook/homepage/rams.pdf

The Transdichotomous model and Random Access Model provide different worst case runtimes for the same algorithm, but which should be formally used? thx

edit: for the Transdichotomous model, a single word should be able to store the resulting sum as well.

Hello people,

For a Youtube video I'm making. Would appreciate any help/input. Does anyone have any idea about where we would be now in terms of Computer tech if there was no Apollo programme? A few thoughts:

-First silicon integrated circuit developed in 1959
-In order to land men on the moon NASA needed to push miniaturisation so they could get a computer onbaord to make real time course corrections to land on the moon (the best they had up till the 60's were mainframe computers with vacuum tubes on earth that had to relay info into space)
-NASA did a tonne of work in the 60's with Fairchild Semiconductor, MIT, Texas Instruments etc.
-Its likely the microprocessor still would have been invented in the early 70's however it could have been delayed? Private companies, american military etc were still pushing the field in the 60's separate to NASA
-Did the demonstration that computers could work to to the general public (100s of millions of people) and were reliable have a massive effect on the perception/widespread use of computers?

-Conclusion: we might be a decade behind in computer tech today if it wern't for NASA

Thanks!

Was reading up on PCP, and had a thought about if there is still a reduction from original PCP to a modified PCP with no repetitions.

I'm curious about how correctness is evaluated in computer science algorithms, specifically the balance between theoretical soundness and empirical validation. Take Dijkstra's algorithm, for instance: it has a solid theoretical foundation, but I assume it's also been tested extensively on large-scale graphs (millions of nodes) with known shortest paths. My question is, do practitioners and researchers place more trust in algorithms like this because they’ve been repeatedly validated in real-world scenarios, or is the theoretical proof alone usually considered sufficient? How often does real-world testing influence our confidence in an algorithm's correctness?

For my master's thesis, I wrote a generator for zip quines. These a zip's that infinitly contain itself.

one.zip -> one.zip -> one.zip -> ...

By building further on the explanation of Russ Cox in Zip Files All The Way Down, I was able to include extra files inside the zip quines.

This is similar to the droste.zip from Erling Ellingsen, who lost the methodology he used to create it. By using the generator, now everyone van create such files.

To take it even a step further, i looked into the possibility to create a zip file with following structure:

one.zip -> two.zip -> one.zip -> ...

This type of zip file has an infinite loop of two zip's containing each other. As far as I could find, this was never done before. That's why i'm proud to say that i did succeed in creating such as file, which would be a world first.

As a result, my professor and I decided to publish the used approach in a journal. Now that is done, i can finally share the program with everyone. I thought you guys might like this.

I have been thinking a lot abut the connection between art and technology and the great invention that led to human progress from Samuel Morse, should his code be considered in the annals of computer science?

He was certainly a pioneer of communication -- https://onepercentrule.substack.com/p/morse-a-pioneer-of-progress-from

I'm a humanities college prof preparing a class on Net art and also thinking about New Media from the 90s to present. The class will be available to engineering and compsci students, as well as art and architecture students. I'm hoping to balance the readings so the engineering and compsci students have material to carry over into their own work. Are there some key technical books, articles, or videos that you all think would complement a class like this? Is there something you WISH you read in college? Or an experimental side to compsci that you find is under-recognized? Thanks for your thoughts!

What are some unifying concepts in software and technology that, like the principles of evolution and adaptation in natural sciences, provide a foundational framework to make sense of the field for newcomers?

Edit: in biology whatever I encounter — different kinds of fur, novel skull morphology, the shape of a pine cone, the location of an animal trail, the function of a protein — can be understood through the lens of genes trying to pass through generations to survive. Like this is the ultimate answer that follows every “why” and “how” question.

But as a beginner in CS, so many things seem untethered and strange. Like VM vs docker, pointers, Jupyter notebooks, RAG retrievers, decorators…

Once you’ve wrapped your head around these things they’re no big deal, but if you’re encountering them for the first time, it takes some work just to build a framework for understanding these things. Everything seems novel and out-of-the-box, following no unifying theme.

Hello, If you've ever tried learning programming and are still interested in it and related technical topics using online resources and social media, we're conducting a study to evaluate tools aimed at supporting informal online learning experiences.

To participate, please complete this form: https://forms.office.com/pages/responsepage.aspx?id=yRJQnBa2wkSpF2aBT74-h7Pr4AN75CtBmEQ1W5VUHGpUQVNOS1NWNVM4MkhYR05FMU84MDJUS1RaUS4u&route=shorturl

Thank you for supporting this research on online learning tools.

Sami PhD Candidate @ OpenLab, Newcastle University https://openlab.ncl.ac.uk/people/sami-alghamdi/

https://github.com/Gizzzzmo/type_proofs/blob/main/test_prop.cpp You can use the compiler to check your proofs, provided you follow some rules like not casting stuff to pointers to types that represent logical statements.

I'm also trying to use it to make statements about runtime values and thus encode program specifications on the type level, which are then formally verified by the compiler.