It’s been quite a while since I did a course (as I regularly used to) to top-up my knowledge on the rapidly evolving field of AI. As a new parent, I guess it can sometimes get tough to make time for doing such courses, and regularly posting updates on a blog.
Since April 2023, I’ve been working on Muse at Unity. Muse is an LLM-driven AI assistant for Unity developers and enthusiasts that began as a web-based chat interface back then and has over time gotten closer and closer to Unity Editor to the point that now it’s able to take stock of what a user is actively working on in the Editor and provide tailored advice, code and even perform tasks within the Editor on their behalf.
I’ve been a part of this project pretty much since its inception, and have learned a lot simply by doing. There was little time to actually learn about LLMs more systematically given how hectic things have been at work (and outside work too), and I noticed quite a few gaps in my understanding of the wider LLM-space. So, I finally took the time to do a Coursera foundation course on LLMs which gave me the opportunity to fill some of these gaps. I really enjoyed doing this particular course, and I feel it was very well designed and executed by Andrew Ng and his team of instructors! And I would highly recommend it to anyone interested in getting a general idea of the space, key concepts and some basic hands-on experience in prompt engineering and model fine-tuning. As always, I chose to do it with the option of getting a certificate of completion.
Of course, this was only the tip of the iceberg when it comes to LLMs! I’m looking forward to now placing anything new I come across into a more structured understanding of the LLM space that this course has given me!
Back in December, I completed the C# course on Codecademy. This was mainly in order to be able to broaden the scope of my contribution to the project I was involved with at Unity and take a step outside the Python bubble I had for so long limited myself to. This was shortly before I went on paternity leave. On returning from my leave, however, I found that a lot had changed. Most relevant to this post, the team had decided to move away from the Unity-oriented C# implementation of the product to one in TypeScript.
I, for one, had never programmed before in TypeScript but this was not going to deter me from giving it a shot. Having had a positive experience in learning C# on Codecademy, I was pleased to see that they had a course on TypeScript as well and signed up for it immediately. What was different this time was that I wasn’t learning TypeScript solely from the course. I already had a team implementing a product with this language, and this served as a very valuable means to get hands-on experience with it while I got myself familiar with the fundamentals and features of the language through the course. I noticed quite a few similarities to Python (focus on scripting, pyenv versus nvm for managing language versions and packages, similarity between npm / npx commands and the python command), and this helped me hit the ground running. What unexpectedly helped me a lot was my use of mypy in making my Python code type-safe over the past year or so thanks to my colleague Matti’s insistence. I felt totally at home in adding and manipulating the types of variables in TypeScript, which is something that would’ve taken me a while to get used to otherwise. Anyway, now I’m actively contributing to our new codebase thanks to the kind feedback and review of my colleagues and it feels good to be getting better at a new way of expressing myself in code :-).
Over the past three years, I have (and might I add, serendipitously) ended up programming in Standard ML, Racket (both as part of an excellent series of courses on functional programming offered on Coursera), C# and now TypeScript. It’s hard to measure how better a programmer this has made me, but it has certainly broadened my perspective to what one can do across programming languages and how it’s only a matter of getting used to some basic (often superficial) differences in how one reads and writes code before being able to apply what one has learnt or used in a previous language. The theoretical concepts, of course, are very similar. It’s just that some languages make it easier to do certain things than others. And this was one of the things that was emphasised in the Coursera courses on Programming Languages. Over the past year I have worked with some excellent programmers at Unity, some of whom have been academically involved with Programming Languages, and I bet any wisdom I have to offer in this little post would only scratch the surface of what they might have to say on the subject. Anyway, I really look forward to see where things go from here for me!
It’s been just over a year since I started working at Unity, and it might come as a surprise to some that I haven’t coded in C# during all this time. Why? Because Unity is written in C# and so is much of what is created using Unity. To be fair, I was able to get on with my work using just Python given that it was mostly research and prototyping. I did try learning to code in C# through some Unity tutorials back in December 2020, but those turned out to be more advanced than I could handle and didn’t cover the absolute basics well enough (at least what I had come across) so I shelved that effort then.
Fast-forward to a year later in December 2021, and I found myself having to go on a month long leave to be in India while my wife and I expect our first child. Other than taking care of her and catching up with my parents who I hadn’t visited since around two years owing to the pandemic, I had quite a bit of free time on my hands. So I decided to take up the task of learning C# once again. This time, I came across Codecademy, where I found introductory courses for different programming languages including C#. And I’m talking real beginner stuff – how to declare variables, conditionals, loops, etc. This was great because, although I could understand these basics well enough without a course, it seemed to gracefully lead on to more advanced concepts such as classes, interfaces, inheritance, LINQ, etc.
So I got started with the course. Codecademy provides one with a browser-based editor and terminal to write and compile one’s code for convenience. I actually found it annoying because it was quite sluggish, didn’t have auto-completion and gave me no idea of how I would write the code on my own machine having set up everything I need to run C# code locally. So I took some time to research how this is done – installing the Mono Compiler and the necessary Dotnet libraries for Linux to write and compile C# and Dotnet projects respectively. Not just that, it took a while to then install the necessary Omnisharp libraries in order to make auto-completion work in my editor of choice – Vim! I’ll try to write a more detailed post on this sometime later, but no promises – the baby is here now ;-).
Once all that was done, I was ready to go! I got done with the course in about a month, at my own steady pace. Repetition was the key – I made sure to write every piece of code myself in my local machine although a lot of it was the same, such as imports, base class and main function declarations and so on. That really helped with developing fluency and also getting a sense of what is needed and not needed in different scenarios. The course, I must say, is very well-designed. The first few chapters were bordering boring for me because I was already familiar with much of what was there, having programmed in C / C++ in the long past but once I got to the chapter on Classes and Objects, things started to get more interesting! What helped was that over the past year, I maintained some discipline in writing typed Python code with the help of MyPy and also using abstract classes via the ABC Python module. C# being strongly typed, the practice of using types in Python obviously helped. But working with abstract classes in Python certainly made it easier to understand interfaces and inheritance in C# better! Same when it came to references, because I did read up quite a bit on mutability in Python. And finally, the section on LINQ was a lot of fun, and bore resemblance to the kind of step-by-step data-processing code I wrote about a year ago in PySpark.
So, now that I’m done with this course, I have this shiny certificate acknowledging my effort!
Next, my plan is to head over to CodeWars and get started with a few Katas to further consolidate what I have learned so far! And perhaps think of an idea that would help me better understand how to organise my C# code into a larger project. Still a long, exciting way to go!
It didn’t surprise me a few weeks into starting work at Unity that Reinforcement Learning would be a useful thing to know at least a little about. So I started studying the fundamentals of Reinforcement Learning from what seemed to be the most recommended reference on the subject – Reinforcement Learning: An Introduction by Sutton & Barto. I must acknowledge that this is a fantastic read and so thoroughly explained. It did take me several revisions of certain topics to read what is implied between the lines, which happens to be quite a lot of useful insights and information, but overall this textbook covers RL theory very very well!
After having spent a few weeks going through the chapters on the Dynamic Programming, Markov-Chain Monte-Carlo and Temporal Difference methods, I felt that I could use some hands-on practice to take the message home and, as always, I looked up Coursera to find the course Practical Reinforcement Learning. It took me more than a month (nearly two) to get through this course. This was partly because I was making sure to review the same material covered in the course in the reference textbook as well, which was very useful. And partly because the course material itself didn’t feel very up to the mark. I felt that in wanting to cover a vast amount of topics in the span of a single course, things got quite rushed. And the assignments were also not very well explained, and offered very little feedback in terms of what was wrong, which made it incredibly frustrating to get through them. To be honest, about half-way into the course I was no longer enjoying it, and was eager to just be done with it ASAP. And that’s exactly what happened. I can’t say I’m very thorough with any of the material covered in weeks 5 and 6, which I would definitely like to revisit in the future.
That being said, Reinforcement Learning is actually one of the most interesting topics in Computer Science / Machine Learning that I have done and I really do hope I have the opportunity to do something interesting using it in the future. And, of course, here’s the certificate that I completed the Coursera course (phew!).
Earlier at the start of this month, I began the second Programming Languages course (Part B), offered by Prof. Dan Grossman of the University of Washington. I had done the first course a few months ago and found it very beneficial when it came to my understanding of some functional programming concepts and idioms, the notion of elegance in programming and good programming practices in general. It also really helped me formalise much of what I had come across in relation to Functional Programming, and approach the adoption of this style of programming more systematically in my own day-to-day programming projects. After nearly two months of having done that very interesting and challenging course, and having felt that a good bit of it had sunk in I decided to take on this second one.
The goals of this course were three-fold:
To allow one to apply some of what was taught in the first course in the context of Standard ML (SML) to a new programming language, namely Racket.
To introduce features of Dynamically Typed programming languages through Racket, and compare these in contrast with those of Statically Typed programming languages, such as SML.
To understand the inner workings of a language interpreter by implementing one for a very simple hypothetical programming language in Racket.
I won’t be going into much details about the learnings of this course yet. I plan to do so in a couple of months when I’ll be done with the third and final course in this module and I will have had the chance to re-visit the contents of the first two courses to gain a better overall perspective.
Having been curious about Functional Programming for a while now, and tried incorporating features of the paradigm into my own work with Python, I decided to give the first (Part A) of the three-part Programming Languages course module on Coursera. The module is meant to systematically introduce one to various theoretical concepts of programming languages, while having a special focus on Functional Programming. This first course (Part A), which I recently completed with a score of 98%, illustrated said concepts with the help of Standard ML – a Functional-style language.
It was excellently designed course, and also quite challenging. Apart from spending time on introducing the very basics of SML early on, it covered some very interesting concepts such as Pattern Matching, Function Closures, Partials, Currying and Mutual Recurstion. The programming assignments really made sure you understood what was covered in the course material, and the course-handouts were thorough and clear. There was also a strong focus on the matter of programming style, with the instructor commenting on what he considered good/poor programming style while covering the various concepts. We were marked on the style of our submissions too.
Now that I’m no longer working at Jukedeck, I happen to have plenty of free time on my hands! I’ve been spending this time travelling, catching up on my reading list, helping out with activities of the Music Tech Community – India and making music among other things. In an effort to satisfy a long-standing curiosity, I signed up for the Recommender Systems specialisation being offered on Coursera by University of Minnesota, and recently completed it. It comprised of four courses:
Introduction to Recommender Systems: Non-personalised and Content-based (certificate)
Recommender Systems: Evaluation and Metrics (certificate)
Matrix Factorisation and Advanced Techniques (certificate)
It took me about a month to complete all four courses at a fairly liesurely pace given how much time I had at my disposal while not working. This was a very well-taught specialisation with some of the best-designed Courses I’ve done on Coursera so far. It covered a wide range of topics that offered a comprehensive overview of a vast area of research. Solving the assignments by hand was a new, but very engaging experience that really allowed me to focus on what actually happens at a very basic level under-the-hood in such systems. It was all done by implementing the various formulae for content-based filtering, item-item collaborative filtering, user-user collaborative filtering (including matrix factorisation methods) in spreadsheets. There was an Honours Track in each course that focused on implementing the various types of recommender systems and related concepts that I decided not to pursue, as all the programming was in Java. I decided I would follow the courses up with my own implementation projects in Python as that’s something of greater interest to me. So now I’m looking for little projects to get me going.
I would definitely recommend this specialisation to anyone interested in Recommender Systems. It has left me with a very good understanding of the basics and a fair idea of the various directions in which I can pursue things in more detail. Not to mention, a tonne of references to read up on which I look forward to doing along with implementing some of the algorithms in the coming weeks.
I successfully completed this course with a 98.9% mark. This course was relatively more focused than the others so far. The machine learning theory that was covered in it was very basic and good for beginners so I skimmed through it fairly quickly. Nevertheless, it was a good refresher of models such as Naive Bayes, Decision Trees and k-Means Clustering. What I found particularly useful was the introduction to the KNIME and Spark ML frameworks and the exercises where one had to apply these ML models to some example datasets.
I think this course and the last one were more hands-on and what I was looking for when I first started this module with a greater focus on ML in the context of Big Data.
And here’s the certificate that I was awarded on completing the course.
I successfully completed this course with a 97.7% mark. This course was once again broad and touched upon some big data technologies through a series of lectures, assignments and hands-on exercises. The focus was mainly on querying JSON data using MongoDB, analysing data using Pandas, and programming in Spark (Spark SQL, Spark Streaming, Spark MLLIB and Spark GraphX). All these were things I was curious about and it was great that they introduced these in the course. There were also an exercise on analysing tweets using both MongoDB and Spark. They had one section on something called Splunk which I thought was a waste of time but I guess they have to keep their sponsors happy.
This specialisation so far (I’m halfway through) has been fairly introductory and lacking depth. It’s been good to the extent that I feel like I’m aware of all these different technologies and would be able to know where to start if I was to use them for some specific application. As I expected, this course was more hands-on which was great!
