On January 23rd I graduated with an MSc in Advanced Computer Science from The University of York. It was a nice occasion to get together and be merry with the family, and of course for some photos in my cap and gown — this time they were grey and blue.
My parents took my degree home with them and hung it up next to my undergraduate degree and departmental award. I think they look nice together.
For some more nice pictures you can check out my dads blog post about it.
Last week I submitted my thesis, workshop report and conference presentation for my MSc in Advanced Computer Science. Two days after my submission I was also required to present my research and answer a few questions fielded from a lecturer in Yorks Department of Computer Science who had not previously seen my work. The video shown above is the one which will be used to mark my presentation and question answering skills.
Having completed the three deliverables and the presentation my research semester, and thus my masters, is complete.
I expect to find out my final result in 4 to 6 weeks, however currently I am more focused on my impending start at Trainline — which I hope to write about soon.
My final semester at The University of York has officially begun. Over the next 5 months I will be conducting 100 credits worth of (hopefully) novel research in the area of Git Source Control Querying and Analytics through the use of Model-Driven Engineering under the supervision of Dr. Dimitris Kolovos.
The original project proposal is shown below:
Advanced Querying of Git Repositories
Git is a distributed version control system that is widely used both in academia and industry. Git provides a command-line API through which basic queries can be evaluated against local repositories (e.g. git log) but lacks facilities for expressing complex queries in a concise manner. The aim of this project is to support such complex high-level queries on Git repositories. In the context of this project, the student will need to
1) identify the metadata stored in a Git repository and extract it to an object-oriented representation (e.g. using JGit)
2) develop a driver that will allow languages of the Epsilon platform to query extracted metadata at a high level of abstraction. For example, the following query would select all files larger than 200 lines and which were last modified by email@example.com on a Wednesday:File.all.select(f|f.lines > 200 and (f.lastModifiedBy = "firstname.lastname@example.org" or f.lastModifiedDay = "Wednesday"))
Such an advanced query facility would enable the development of advanced Git repository analytics and visualisation services (e.g. using Epsilon’s EGL as a server-side scripting language).
I’m currently in the very early stages of literature review and finding out what other git analytics programs are available so there isn’t too much to talk about. However, I will as ever keep the blog up to date with my progress over the next few months.
The other module I was working on alongside “Topics in Privacy and Security” was “Formal Specification”.
In this module I used Z notation to formally specify a navigation system for Robot Vacuum Cleaners (A bit of a computer science obsession it seems). I then used the technique of promotion to allow for more than 1 robot vacuum cleaner to be in a room and observed some emergent interaction.
I really enjoyed this module, I like the challenge of working more on a mathematics level rather than a programming level — you have to work with different ‘data structures’ and work with different operators and structures of notation.
I would recommend for anyone to look in Z as it really makes you think about methods and functons in a different way. In terms of pre-conditions (what must be true for the function to start?), post-conditions (what must be true at the end of the function?) and invariants (what must always hold true?). It strikes me as a very good way to think about testing programs, even if you don’t formally specify them before producing them.
Formal specification is probably a bit over the top for most software engineering projects, but if I were to ever work on a Planes autopilot system, or a system which moved the control rods in a Nuclear Power Station, I’d want to know formal specification had taken place. So it’s a useful skill to have learnt. It was also a nice refresh on discrete mathematics.
Last week was a hectic one. I had a coursework deadline for my Adaptive Learning Agent Systems module, and a exam for Static Analysis and Verification. Amongst all the work I received my results for my Topics in Privacy and Security Module.
The module was assessed by a 100% weighted coursework for which the aim was to develop both a security risk management strategy for a telehealth company and develop some software to determine the best reputation metric for a star-rating system for e-commerce websites to reduce the effect of self-promoting and slandering attacks at different scales.
For the security risk management strategy the ISO/IEC 27002 and ISO/IEC 27005 standards were followed. Assets, user roles, system boundaries and businesses processes were identified, possible violations were considered, threat agents and paths were analysed and critical analysis of which risks had to be managed and which controls to use to mitigate their risks took place.
I used the programming portion of the coursework as an opportunity to learn cross-platform GUI development in Java, using JavaFX. As of the time of writing JavaFX still doesn’t support simple dialog boxes without a host of libraries… which made it interesting. However, it was quite impressive to see ‘write once (carefully), run anywhere (conditionally)’ work in action. I also used it as a chance to try out a form of more modular development, in which all of my business logic was in a library which any GUI could tap into, whether that be a Java Servlet, JavaFX or Command Line program. For the coursework I developed both the aforementioned GUI and a simple Terminal Interface, both running on the same shared .jar library.
Thankfully, now that this week is over, so is the taught portion of my masters degree. For the next 4 months I will be working on my research project, which will be discussed in a future blog post.
One of the more challenging modules I’ve taken at York is Constraint Programming. It’s was an interesting module to take because it was much more mathematical than other things I have done before, and also because it introduced an entirely new way to think about programming and problem solving in general.
Most of the programming I have done has been procedural or, in other words, telling the computer how to solve a problem. Constraint Programming on the other hand allows you to specify a problem through constraints and then ask a finite domain solver to solve it.
Important elements of the process that we covered were: Developing an abstract syntax of a problem; converting from an abstract syntax to a concrete syntax (The constraint programming language MinZinc); symmetry breaking, implied and dominance constraints, and configuring search through the problem space.
The complete process came together in the 100% weighted coursework, in which we developed a solution to determine the minimum number of sheets, of a given size, required to satisfy a given demand for certain sizes of ply wood.
I was given a grade of 80% for the coursework, which I was happy with 🙂 This now means that I have all of my grades for the first half of the taught part of my course:
- Model-Driven Engineering: 80%
- Concurrent and Real-Time Programming: 99%
- Evolutionary Computation: 80%
- Constraint Programming 80%
- Average: 84.75%
This means that now, short of an absolute disaster, I should achieve an overall mark of distinction in the taught part of the degree. 🙂 However, there is no rest for the wicked and I am already around half way through the coursework for my Formal Specification and Topics in Privacy and Security modules.
The Evolutionary Computation module I took in my first term of this year was assessed through one piece of coursework worth 100% of the module.
In this coursework we had to design an evolutionary algorithm to produce tanks for a tank battle game called Robocode. The algorithms we designed were judged on their ability to produce tanks which were robust against a diverse range of other tanks — in other words their ability to solve a multi-objective problem evolutionarily.
Many forms of evolutionary algorithm could have been used to develop these tanks, however because all tanks in Robocode are compiled Java classes I decided to use a Grammatical Evolution algorithm. As well as the standard GE algorithm I also produced a coevolutionary algorithm which employed grammatical evolution.
I found the real skill in evolutionary computation was working out which parameters to use in such an algorithm (e.g. What population size, how often should mutation of a gene take place on average, which breeding method should be used, how many codons of genes should there be), and developing a BNF grammar that wouldn’t result in too much recursion and therefore invalid tanks once you ran out of genes to generate code which got you out of the recursion, but was still useful.
The coursework was marked based on the report we produced explaining our decision making processes, analysing our algorithms and using statistical methods to evaluate our algorithms and tanks. By the time I was finished I had written 15 pages and had a further 25 pages of appendices.
Overall I found the coursework quite enjoyable, and the best tank I produced was quite amusing to watch as it flailed around the screen constantly rotating its turret and shooting at any enemy it could find.
I’m happy to say that I found out last week that I achieved a grade of 80% for the coursework, and therefore for the module overall. This keeps me on track for the Distinction I so badly want in the degree overall.
Today I received my grade for the second assessment of the Model-Driven Engineering module. In this open assessment we built on the work we had done in assessment 1 by developing a graphical editor for users of our Media Library model, developing two model-to-model (m2m) transformations, and a model-to-text HTML report transformation.
I’m happy to say that I received a mark of 83% for part two of this module, giving me an overall grade of 80% for MODE.
This grade alongside my 99% for CRTP means I’m currently in a very good position to get a distinction in my masters degree, which has always been the aim.
Due to some mitigating circumstances I am still working on my EVCO and COPR module assessments, and expect to have these finished by the end of this week. I will keep the blog updated with information about them (and hopefully some non-academic blog posts once I get some more free time)
Last week I took my first sit-down exam at The University of York, it was for the module “CRTP – Concurrent and Real-Time Programming” and was worth 100% of said module.
The module focused on the concepts and theories of concurrent and real-time programming that would be useful independent of any particular programming language as well as having a series of practicals in which we used the Real-Time Specification for Java. Having only used very basic threading a few times it was nice to flesh out my knowledge in this area.
Due to the fact that I hadn’t taken an exam here at York before, and not knowing much about the institution and its style of examination I was a bit worried about how well I would do. Therefore I made it my aim to do a week and a half of solid revision — which was tough, but cemented all of the concepts in my head really well.
The examination consisted of 3 questions, each worth 50 marks, of which we had to answer 2. Each question had some Book Work — essentially questions asking about concept for which an answer could be recited from a book — some Analysis, usually of code, and a hard unseen problem — which involved writing Java code for the Real-Time Specification for Java, by hand.
Even after having completed the exam I wasn’t sure how well I’d done. Fortunately the papers were marked 3 days later and I was very surprised, relieved and happy to find I had achieved a mark of 99%. I was later told this was the highest mark that had ever been achieved in the module.
The same day as the CRTP exam I had to hand in a coursework for my Model-Driven Engineering module. I will of course keep the blog updated about that and the two other courseworks I am currently working on for my Evolutionary Computation and Constraint Programming modules.