DEV Community: Tong Liu

Reflect: Release 0.4 3/3

Tong Liu — Sun, 11 Dec 2022 19:04:31 +0000

I finally finished implementing the issue of #1057 I selected for Release 0.4. Here is the Pull Request link for it #1157. This issue is the biggest issue I have worked on so far on GitHub, the complexity of this issue also suggests the same way. However, when I look back at what I have done throughout this issue, I found out that it is actually not as terrific as I thought it would be in the first place.

My Pull Request may not be accepted before this class ends

Although I submitted the Pull Request early enough for my Pull Request to get reviewed, the maintainer will not be able to give me a review at any time soon since the project maintainer has been burnt out by the high level of workload during Hacktoberfest 2022 as well as the backlogs of Pull Requests. However, this does not mean that this issue has never become less significant to me, on the contrary, I have learned lots of knowledge of Android including database, Intent mechanism, Data Object serialization, and so on. I may not be able to get my Pull Request accepted for merge, but even after this course ends, I will keep following up with my Pull Request until it's accepted and merged.

What have I achieved in this Issue?

In this issue, I implemented a feature which automatically sets cover images to the card when the user adds a card by scanning a barcode picture in the local gallery. To give the right of selection to users to decide if they want to automatically set the cover images, I also created a dialog to ask if the user wants to set the scanned picture as the cover image. Moreover, if the cover image has already been set by the user, it will not replace the cover image when the user rescans the barcode. To make the app know if the front/back cover image is set by the user, I need to create 2 extra flag variables to the Card Data Entity. Since the Card Data is stored in the database, I also modified the database to save them. However, since the parameters of the data-saving function changed, I have to fix every single line of code that uses it, including the tests which call this function more than 30 times.
Here is the image of the prompting dialog.

And once I clicked yes, the scanned barcode photo will be set as the front or back photo depending on which one has not been set yet.

What I've learned

I have learned a lot of Android knowledge throughout this Issue. It mainly boils down to two points:

Database: This is the biggest thing I've learned. Now I know to create a database I need to create a class that extends SQLiteOpenHelper and DB initialization code(e.g. table creating code) should go into the onCreate() function. To read data from the database, I need to pass a SQL sentence to the function database.query() and use the returned cursor to get specific data with the column name, for example, when I want to get the card's note I call cursor.getString(LoyaltyCardDbIds.NOTE). Another important element of the Android database is "update". To update the database from the old version to the new version, I should override the function onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) and use the SQL sentence ALTER TABLE to add or remove columns from a table based on the version range of the user's database.
Activity Intent: Passing data between Activities can be done by using an Android pre-built mechanism named Activity Intent. Since card editing Activity is shared among the 3 ways of adding cards (adding by scanning with the camera, adding by scanning library photo, and adding by manually inputting). In the adding by scanning library photo mode, I used bundle.putParcelble() to pass the URL of the scanned photo to the card editing activity to tell the card editing Activity that it needs to do the process to automatically add cover photos. It was quite straightforward, but it did take me some time to figure it out.

At the end

DPS909 has been the best course I've ever taken at Seneca College. I'm so happy that I could choose this course to allow me an immersive in-depth experience on GitHub open-source projects.

Reflect: Release 0.4 2/3

Tong Liu — Sun, 11 Dec 2022 15:03:49 +0000

The project I will be working on

I finally decided the project that I want to make a contribution to for Release 0.4 is Catima. For more information about it, Catima is a card management app running on Android, it allows users to save their physical card to their phones by manually inputting, and scanning. As for now, it has 147 contributors working on this project.

What is the issue about?

The reason why I chose this project is this because I'm already pretty familiar with the structure of this Android App since I've made 2 contributions to this repository during Hacktoberfest 2022,
which means that I don't need to spend extra time focusing on reading the code to figure out where should I start. The issue I chose is #1057, in this issue, a new feature that automatically adds cover images to the current card should be added to the existing logic of "adding card from image" function and once the user imports a card from a picture that contains a barcode, a dialog should be shown to the user to ask if they want to set the imported picture as the cover of the current generated card, if the user selected yes, the cover image should be set, otherwise, no cover image will be set. What's more to this is that I should add extra variables to track if the cover images (both front and back) were added manually or automatically and if the user rescans the card the new cover image should only be automatically set when the cover images were set automatically, otherwise, they should remain still.

My analysis of how to implement this issue

To implement this feature, I need to understand how the data are stored in the database and add a couple of columns to trace if the cover images are added manually. Also, I need to consider how to implement the database upgrade SQL sentence to upgrade the database from the old version to the new version because users' data still need to be kept, we can't just simply drop all tables and create new ones, but we need to alter and upgrade the schema of tables so that the data of those cards that already exist will be untouched.
Also, I can foresee that I need to also upgrade the testing code to make the tests cover the database logic I added.
Also, since "adding card from camera scanning", "adding card manually", and "adding card from image" all share the same Activity, I may need to add an extra bundle to the Intent of the activity to distinguish which entry started the card editing activity and I should add this new future to the scenario where the card editing activity is started by "adding card from image".

Reflect: Release 0.4 1/3

Tong Liu — Wed, 30 Nov 2022 20:17:13 +0000

Release 0.4 is the last assignment we have for DPS909. In this assignment we are going to be working on a project that has bigger scale, more complexity than other open-source project we have contributed to throughout this course.
To make this very last assignment meaningful, I would like to work on a project that has more than 100 contributors and I will choose an issue that requires me to add a feature instead of fixing a bug.
The repositories that I would like to choose from are these:

Repository List

https://github.com/AntennaPod/AntennaPod
This is a podcast Android app project that I have worked with previously for release 0.3.
https://github.com/CatimaLoyalty/Android
This is a gift card managing app on Android. I have made 2 contributions to this project during Hacktoberfest 2022, the repository owner of this project is very nice and has a high standard on code quality. This is the project that I want to work with the most.
https://github.com/nextcloud
NextCloud is an Android app that helps users to view and manage their phones on the cloud. Up until now, this project has more than one thousand opened issues for me to work on.
https://github.com/nextcloud/server
This is the server side of NextCloud I mentioned earlier. This project is implemented in JavaScript with Node.js, to make more the variety of the project I contribute to, I might choose to work on this as well.
https://github.com/Seneca-CDOT/telescope
Telescope as the project of the project that's collectively created by Seneca students, I feel that I'm very much obligated to make as much contribution as I could to it. In addition to this, since I spent a lot of time on this project during Release 0.3, I've already gotten more experience with this project, which means that I might find it easier to work on this project than start working on a new project from ground zero.

Lab10 Reflect

Tong Liu — Sat, 26 Nov 2022 01:10:40 +0000

In this week, I uploaded my SSGifier to a C++ package manager named conan. It was quite a lot of learning I had this week in trying to understand how does conan work, how do I integrate it into my project, and how do I encapsulate and upload a package of my project to remote server for other users to use. However, conan only provides packages as libraries for other projects to use, it is not like pip in python where we can install packages and use it standalone. That is being said, we need to createa conan project to use the package. To make sure that my instruction is easy to read and covers all needed requirements, I asked Piotr to install it with the only instruction from my README.md, and he later found out he has no difficulty installing my package.

How did I set up conan?

To set up conan, there are few steps need to be followed:

Install python first because conan relies on python to run its script.
Use pip install conan to install conan.
In the SSGifier project folder, create a folder named packageand create a folder src inside package and put all source files of SSGifier to the package/src folder.
In package folder, use $ conan new mypackage/1.0 -t to generate a package template for us to use.
Edit the generated conanfile.py and add the source files that to be packed into the package into the function def package(self). For example, self.copy("*.h", dst="src", src="src").
After finished setting up the conanfile.py, we need to register an account here to host our packages.
Follow the instruction to add the remote package source to conan.
In the package folder, use conan upload . -r put-your-remote-name-here --all to upload the package to remote. Now the package is uploaded to the remote server.

How to use the package?

You can also use SSGifier in your projectas as a library. To use it you need to do following:

Downlaod & install Conan from here and clang from here.
Create a conanfile.txt inside your project and add SSGifier/1.0.0 in the category of [requires] to conanfile.txt. Click to see official documents. You can use this template:

[requires]
SSGifier/1.0.0

[generators]
cmake

Edit conan.conf file in the location C:\Users\<your user name>\.conan and add revisions_enabled = 1 to [general].
Add this remote repository to conan by using this command conan remote add tommy-conan-local https://tommyliu.jfrog.io/artifactory/api/conan/tommy-conan-local
Add credential information to this repository by using this command conan user -p AKCp8nHPJwRCr2my24TiMaikQgQUW4e3xRbqsiGw45j9nPfPdLWEREYigcMLLW4pQtqg18n8b -r tommy-conan-local lt19930320@gmail.com.
Go to the directory of you project which you created in step 2(make sure conaninfo.txt), install SSGifier by using conan install . -r tommy-conan-local
Go to C:\Users\<your user name>\.conan\data\SSGifier\1.0.0\_\_\package\3fb49604f9c2f729b85ba3115852006824e72cab\src to find the source file.
Compile these code. For gcc, use g++ -std=c++17 main.cpp Utils.cpp ArgumentQueue.cpp FileProcessor.cpp MessagePrinter.cpp, for clang, use clang++ -std=c++17 main.cpp Utils.cpp ArgumentQueue.cpp FileProcessor.cpp MessagePrinter.cpp.
After compilation, a binrary executatable of SSGifier will be generated with the name of a.exe.

Reflect on Pull Request code review

Tong Liu — Fri, 18 Nov 2022 14:12:26 +0000

This is my first-time reviewing code on Github. It was actually quite fun to read others' code because I was scrutinizing the code suspiciously while I was reading others' code, and through this inspection of code, I realized that it is not easy to do code reviews than writing code because doing code review requires us to not only know how the functions should be implemented but we also need to reading others' code and trying to understand them. On top of that, we also need to know the best practice for the code we review, which requires us to have somewhat experience in this field. However, since we can't think about every aspect of our code when we are writing them, we might make mistakes or not perform the best practice, this is the scenario where code review becomes very important for keeping a good standard in the code we submit.

What did I review?

Telescope
Link: https://github.com/Seneca-CDOT/telescope/pull/3762/files/87742e87eac0b136f6f53b0c38c2679f03317abd
This is a PR made by Piotr to modify the documentation to provide a solution for data not showing up after the project is set up. This problem was found by me and Piotr while we are trying to work on the issue 3639. In this code review, Piotr updated the documentation for specific detailed steps we need to do after initializing the project in our local environment. I found at the end of the document he modified, a generalization of the problem and solutions is mentioned, however, the fact that the parser needs to be restarted after db:init was not mentioned, so I made a code review on this trying to amend it.
MyPhotoHub
Link: https://github.com/humphd/my-photohub/pull/9/files/f65ac86f3321207953d66b02c9b9fff1942828f1
This PR was made to make an initial implementation for this project. In this project, I found that the Regular Repression that matches a parameter was hard-coded and has occurred more than once. I think this might not be a good practice to hard code it on every occurrence since it's not future-proof when the regular expression needs to be changed. If this Regular Expression could be referenced from a variable or configuration file, it would make the future changes on it way less headache.

Reflect: PR2 of Release 0.3

Tong Liu — Thu, 17 Nov 2022 05:29:26 +0000

The issue that I was not able to fix...

This week I made a contribution to Telescope, and this is my first-time creating a Pull Request for Telescope which means I had zero knowledge of this project regarding its system structure design and it actually caused me to under-estimate my first attempt on issue #3639 which is later to be proven infeasible both for me and my co-contributor Piotr with our limited knowledge on this project. When we were first assigned this issue, we thought changing it would be as straightforward as we thought it would be if we had designed it. After a few reverse engineering from the HTTP requests of the frontend, we located the code that we need to change in the backend, however, it is not easy to change any of the data structure since the fact that this project uses many layers of data, which requires us to not only change the data field of posts in Radis but we also need to add a column to the database. After a few poking around, we remeasured the workload of this issue and soon found out that we might not be able to create a Pull Request to fix this issue before the due of Release 0.3 which is Nov.18th, and both of us switched to another issue.

The second issue I chose and how I fixed it

The second issue I chose was #3615. Since my previous involvement with this project, I realized the part that I need to modify was posts.js in the Posts Service, here is how I made modified the code.

As per the suggested solution made by David, I added a query param expand to the request /post/ to use this extra query param to control if the returned data should contain detailed information(which are author, title, and publishDate) about the feed.
I used an if-else statement to check if the expand equals 1, and if it equals 1, I will call Post.byId(id) on each post in the post array to query their extra information from Radis, otherwise, it will return the original data as before. The thing that I was struggling with in this step was Post.byId(id) is executed asynchronously, so I need to use an asynchronous function to call it. After a few google searches, I realized I could use await Promise.all(async()=>{}) to execute this asynchronous function synchronously.
Return the data that is created inside the if-else statement.

Post-fixing jobs

After finishing coding, I updated the document for the posts and also I wrote some tests to test my code, however, for the scenario when the request query param has expand=1, although this API works pretty well in actuality, the test still fails. This issue is still confusing me up until now when this reflect is written but I will find out the culprit that causes this test failure.

UPDATE: I have already found the cause of this problem and fixed it. The problem appeared to be in the data of feed in each post. If I were writing feed content directly to post, it will fail since the feed object will not be recognized by post::ensureFeed(), the feed object will become null so the whole test will fail. To fix it, I simply replace the post's feed object with the feed id, so that post::ensureFeed() will always fetch the correspondent feed from Radis.

Thanks for our fellow developers

In the end, I want to shout out to Tue who helped us to solve the issue in which the posts don't show even though the database is already well-set. We won't be able to make the whole service run if there wasn't your help.

Reflect of Lab09

Tong Liu — Tue, 15 Nov 2022 01:57:43 +0000

In Lab09, we are going to implement GitHub Actions which is a C/I tool to automate tests of our project. This technology is widely used by most repositories on GitHub because it could save the repository maintainer a lot of times on finding the potential bugs and checking the submitted code that don't conform with the suggested code style.

Links

My successful GitHub Actions run: 3464401840
Testing PR to Another Repo: 3466622227

Setup

To set up the GitHub Actions, we first need to create 2 folders, a .github in the root directory of the repository, and a workflows folder inside .github folder we just created. In the workflows folder, we create a YAML file to save the GitHub Actions configuration.
I programmed my project in C++ with Catch 2 for the testing framework， my GitHub Actions should be set up with C++ software stacks. The process of how I set up my YAML is as follows:

To make the GitHub Actions workflows run, I first set up the actions and branches that I want the GitHub Actions workflow to execute on. In my repository, it should be the push action and pull_request action on the main branch.
I need to install the C++ compiler for the testing environment to compile my tests, in this case, I used apt-get install -y clang to install clang++.
Before running the test cases, I need to add the code to compile the test. I used clang++ $CXXFLAGS $CXX -o $OUTPUTFILE to compile my tests, CXXFLAGS, OUTPUTFILE, and CXX are the variables I define in the env: because I want to segregate my actual compile command with parameters that are passed to it.
1. Now that my tests are compiled, I can run them now. To run them, I defined a new step in GitHub Actions. In this step, I just used ./test.o to run the compile binary tests.
2. Last is to delete the compiled test file. I think this step is omittable since every time we run GitHub Actions, there will always be a new environment created to run the workflows, and once the workflows are done, the environment will be deleted, so files that are generated during the tests will remain in the test GitHub Actions environment and it should not pollute my repository.

GitHub Actions differences

The partner I have this time is Piotr Drozd (here's his repo link). As I compared his GitHub Actions script with mine, I found differences as follows:

Since our repositories are built with different languages, the dependency and build tools we use for GitHub Actions are also different.
The way how we pass parameters to the testing framework is different. he directly passes parameters to the command, and I use variables to pass parameters.

Thoughts on CI.

After this lab, my thought on CI has been dramatically shifted, because initially, I thought setting CI would be pretty difficult to do, however, when I actually get into it, I found out that not only the syntax for GitHub Actions is pretty straightforward, but there's also tons of templates for us to use. Also, I realized that using GitHub Actions can drastically decrease the possibility of my contributors making dumb mistakes because GitHub Actions will automatically check their submitted code and prompt them whenever violations happen.

Reflect for PR1 in Release 0.3

Tong Liu — Mon, 14 Nov 2022 15:32:02 +0000

Links

Issue link: #6152
Pull Request link: #6186

Which Repository and Issue I was working on?

Although Hacktoberfest has already officially been over, our contribution to GitHub will still be going on. In Release 0.3, we are going to make 2 pull requests, and 2 code reviews. For the first pull request I made, it is an open-source podcast app on Android which has 4.5K stars. The issue I was working on is a new feature adding.

In this issue, the issue reporter suggests adding a mechanism to remember the user’s decision to let the "remove all from inbox" confirmation dialog never show again. Since this was the last repository I was working on for Hacktoberfest 2022, I still remember the structure of this project, I don't need to spend a lot of time getting familiar with the code base, so I decided to work on this one.

How did I fix it?

To make the app remember the users’ decisions on Remove all from inbox dialog, the first solution I came up with was to add the popup dialog with a “never ask again” check box which users can click to check to inform the app that they do not want to see this confirmation again. To make this data persistent, I used the mechanism named “SharedPreference” which is provided by the Android system for developers to save the basic typed data into the app.

I also considered the situation where users may want to withdraw this decision since once the users have checked the “never ask again” check box, they will no longer be able to see this dialog to withdraw their decision. My solution is to add an extra option to the Setting Activity so that the users can toggle on or off the “never show remove all from inbox dialog again”, from which users can withdraw their previous selection.

After a few twitches here and there, this flow finally runs well. This is what this dialog now looks like.

Lesson learned

Right before I made a PR, I sent a comment to the issue page to ask what the maintainer thinks about it. However, the maintainer did prefer the already-bloated setting page, since it will give more of a headache in finding the settings they want. He thought it is not necessary to give users a selection for them to withdraw this decision. Hence, I had to remove all the code related to settings.
From this experience, I learned that always make everything clear before starting coding, because I don't want to expect surprise and make the code that I have already written futile.

A reflect for Lab 8

Tong Liu — Thu, 10 Nov 2022 20:39:35 +0000

As a programmer who usually makes mistakes (sometimes dumb mistakes) I found the content of this week is pretty relevant and useful to me. Since programmers are humans and humans make mistakes, writing unit tests to dig out the potential issues in our code is as important as implementing features.

Which Unit testing framework did I use? and why?

To implement Unit Tests for my project, I dug through the google search result and GitHub and I found that it's quite opposite to the notorious fame of C++ that C++ is a very old-fashioned and anti-developers language, there are actually quite a few unit testing frameworks for C++. The one that I chose is Catch. Just like its name suggests, Catch is a unit testing framework for C++ to catch potential bugs in the code by writing unit tests. Not like other testing frameworks, catch only requires writing very few amounts of code to set up a unit test, this means I could be focusing on my actual test logic rather than being drawn away by the unit testing framework itself.
It's pretty easy to set it up, as the documentation shows, I only downloaded a header file catch_amalgamated.hpp and an implementation file catch_amalgamated.cpp to add Catch to my project. For setting up the Unit Tests, I read Catch's document and found out the process for me to set up Catch should look like follows:

Create a .cpp file to save unit test code and include Catch's header file in it.
Use TEST_CASE() to specify a test case and SECTION() to segregate the test case with different types of wrong arguments that get passed into the target function, although this is not required, it's still recommended for a more readable report file.
Inside each SECTION(), use REQUIRE() to assert the value against the expected value. If the tested code did not return the expected value, it will be counted as a failed test.
The result will be printed to the console and a report file named test_result.xml will be generated.

The problems I found through the Unit Tests

Just like I mentioned at the beginning of this post, I tend to make dumb mistakes by coding inconsiderately. One of the bugs I made in my code was a very typical empty-checking issue. There is a function that takes in a string of the path of the txt file to be read, and the function will open up a file stream to read the txt file to convert it as an HTML string and return it to the caller. Everything will work fine if I pass the txt file following the rule that the txt file is neither empty nor null pointer. However, if I pass in an empty string to represent the path of the file, everything will crash. This is because I forgot to add a condition to check if the parameter file path string is empty or not since I checked it on the caller side, although I know it's empty checked somewhere in my code, I still want my function to be able to resist empty values because I cannot just assume the callers have made sure that the passed string is not empty.
In the end, I was pretty excited about setting up this test framework because I knew I was going to make mistakes in the coding process, and I believe this is what makes it more worthwhile for me to set up this unit testing framework.

A very late-coming reflect for Hacktober 2022 event

Tong Liu — Thu, 10 Nov 2022 02:29:57 +0000

Time flies, Hacktoberfest 2022 has now already been over within a blink of an eye. However, being short in time does not make it less significant to me, on the contrary, it has helped me to gain a new perspective about how I should collaborate with people who I don’t know from all over the world, and also it helped me to overcome the world-wide difficulty, which is being involved. On top of that, as a former Android developer who has 4 years of work experience working, I have used many open-source projects on GitHub, which saved my life countless times, but never had I once done something in return. Luckily, I had Hacktoberfest pushing me out of my comfort zone, I am proud of myself that I can finally pay back to the GitHub community.

What I have done in Hacktoberfest 2022 and what have I learned?

During Hacktoberfest 2022, I made 5 PRs in total, although having 4 PRs was required for marking it as finished, I still wanted to do one extra because the last issue was connected to my previous issue and I wanted to make my fix complete. The Pull Requests that I love the most were the ones I created for Catima, because during these 2 PRs, I had my back-and-forth interactions which I really enjoyed with the repository owner, what is more important is that through this interaction, we both shared and learned lots of knowledge about Android Development, and this was the scenario I pictured in my mind about how the interaction on GitHub would be, I’m so glad this could really happen to me.
Let alone those wonderful interactions I had with repository maintainers, I now also learned that when I create an issue, I should always follow a certain format to make clear every aspect of the issue I want to submit, this includes the description of the issue, the replication method of the proposed bug, also don't forget to attach the log of when the bug happens. From the repository maintenance perspective, I also learned how it would actually be to maintain a repository that has actual users. Now I know I should always thoroughly test my code to cover as many corner cases as possible and when I finished coding, I should always run the unit test, integrate test and linter to check and fix the potential issues in my code. Although the steps may vary from repository to repository, always reading contributing.md is very important for knowing what tests the repository maintainers do expect before submitting Pull Request when finished coding.

At the end

Hacktoberfest for 2022 has indeed come to an end, but my contribution to GitHub will not stop there. I will try to make more contributions along the way to not only put my expertise into practice but also make it grow even bigger.

Formatter and Linter for C++ - Lab7

Tong Liu — Tue, 01 Nov 2022 18:59:37 +0000

In this lab, we are going to add a formatter and a linter to our project to regulate our contributors on their submissions. I think this lab is very interesting since I've always been seeing my submitted code on the repositories that I contributed for Hacktoberfest was checked by a component called Linter and it really helped me to find some stupid mistakes I made (for example, unused variables, misspell). Before this lab, I had already been considering implementing a Linter in my repository. Luckily, we have lab7.

The tools I used

The tools I used are clang-formatter and clang-tidy. As their names suggest, clang-formatter is for code-formatting and clang-tidy is for code-tidying(linting). These tools are pre-built with LLVM(Clang) which means it doesn't require any extra software, and also, this is the reason why I chose them.
Clang-tidy has helped me find many unsafe usages in my code, for example, strcpy() is the string copying function that I used throughout SSGifier, however, this function does not check the boundary of the string it copies, which could potentially cause memory buffer overwritten issue which can be used as a means to exploit our code. Instead, I changed it to strncpy() which copies string with respect to the boundary of the string.

Documents

clang-formatter
clang-tidy

Setup

Clang-formatter
To set up clang-formatter the only thing we need to do is create a config file named .clang-formatter. For more convenience, we can use this command clang-format -style=llvm -dump-config > .clang-format to generate one and customize it based on preferences.
Clang-tidy
Similar to clang-formatter, a config file named .clang-tidy is also needed for clang-tidy. We can use clang-tidy --dump-config to generate one, however, I don't recommend using this command to generate because the generated config file has many redundant properties, I would suggest using this config instead.

Run

To run clang-formatter, we should use the command clang-formatter -i -style=file *.cpp *.h. For the attributes we pass to clang-formatter, -style=file means we want to load the default config file for formatter to load, -i means we want to write the formatted lines back to the original files instead of printing it on the terminal. And also, we can pass the files to be checked into clang-formatter, and we can use *.cpp and *.h to check all cpp files and header files.
To run clang-tidy, we can use the command clang-tidy --extra-arg="--std=c++17" *.cpp *.h to check all cpp files and header files. This command will load and apply the config file .clang-tidy by default. Be careful --extra-arg="--std=c++17" is very important if you have used any function in C++17, such as std::filesystem.

Visual Studio Code Integration

Clang-tidy and Clang-format are bundled with a C++ extension plugin on Visual Studio Code. To use them, we need to follow these steps:

Clang-format

Install C++ extension plugin from Extensions tab in Visual Studio Code.
Format document with VS Code's default formatter(Ctrl + Alt + L by default) and .clang-format will be used as the guideline of the formatter.

Clang-tidy

Install C++ extension plugin from Extensions tab in Visual Studio Code .
Open action search by pressing Ctrl+Shift+P and type Run Code Analysis to search the action of clang-tidy.
Select C/C++:Run Code Analysis on All Files and wait for the checking process to be done.
select PROBLEMS tab on the bottom panel to check the suggested problem by clang-tidy.

Reflect for PR 4

Tong Liu — Mon, 31 Oct 2022 00:52:02 +0000

Links

Pull Request
issue

It was such a blast to be participating in Hacktoberfest. After I signed off this event with my last Pull Request, my effort and dedication towards Hacktoberfest have finally paid off. Hacktoberfest has not only helped me to finally get involved with the open-source community breaking me free from my comfort zone, but it also helped me to overcome my fear of being involved.

What did I do for the last PR

For my last PR, I decided to try something even bigger, so I chose an Android project named AntennaPod which has 4.5K stars with 1.2K forks. This is because I want to see how a bigger project is managed on GitHub and also how a bigger project's code framework is designed.
When I was looking for an issue to work on, I found an issue which reported a bug that when users set the default page of the app as Inbox Page, which shows all of the recently updated podcasts of the subscribed channels, the Index page will not actually show up when the app is opened. Since it was my first time contributing to this project, I have not gotten familiar with the code of this project, thus, I need a starter issue for me to get familiar with everything. This issue worked for the best because I only need to fix a bug and did not need to add new features to it.

How did I find a fix for it and how did I fix it?

After having browsed through the UI on how the settings are saved, I noticed they use an Android pre-built mechanism to save them, named PreferenceScreen. From the Android official document of Settings, I learned that all the values of those settings are saved in XML files, usually in attrs.xml. Soon I found there is a layout named preferences_user_interface.xml uses this file and also this layout file is referenced by UserInterfacePreferencesFragment which calls another function UserPreferences::setDefaultPage() to save this setting and next to it there was another function named getDefaultPage(). Now that I knew how the value is saved and read, I can check if it is the problem with the reading function or the saving function. After adding breakpoints here and there and having traced some relevant values, I noticed that the matching TAG of this setting is different between the read and save functions, which means, no matter how this setting is saved, the reading function will always not be able to find it since they are using different TAGs. Since now everything is clear, I could just either change the tag of the reading function or the saving function to get the issue solved. I chose the first and created this PR to request to merge it into the original repository. However, after the maintainer reviewed my code, they prefer to change the saving function instead of the reading function because changing the reading function breaks the naming consistency of other variables. After I reworked my fix and changed my fix on the saving function and pushed my code, my last PR was finally accepted which brought my hacktoberfest of 2022 to a successful end.