Work Experience
Tatsu Works is the creator of the widely used Discord bot Tatsu.
It is used in more than 1,400,000 Discord servers and helps online Discord communities engage their community members by providing them with games and utilities.
The main selling point of Tatsu is the Tatsugotchi game, based on the popular Tamagotchi fad where users can collect pets, customize their own houses with more than a 1000 different pieces of furniture.
Tatsu also provides comprehensive utilities such as moderation features for server moderators and rewards members for activity in the Discord servers.
They are currently developing an idle MMORPG within Discord, Tatsumeeko, whose initial concept design I had also been involved in during my time there.
My main responsibility as a Backend API Developer during my internship was the implementation of API endpoints for Tatsu, using Node.js.
In addition, I was also involved in the game design and implementation for multiple events,
namely Tatsu's Launch Event and the Starlight Festival 2020.
For both the Launch Event and the Starlight Festival, there were a bunch of limited-time mini-games added to Tatsu, along with limited pets and cosmetics.
The design of the mini-games were decided after team brainstorming sessions that I was a part of, before each of them were delegated to different developers.
I was in charge of implementing the Daily Spinner and Greench (wordplay on the fictional character, the Grinch) mini-games. I also designed the arrangement of the Bingo Board, balancing each line to make sure that task difficulties were spread out evenly.
I was also given the task of game economy balancing. There was a limited-time event shop during the Launch Event, with limited pets and cosmetics on sale that players would buy with the event currency (earned through the mini-games).
I had to balance the currency gain from the mini-games with the prices of items in the shop - the currency sink.
The goal was to ensure players of different participation levels would ALL have something they could afford in the shop and have fun choosing what they want and spending their currency.
The event turned out to be a resounding success, with more than 110,000 users involved in the Treetsu mini-game!
Along with these events, new features were added to Tatsu. One of them was the Mail system.
I was tasked alone with this project, to design the entire system - both on the database side and the backend.
The implementation on the database would be done by a colleague, but the backend implementation would be done by me.
I designed how the database would store all the required information, down to the data types and procedures each call would do, along with the backend functionality.
Other than a slight hiccup with the database implementation, the design worked well! The system could handle sending mail to ALL users (with hundreds of thousands of users, this was non-trivial and needed to be handled) and mail to specific users.
I handled that concern by having a separate "Global Mail" and a "Personal Mail" where announcements would be stored in the Global Mail, which was stored in 1 location that all users would access.
This meant that there was no duplication of data and global mail would be have O(1) space and time complexity.
When individual users handled the Global Mail, for example by deleting, reading or marking as unread, a separate flag would be set for each user (with defaults).
Another sizeable feature I worked on was the Moderation features, namely the infract, warn, prohibit and exception commands.
It was added to make Tatsu a more comprehensive Discord bot, so that servers would not need to get a separate bot to deal with moderation unless they needed very specific features.
When enabled, Tatsu could screen members' messages and delete the message and warn or even remove them from the server if they contained any offensive words.
This required me to work with a NoSQL database, Redis that Tatsu Works used, a different one compared to the SQL database, PostgreSQL that I worked with in the Mail system.
At the time of writing, these moderation commands are still the ones used by Tatsu now!
One other project that I was initially assigned was the re-design of the basic text-based fishing game they had in Tatsu.
As with the other games, we did some brainstorming as the game design team and came up with an initial set of features that the revamp should include. I was put in charge of the game mechanics design
and introduced to Machinations, a game economy & systems design tool.
It's a tool that simulates systems such as players' currency gain, damage calculation that involves a significant amount of math and historically, messy Excel spreadsheets with complicated formulas.
I picked it up and used it for preliminary design on how the revamped fishing game's numbers would be calculated.
Check out my initial drafts on fishing catch rates on the left/above!
I was experimenting with different scalings for the rates (linear + Pokemon-based) on Machinations. Sample results are shown on the graph!
One of the co-founders of Machinations, Mihai, also took an interest (from one of my queries while working on it) and featured my catch rate diagram on the website!
Even though the revamp was postponed to a future update because of the urgent requirements in developing the events above and bot features instead, I accrued invaluable insights from
discussing and planning the system that I'm sure will come to be useful in future projects.
Tatsu Works uses the Agile methodology and we had regular sprints where we designated tasks and allocated task priorities before assigning them to the respective developer.
We used Trello to keep track of tasks. It was my first experience with the Agile framework and I found it very useful in viewing our progress and checking what tasks we had left.
My time at Tatsu Works was very busy but also fun and very fulfilling! I learnt loads from the colleagues I worked with, about different technologies and how a team collaborates and works together.
I also got the opportunity to work on many projects where my work was released to production and entertained many users! Different areas were exposed to me, designing games, balancing game economies and systems,
working with different databases, backend development and more!
I was approached to extend my internship into a full or part-time role but I wanted to prioritize my studies and
so declined the offer. Even now, I'm sure it would have also been a great role, but I feel that the time wasn't right to accept it!
National Parks Board, or NParks for short, is one of the statutory boards of the government of Singapore.
They are the lead agency for greenery, biodiversity conservation, and wildlife and animal health, welfare and management.
I was posted to the Plant Records Unit. The unit is in charge of surveying, labelling and tracking the living collections in the Singapore Botanic Gardens.
With thousands of species of flora in the Gardens, this is no small task!
My primary task was to migrate their current ageing database to a new database.
This included the analysis of different prospective databases to come up with a recommendation on which would be the best option,
and exporting of the current data.
Since there are numerous accesses and updates made to the database daily (with the huge number of plants in the Gardens), one major consideration is that those processes should be fast and streamlined.
I looked into the regular tasks that my colleagues did to understand the processes and workflow.
Also, different databases also differ in the services that they provide.
For example, the BRAHMS database has an in-built ARCGIS feature (a mapping solution) that make it easy to map botanical collections
if the existing collection already utilizes some ARCGIS-compatible maps.
Other than the database analysis, I also joined in a number of physical surveys of the plants in the Gardens with my colleagues.
I noticed that in their regular tasks of identifying and labelling trees, they had to record and track data on paper before manually entering them into the database back in the office.
This was partly due to the remoteness of certain locations and lack of Internet connectivity, resulting in a significant overhead and loss of time.
Thus, I set out to create a HTML form that could be used offline and could automatically convert collected data into an Excel file.
Personnel could use the form to record data while out in the field and would not need to spend time manually transferring the data to the database.
I picked up some HTML, CSS and Javascript to do so and managed to create a prototype form that could accomplish this task.
Here is a demo of the prototype form on the left/above! Since this is just a prototype, it's pretty barebones and simply functional.
Further improvements such as adding the ability to view added records, editing your entries can be done too!
In a functional botanic garden, making sure that all the collected data is accurate is essential.
Any inaccuracies such as mistyped identification numbers can result in "ghost" specimens that exist in the database but cannot be found in the Gardens.
One of the other tasks I was given was to work on a checksum algorithm.
Checksum algorithms are used to detect errors that occur during transmission or storage, mostly due to human error.
This would reduce errors such as a typo in the accession number when a personnel entered new data into the database.
I considered a few algorithms, the Luhn, Verhoeff and Damm algorithms and eventually selected the Luhn algorithm.
The other 2 algorithms were more complex and might take a longer time to process.
Also, since accession numbers, which is what the checksum will be used for,
contains special characters along with numbers, the Luhn mod N algorithm was chosen as it could handle special characters.
Here's my implementation of the Luhn mod N algorithm in Visual Basic on the right/below.
I used N = 39 as that is the total number of possible characters that can appear in a specimen's accession number.
To make sure that my implementation was correct, I created some automated tests in Excel using Visual Basic to check for the errors that the algorithm could not detect.
Since the algorithm was relatively simple, it could not detect all errors and double transposition errors ("103" instead of "301") and a few twin errors ("99" mistyped as "22") would pass.
However, these errors are very unlikely and the Luhn mod N algorithm will be sufficiently strong enough to detect most human errors and improve data integrity significantly.
A GIF of my conclusions from the tests is on the right/below! As mentioned above, double transposition errors aren't caught. This is because Luhn's algorithm
sums up the all digits after doubling the even digits. So if a digit is accidentally swapped with another even digit, the algorithm will not detect it.
Being my first foray into the workplace, my internship at NParks was a great starting point.
Although it isn't a software-focused company, meaning that it could not teach me nor expose me to more technical knowledge for my field, I could still learn non-technical stuff!
It forced me to self-learn and research, picking up HTML, CSS and Javascript which I had not worked with before.
Hearing from my colleagues' gripes about software also taught me that it is important for software to be built with the user in mind.
Even if a program had the functionality to complete a task, if users found it hard to navigate and use the interface, it would not be a good program.
The Botanic Gardens was also a very pleasant place to work at. Being someone that enjoys nature, whenever I needed a break, I could relax and walk around the Gardens to clear my mind.
My colleagues were also very passionate people (which I suppose comes from the closeness they work with flora) and inspired me to put my all into my work!
