Hacker News Reader

One time in a take home programming interview problem I was asked to create my own quicksort implementation in python. I had already done this previously in answer to a StackOverflow question, so I just submitted a copy of that implementation.

Later I was told I was disqualified because I had cheated and copied my answer from StackOverflow. I tried to explain that the user I copied it from was indeed me and that I could prove it by logging into SO in front of them but I never heard back.

I wrote and published a book through Createspace and Kindle on Amazon a few years ago. I got an email from Amazon that the Kindle book was flagged as containing material from other sources. This was, in fact, the case given that parts of the book drew heavily on blogs I had published in a number of different places. I emailed back that I had the rights to the material and provided a bunch of links. I never heard back but they went ahead and published.

FFS how many different implementations of quicksort in Python can there possibly be? How would they expect you to make yours unique? Different variable names or something?

I'll never understand the concept of plagiarizing long-established solutions to problems.

It's ridiculous. If you're going to require a take home programming test, at least make it something that isn't solved immediately just by opening SO. Ask a cookie cutter question, get a cookie cutter answer.

Honestly, I think I'd be more impressed by the person who got the answer off of SO. At least that person isn't wasting their time trying to solve silly problems that have already been done.

Or Wikipedia. (OK, you'd have to turn the pseudocode into Python. I'm not even primarily a developer and that would take me about 10 minutes.) Or wherever. There are apparently a few slightly different implementation details to Quicksort but how unique can a Quicksort be?

> FFS how many different implementations of quicksort in Python can there possibly be? How would they expect you to make yours unique? Different variable names or something?

Not even different variable names, as any plagiarism detector which is halfway-competent would have to ignore them because changing variable names is one of the things any halfway-competent plagiarist would do. The arms race has gone to the point where it's impossible to detect mechanically whether an implementation of a standard algorithm has been plagiarized. It's probably impossible for a human to detect it without other context.

And that context comes down to "Has this student shown steady gains or are they suddenly handing in competent code after demonstrating complete incompetence?" which you can't know unless the class is structured such that students show what they know to the graders in person. Which requires a certain student-to-grader ratio. Which is expensive.

The problem is, it isn't at all unlikely that a quicksort implementation created entirely independently w/o plagiarizing will match an implementation somewhere online. When I took algorithms, I would normally do the assignment and compare my implementation with online sources, mostly to compare against. Aside from variable names, ~80% of those assignments matched one of the first few SO answers. I think the real fail here is a company assigning something like quicksort and expecting to get original answers.

> The problem is, it isn't at all unlikely that a quicksort implementation created entirely independently w/o plagiarizing will match an implementation somewhere online.

It's practically guaranteed. Quicksort is quicksort. You can't get creative with it without implementing something which isn't quicksort anymore. That code may well sort a list, but if the assignment is to implement quicksort, you've failed at the task.

> I think the real fail here is a company assigning something like quicksort and expecting to get original answers.

Right. You have to go to IOCCC levels of perversity to be able to turn in something which is quicksort but isn't going to trip a well-trained plagiarism detector.

I remember being asked how I'd go about implementing quicksort in a phone interview. My response was: I wouldn't. Sorting is a solved problem that's available in pretty much any language's standard library (every non assembly language I've used, at least). The interviewer chuckled and something to the effect of "good answer, then can you describe the algorithm to me?", to which I said sure, and did.

Thankfully, I went through college before these automated plagiarism detectors had caught on. They were around, but not as pervasive as today. I mean, if you're going to sort a vector in C++ for a trivial app, there's only so many ways to write:

  std::vector<int> stuff{...};
  std::sort(std::begin(stuff), std::end(stuff));

And, lets face it: most lab assignments requiring a student to write a program are pretty small and trivial (at least mine were 20 years ago). The projects, on the other hand, were definitely more involved and you'd likely see more divergence in solutions there.

I've often re-implemented long established solutions, just to become intimate with the inner workings. Sort of like taking things apart and trying to put them back together as a child. While I may never use that exact knowledge, I may be able to apply the principles elsewhere. I imagine that is the perceived benefit to a student (of which I was never a very good one).

Why do we even ask these questions?

I don't want to work with someone who trusts their own quicksort implementation over one from an OSS library. It's a toxic combination of optimism and egotism that I don't have time for. What other stupid shit are they doing all day long? What does it say about my team if I'm on the asking end? Interviews are short, and information exchange is always limited.

Instead I may ask them to sort a complex object, or cook a piece of data that's organized opposite of what the UI will require. lots of people fail at these tasks. They're my version of fizzbuzz, but they actually represent the work we do.

> cook a piece of data that's organized opposite of what the UI will require

What does this mean?

Maybe modeling a many to one relationship inversely? Like if you want to show all the chips sold in a day but the data comes back with chips sold per customer and then you have to massage that to show how many chips were sold at a location.

Even the bugs, if there are any, are not likely to be original. That's why the idea of increasing software reliability by combining multiple independently-developed implementations of a set of requirements with a voting strategy is not as effective as it would appear under the assumption of uncorrelated errors.

Well, that is self plagiarism. Although I don't agree with the question or how that was handled, it is using your previous work without citing that you had previously written it.

An interview has to show capability, self plagiarism is not relevant there.

Anything can be considered relevant in an interview -- excepting illegal discrimination.

I guess the corollary would be a baker asking a potential apprentice to bake a baguette and send a photograph. Sending a photo from your blog of a baguette you cooked a year ago might still be considered disingenuous, even if it shows capability.

Well, no, because a code snippet is the same every time you write it, whereas an apprentice may, even while following the same recipe, produce variations in the result due to the nature of baking.

If you can write the exact same (non-trivial) code twice, that's fairly remarkable.

Alas they'll attempt to justify it by saying they want your capability now, not X years ago. Maybe it's not entirely unjustified -- I have some old mathematical code on github that I don't think I could explain the technical details of without many hours of review, I wouldn't want to be hired to produce more code of that sort without an understanding that ramp up will be needed to return to my previous level. Given something like quicksort, though, I'd just get the feeling of "dance, monkey, dance".

dodged a bullet, there.

I just learned this myself, but apparently if you don't cite yourself as the source of previously published information it's considered self-plagiarism.

This is actually a thing. John Fogerty might be an unlucky pioneer. http://mentalfloss.com/article/27501/time-john-fogerty-was-s...

http://www.ithenticate.com/resources/papers/ethics-of-self-p...

Basically, it's not necessarily OK to plagiarize yourself. Always disclose when you do it.

I had an interview about a decade ago, before doing a massive amount of prep on toy problems became standard for interviews candidates. The first question was to implement itoa, by far the easiest question of the day, and one presumably designed to warm the candidate up while also directing interviewers whether they should even bother with their harder questions.

I walked to the whiteboard and just wrote the implementation top to bottom without mistakes, then explained the code. I may have been a little lucky that I didn’t have any missteps, such as briefly forgetting to handle negatives or zero, or not immediately realizing that the first idea that pops into your head for pulling digits off will be a little awkward as you want to fill the string in the reverse order. But I’d never done itoa before so I didn’t think to offer any sort of disclaimer about why this was particularly easy, I was just happy with my performance and ready to do the next question.

The interviewers excused themselves and I saw them consulting the person who recommended me down the hall. I was surprised to learn that they were asking if it was possible I’d been supplied a list of interview questions and memorized the answers, to work out whether they even wanted to proceed from there.

That must've been a pretty excellent feeling. Did you get the job in the end?

Yep -- still have it, too.

Oh man. One of my biggest pet peeves is being accused of something I did not do. I would have probably gotten into trouble for heading back to that guy's office and ripping him a new *hole for presuming I am guilty based on a faulty software tool without first verifying the result manually himself. That's just absolutely ridiculous. I mean... that is a really serious accusation!

We trust our systems way too much, when we should first be trusting our own minds, and other people.

I nearly had an incident in a MIPS assembly class. There was a fairly basic data structures assignment that I had submitted only to be called into the professor's office being accused of plagiarism. The program used aggregates all submissions over the lifetime of the class and compares them.

Because of how basic the assignment was, and how rigid assembly is, there's a baseline ~40% match with all assignments, and mine just happened to hit ~50% and that was grounds for plagiarism. The match was for some submission 6 years prior.

At the time I took backups of school projects on save and could replay the history and walk through my design which was enough to convince the professor. There were at least 3 other students roped into this and were probably not as lucky.

My university basically did a viva to get around this. They know they can't prevent you from copying the code, but they _can_ make sure you understand it well enough to walk through it and be able to explain why you did things, and ultimately that's more important.

They also biased _heavily_ in favour of exams (practicals are essentially something you had to do, but are ungraded), where there is no (reasonable) opportunity for plagiarism.

I studied electrical and computer engineering in college. One of the classes was a hardware/software codesign class. There was a graded lab component, i.e. We had to design and build a circuit for the given purpose, hook it up to a bare-bones computer w/ a 68K chip and write assembly to drive the circuit and pass a set of tests.

Each lab was typically booked as 2 3-hour sessions (one session per week). I lived off campus, and the commute was about an hour, in good traffic, so I wanted to minimize the number of times I had to go to campus.

Unlike the students that lived on campus, I was methodically prepared walking into the first session. I'd probably have spent 6-8 hours on a weekend working on the lab. I was meticulous. I designed the circuit using Visio (obviously can't simulate, but I was concerned with layout), so I had precise diagrams of the circuit.

My diagrams matched the layout of the bread board, and my physical implementation was clean (wires were always just as long as they needed to be and never longer). I could take the diagram and literally check off wires as I placed them (and my wiring was clean).

I had my 68K assembly written ahead of time and was generally bug-free, though some debugging was needed from time-to-time.

I was generally in and out of lab in 15 minutes of what was supposed to be a 6 hour session. After a few rounds of this, my TA suspected I might be cheating and he walked up, ripped out a bunch of random wires from my circuit and told me to fix it. I chuckled, said ok, and I pulled out my design, replaced the wires and checked them all off, plugged it back in and it passed. He was dumbfounded. He sort of had a "Wow, a student that's actually prepared for lab for once" kind of look on his face.

He never bothered me again.

I think the TA was doubly surprised because I also had a habit of obviously sleeping during lecture, dead center in the front row.

May I ask how you made backups on save?

What you described sounds like it might come in handy some time for me personally

A git repository would suffice, just commit throughout the project as normal.

Vim supports an undofile, to keep undo history persistently. https://jovicailic.org/2017/04/vim-persistent-undo/

IntelliJ has a feature called "Local History" which stores basically is storing undo history, but it stores other things too (like test execution).

https://www.jetbrains.com/help/idea/local-history.html

It sounds like that detector didn't reveal the source that was supposedly plagiarized. Who would be dumb enough to rely on the results of such a tool? Is that a common attribute of modern detectors?

Revealing a paper that another student had written, would violate that student's FERPA rights, and potentially lead to abuse. For instance, if you knew that your papers were all going to be gathered in a centralized database, would you share your innermost thoughts about any sensitive topic?

It seems like the existence of these tools implies that all of your papers are "going to be gathered in a centralized database," right?

(I'm lucky enough to be old enough that this wasn't an issue. OTOH, we couldn't just Google or search Stack Overflow from source code examples...)

When I was in college, 1999-2003, they were explicit in that the institute assumed copyright ownership of all class work submitted be it an essay, lab write up, project submission, etc. It was a condition of attending.

Yes, but that's about copyright, not FERPA.

That's why I'll never accept automated systems for determining things that need a human with context. "We used our black box and it says you're guilty." - what do you do against that? There's nothing to argue and inevitably you'll end up facing some tribunal where a group of people are going to decide your ultimate guilt. What if they use their own black box?

"There should be one — and preferably only one — obvious way to do it."

Clearly they hadn't read the Zen of Python.