Install Packages

To get started, we need the following packages:

• yfinance: to fetch Forex data
• matplotlib: for plotting
• seaborn: for enhanced plotting with better visualization

1pip install yfinance matplotlib seaborn

Fetch the Data

 1import yfinance as yf
 2import seaborn as sns
 3import matplotlib.pyplot as plt
 4
 5sns.set_style("whitegrid")
 6
 7# Define the forex pair and date range
 8pair = "EURUSD=X"
 9# Define the start date and end date
10start_date = "2024-01-01"
11end_date = "2024-12-31"
12# Define the interval
13interval = '1h'
14
15# Fetch forex data
16forex_data = yf.Ticker(pair)
17
18
19# Fetch historical forex data
20data = forex_data.history(start=start_date, end=end_date, interval=interval)
21
22# Data overview
23data.info()
24
25"""Output
26<class 'pandas.core.frame.DataFrame'>
27DatetimeIndex: 6178 entries, 2024-01-01 18:00:00+00:00 to 2024-12-30 23:00:00+00:00
28Data columns (total 7 columns):
29 #   Column        Non-Null Count  Dtype
30---  ------        --------------  -----
31 0   Open          6178 non-null   float64
32 1   High          6178 non-null   float64
33 2   Low           6178 non-null   float64
34 3   Close         6178 non-null   float64
35 4   Volume        6178 non-null   int64
36 5   Dividends     6178 non-null   float64
37 6   Stock Splits  6178 non-null   float64
38dtypes: float64(6), int64(1)
39"""

Data Quality Check

Missing values

We can check the missing values by

 1data.isna().sum()
 2
 3""" Output
 4Open            0
 5High            0
 6Low             0
 7Close           0
 8Volume          0
 9Dividends       0
10Stock Splits    0
11dtype: int64
12"""

No missing values, nice :)

Removing Irrelevant Columns

Upon closer inspection, we notice that the Volume, Dividends, and Stock Splits columns have all values equal to 0. These columns are not useful for our analysis, so let’s drop them.

 1cols = ['Volume', 'Dividends','Stock Splits']
 2(data[cols] == 0).all()
 3
 4""" Output
 5Volume          True
 6Dividends       True
 7Stock Splits    True
 8dtype: bool
 9"""
10
11data.drop(columns= cols, inplace = True)

After this, we have a cleaned DataFrame.

 1data.info()
 2
 3""" Output
 4DatetimeIndex: 6178 entries, 2024-01-01 18:00:00+00:00 to 2024-12-30 23:00:00+00:00
 5Data columns (total 7 columns):
 6 #   Column        Non-Null Count  Dtype
 7---  ------        --------------  -----
 8 0   Open          6178 non-null   float64
 9 1   High          6178 non-null   float64
10 2   Low           6178 non-null   float64
11 3   Close         6178 non-null   float64
12 4   Volume        6178 non-null   int64
13 5   Dividends     6178 non-null   float64
14 6   Stock Splits  6178 non-null   float64
15dtypes: float64(6), int64(1)
16"""

Data Visulazation

We will now use seaborn to plot the hourly closing prices.

 1import seaborn as sns
 2import matplotlib.pyplot as plt
 3
 4# Set up the plot style
 5sns.set_style("whitegrid")
 6plt.figure(figsize=(12, 6))
 7
 8# Plot the hourly closing prices
 9sns.lineplot(x=data.index, y=data["Close"])
10
11# Formatting the plot
12plt.xlabel("Date")
13plt.ylabel("EUR/USD Hourly Closing Price")
14plt.title("EUR/USD Hourly Closing Price (2024)")
15plt.xticks(rotation=45)
16plt.show()

This will generate a line plot showing the hourly closing prices for the EUR/USD pair in 2024.

Conclusion

In this blog, we learned how to fetch Forex data using the yfinance library, cleaned the dataset by removing irrelevant columns, and visualized the EUR/USD hourly closing prices with seaborn. This simple step can serve as the foundation for more complex Forex analysis and hedging strategies.

I see this home lab as the start of a long-term (10+ years) project—one that allows me to enjoy the process of building and creating. Technology is a vast and dynamic field, with new developments emerging every second: new languages (like Rust), frameworks (React 19), tools (Heptabase), and AIs (DeepSeek). While fascinating, it’s also overwhelming. I often find myself hoarding tutorials, trapped in what many call “tutorial hell”—living under the illusion of learning while simply saving resources I never have time to explore.

It’s time to break free from that cycle. I want to shift to a project-based, interest-driven approach. I don’t know exactly where this journey will take me, but I’m certain it will be anything but boring. Plus, creating tangible improvements in my daily life will bring a much-needed sense of achievement.

Control the System, Not the Other Way Around

Linux has always fascinated me with its elegance, and I’ve long wanted to explore it in depth. With academic pressures now behind me, this feels like the perfect time to dive into this mysterious yet exciting world and experiment with cutting-edge technologies. My trusty Raspberry Pi 4 Model B remains an excellent tool for this exploration.

Five years ago, my first experience with CentOS was both thrilling and intimidating. The freedom to control everything felt powerful but also risky—one careless command could ruin the entire system. Yet, that same freedom gave me an exhilarating sense of ownership. For the first time, I had full control over both the operating system and the hardware beneath it. The possibilities felt limitless, and the sense of empowerment was incredible.

Reclaiming My Attention

Last year, I struggled with information overload—too much content demanding too little focus. To regain my concentration, I intentionally quit most social media platforms. It became clear to me that attention is my most valuable resource. During this process, I rediscovered the beauty of old-school RSS. It’s exactly what I need: a way to read content with depth and authenticity, written by people who aim to express, not impress.

Since I enjoy reading on my Kindle, I was thrilled to discover the potential of a self-hosted send-to-Kindle service like Feedi. I deeply resonated with the creator(Facundo Olano)’s motivation on the blog Reclaiming the Web with a Personal Reader:

It felt refreshing to be back in control of my feed, to receive strictly chronological updates instead of having an algorithmic middleman trying to sell me stuff.

This inspired me to set up a home server or lab to fully take control of my digital consumption.

Looking Forward

In the future, I hope it becomes a great space for me to experiment with and configure different things that appeal to me, fueling my curiosity even further. But most importantly—it’s all about having fun.

 1Traceback (most recent call last):
 2
 3  File ~/anaconda3/envs/fin/lib/python3.10/site-packages/IPython/core/interactiveshell.py:3577 in run_code
 4    exec(code_obj, self.user_global_ns, self.user_ns)
 5
 6  Cell In[1], line 1
 7    import yfinance as yf
 8
 9  File ~/anaconda3/envs/fin/lib/python3.10/site-packages/yfinance/__init__.py:30
10    from .screener.screener import Screener
11
12  File ~/anaconda3/envs/fin/lib/python3.10/site-packages/yfinance/screener/__init__.py:1
13    from .screener import Screener
14
15  File ~/anaconda3/envs/fin/lib/python3.10/site-packages/yfinance/screener/screener.py:101
16    logger.error(f"Failed to get screener data for '{self._body.get('query', "query not set")}' reason: {e}")
17                                                                              ^
18SyntaxError: f-string: unmatched '('

Don’t worry! This error is a known issue with the yfinance 0.2.45 source code, and it’s easy to fix. Below, I’ll explain what causes this error and two simple ways to resolve it.

Why This Happens

The issue occurs in this line of the yfinance source code:

1logger.error(f"Failed to get screener data for '{self._body.get('query', "query not set")}' reason: {e}")

The problem lies in the mixing of single and double quotes inside the .get() method. Python tries to process both 'query' and "query not set" within the same string, causing confusion. Since the string started with a single quote, Python expects a matching single quote but encounters a double quote, leading to a syntax error.

Two Simple Fixes

You can fix this issue in one of two ways: either by downgrading to an earlier version of yfinance or by manually correcting the source code. Here’s how:

1. Downgrade to a Previous yfinance Version

If you don’t need the latest features of yfinance 0.2.45, simply downgrade to version 0.2.44 by running this command in your terminal:

1pip install --force-reinstall -v "yfinance==0.2.44"

After downgrading, restart your Jupyter notebook, and the issue should be resolved.

2. Manually Edit the Source Code

If you prefer to stick with yfinance 0.2.45 for its new features, you can manually correct the problematic line in the source code.

Follow these steps:

1. Locate the file: yfinance/screener/screener.py.
2. Find the offending line:

1logger.error(f"Failed to get screener data for '{self._body.get('query', "query not set")}' reason: {e}")

and change it to

1logger.error(f"Failed to get screener data for '{self._body.get('query', 'query not set')}' reason: {e}")

This small change ensures consistent use of single quotes, preventing the syntax error.

Conclusion

This error in yfinance version 0.2.45 is easily fixable, either by downgrading to a previous version or manually editing the source code. Choose the method that works best for your needs, and you’ll be back to analyzing financial data in no time!

In this blog, I will walk you through all the technical settings of this lightweight yet powerful tool and end up getting your site indexed in Google within 48 hours.

🔗 Google Account Preparation

Register a Google Cloud account

Enable Google Search API here.

Enable Web Search Indexing API here.

Create a service account

Create a service account here

Then click the service account we just created, and go to the Keys panel to create a new key.

Then a window will pop up and we just download the key we generated; Then, we change its name to service_account.json.

Add your service account to Google console as Owner

Copy our service account email to clipboard, we will use this in a moment.

Visit Google Console. In ‘Settings’ panel, click ‘add user’. Then, in the pop-up window, paste our service account email and make sure the permission is set to ‘Owner’

After clicking ‘Add’, you service account should be successfully added to Google Console:

🛠️ Environment Preparation

Node.js

Go to Node.js , download and install the Latest LTS Version of Node.js, it’s 20.11.0 at current time.

Open the terminal of your computer, check whether Node.js has successfully installed

1node -v
2# 20.11.0

Git

You can check whether you have installed Git by running this command in the terminal

1git version
2# git version 2.33.0

If you haven’t installed it, you can refer to this guide.

✏️ Script Configuration

This is the last step in our progress.

download the script

use this command to download the script into our local computer:

1git clone https://github.com/goenning/google-indexing-script.git

install dependencies

Open the folder we just downloaded in an IDE; I personally use ‘WebStorm’. Then, in the terminal, run the following command to install all the necessary dependencies of this script.

1npm install

set the credentials

Move the service_account.json we downloaded in previous step to the same same folder as the script.

The directory should be the following:

1.
2├── LICENSE
3├── README.md
4├── output.png
5├── package-lock.json
6├── package.json
7├── src
8├── node_modules
9└── service_account.json

Run the Script

In the terminal, run

1npm run index yourWebsiteDomain.com
2# OR
3npm run index https://yourWebsiteDomain.com

For instance, since the domain of my blog is ‘byteli’, so I just run

1npm run index byteli.com

And we just submitted the unindexed pages in seconds 🎉

Check the Updates

In one or two days, visit Google Search Console, under ‘Indexing’ - ‘Pages’, you can view the updates of the newly indexed pages.

🎉 Conclusion

In conclusion, overcoming the frustration of delayed Google indexing is a game-changer for any blogger. The journey outlined in this blog, from Google account preparation to environment setup and script configuration, provides a comprehensive guide to tackle the indexing challenge effectively. As you embark on this journey, embrace the power of automation and witness the positive impact on your blog’s discoverability. Happy blogging!

The hue parameter in Seaborn allows for the seamless integration of categorical variables, introducing a spectrum of colors that not only enhances the aesthetic appeal of your plots but also provides a powerful tool for conveying intricate relationships within your data. In this blog, we will embark on a journey to explore the nuances of using ‘hue’ in Seaborn, unlocking its potential to reveal insights, distinguish patterns, and elevate the clarity of your visual narratives.

📊 Usage

Firstly, We will load tips dataset from the online repository in Seaborn. This dataset contains the following data:

One waiter recorded information about each tip he received over a period of a few months working in one restaurant

1import seaborn as sns
2import matplotlib.pyplot as plt
3
4# Load sample data
5data = sns.load_dataset("tips")

Like always, We will inspect our data then:

 1data.info()
 2
 3"""
 4<class 'pandas.core.frame.DataFrame'>
 5RangeIndex: 244 entries, 0 to 243
 6Data columns (total 7 columns):
 7 #   Column      Non-Null Count  Dtype
 8-- -----     ------------- -----
 9 0   total_bill  244 non-null    float64
10 1   tip         244 non-null    float64
11 2   sex         244 non-null    category
12 3   smoker      244 non-null    category
13 4   day         244 non-null    category
14 5   time        244 non-null    category
15 6   size        244 non-null    int64
16dtypes: category(4), float64(2), int64(1)
17memory usage: 7.4 KB
18"""

According to the dataset description, each variable has the following meaning:

total_bill: bill in dollars, tip: tip in dollars, sex: sex of the bill payer, smoker: whether there were smokers in the party, day: day of the week, time: time of day, size: size of the party.

Scatter Plots

In this example, we’ll compare a simple scatter plot with and without hue to showcase how it can enhance our understanding of the data.

Without hue

1sns.scatterplot(x="total_bill", y="tip", data=data)

With hue

1sns.scatterplot(x="total_bill", y="tip", hue="time", data=data)

In this example, we compare two scatter plots side by side. The left plot (without hue) shows a basic scatter plot of total bill amount vs. tip without distinguishing different days. The right plot (with hue) introduces the ‘day’ column as the hue parameter, coloring the points based on the days of the week.

By using hue, we can observe how the relationship between total bill and tip varies across different time. This additional categorical information enhances the visualization, making it easier to differentiate patterns and trends within the data.

Bar Plots

1sns.barplot(x="day", y="total_bill", hue="sex", data=data)

Box Plots

1sns.boxplot(x="day", y="total_bill", hue="sex", data=data)

Violin Plots

1sns.violinplot(x="day", y="total_bill", hue="sex", data=data)

Count Plots

1sns.countplot(x="day", hue="sex", data=data)

🤔 When to Use and When Not to Use hue?

The use of hue is particularly beneficial in the following cases:

• Visualizing Categorical Relationships: When you are visualizing relationships between two numeric variables and have a third categorical variable that you want to explore simultaneously.

• Highlighting Patterns or Trends: When you want to highlight patterns, trends, or differences in your data by using different colors for different categories.

• Enhancing Interpretability: When you want to enhance the interpretability of your visualizations by adding an extra layer of information through color.

While the hue parameter in Seaborn can be a powerful tool for enhancing visualizations by incorporating an additional categorical variable, there are situations where it might not be necessary or could potentially lead to confusion:

• Limited or No Categorical Data : If your dataset has very limited categorical data or if the categorical variable doesn’t provide meaningful insights into the patterns you are exploring, using hue might not add much value. When the variable specified in hue is not categorical, but rather a continuous variable, using hue may not be appropriate. In such cases, alternative approaches like color gradients or size encoding might be more suitable.

• Overcrowded Plots: When the number of categories within the hue variable is large, it can lead to overcrowded plots with too many colors, making it difficult to distinguish and interpret the information.

• Color Vision Impairments: Consider the audience of your visualizations. If there is a possibility that the audience includes individuals with color vision impairments, relying heavily on color differentiation (such as with hue) might limit accessibility. Ensure your visualizations are still interpretable in grayscale.

Conclusion

In conclusion, Seaborn’s hue parameter is a dynamic tool that breathes vitality into visualizations, providing nuanced insights across plot types, from scatter plots to count plots. By introducing an additional layer of categorical information, hue unveils hidden patterns and relationships. However, its use should be judicious, especially when simplicity is crucial.

1$ npm install remark-math rehype-katex

 1import { defineConfig } from 'astro/config'
 2import remarkMath from 'remark-math'
 3import rehypeKatex from 'rehype-katex'
 4
 5export default defineConfig({
 6	//
 7	markdown: {
 8		remarkPlugins: [remarkMath],
 9		rehypePlugins: [
10			[
11				rehypeKatex,
12				{
13					// Katex plugin options
14				}
15			]
16		]
17	}
18})

 1<html lang="en" class="scroll-smooth">
 2	<head>
 3		<!-- Katex -->
 4		<link
 5			rel="stylesheet"
 6			href="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.css"
 7			integrity="sha384-n8MVd4RsNIU0tAv4ct0nTaAbDJwPJzDEaqSD1odI+WdtXRGWt2kTvGFasHpSy3SV"
 8			crossorigin="anonymous"
 9		/>
10		<script
11			defer
12			src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/katex.min.js"
13			integrity="sha384-XjKyOOlGwcjNTAIQHIpgOno0Hl1YQqzUOEleOLALmuqehneUG+vnGctmUb0ZY0l8"
14			crossorigin="anonymous"
15		></script>
16		<script
17			defer
18			src="https://cdn.jsdelivr.net/npm/katex@0.16.9/dist/contrib/auto-render.min.js"
19			integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05"
20			crossorigin="anonymous"
21			onload="renderMathInElement(document.body);"
22		></script>
23	</head>
24
25	<body>
26		<slot />
27	</body>
28</html>

 1# For getting historical financial data
 2import yfinance as yf
 3# For scientific computing in statistics
 4from scipy.stats import norm
 5# For plotting and visualization
 6import matplotlib.pyplot as plt
 7
 8# Fetch AAPL data
 9stock_data = yf.download('AAPL', start='2023-01-01', end='2023-12-31')
10# Get a concise summary of our DataFrame
11stock_data.info()
12
13"""
14<class 'pandas.core.frame.DataFrame'>
15DatetimeIndex: 250 entries, 2023-01-03 to 2023-12-29
16Data columns (total 6 columns):
17 #   Column     Non-Null Count  Dtype
18---  ------     --------------  -----
19 0   Open       250 non-null    float64
20 1   High       250 non-null    float64
21 2   Low        250 non-null    float64
22 3   Close      250 non-null    float64
23 4   Adj Close  250 non-null    float64
24 5   Volume     250 non-null    int64
25dtypes: float64(5), int64(1)
26memory usage: 13.7 KB
27"""
28
29# Get the daiily return using `pct_change()`, remove missing values
30stock_returns = stock_data['Adj Close'].pct_change().dropna()

1# Inspect the distribution by plotting histogram of daily returns
2plt.figure(figsize=(8, 6))
3plt.hist(stock_returns, bins=50, density=True, alpha=0.7, color='skyblue', edgecolor='black')
4plt.title('Histogram of Apple Inc. (AAPL)  Daily Returns in 2023')
5plt.xlabel('Daily Returns(%)')
6plt.ylabel('Frequency')
7plt.grid(True)
8plt.show()

1# Calculate mean and standard deviation of daily stock returns
2mean_return = stock_returns.mean()
3std_deviation = stock_returns.std()
4
5# Create a normal distribution based on the calculated mean and standard deviation
6appl_daily_return_distribution = norm(loc=mean_return, scale=std_deviation)

 1# CDF
 2appl_daily_return_distribution.cdf(0.01)
 3
 4# 0.7420136860623278
 5# 74.20% of the daily returns of Apple is less or equal to 1%
 6
 7appl_daily_return_distribution.cdf(0.005)
 8# 0.5994001904523659
 9# 59.94% of the daily returns of Apple is less or equal to 0.5%
10
11appl_daily_return_distribution.cdf(0.01) - appl_daily_return_distribution.cdf(0.005)
12
13# 0.14261349560996184
14# 14.26% of the daily returns of Apple is greater than 0.5% and less or equal to 1%

 1# PPF
 2appl_daily_return_distribution.ppf(0.9)
 3
 4# 0.017944086843352632
 5# The value of which 90% of all the daily returns are less or equal to is 1.79%
 6
 7appl_daily_return_distribution.ppf(1 - 0.9)
 8# -0.014274232117790355
 9# The value of which 90% of all the daily returns are less or equal to is -1.42%
10# In other words, the value of which 90% of all the daily returns are greater to is -1.42%.

 1# Calculate the CDF for a range of values
 2x_values = sorted(stock_returns)
 3y_cdf = appl_daily_return_distribution.cdf(x_values)
 4
 5# Plotting the Cumulative Distribution Function (CDF)
 6plt.figure(figsize=(8, 6))
 7plt.plot(x_values, y_cdf, label='CDF')
 8plt.title("Cumulative Distribution Function (CDF) of Apple's Stock Daily Returns in 2023")
 9plt.xlabel('Daily Returns(%)')
10plt.ylabel('Cumulative Probability')
11plt.legend()
12plt.grid(True)
13plt.show()

 1# Calculate the PPF for a range of probabilities
 2probabilities = [0.05, 0.25, 0.5, 0.75, 0.95]
 3x_ppf = appl_daily_return_distribution.ppf(probabilities)
 4
 5# Plotting the Probability Point Function (PPF)
 6plt.figure(figsize=(8, 6))
 7plt.plot(probabilities, x_ppf, marker='o', linestyle='None', label='PPF')
 8plt.title("Probability Point Function (PPF) of of Apple's Stock Daily Returns in 2023")
 9plt.xlabel('Probability')
10plt.ylabel('Stock Daily Returns(%)')
11plt.legend()
12plt.grid(True)
13plt.show()

• When the stock price falls under the strike price

  Let’s say the stock price falls to $180. In this situation:

  • our payoff from the stock is $\$180 - \$190 = -\$10$
  • our payoff from the put option is $Max(\$190 - \$180, 0) - \$2 = \$8$
  • the total payoff is $-\$10 + \$8 = -\$2$

  By doing so, we successfully limit our potential loss to -$2, which is the cost of the put option, aka put premium. In fact, our loss will be limited to $2 regardless of how much the underlying stock price falls.

• When the stock price rises above the strike price

  Suppose the stock price rises to $191. In this situation:

  • the payoff from the stock is $\$191 - \$190 = \$1$
  • the payoff from the put option is $Max(\$190 - \$191, 0) - \$2 = -\$2$
  • the total payoff is $\$1 - \$2 = -\$1$

  Notice that even if the current stock price is higher than our previous buy price, we’re still losing money due to the put option’s cost. In fact, we can only gain once the current stock price is greater than the sum of the buy price and the put premium. In other words, our break-even point in this situation is 190 + 2 = $192.

  Assuming the stock price continues to rise to $200. In this scenario, our return is calculated as follows:

  • the payoff from the stock is $\$200 - \$190 = \$10$
  • the payoff from the put option is $Max(\$190 - \$200, 0) - \$2 = -\$2$
  • the total payoff is $\$10 - \$2 = \$8$

  We can still profit from the increase in stock price.

Strengthens and Weakness

Strengthens:

• Downside Protection

  The Protective Put strategy allows investors to limit potential losses in the event of a market decline or a drop in the underlying asset’s value while still benefiting from market upsides.

• Simplicity

  The Protective Put strategy is relatively straightforward to understand and implement, providing a clear and easy-to-follow approach to risk management.

• Participation in Upside Potential

  The investor can benefit from the appreciation in the asset’s value while having the downside risk hedged by the put options.

• Flexibility

  The Protective Put strategy can be applied to various underlying assets, including stocks, ETFs, or indexes.

Weakness:

• Limited Upside

  The Protective Put strategy’s primary objective is to hedge against downside risk. If the market rises, the value of the put options may decrease or expire worthless, which can offset gains in the underlying asset.

• Cost

  The put premium can eat into your overall returns, especially when the market is stable or only experiences a minor decline.

• Rolling Costs

  To maintain continuous protection, investors must roll their options positions by closing out expiring options and opening new ones. This rolling process incurs additional transaction costs, which can impact overall returns.

Conclusion

In summary, a protective put provides downside protection by setting a floor price at which you can sell your shares; the downside risk is limited at the cost of the put premium, i.e. the money we have to pay for the put option. While the Protective Put strategy offers such advantages, it’s essential to notice that it has some weaknesses that can negatively affect the total payoff. Hence, we must assess its suitability based on investment goals, risk tolerance, and market outlook.

Qualitative questions weigh more than quantitative ones.

From the feedback I got from the BT forum, the P2 exam has always focused more on qualitative questions in recent years.

So you better understand the theoretical concepts in the first place rather than memorize formulas repeatedly and painfully.

How to distinguish important theoretical concepts? Check the LOs.

Do NOT expect to memorize and understand everything at once.

Leave time for the second round of study.

Don’t push yourself to remember every trivial detail in the first study round, cause:

• You can’t distinguish the knowledge that matters, so your memory load is unnecessarily heavy. Finish your first study round, and you’ll get the big picture.
• Most importantly, it will frustrate you and slow down your learning pace; at this point, some candidates may feel unmotivated and want to quit. (But not YOU.)

After you finish your first study of the material, you may find yourself can barely remember what’s in the first 2 or 3 books. That’s how memory works, the good news is you can easily solidify those memory links in your second study round, and that’s where ‘Ah, everything is connected.’ happens most. Personally, I leave 6 weeks for another round of review this time. I work full-time during the daytime, so I tend to leave more time for myself. Surely, this timeframe varies from person to person.

QB and MOCKs

• QB - Collect & review your mistakes regularly

  I completed all BT’s practice questions. But I don’t recommend this approach, cause BT’s practice questions are far more difficult than actual GARP’s, especially the quantitative ones. If you just want to pass the exam, you do not need to spend soooo much time and energy.

  However, regular review of your mistakes really helps, you may surprisingly find yourself making the same mistakes repeatedly, and you’ll learn from them every single time.

MOCKs - Do the GARP Practice Exams.

I only did two GARP Practice Exams during the whole study. I think it matches the actual exam’s difficulty and solution logic. I recommend every candidate take advantage of it, you can get it directly from GARP’s official website, totally free.

When finish the mock, carefully review EVERY problem to:

• diminish your known unknowns and, most importantly, your unknown unknowns;
• realize how different LOs are organized and tested as a whole;
• follow up the solution pattern, especially the qualitative questions, cause you often can’t solve them directly.

The previous day before the exam

• Check the calculator and all your document.
• Review all your mistakes.
• Have a good sleep.

On the exam day.

• Eat breakfast (my exam was in the morning)

  Your heart needs that energy to pump blood to your brain.

• Bring a bottle of water.

  Staying hydrated makes brains think better and make smarter choices.

• Stay calm

  Whatever questions and situations you encounter, just don’t panic.

  (BTW, my computer crashed TWICE on exam day.)

Tools I use

• Excel

  Forget about fancy to-do apps, over-priced task management software, Notion, etc., excel is enough to quantify your OKRs and track your progress.

• Anki

  Powerful, intelligent flash cards. Remembering things just became much easier. – Anki

  Anki is a free software(except for iOS) to make flash cards.

  I use it to make flashcards of P2 LOs, so I can use the fragmented time, such as commuting, to memorize knowledge points in a way that conforms to the forgetting curve.

• Pomodoro Technique

  The Pomodoro Technique is a good way to deal with procrastination, greatly reducing the resistance to starting work. At the same time, it also well combines highly focused time and guilty-free breaks, which saves me a lot from a heavy study load.

• Study Together

  Study Together is a discord group, where members can join a muted study call, only opening their video cameras and study live. It’s kinda like a virtual library, creating the study vibes whenever you need to figure the Greeks out.