Hello,
In this blog post, I will be discussing my first year of University as a Computer Science student. For a little background information, I had recently completed a computer networking college course, similar to a BTEC, which was the equivalent to 3A Levels. I came out with the grades D*D* for the main course, A for an extended project qualification, and a C for AS Mathematics.
Firstly, I will mention the modules I had undertaken, which were mandatory for all first-year students.
Autumn Term
Spring
During the first year, I had 8 modules. 5 of which consisted of 50% coursework, and 50% exam. The other 3 modules consisted of 100% coursework.
Introduction to Object Orientated Programming
Let’s talk about the first module – Introduction to Object Orientated Programming. Overall, this was a very enjoyable module, even if you had no prior programming experience.This module consisted of learning the basics of the Java programming language, and the object orientated programming model. This module consisted of three assignments, which got gradually harder, and an in-class programming test. The modules lectures consisted of teaching topics out of the book Objects First with Java by David Barnes (the lecturer). Every week we would be given a task to complete which would relate to a particular topic in the book, which was then assessed in a weekly class. The class material contributed 20% of the grade, while the three assignments and class test attributed the other 80%.
As the course of the module went on, more features of the Java programming language were introduced. Loops were introduced (for loops, for-each, while) , collections (sets and maps), inheritance, recursion.
The first assignment tasked you with simply defining a class with a constructor, simple fields, accessor methods, mutator methods, etc. In hindsight, this first assignment was simply an introduction to the assignment format and the rules and guidelines surrounding them, such as no plagiarising code or sharing code.
The second assignment was a little more complicated. The assignment contained tests which at the start all fail, and you were responsible for fixing them, and creating a fully functional program. This assignment was mainly testing your knowledge of collections, such as array lists and hash maps.
The third assignment was entirely focused on inheritance. You were responsible converting a program to use inheritance rather than the existing method.
The final assessment for this module was the in-class assessment. For this, you were given information on functionality they want from a program, and it is your job to implement it within two hours, with only the help of the course book, and search engines. You were however, allowed to look at the Java API, and previous work you have done. This exercise was fun, as it put your skills to the test, and truly shows how good you are without using StackOverflow for all your errors.
In conclusion, this module gave me a great foundation of the Java programming language and the object orientated programming model.
Computer Systems
Moving onto the second module, Computer Systems. This module aimed to provide an undestanding of the fundamental behaiour and components of a typical computer system. Coming from computer networking course, I already had a very solid understanding of a computer system, so this module was relatively easy.
This module covered various topics, starting with operating systems, then networking, and finally computer architecture. Although I was quite knowledgeably of some topics, it was nice to be given a deeper look of things such as kernels, paging systems, file systems work, to name a few.
For this module, it was 50% exam and 50% coursework. The coursework portion consisted of 4 online quizzes which were ridiculously easy and poorly put together.
The exam for this module tested knowledge entirely from the lectures and was relatively easy if you understood the contents. What was challenging, however, was the amount of content covered, and only being able to predict what will be present in the exam based on past papers from previous years.
Human Computer Interaction
This module was revered as the by far the worst of the eight by the majority of students. From the title, it sounds rather interesting. How do we as humans interact with computers? However, It felt like this module was something you’d expect to see in a psychology course, it didn’t really feel like computer science. I’d be lying if I didn’t find this module useful though. To give you an understanding of the structure of the module, we covered HCI guidelines and principles, qualitative evaluation methods, interaction styles, lo-fi prototyping, quantitation evaluation methods, features of human memory, errors and feedback, and security authentication.
The reason why so many students disliked this particular module was due to it being almost entirely group-based coursework. Although working within a group is an important skill, you will inevitably be grouped with someone who will contribute very little to the project.
The first assignment tasked a group with going out into the world and observe what people are doing, and why they’re doing it. Again, seems more like a psychology thing. Then, present a presentation of your findings.
Where the module began to get exciting was when we began working with interfaces and prototyping, and then analysing them. The second assignment tasked you with analysing an interface you use on a daily basis. Using the methods taught in the lectures to evalulate them. This was rather interesting as it allows you to see how an interface violates a HCI guideline. This was great because it allowed us to put what we had learnt to the test. I had chosen to evaluate the iOS Spotify interface, and it was very eye-opening to what heuristics such a popular and widely used application violates.
For the final assignment, we were responsible for designing an interface for an application. This was interesting because we had to attempt to allow for functionality, but avoid breaking design heuristics.
The exam portion was interesting as instead of simply regurgitating the contents of the lectures, we had to draw an interface within the exam. So while some questions were simply knowledge you’ve obtained from lectures, some questions put your knowledge to the test by tasking you to create an interface for a particular purpose with heuristics in mind.
Foundations of Computing I
The final module of the autumn term is Foundations of Computing I. This module was entirely mathematics based and was introduced to us as a cross between GCSE and A-level topics. The module consisted of statistics, computer arithmetic, proof, set theory. A lot of students who had studied A-level Mathematics had found this module relatively easy, I, however, had not covered the majority of topics previously.
I had found this module the most enjoyable of the first term, as it was very satisfying to learn a new mathematical concept such as proof, or set theory, and actually be able to answer rather difficult questions.
Once again this module was 50% exam, 50% coursework. The coursework portion was interesting as we given a set of questions which we had to complete over a week, kind of like homework, but it was graded and contributed to your overall grade. The problem with this approach is that you could often find answers online for the majority of questions, and it was very easy to conversate with friends about the answers to some questions.
Since this blog post is already rather long, and probably nobody is reading at this point, I’m going to end it here and discuss the spring term modules in another post, and I will also mention my grades for each module.
Thanks for reading!