The nudge came from zhangchitc, who shared a polished Ghostty config along with a relevant data point: Boris, the lead on Claude Code, has said his team's go-to terminal is Ghostty — running five instances in parallel. If the people building Claude Code are running it in Ghostty, that's a reasonable signal worth paying attention to.

zhangchitc open-sourced his config, I ran it for a few days, adjusted it to fit my workflow, and here's where I landed.

What I Changed

zhangchitc's config is already well thought-out — the changes I made are purely personal preference:

• Font: Maple Mono NF CN → Monaco Nerd Font Mono — just find Monaco easier on the eyes for code

• Theme: Catppuccin Mocha → Selenized Black — pure black background, high contrast, easier to read logs for long stretches

• No background transparency: zhangchitc uses background-opacity = 0.85 for a frosted-glass look, which is nice, but I prefer a solid background for reading focus

• Cursor: non-blinking block cursor (block + blink = false), with shell-integration-features = no-cursor to prevent shell integration from overriding it

• Removed Ghostty's native splits: my workflow puts different SSH connections in separate Ghostty tabs, with tmux handling splits on the remote side — so the cmd+d split keybinds are gone

• No window state persistence: dropped window-save-state = always, so each launch starts clean

Net result: pure black background, solid block cursor, no transparency, no native splits — as minimal as a terminal gets.

Why Your Terminal Actually Matters

The terminal is one of those tools you use every day but rarely optimize. A few areas where Ghostty genuinely helps:

• GPU rendering: when backtests are dumping large volumes of log output, iTerm2 can stutter. Ghostty renders on the GPU — scrolling through dense output stays smooth

• Quick Terminal: global hotkey Ctrl+` drops a terminal down from the top of the screen from any app. Great for a quick script or a fast git push without switching context

• Claude Code workflow: one tab running Claude Code, another SSH'd into a server tailing live logs, Quick Terminal for one-off commands — tab switching is fast and all tabs share a consistent color scheme

• tmux on the remote: remote servers use tmux for multi-pane process management (data feeds, strategy processes, monitoring). Ghostty handles local tabs and connections; tmux handles remote layout. They don't step on each other.

Installation

On macOS: brew install --cask ghostty. Config goes in ~/.config/ghostty/config.

One macOS gotcha (possibly a bug): the system config at ~/Library/Application Support/com.mitchellh.ghostty/config may contain a line like theme = TokyoNight Night. If it does, comment it out — otherwise it overrides your theme setting in ~/.config/ghostty/config, locking you into TokyoNight Night regardless of what you set.

Config

My config:

# ============================================
# Ghostty Terminal - My Config
# ============================================
# Location: ~/.config/ghostty/config
# Hot reload: Cmd+Shift+,
#
# Reference: config shared by zhangchitc
# https://gist.github.com/zhangchitc/7dead7c1b517390e061e07759ed80277
#
# Based on the reference config, adjusted to personal preferences:
# - Font: switched to Monaco Nerd Font Mono
# - Theme: switched to Selenized Black
# - Transparency: no background transparency, solid color for focused reading
# - Split keybinds: removed Ghostty native splits
#                   different SSH connections separated by Ghostty tabs, remote splits handled by tmux
# - Quick Terminal: enabled, globally summon with Ctrl+` anytime, supplements regular terminal windows
# - Window state: not saved

# --- Font & Typography ---
font-family = "Monaco Nerd Font Mono"
font-size = 14

# --- Theme ---
theme = "Selenized Black"
# Increase ANSI faint/dim text opacity to prevent it from being too light on the Selenized Black theme
faint-opacity = 0.8

# --- Window Appearance ---
# No transparency, solid background
window-padding-x = 10
window-padding-y = 8

# --- Cursor ---
# Non-blinking block cursor
cursor-style = block
cursor-style-blink = false
shell-integration-features = no-cursor

# --- Mouse ---
# Hide mouse pointer while typing
mouse-hide-while-typing = true
# Selection is copied directly to system clipboard
copy-on-select = clipboard

# --- Quick Terminal (global dropdown terminal) ---
# Global hotkey Ctrl+` to summon/dismiss from the top of the screen
# Can be triggered from any app, useful for quick commands and git operations
quick-terminal-position = top
# Appears on the screen where the mouse is (multi-monitor friendly)
quick-terminal-screen = mouse
# Auto-hide when clicking another window
quick-terminal-autohide = true
quick-terminal-animation-duration = 0.15

# --- Security ---
# Prevent malicious content from injecting commands via clipboard
clipboard-paste-protection = true
clipboard-paste-bracketed-safe = true

# --- Shell Integration ---
# Auto-detect zsh/bash/fish and inject integration scripts
shell-integration = detect

# --- Performance ---
# ~25MB scrollback buffer
scrollback-limit = 25000000

# --- Keybinds ---
# Tabs (use case: different SSH connections in separate tabs)
keybind = cmd+t=new_tab
keybind = cmd+shift+left=previous_tab
keybind = cmd+shift+right=next_tab
keybind = cmd+w=close_surface

# Quick Terminal global hotkey
keybind = global:ctrl+grave_accent=toggle_quick_terminal

# Font size
keybind = cmd+plus=increase_font_size:1
keybind = cmd+minus=decrease_font_size:1
keybind = cmd+zero=reset_font_size

# Hot reload config file (no restart needed after config changes)
keybind = cmd+shift+comma=reload_config

zhangchitc's original config:

See zhangchitc's GitHub Gist.

This guide will show you how to use Python asyncio to subscribe to Binance K-line data via WebSocket, and asynchronously record Binance K-line market data as Pandas DataFrame in Parquet format.

Connecting to Binance Market Data WebSocket

To get market data via WebSocket, we first need to implement a robust WebSocket client.

Here, we will use a simplified version of ReconnectingWebsocket from python-binance's streams.py, which can be directly called from ws_basics.py.

In binance_market_ws.py, we define the functions to generate Binance K-line WebSocket connections as follows:

from ws_basics import ReconnectingWebsocket

# Spot WS Base URL
SPOT_STREAM_URL = 'wss://stream.binance.com:9443/'

# USDT Futures WS Base URL
USDT_FUTURES_FSTREAM_URL = 'wss://fstream.binance.com/'

# Coin Futures WS Base URL
COIN_FUTURES_DSTREAM_URL = 'wss://dstream.binance.com/'


def get_coin_futures_multi_candlesticks_socket(symbols, time_inteval):
    """
    Returns a WebSocket connection for multiple symbols' K-line data for coin-margined futures.
    """
    channels = [f'{s.lower()}@kline_{time_inteval}' for s in symbols]
    return ReconnectingWebsocket(
        path='/'.join(channels),
        url=COIN_FUTURES_DSTREAM_URL,
        prefix='stream?streams=',
    )


def get_usdt_futures_multi_candlesticks_socket(symbols, time_inteval):
    """
    Returns a WebSocket connection for multiple symbols' K-line data for USDT-margined futures.
    """
    channels = [f'{s.lower()}@kline_{time_inteval}' for s in symbols]
    return ReconnectingWebsocket(
        path='/'.join(channels),
        url=USDT_FUTURES_FSTREAM_URL,
        prefix='stream?streams=',
    )

def get_spot_multi_candlesticks_socket(symbols, time_inteval):
    """
    Returns a WebSocket connection for multiple symbols' K-line data for spot trading.
    """
    channels = [f'{s.lower()}@kline_{time_inteval}' for s in symbols]
    return ReconnectingWebsocket(
        path='/'.join(channels),
        url=SPOT_STREAM_URL,
        prefix='stream?streams=',
    )

Using the example code ex1_recv_single.py, we try to connect to the WebSocket and receive BTCUSDT perpetual contract 1-minute K-line data and print it to the screen:

import asyncio
import logging

from binance_market_ws import get_usdt_futures_multi_candlesticks_socket


async def main():
    socket = get_usdt_futures_multi_candlesticks_socket(['BTCUSDT'], '1m')
    async with socket as socket_conn:
        while True:
            try:
                res = await socket_conn.recv()
                print(res)
            except asyncio.TimeoutError:
                logging.error('Recv candle ws timeout')
                break


if __name__ == '__main__':
    asyncio.run(main())

Running the above code, we get representative data similar to the following:

{'stream': 'btcusdt@kline_1m', 'data': {'e': 'kline', 'E': 1719765539838, 's': 'BTCUSDT', 'k': {'t': 1719765480000, 'T': 1719765539999, 's': 'BTCUSDT', 'i': '1m', 'f': 5122041311, 'L': 5122041720, 'o': '61607.90', 'c': '61623.30', 'h': '61623.30', 'l': '61605.30', 'v': '16.692', 'n': 410, 'x': False, 'q': '1028411.77850', 'V': '12.553', 'Q': '773414.33780', 'B': '0'}}}
{'stream': 'btcusdt@kline_1m', 'data': {'e': 'kline', 'E': 1719765540037, 's': 'BTCUSDT', 'k': {'t': 1719765480000, 'T': 1719765539999, 's': 'BTCUSDT', 'i': '1m', 'f': 5122041311, 'L': 5122041728, 'o': '61607.90', 'c': '61624.90', 'h': '61624.90', 'l': '61605.30', 'v': '16.710', 'n': 418, 'x': True, 'q': '1029521.00470', 'V': '12.571', 'Q': '774523.56400', 'B': '0'}}}
{'stream': 'btcusdt@kline_1m', 'data': {'e': 'kline', 'E': 1719765540545, 's': 'BTCUSDT', 'k': {'t': 1719765540000, 'T': 1719765599999, 's': 'BTCUSDT', 'i': '1m', 'f': 5122041729, 'L': 5122041730, 'o': '61624.90', 'c': '61625.00', 'h': '61625.00', 'l': '61624.90', 'v': '0.026', 'n': 2, 'x': False, 'q': '1602.24770', 'V': '0.003', 'Q': '184.87500', 'B': '0'}}}

Each piece of data is parsed into a Python dictionary, and we need to convert this data dictionary into a DataFrame.

Parsing Binance Market Data

According to the Binance documentation, we can map the k field in the data dictionary to common K-line DataFrame column names.

import pandas as pd

def convert_to_dataframe(x, interval_delta):
    """
    Parse WS returned data dictionary, return as DataFrame
    """
    columns = [
        'candle_begin_time', 'open', 'high', 'low', 'close', 'volume', 'quote_volume', 'trade_num',
        'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume'
    ]
    candle_data = [
        pd.to_datetime(int(x['t']), unit='ms', utc=True),
        float(x['o']),
        float(x['h']),
        float(x['l']),
        float(x['c']),
        float(x['v']),
        float(x['q']),
        float(x['n']),
        float(x['V']),
        float(x['Q'])
    ]

    # Use K-line end time as the timestamp
    return pd.DataFrame(data=[candle_data], columns=columns, index=[candle_data[0] + interval_delta])

For robustness, we need to further adopt defensive programming, strictly checking data validity and determining if the K-line is closed, only accepting closed K-lines.

def handle_candle_data(res, interval_delta):
    """
    Handle WS returned data
    """

    # Defensive programming, discard if Binance returns no data field
    if 'data' not in res:
        return

    # Extract data field
    data = res['data']

    # Defensive programming, discard if data does not contain e field or e field (data type) is not kline or data does not contain k field (K-line data)
    if data.get('e', None) != 'kline' or 'k' not in data:
        return

    # Extract k field, i.e., K-line data
    candle = data['k']

    # Determine if K-line is closed, discard if not closed
    is_closed = candle.get('x', False)
    if not is_closed:
        return

    # Convert K-line to DataFrame
    df_candle = convert_to_dataframe(candle, interval_delta)
    return df_candle

Based on the example code ex2_parse_data.py, we attempt to parse the K-line data received in the previous section (K-line data saved as ex2_ws_candle.json).

import json
import pandas as pd

def main():
    # Load JSON data
    data = json.load(open('ex2_ws_candle.json'))

    # K-line interval is 1m
    interval_delta = pd.Timedelta(minutes=1)

    # Try to parse each WS data
    for idx, row in enumerate(data, 1):
        row_parsed = handle_candle_data(row, interval_delta)
        if row_parsed is None:
            print(f'Row{idx} is None')
        else:
            print(f'Row{idx} candlestick\n' + str(row_parsed))


if __name__ == '__main__':
    main()

The output is as follows:

Row1 is None
Row2 candlestick
                                  candle_begin_time     open     high      low    close  volume  quote_volume  trade_num  taker_buy_base_asset_volume  taker_buy_quote_asset_volume
2024-06-30 16:39:00+00:00 2024-06-30 16:38:00+00:00  61607.9  61624.9  61605.3  61624.9   16.71  1.029521e+06      418.0                       12.571                    774523.564
Row3 is None

The first and third records are discarded because the K-line is not closed, resulting in an output of None.

The second record is a closed K-line and is parsed into a DataFrame.

Single Time Interval Multiple Symbol WebSocket K-Line Data Receiver CandleListener

Combining the previous two sections, we can define CandleListener (candle_listener.py).

The main function is start_listen, which is responsible for establishing the WebSocket connection and receiving K-line data.

The handle_candle_data function is responsible for parsing the received K-line data, pushing valid and closed K-lines into the message queue (self.que) introduced in the next section.

import asyncio
import logging
from datetime import datetime, timedelta

import pandas as pd
import pytz

from binance_market_ws import (get_coin_futures_multi_candlesticks_socket, get_spot_multi_candlesticks_socket,
                               get_usdt_futures_multi_candlesticks_socket)


def convert_to_dataframe(x, interval_delta):
    """
    Parse the dictionary returned by WS and return a DataFrame
    """
    columns = [
        'candle_begin_time', 'open', 'high', 'low', 'close', 'volume', 'quote_volume', 'trade_num',
        'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume'
    ]
    candle_data = [
        pd.to_datetime(int(x['t']), unit='ms', utc=True),
        float(x['o']),
        float(x['h']),
        float(x['l']),
        float(x['c']),
        float(x['v']),
        float(x['q']),
        float(x['n']),
        float(x['V']),
        float(x['Q'])
    ]

    # Use the K-line end time as the timestamp
    return pd.DataFrame(data=[candle_data], columns=columns, index=[candle_data[0] + interval_delta])


class CandleListener:

    # Mapping of trade types to ws functions
    TRADE_TYPE_MAP = {
        'usdt_futures': get_usdt_futures_multi_candlesticks_socket,
        'coin_futures': get_coin_futures_multi_candlesticks_socket,
        'spot': get_spot_multi_candlesticks_socket
    }

    def __init__(self, type_, symbols, time_interval, que):
        # Trade type
        self.trade_type = type_
        # Trading symbols
        self.symbols = set(symbols)
        # K-line period
        self.time_interval = time_interval
        self.interval_delta = convert_interval_to_timedelta(time_interval)
        # Message queue
        self.que: asyncio.Queue = que
        # Reconnection flag
        self.req_reconnect = False

    async def start_listen(self):
        """
        Main function for WS listening
        """

        if not self.symbols:
            return
        
        socket_func = self.TRADE_TYPE_MAP[self.trade_type]
        while True:
            # Create WS
            socket = socket_func(self.symbols, self.time_interval)
            async with socket as socket_conn:
                # After the WS connection is successful, receive and parse the data
                while True:
                    if self.req_reconnect:
                        # Reconnect if reconnection is required
                        self.req_reconnect = False
                        break
                    try:
                        res = await socket_conn.recv()
                        self.handle_candle_data(res)
                    except asyncio.TimeoutError: 
                        # Reconnect if no data is received for long (default 60 seconds)
                        # Normally K-line is pushed every 1-2 seconds                        
                        logging.error('Recv candle ws timeout, reconnecting')
                        break

    def handle_candle_data(self, res):
        """
        Handle data returned by WS
        """

        # Defensive programming, discard if Binance returns an error without the data field
        if 'data' not in res:
            return

        # Extract the data field
        data = res['data']

        # Defensive programming, discard if the data does not contain the e field or the e field (data type) is not kline or the data does not contain the k field (K-line data)
        if data.get('e', None) != 'kline' or 'k' not in data:
            return

        # Extract the k field, which is the K-line data
        candle = data['k']

        # Check if the K-line is closed, discard if not closed
        is_closed = candle.get('x', False)
        if not is_closed:
            return

        # Convert the K-line to a DataFrame
        df_candle = convert_to_dataframe(candle, self.interval_delta)

        # Put the K-line DataFrame into the communication queue
        self.que.put_nowait({
            'type': 'candle_data',
            'data': df_candle,
            'closed': is_closed,
            'run_time': df_candle.index[0],
            'symbol': data['s'],
            'time_interval': self.time_interval,
            'trade_type': self.trade_type,
            'recv_time': now_time()
        })

    def add_symbols(self, *symbols):
        for symbol in symbols:
            self.symbols.add(symbol)

    def remove_symbols(self, *symbols):
        for symbol in symbols:
            if symbol in self.symbols:
                self.symbols.remove(symbol)

    def reconnect(self):
        self.req_reconnect = True

Recording Binance K-Line Market Data

In this section, we asynchronously receive K-line data for spot, USDT-margined contracts, and coin-margined contracts through multiple WebSocket connections and store the K-line data DataFrame on the hard disk in Parquet format.

To achieve this, we first review the producer-consumer architecture: The producer-consumer architecture is a common software design pattern in concurrent scenarios, where producers provide data, consumers process data, and data is typically passed between producers and consumers through a message queue.

This pattern decouples data production from data processing. In our business scenario, using multiple producers and a single consumer ensures the correctness of hard disk writes.

In the example code ex3_record_multi.py, we define three producers, all of which are instances of CandleListener:

• listener_usdt_perp_1m: Receives 1-minute K-line data for the BTCUSDT and ETHUSDT USDT-margined contracts.

• listener_coin_perp_3m: Receives 3-minute K-line data for the BTCUSD_PERP and ETHUSD_PERP coin-margined contracts.

• listener_spot_1m: Receives 1-minute K-line data for the BTCUSDT and BNBUSDT spot pairs.

A consumer is defined to update the K-line data.

def update_candle_data(df_new: pd.DataFrame, symbol, time_interval, trade_type):
    """
    Writes the received K-line data DataFrame to the hard disk in Parquet format.
    """
    output_path = f'{trade_type}_{symbol}_{time_interval}.pqt'

    if not os.path.exists(output_path):
        df_new.to_parquet(output_path, compression='zstd')
        return

    df = pd.read_parquet(output_path)
    df = pd.concat([df, df_new])
    df.sort_index()
    df.drop_duplicates('candle_begin_time')
    df.to_parquet(output_path)


async def dispatcher(main_que: asyncio.Queue):
    """
    Consumer that processes the received K-line data.
    """
    while True:
        # Get data from the main queue
        req = await main_que.get()
        run_time = req['run_time']
        req_type = req['type']

        # Call the appropriate processing function based on the data type
        if req_type == 'candle_data':  # K-line data update
            symbol = req['symbol']
            time_interval = req['time_interval']
            trade_type = req['trade_type']
            update_candle_data(req['data'], symbol, time_interval, trade_type)
            logging.info('Record %s %s-%s at %s', trade_type, symbol, time_interval, run_time)
        else:
            logging.warning('Unknown request %s %s', req_type, run_time)

The core calling code is as follows:

# ex3_record_multi.py

async def main():
    logging.info('Start recording candlestick data')
    # Main queue
    main_que = asyncio.Queue()

    # Producers
    listener_usdt_perp_1m = CandleListener('usdt_futures', ['BTCUSDT', 'ETHUSDT'], '1m', main_que)
    listener_coin_perp_3m = CandleListener('coin_futures', ['BTCUSD_PERP', 'ETHUSD_PERP'], '3m', main_que)
    listener_spot_1m = CandleListener('spot', ['BTCUSDT', 'BNBUSDT'], '1m', main_que)

    # Consumer
    dispatcher_task = dispatcher(main_que)

    await asyncio.gather(listener_usdt_perp_1m.start_listen(), listener_coin_perp_3m.start_listen(),
                         listener_spot_1m.start_listen(), dispatcher_task)

The runtime output is as follows:

20240630 22:59:36 (INFO) - Start record candlestick data
20240630 23:00:00 (INFO) - Record usdt_futures ETHUSDT-1m at 2024-06-30 15:00:00+00:00
20240630 23:00:00 (INFO) - Record spot BNBUSDT-1m at 2024-06-30 15:00:00+00:00
20240630 23:00:00 (INFO) - Record spot BTCUSDT-1m at 2024-06-30 15:00:00+00:00
20240630 23:00:00 (INFO) - Record usdt_futures BTCUSDT-1m at 2024-06-30 15:00:00+00:00
20240630 23:00:01 (INFO) - Record coin_futures ETHUSD_PERP-3m at 2024-06-30 15:00:00+00:00
20240630 23:00:02 (INFO) - Record coin_futures BTCUSD_PERP-3m at 2024-06-30 15:00:00+00:00
20240630 23:01:00 (INFO) - Record spot BNBUSDT-1m at 2024-06-30 15:01:00+00:00
20240630 23:01:00 (INFO) - Record spot BTCUSDT-1m at 2024-06-30 15:01:00+00:00

The Parquet files written to the hard disk are as follows:

-rw-rw-r-- 1 admin admin 8.8K Jun 30 23:09 coin_futures_BTCUSD_PERP_3m.pqt
-rw-rw-r-- 1 admin admin 8.8K Jun 30 23:09 coin_futures_ETHUSD_PERP_3m.pqt
-rw-rw-r-- 1 admin admin 9.3K Jun 30 23:10 spot_BNBUSDT_1m.pqt
-rw-rw-r-- 1 admin admin 9.3K Jun 30 23:10 spot_BTCUSDT_1m.pqt
-rw-rw-r-- 1 admin admin 9.4K Jun 30 23:10 usdt_futures_BTCUSDT_1m.pqt
-rw-rw-r-- 1 admin admin 9.4K Jun 30 23:10 usdt_futures_ETHUSDT_1m.pqt

The recorded data examples are as follows:

In [2]: pd.read_parquet('usdt_futures_BTCUSDT_1m.pqt')
Out[2]:
                                  candle_begin_time     open     high      low    close   volume  quote_volume  trade_num  taker_buy_base_asset_volume  taker_buy_quote_asset_volume
2024-06-30 15:00:00+00:00 2024-06-30 14:59:00+00:00  61580.2  61586.1  61580.2  61581.7   18.203  1.121016e+06      340.0                        6.931                  4.268353e+05
2024-06-30 15:01:00+00:00 2024-06-30 15:00:00+00:00  61581.8  61612.8  61581.7  61612.7   79.385  4.890301e+06     1015.0                       62.865                  3.872662e+06
......
2024-06-30 15:10:00+00:00 2024-06-30 15:09:00+00:00  61643.5  61643.5  61633.5  61636.9   35.319  2.176951e+06      530.0                       11.421                  7.039525e+05

In [3]: pd.read_parquet('coin_futures_ETHUSD_PERP_3m.pqt')
Out[3]:
                                  candle_begin_time     open     high      low    close   volume  quote_volume  trade_num  taker_buy_base_asset_volume  taker_buy_quote_asset_volume
2024-06-30 15:00:00+00:00 2024-06-30 14:57:00+00:00  3386.98  3387.00  3386.48  3386.98  54646.0    161.348842      259.0                      31434.0                     92.810019
2024-06-30 15:03:00+00:00 2024-06-30 15:00:00+00:00  3386.98  3389.36  3386.98  3389.35  29754.0     87.806150      275.0                      27826.0                     82.116929
2024-06-30 15:06:00+00:00 2024-06-30 15:03:00+00:00  3389.36  3389.79  3387.27  3388.39  39127.0    115.465249      363.0                       9255.0                     27.315708
2024-06-30 15:09:00+00:00 2024-06-30 15:06:00+00:00  3388.39  3390.59  3388.39  3390.22  15443.0     45.562138      220.0                       8133.0                     23.994293

At this point, we have essentially implemented a simple asynchronous Binance K-line data client.

However, creating a robust Binance real-time data client is not simple; more logic needs to be added to ensure data integrity and accuracy.

Stay tuned for subsequent technical reports.

The economy operates like a simple machine, yet many people are unaware or disagree with this perspective, leading to unnecessary economic losses.

Here is an analysis framework that may not perfectly align with traditional economics but is highly useful:

• The economy appears complex but functions in a straightforward and mechanical way.

• It is composed of a few simple parts and countless simple transactions, driven by human nature.

• Three main economic forces:

  1. Productivity growth

  2. Short-term debt cycle

  3. Long-term debt cycle

Transactions

• An exchange between a buyer and a seller is called a transaction, which occurs constantly.

• The economy is the sum total of numerous transactions.

• In each transaction: Buyers pay money or credit to obtain goods, services, or financial assets from sellers.

  • The sum of money and credit paid by the buyer is the total spending, which is the driving force of the economy, i.e., Total Spending = Money + Credit.

  • Dividing the total spending by the seller's product sales volume gives the price, i.e., Price = Total Spending / Sales Volume.

• Transactions are the fundamental components of the economic machine; all economic cycles and forces are caused by transactions. Thus, understanding transactions is to understand the economy.

Markets

• A market consists of sellers and buyers trading the same type of goods, such as wheat markets, car markets, stock markets, etc.

• The economy is made up of all transactions within all markets. Adding up all the markets' total spending and sales volumes gives us all the information needed to understand the economy.

• Individuals, companies, banks, and governments all engage in transactions.

• The government is the largest seller and buyer, consisting of the central government and the central bank:

  • Central government: Responsible for taxation and spending.

  • Central bank: Unlike other buyers and sellers, the central bank controls the amount of money and credit in the economy by influencing interest rates and issuing currency, playing a crucial role in the circulation of credit.

Credit

• Credit is the most important and most volatile part of the economy.

• Participants in credit include borrowers and lenders:

  • Lenders: Desire to earn interest on their money by lending it to borrowers.

  • Borrowers: Wish to purchase something they currently cannot afford and borrow money from lenders, repaying the principal and interest at a later date.

• The impact of interest rates on borrowing: High interest rates mean more interest to pay, reducing borrowing; low interest rates encourage borrowing due to lower interest expenses.

• As long as borrowers can assure repayment and lenders trust their promise, credit is created; thus, any two people can create credit out of thin air.

• Debt comes with the creation of credit; it is an asset to the lender and a liability to the borrower. When the loan is repaid, these assets and liabilities disappear simultaneously.

• A borrower's creditworthiness includes two aspects:

  • A higher ratio of income to debt indicates good repayment capacity.

  • Sufficient collateral that can be used to repay the debt if unable to pay back in cash.

• The significance of credit: When borrowers obtain credit, they can increase spending, which in turn increases someone else's income; the increase in income can lead to more borrowing and credit, causing the economy to rise, but also leading to economic cycles.

Cycles

• Over the long term, productivity improvements lead to income growth, but productivity does not fluctuate sharply and is not a significant driver of short-term economic fluctuations.

• In the short term, credit is most crucial because borrowing leads to consumption exceeding output, and repayment causes consumption to fall below output.

• Fluctuations in debt levels create two major cycles:

  • Short-term debt cycle: Lasts approximately 5-8 years.

  • Long-term debt cycle: Lasts approximately 75-100 years.

• The rise and fall of the economy depend mainly on the total amount of credit. Without credit, the economy would grow solely in line with productivity.

• Due to the existence of credit, the economy experiences cyclical fluctuations, determined by human nature.

• A cycle that applies both to individuals and the overall economy:

  • Currently, consumption exceeds income through borrowing.

  • In the future, consumption must be less than spending to repay debts.

The Difference Between Money and Credit

• Transactions completed with money are settled immediately.

• Transactions completed with credit, such as buying on credit, create liabilities and assets, and are only concluded once the debt is repaid, with liabilities and assets disappearing simultaneously.

• In reality, most money is actually credit. For example, in the United States, the total credit is approximately $50 trillion, while the total money supply is about $3 trillion.

• In a credit system, increasing credit can boost income growth in the short term, but not necessarily in the long term.

• Credit is not inherently bad, but it does cause cyclical changes in the economy:

  • Bad credit: Credit leads to consumption that exceeds the ability to repay.

  • Good credit: Efficiently allocates resources and generates income that can repay debts.

• Borrowing creates cycles that rise and fall.

Short-term Debt Cycle

• The first phase: Expansion occurs as economic activity increases; during this stage, credit is created out of thin air, spending increases, but total sales volume does not keep up with the increase in spending, leading to rising prices and inflation.

• The second phase: The central bank, not wanting high inflation, raises interest rates, making fewer people borrow and increasing repayments, which reduces spending and income. Prices drop, causing deflation and economic recession.

• The next cycle: The central bank lowers interest rates, leading to another economic expansion.

Thus, in the short-term debt cycle, the economy moves mechanically with interest rate changes: low interest rates lead to expansion, high interest rates lead to contraction.

Long-term Debt Cycle

The short-term debt cycles repeat, but after each cycle, economic growth and debt exceed the previous cycle (driven by human nature), forming the long-term debt cycle.

• Prosperity period:

  • During this period, incomes rise, and asset prices increase simultaneously, allowing more borrowing and consumption, creating a cycle. However, economic bubbles also form.

  • If debt growth matches the growth rate of income and asset prices, the debt burden remains manageable, but this situation cannot last forever.

• Peak of long-term debt: As the debt burden increases and the cost of debt grows faster than income, people are forced to cut spending, further reducing income and increasing debt costs, forming a vicious cycle, reaching the peak of long-term debt, and reversing the cycle (e.g., the 2008 subprime mortgage crisis, the 1929 Great Depression).

• Deleveraging period: People cut spending, income falls, credit disappears, asset prices drop, banks face runs, creating a negative spiral. As interest rates are already low, the central bank cannot reverse the situation by lowering rates, and the entire economy loses credibility.

• Deleveraging can occur in four ways, some leading to deflation, others to inflation. Policymakers need to carefully balance the two to deleverage harmoniously:

  1. Cut spending:

     • During deleveraging, individuals, companies, and governments reduce spending to repay debts, leading to decreased income and an increased debt burden, causing deflation.

     • Companies cut costs, raising unemployment rates.

  2. Reduce debt:

     • With falling incomes and rising unemployment rates, borrowers cannot repay loans, banks face runs, and individuals, companies, and banks default, leading to severe economic contraction—depression. The main characteristic is that much of the wealth supported by credit vanishes due to defaults.

     • Some lenders may allow debt restructuring to prevent total loss from defaults, including reducing repayments, extending terms, lowering interest rates, etc. These measures also reduce debt but cause asset prices to fall, resulting in deflation.

  3. Wealth redistribution:

     • With falling incomes and rising unemployment, government tax revenues decrease, while governments need to increase spending on stimulus programs and relief efforts, leading to increased fiscal deficits. Governments must finance from the wealthy.

     • Governments might need to tax the wealthy to transfer wealth to the poor to stimulate consumption and the economy, but income disparity leads to social tensions and increased conflict.

     • Similar tensions exist between debtor and creditor nations. In the 1930s, such tensions led to World War II and the Great Depression in the United States.

  4. Print money:

     • The central bank can print money to compensate for the lack of credit, stimulating the economy, but this can lead to inflation. Hyperinflation like that of 1920s Germany must be avoided.

     • The central bank can use newly printed money to purchase financial assets and government bonds, as was done during the Great Depression and the 2008 crisis in the US. This helps raise asset prices and bolsters the credit of those with financial assets.

     • Central bank purchases of government bonds help the government finance, distribute relief funds, and implement stimulus plans. Government debt may rise, but the total debt burden decreases.

• Reflation: When income levels exceed debt, spending increases, and the economy grows again, entering the reflation phase.

• The lost decade: Depressions and reflation typically last about ten years, hence the term "the lost decade."

Conclusion

Combining productivity growth, the short-term debt cycle, and the long-term debt cycle provides a useful model.

Although the real economy is much more complex than this model, it helps us clearly understand past and present situations and anticipate potential future developments.

Three Rules of Thumb

1. Do not let debt growth exceed income growth.

2. Do not let income growth exceed productivity growth.

3. Strive to increase productivity by all means possible.

AROON is a common technical indicator, whose definition can be found at Investopedia.

The challenge in implementing this indicator lies in the rolling argmax operator, for which pandas does not provide an official implementation. A naive implementation based on Series results in considerably slow computations.

Optimizing the computation of this indicator presents an interesting but not easy problem.

Code reference is available at Github.

Data and Parameters

First, we generate a HLC candlestick DataFrame of length 50,000 through a random walk to simulate the trend of an arbitrary commodity.

We set the lookback window n=200:

length = 50000
n = 200

np.random.seed(2022)
cl = 10000 + np.cumsum(np.random.normal(scale=20, size=length))
hi = cl + np.random.rand() * 100
lo = cl - np.random.rand() * 100

df = pd.DataFrame({'high': hi, 'low': lo, 'close': cl})

print(df.head()[['high', 'low', 'close']].to_markdown(), '\n')

print(df.tail()[['high', 'low', 'close']].to_markdown(), '\n')

print(df.describe().to_markdown())

Samples and statistics of the generated data:

|      |    high |     low |   close |
| ---: | ------: | ------: | ------: |
|    0 | 10017.9 | 9965.82 | 9999.99 |
|    1 | 10012.4 | 9960.32 | 9994.49 |
|    2 | 10009.6 | 9957.53 | 9991.71 |
|    3 | 10049.3 | 9997.23 | 10031.4 |
|    4 |   10055 | 10002.9 |   10037 |

|       |    high |     low |   close |
| ----: | ------: | ------: | ------: |
| 49995 | 13187.1 |   13135 | 13169.2 |
| 49996 | 13209.7 | 13157.6 | 13191.8 |
| 49997 | 13223.1 |   13171 | 13205.2 |
| 49998 | 13221.6 | 13169.5 | 13203.7 |
| 49999 | 13242.1 |   13190 | 13224.2 |

|       |    high |     low |   close |
| :---- | ------: | ------: | ------: |
| count |   50000 |   50000 |   50000 |
| mean  | 11801.7 | 11749.6 | 11783.7 |
| std   | 943.887 | 943.887 | 943.887 |
| min   | 9543.01 | 9490.91 | 9525.09 |
| 25%   | 11007.4 | 10955.3 | 10989.5 |
| 50%   | 11986.2 | 11934.1 | 11968.3 |
| 75%   | 12524.3 | 12472.2 | 12506.4 |
| max   | 14159.4 | 14107.3 | 14141.5 |

Naive Implementation Based on Pandas Series

Initially, we implement a naive version of the Aroon indicator using Series as a baseline.

def aroon_naive(df, n):
    # index of maximum value in the rolling window
    high_len = df['high'].rolling(n, min_periods=1).apply(lambda x: pd.Series(x).idxmax())

    high_len = df.index - high_len
    aroon_up = 100 * (n - high_len) / n

    low_len = df['low'].rolling(n, min_periods=1).apply(lambda x: pd.Series(x).idxmin())
    low_len = df.index - low_len
    aroon_down = 100 * (n - low_len) / n

    return aroon_up, aroon_down

%time up_naive, down_naive = aroon_naive(df, n)

This version utilizes DataFrame.rolling and creates a new Series in each lambda function to compute the rolling argmax.

Due to the high cost of creating Series and suboptimal complexity, where complexity = O(N_candles * N_window), this code is exceedingly slow.

Test results:

CPU times: user 2.82 s, sys: 134 ms, total: 2.95 s
Wall time: 2.83 s

Testing Function

We verify the correctness of each implementation using the following function.

This function will print out how many nan values are in the the tested signal, how many non-nan values are correct or incorrect, and the accuracy rate.

def check_signal(sig_original, sig_check):
    print('Num of nan:', sig_check.isna().sum())
    mask = sig_original.notnull() & sig_check.notnull()
    n_eq = ((sig_original[mask] - sig_check[mask]).abs() < 1e-8).sum()
    l = mask.sum()
    print(f'Num of equal: {n_eq}, Num of not equal: {l - n_eq}, Ratio good: {n_eq / l * 100.0}%')

Numpy Implementation

A simple optimization method is to use numpy functions, avoiding the repeated creation of Series and thus improving efficiency to some extent.

def high_len_cal(x):
    return (np.maximum.accumulate(x) == x.max()).sum()
  
def low_len_cal(x):
    return (np.minimum.accumulate(x) == x.min()).sum()

def aroon_numpy(df, n):
    high_len = df['high'].rolling(n).apply(high_len_cal, raw=True, engine='cython') - 1
    aroon_up = 100 * (n - high_len) / n

    low_len = df['low'].rolling(n).apply(low_len_cal, raw=True, engine='cython') - 1
    aroon_down = 100 * (n - low_len) / n
    return aroon_up, aroon_down

%time up_numpy, down_numpy = aroon_numpy(df, n)
print('Check up')
check_signal(up_naive, up_numpy)

print('Check down')
check_signal(down_naive, down_numpy)

Test results are as follows:

CPU times: user 369 ms, sys: 1.77 ms, total: 370 ms
Wall time: 370 ms
Check up
Num of nan: 199
Num of equal: 49801, Num of not equal: 0, Ratio good: 100.0%
Check down
Num of nan: 199
Num of equal: 49801, Num of not equal: 0, Ratio good: 100.0%

Naive Numba Implementation

To avoid using python functions during the rolling process, we consider abandoning pandas and using numba njit + numpy .argmax to implement the rolling argmax.

@nb.njit(nb.int32:, cache=True)
def rolling_argmin(arr, n):
    idx_min = 0
    results = np.empty(len(arr), dtype=np.int32)
    for i, x in enumerate(arr):
        if i < n:
            results[i] = np.argmin(arr[: i + 1])
        else:
            results[i] = np.argmin(arr[i - n + 1: i + 1]) + i - n + 1
    return results

def aroon_numba(df, n):
    low_len = pd.Series(rolling_argmin(df['low'].values, n))

    high_len = pd.Series(rolling_argmin(-df['high'].values, n))

    high_len = df.index - high_len
    low_len = df.index - low_len

    aroon_up = 100 * (n - high_len) / n
    aroon_down = 100 * (n - low_len) / n
    return pd.Series(aroon_up), pd.Series(aroon_down)

%time up_numba, down_numba = aroon_numba(df, n)
print('Check up')
check_signal(up_naive, up_numba)

print('Check down')
check_signal(down_naive, down_numba)

Test results are as follows, with no nan values in the signal and all results being correct.

CPU times: user 27.8 ms, sys: 189 µs, total: 28 ms
Wall time: 28 ms
Check up
Num of nan: 0
Num of equal: 50000, Num of not equal: 0, Ratio good: 100.0%
Check down
Num of nan: 0
Num of equal: 50000, Num of not equal: 0, Ratio good: 100.0%

Numba + Monotonic Queue Implementation

In the naive numba implementation, although time efficiency was improved by avoiding frequent python function calls, its complexity still remains at O(N_candles * N_window), which is not ideal.

In the field of algorithms, there is a standard optimal solution for rolling argmax. It utilizes the monotonic queue, and optimizes the complexity down to O(N_candles + N_window).

The specific principle of this algorithm is complex and can be referred to in the LeetCode 239 solution, which is considered hard difficulty on LeetCode.

@nb.njit(nb.int32:, cache=True)
def rolling_argmin_queue(arr, n):
    results = np.empty(len(arr), dtype=np.int32)
    
    head = 0
    tail = 0
    que_idx = np.empty(len(arr), dtype=np.int32)
    for i, x in enumerate(arr[:n]):
        while tail > 0 and arr[que_idx[tail - 1]] > x:
            tail -= 1
        que_idx[tail] = i
        tail += 1
        results[i] = que_idx[0]
    
    for i, x in enumerate(arr[n:], n):
        if que_idx[head] <= i - n:
            head += 1
        while tail > head and arr[que_idx[tail - 1]] > x:
            tail -= 1
        que_idx[tail] = i
        tail += 1
        results[i] = que_idx[head]
    return results
            
def aroon_numba_queue(df, n):
    low_len = pd.Series(rolling_argmin_queue(df['low'].values, n))
    high_len = pd.Series(rolling_argmin_queue(-df['high'].values, n))
    
    high_len = df.index - high_len
    low_len = df.index - low_len

    aroon_up = 100 * (n - high_len) / n
    aroon_down = 100 * (n - low_len) / n
    return pd.Series(aroon_up), pd.Series(aroon_down)

%time up_nbque, down_nbque = aroon_numba_queue(df, n)
print('Check up')
check_signal(up_naive, up_nbque)

print('Check down')
check_signal(down_naive, down_nbque)

Test results are as follows, with no nan values in the signal and all results being correct.

CPU times: user 1.79 ms, sys: 67 µs, total: 1.86 ms
Wall time: 1.87 ms
Check up
Num of nan: 0
Num of equal: 50000, Num of not equal: 0, Ratio good: 100.0%
Check down
Num of nan: 0
Num of equal: 50000, Num of not equal: 0, Ratio good: 100.0%

Conclusion

Comparing the time consumption of various methods, the summary is as follows:

|               | Time(ms) | Speedup |
| ------------- | -------- | ------- |
| Naive         | 2830     | 1       |
| Numpy         | 370      | 7.65    |
| Naive Numba   | 28       | 101     |
| Numba + Queue | 1.87     | 1513    |

In this article, we will discuss a straightforward method for installing TA-Lib within the Python Anaconda environment as of today (2023–06–23).

For all 64-bit operating systems, including Windows, Linux, and macOS (Arm64 M1-M3 CPUs are supported), installation can be completed using a single command:

> conda install -c conda-forge ta-lib

After installation, we can verify with the following:

> python -c "import talib; print(talib.__version__)"
0.4.19

Support for the arm64 version of macOS has been recently added. With the latest Anaconda release, Anaconda3–2023.03–1-MacOSX-arm64, you can verify the installation using:

> python -c "import talib, platform; print(platform.processor(), talib.__version__)"
arm 0.4.19

This confirms that the library has been installed correctly on the Arm64 version of macOS.