Diary of Working on Notas - Part II

Challenges

Today, Hanoi is windy, cool, and lightly drizzling. I resumed working on Notas after nearly 3 weeks of rest and focus. Just this morning, I still didn't have any ideas for the next article because there were too many major issues that I hadn't resolved yet. But luckily, just recently, while cleansing my soul in the droplets of water from the fountain, I found the missing piece for the long-lasting troubles.

As usual, this week I will summarize the issues, difficulties I am facing, what I have accomplished, and the plan for the next week.

Difficulties

There are many significant challenges that I am currently facing.

In the previous article, I mentioned the structure of the Adapter as the database. Initially, I implemented the LocalStorage Adapter to retrieve data from the Local Storage in the browser. If I were to add a new Adapter to retrieve data from a specific server and handle synchronization, the user would need to connect to the internet to use that Adapter.

This means that a note-taking application would require an internet connection to be used. Hmm... that doesn't seem logical, as not everyone always has an internet connection. If they go outside and are offline but need to take notes, they won't be able to use the application, right?

Therefore, I had to find another solution that allows users to use the application both online and offline.

In the previous 3-tier architecture: UI, Logic, and Adapter, it seems that it is not enough to make the application work offline. To ensure that the application still works offline, we need to come up with a way to store user data when they have no internet connection.

So, we need to add a storage layer - which I call Storage - between Logic and Adapter. Storage acts as a local data storage, meaning that users can interact with the data even when they are offline. At this point, Logic will directly interact with Storage as a local database and also need to add a mechanism to synchronize data from Adapter to Storage.

It sounds simple, but when I started working on it, things were not easy.

First, I had to modify a lot of code and create an additional Storage layer to store data in the Local Storage as an offline database for users.

Second, the synchronization mechanism between Storage and Adapter is not very convenient, especially when adding a second client that participates in the synchronization server. So, when someone edits data in the same synchronization server, the data must be immediately synchronized to the other machines. Not to mention when multiple machines participate in editing the same note, it will be very complicated.

Third, even if a client has enabled data synchronization, if for some reason the machine is not connected to the network but still performs offline add/edit/delete operations, when there is a network connection, the data still needs to be synchronized with the server according to a certain rule.

It's really headache-inducing. When I first started, I didn't think this issue would be so complicated. Honestly, for the past week, every morning when I woke up, the first thing I thought about was how to solve this synchronization problem.

Finally, I had to modify my code many times to find a common rule for synchronization, and perhaps the light is shining through the leaves more clearly day by day.

Solution

Let's think about git along with its data pull/push mechanism. A remote server stores the remote repository, and a repository is "cloned" to the local storage on the computer. The task of git is to provide a mechanism to synchronize between remote and local, meaning that somehow it ensures that the data in the local storage is always the same as the remote.

If applied in that way, the Adapter will be like the remote, and the Storage will be like the local. Notas will require the Adapter to implement corresponding pull/push functions for retrieving and pushing new data to the synchronization server.

The remaining challenge is determining when to pull and push data.

Achievements and Goals for the Next Week

You may not believe it, but this Part II summary article is being written within the Notas application itself.

Notas can now function with alpha-level synchronization features. Using it to write is also a way to test its accuracy. Of course, there are still errors that occur while writing, many of which are related to asynchronous pull/push behaviors, causing data loss at certain times. Hopefully, these errors will be fixed in the coming week.

Finally, thank you for following along. If you have any questions or anything that is still unclear, please leave a comment below the article. I am more than happy to answer!