As a programmer, I have always found that creativity and knowledge while building an application go hand in hand. Without the ability to imagine the solution to a problem and the knowledge to implement it, one would find it hard to achieve a goal. While this is true in the current climate of software development, solutions to pre-defined problems or use-cases are regurgitated or hacked together from various sources that are usually open-source and then packaged neatly as a containerized application that is delivered to the client. Setting aside the licensing and copyright discussions that this could entail, one can see this as a fundamental change in the behaviour of modern programmers.
Trusting a common registry or repository, and believing the correctness of open-source code without personal review and understanding of the original programmer’s design leads to the stunting of one’s own growth in the field. I too am a victim of such practices. While these issues are bypassed in an organization through optimizations, peer review and quality control (not dependencies, but code hacked together from Stack Overflow), the real problem arises not in an organization, but in schools.
The student is liable for this behaviour, and one can say it is fair to do so, because why not? It is a skill that is valuable and required by the industry. In today’s world, a developer’s skill to build solutions to problems is a translation of his/her ability to Google. If so, then how must a student be assessed? How do professors know whether a student has built something that is, to the greatest extent, their own? What is the line that a student must not cross to say that his/her creation is their own? Sadly, an educator has no reliable means to police or check such behaviour, but a clear expression of requirements and expectations and the reasoning behind it can help students realise the value of being responsible. Almost all programming is derived from patterns, patterns that are reused in the optimal solution. Would a students’ search for a viable pattern constitute plagiarism?
If solutions are going to be a myriad combination of reusable patterns picked from different corners of the internet that result in a novel solution, then we would have to assess the student on the exactness of the solution to a given problem, rather than the subject itself. The conundrum faced by educators is quite real; to be fair, the course dictates evaluation based on the subject and not the solution and thus, the skill of the student at a given phase should not be dictated by the grandness of a solution but the fundamentals of the subject itself. One cannot ignore the fact that the industry also wants students with knowledge of fundamentals and a knack for figuring out the right solutions. So how does a student get around this?
We have to understand that the work we do as students does not merely end at the school, but can be carried over and improved upon at a later time. When you can compare your solutions to that of real-time, industry-oriented solutions, you can learn so much more and can incorporate these practices into your own codebase. This allows us to practice our fundamentals and employ industry standards as well. Even though it can be a hard pill to swallow, we as students must know how to strike a balance between the two and strive to be better engineers.
I have always been puzzled by how my professors know my work is my own. Surprisingly, they have always been accurate, they notice the little mistakes that I would make over what I wouldn’t. The inputs that many have given to me over the years have helped me evolve as a student and a programmer. I had to learn the hard way that trying to be perfect and circumventing my way to reach the goal has only brought me more harm than good. Being intentional and responsible when I, as a student work on my projects, gives me the best return on investment in the long run.