Second Year

Software Hut

Software Hut is a microcosm of Software House and provided me with the opportunity to work with a real client and further develop my software engineering skills, part of the which were covered in previous modules I have taken as part of my degree. The module gave me a taste of some of the problems which I might encounter in a real working environment, such as working with apathetic team members or being forced to use an outdated software. On the other hand, I really enjoyed building a software for a client - the experience of getting the customer's requirements right, through building concepts and delivering a high-quality, future-proof system, regardless of the issues I have run into during the process.

The assessment was comprised of several different components, such as team organisation and management, progress with implementation, documents (story cards, requirements documents, database design, state-machine diagram, mock-ups and manuals), unit and system tests, quality assurance task, communication with the client throughout the semester, the quality of the system (ease of use, completeness, innovation and robustness), as well as the overall impression of the system.
Achieved Result: First (97%)

Group Project: Learning Spaces

Our client was the University of Sheffield Library who was looking to replace the current outdated website with a dynamic application. “Learning Spaces” is about helping students finding their preferred study space, based on location and different filters. We were shown a similar system, made by another UK-based university, as an example of what was expected as a final result. Having seen the example provided, I wanted to build an app which would provide similar functionality in a simpler and more efficient way, while also providing familiar experience to the University of Sheffield students.

My design is based on the latest trends in web design - it is fully responsive and offers three different viewports - for mobile, tablet and desktop devices - so that the screen estate can be utilised in the best possible way. What is more, some of the elements are rounded, so that it can look better on mobile devices with edge to edge displays. As there is a map for showing the user’s location and the University’s buildings, as well as list with buildings with images of each, I wanted to have the colour scheme as clean as possible, so I used white all around and, as an accent colour, I have chosen the shade of blue, which is part of the University's logo. What is more, the typeface is the one that is used for the official University website.

Learning Spaces project showcase

The website shows all of the University buildings, sorted by distance, with closest to the user being on top. The pins on the map show the location of each building and are also colour-coded, based on the operating hours of the building. There is a filter where the user can filter based on the type of study spaces he is looking for or based on facilities, such as café or computer rooms. On clicking “Read More” for a given building, the user can see detailed information about the building, additional and exam information, study spaces and facilities available, opening hours for each day of the week, address and contact details.

There is also an admin panel where buildings, study spaces, facilities, special periods and admins can be created, edited and deleted. The system comes with additional features, such as exam-only buildings and support for different operating hours for each special period, which are fetched from the database as efficiently as possible.

The project was built with Ruby on Rails and it uses different web technologies, such as SCSS, HAML and JavaScript. It was designed and developed in a way that would allow an easy expansion, both content and feature-wise. User, admin and developer manuals were written and delivered to the client, so that other developers can implement new features and make changes, if needed. Apart from communicating with the client, eliciting requirements, designing and building the system, writing manuals and managing the team, I also took part of the quality assurance process, during which I had to test a system, built by another team, and had to provide a detailed feedback about it.

As we had to work for the library team, we had different members of the team attending different meetings, which required finding the best way of achieving the requirements of all staff members and building a system that could satisfy them all. The good communication skills with all of the clients were prised during the feedback session and were also given as a reason why other teams might have failed to live up to the expectations. The client also mentioned the poor design choices and feature implementation of the other two teams who were working on the same project. The quality of my design was pointed out as the biggest advantage of ours submission and I got 97%. As being the best one, our project was awarded and also a customer satisfaction of 100% was achieved.

Systems Design and Security

The module covered different aspects of software systems design process - choosing an appropriate software lifecycle model, the interaction between developer and customer, the management of information, development of efficient and secure databases, the design of user interfaces, validation and protection of data and techniques to counter security threats.
Achieved Result: First (87%)

Group Project: University Managment System

During the second half of the Autumn semester, I had to work on a group project, which was about creating a University Management System. We had to come up with a robust design that had to be represented using different UML diagrams - use case, class, database and state machine. Building a secure and efficient database was a major part of the design process. My main responsibility was the GUI, although I have contributed to all stages - the design, the actual implementation and the testing.

The system supports users with different roles - administrators, registrars, teachers and students. All of them have different privileges. The administrators are responsible for creating users and assigning roles, adding departments, degrees and modules. Registrars deal with students - they make new student registrations and assign optional modules to them. Teachers can add grades and decide if the student might progress, based on the student's status and grades. The students can see theirs personal details and status - registration number, modules and grades, or they can see their degree outcome if they have graduated.

The GUI was built in a way that it would prevent all possible user mistakes - such as trying to delete a student without it being selected or changing grades for a previous year of study. What is more, all of the user input is validated and only accepted if it is sensible. As MySQL was used for the database implementation, different security risks had to be considered. Formal and informal methods of verification and testing were used to ensure correctness. An individual grade of 95% was achieved.

University Managment System - Admin View
University Managment System - Registrar View
University Managment System - Teacher View

Functional Programming

The module helped me develop understanding of the main principles of functional programming, using Haskell. The module was divided into three parts, each followed by an assignment. The first part covered functions, parameters, arguments, binding, environments, types, recursive function definitions and function definitions using multiple equations, patters and guards. After it, I had to built bag data structure. The second part introduced anonymous and high-order functions, as well as user-defined data structures and type classes. It was followed by the first stage of building an 8-off Solitaire card game. I had to define the data structures to be used in the game, as well as several utilities and functions. The main one would take a game board and would make all possible moves to the Foundations. The last part of the module covered algebraic data types, partial function applications, lazy programming, function composition and the IO Monad. At the end of the semester I had to build on the previous assignment and write a program to decide on the best move to make from a given position in 8-Off Solitaire.
Achieved Result: First (85%)

Assignment: 8-Off Solitaire

During the second part of the Autumn semester I had to implement an 8-Off Solitaire in Haskell. For the first part of the assignment, I had to define the data structures, write utilities and create an auto-play which moves cards from Tabelau and Reserves to the Foundations. For the second part, I had to write functions which return all possible moves for a given board and chooses the best one to make. I experimented with different ways to weight the possible moves and wrote a report about my findings. With my implementation, the win rate is about 37%, which is above what a professional Solitaire player can score. I could have furter improved the win rate by implementing look ahead or an A* search. The assignment was awarded 87%.

eOExpt 1100 eOExpt 1000 eOExpt 900 eOExpt 800 eOExpt 500
Wins: 40 Wins: 38 Wins: 36 Wins: 35 Wins: 36
Mean: 24.73 Mean: 23.69 Mean: 22.00 Mean: 22.14 Mean: 23.13
Sd: 23.00558 Sd: 22.735743 Sd: 23.044304 Sd: 22.428122 Sd: 22.225054
eOExpt 300 eOExpt 200 eOExpt 100 eOExpt 90 eOExpt 9
Wins: 39 Wins: 35 Wins: 35 Wins: 33 Wins: 42
Mean: 24.0 Mean: 22.07 Mean: 21.93 Mean: 21.78 Mean: 25.96
Sd: 22.689646 Sd: 22.546953 Sd: 22.477211 Sd: 21.766293 Sd: 22.976479

Using an initial seed, eOExpt generates 100 random boards and plays each of them untill there is a win or no more moves are available. Then, the number of wins, the mean of how many cards were moved and the standard deviation are calculated and returned.

Robotics

The module was about providing an understanding of the principles and practices underlying contemporary robotics, with additional insight on designing and implementing effective human-machine interaction. Different topics covered were sensing, actuation and control, autonomous systems, control theory, local guidance and localisation, maps and path planning, cognitive systems, probabilistic robotics and robot learning, as well as the future of robotics. Human-Machine interaction, Human-Robot interaction and Robot-Robot interaction were other fields which were discussed.

The designer Sebastian Conran introduced us to the projects he has worked on, including the MiRo robot which is used within the Computer Science Department at the University of Sheffield. Rob Deaves showed us the Dyson 360 Eye robot vacuum cleaner and emphasised on the approaches and technologies it uses, which we have studied about during the semester, including SLAM (simultaneous localization and mapping), odometry, different safety features and the software architecture.
Achieved Result: 2:1 (63%)

Lab Assignments

Half of the assessment for the module consisted of two group lab assignments which meant to help us put into practice and build on what we have studied during the lectures. The first assignment was about experimenting with different control strategies, such as open and closed loop control, as well as creating and tuning a PID controller. Two ultrasonic sensors were used for sensing distance. The final task was to make a Lego EV3 Mindstorm robot go through a maze, with a random layout, at the maximum possible speed and without hitting walls.

The second assignment was about programming a “search and assist" robot, using multilayer control architecture, based on Rodney Brooks' subsumption architecture. It was composed of several behaviours - obstacle avoidance, search, stop and beaconing. We have experimented with different strategies for each of the behaviours. In addition to the ultrasonic sensors, we also used gyro and colour sensors. The final task was to make the robot find a beacon, using the search behaviour, while avoiding obstacles. Out of 195 students who have submitted the assignment, 14 were awarded a First class grade and our team members were among them.

Apart from programming the robot, we had to write reports for both of the assignments, which included detailed information about the experiments and testing we have made, what our final solution was and what we think could have been improved, based on the final performance and additional research.

Lego Mindstorm Robot

Data Driven Computing

The module builds on the Machines and Intelligence module I took during the first year. It is about Machine Learning and Pattern Processing with a clear emphasis on applications. Bayesian and Linear classifiers, feature selection, dimensionality reduction, unsupervised learning, approaches to clustering, density estimation and mixture modeling were the main topics covered.
Achieved Result: 2:1 (69%)

Assignment: Optical character recognition system

For the assignment I had to implement the classification stage of an optical character recognition (OCR) system for processing scanned book pages. The test data has been artificially corrupted, i.e. random offsets have been added to the pixel values to simulate the effect of a poor quality image. The classifier should use a feature vector containing no more than 10 dimensions and should be able to operate robustly even on low quality, 'noisy' image data. I considered using two dimensionality reduction techniques - LDA and PCA, but decided to implement PCA. I implemented a vectorised k-nearest neighbours classifier which could classify the data in a few seconds. My system managed to classify 40% of the characters on the noisy page, a sample of which is shown below. The assignment was awarded 82%.

A sample of a page, used for testing the performance of the optical character recognition system

Automata, Computation and Complexity

During the Autumn semester I was introduced to Automata Theory - finite automata and regular languages, pushdown automata and context free languages, as well as Turing machines and decidability. The Spring semester covered reductions and Rice's Theorem, P vs. NP, Cook's theorem, techniques for proving NP-hardness, how to deal with NP-hard problems, approximation algorithms and randomization. We were introduced to different problems on graphs, such as Independent Set, Clique and etc. Branch and Bound was used for solving the Knapsack and Vertex Cover. Dynamic Programming was introduced for problems, such as the Weighted Interval Scheduling. Randomised algorithms were studied by case analysis on the Min and Max Cut. Probabilistic complexity classes were also part of the content.
Achieved Result: First (71%)

Logic in Computer Science

The module covered the syntax and semantics of propositional and predicate logic, natural deduction, soundness, completeness and (un)decidability. Applications in computer science, such as theorem provers, using the DPLL algorithm and the resolution method, as well as modal and temporal logics for verification of computing systems, were also shown.
Achieved Result: 2:1 (67%)