Plagiarism and Collusion

Please note: the School takes plagiarism extremely seriously. In all work, the burden of guilt lies on you -- it is up to you to prove yourself innocent by fully referencing sources in your work.

In software coding, the use of standard examples makes it hard to define plagiarism -- it would be like punishing people for using clichés. No one wants source code where every other line is a reference, nor do we want interfaces that pop up a reference each time you use a menu. However, it is important we still give our sources for major chunks of code -- if for no other reason than some poor other devil had to do your thinking for you and deserves recognition.

With this in mind, the rule of thumb we will follow for your work is that if you use more than 5 lines of someone else's code, you should put a reference to where you got it in a comment above it. If you have had to alter the code to get it to work, you should also note that.

For example:

// The following code is altered from that at
// https://github.com/wmdmark/jquery-rickroll
or,
// The following block was developed from that in the
// GIS Class of Billy Bob Botox.

Most code you find on the web will have been put there for you to use, or to help you understand how to handle a problem (the reason we force you to comment code in projects is, in part, to show you understand the code you are using!).

If, however, the code has a licence attached to it, or has a copyright statement on it, you must respect these. Even if it means acting on a couple of pages of legal verbage.

The coding community relies on professional standards in this matter, and it punishes with absolute rigour those who stray off the path. The marking of your work will reflect this.

In addition, it is worth pointing out the issue of collusion. There will always be a time, late in the evening, when you are stuck on debugging some code and need a fresh pair of eyes to see what the problem is.

When this is an occasional fair exchange of information between equals, this is a valuable relationship, and, indeed, standard coding methodologies like "extreme programming" sometimes encourage it. We all get people to look over code when we've got a problem and the solution is escaping us. However, there is also a clear difference between doing this, and working on a project together and turning in what is, to all extents, the same piece of work with a few variable names changed. As this is exactly the kind of thing we'd expect with plagiarism, and by colluding you are halving your own input in preference to someone else's, we would regard this just as seriously as plagiarism.

No one wants to stop you talking to other people about code, but please limit this to discussion about specific bugs and generic coding issues raised during the course, not project-specific elements.

Trust me, by the end of the projects it is blatently obvious if someone is writing the majority of your code for you or if two people are working together, and both parties will be put through the plagiarism process -- which is far from pleasant. It is also obvious who is losing their rag because people are bugging them for help all the time. Please don't bug people outrageously for help -- if you are going to fail, they certainly don't deserve to be taken with you, and staff are here to field queries, not your co-attendees. If you are the person being bugged, please don't help people if you feel you are writing their work for them -- it will do you no favours in the end when it comes to a tribunal.

Please also note: the use of coding forums to request external help is strictly forbidden unless permission is sought from the module convener first.

While there is a place for forums for advanced programmers in the real world, getting experts to do your specific work for you in University is malpractice, and we will treat it as such. Even if you are honest about where the material has come from, we don't want forums filling with basic queries about assessments from Leeds -- if you are stuck ask advice from your course tutors: that's what we are here for. Note that we monitor forums for queries about course material, and external coders have raised with us cases where they felt students were engaging in malpractice.

Note, particularly, that the likely punishment for students who sub-contract projects out to other programmers is expulsion from the entire Masters programme, with *rigour*. We monitor freelancing sites and forums, and freelancers have reported students attempting to do this to us. Through both channels we have caught students attempting to do this, and have expelled them without any degree. You should be aware that it is better to fail this module and still potentially get a degree than risk engaging with a system which we monitor aggresively and punish utilising the University's extremely unyielding malpractice procedure.

If you are struggling with the course to the extent that this seems like an evenly remotely good idea, it *isn't*. Talk to the module convener: they are here to give you all the support and help you need to pass.

Finally, please note that it is highly unlikely that you'll be able to construct a whole piece of work from material on the web, we don't expect more than 20% of your code to come from such sources whether you reference them or not, and you'll be penalized for over-reliance on external code where this is the case (the exception to the 20% limit is the use of declared non-JDK libraries in GEOG5790M, but again, if you find a library that does the job you have been set to code yourself, the code won't count towards your mark, and the likelihood of passing is limited).

Please note that the code we give you won't count towards this 20%. In addition, while it is the standard plagiarism rules in the University that work assessed in one place may not be used in another (so-called "self-plagiarism"), most coders build up a library of useful code, so you may use as much of your own code from your Java practicals as you like without referencing. However, you may not submit complete solutions or significant sub-components developed in this course for assessment in other modules and vice versa. If you are in doubt about what this means, please enquire of the relevant conveners. Finally, please note that automatically generated code may *not* be submitted as the main body of an assessment. While non-JDK libraries may well be automatically generated by others, and may be used in GEOG5790M as ancillary components, code generated by pushing the button on a piece of software (QGIS; Matlab; etc.) will receive a zero mark: we are here to assess your ability to write code, not push a button. There are minor exceptions to this (some GUI builders; code from UML; basic stub generation), but we ask you to confer with the module convener before using these.

The chief purpose of the projects and practicals is to give you the opportunity to sit down and learn Java in a way you won't just sitting in lectures.

If you approach it from this angle, your code will reflect this enthusiasm, and, ultimately, even if it doesn't do exactly what it should, it is still more than likely you'll do better than if the entire thing is obviously constructed from other sources without understanding.