Introduction

Scalability means system's capability of handling more work. 

Consider an example of a website where there is one server handling 1000 users. Due to some reason more and more users are opening the website and suddenly the number of users increased to 50,000. However, the system is not capable of handling more than 50,000 users. In this case if load further increases, the system will fail to serve the users, it may crash.

We can solve this problem primarily in two ways. We can either scale the system Vertically or Horizontally. 

Vertical Scaling

When we increase the capacity of the server to handle more work is considered as vertical scaling. 

Vertical Scaling

Pros

• Easy to maintain as there will be fewer components in the system.

Cons

• Capacity increase comes with additional cost which increases rapidly for large scale systems.
• There is an upper limit till which only you can scale.
• Single Point of Failure. 

Horizontal Scaling

When we increase the number of servers to handle increasing work, is considered as horizontal scaling. By increasing the number of servers we can (evenly) distribute the load amongst these servers to handle more work using the load balancer. 

Horizontal Scaling

Pros

• Can solve single point of failure problem.
• Highly scalable and available.
• Comparatively cheaper as few small servers are cheaper compared to one high end server.

Cons

• Added complexity in deployment and maintenance.

Introduction

A high level summary and commentry on the aforementioned Java 24 performance update video. Java is not just updating it's performance and usability in general but moving way faster year on year. The Java 25 is likely to be released somewhere in 2025. 

This video is of last year Devoxx but recently posted on Java Youtube channel and as a curios Java follower I found it very interesting, thus I decided to write about it on my blog. This video initially gives summary of Java projects, performance metrics, challenges faced in performance and then shared the recent and future performance improvements. If you don't want to get into initial summary and focus on recent performance improvements you can start from here.

Ongoing Java Projects

Speaker summarized the ongoing Java projects which are listed below,

• Amber : Small Java Features.
• Babylon: Extend reach of Java to SQL, ML Models and GPUs.
• Leyden: Improve start up time and reduce memory foot print.
• Lilliput: Reduce size of Java Object Header on 64 bit architecture.
• Loom: Lightweight concurrency.
• Panama: Integration between Java and system level programming languages.
• Valhalla: Augmenting java object model with value objects.

Metrics / Challenges / Tools

In this section speaker briefed about the different metrics one need to consider while checking for performance. Performance needs to be looked from wholestic view which must include usage of memory, CPU, threads, cache and power. Also, start up and warm up time needs to be considered while measuring the performance.

While talking about challenges speaker emphasized that we can not get accurate performance statistics on our laptops it's better to do it on dedicated server post warm up when application is ready to serve. That too one should not consider the result after very few runs, performance results needs to be collected after thousands of executions. Also, suggested to use System::nanoTime instead of System::currentTimeMillis for better accuracy while checking the performance.

Speaker mentioned about JMH (Java Microbenchmark Harness) which can be used to get micro level benchmarking using @Benchmark annotation. He further talks about the internal tools which Java team uses to check the benchmarks in different platforms which gives them an idea of how much the performance improve or degraded in respective platform.

Performance Improvements

Array store operation refers to process of writing values to the array index. Earlier the compiler was merging primitive stores such a way which was causing assertion failures and even incorrect optimizations. 

Using Unsafe and BALE (Internal to JDK, jdk.internal.util.ByteArrayLittleEndian) were alternatives but both are not good considering Unsafe is something we should move away from and BALE may slow down things.

Summay

Apparently, there are other improvements also mentioned which will be the focus for upcoming months on top of these. These updates may look abstract and at first, may sound not making huge impact but by taking a close look it's moving in a direction of high optimization and efficiency.

Introduction

For periodically syncing changes of your Github repository you can automate the process using a script and crontab on Mac OS. It's really quick and simple if you don't have more complex requirements. Note taking is one of the use cases where you want periodic sync to take place automatically to ensure notes are pushed to the cloud without any manual steps.

Setup

1. Open terminal and type crontab -e this will open an editor where you can specify which script to execute, here we want to push our changes so we will point it to that script. Here we have used cron expression "* */2 * * *" which will execute the script every two hours. You can use crontab.guru to generate the expression as per your requirement.

* */2 * * * /path/to/sync.sh >> /path/to/logs/run.logs 2>&1

Save the changes. (Type :wq! to save) 

File sync.sh should be accessible and hold required permissions. Use chmod command to update the permission to necessary state.

2. Define sync.sh in following way to push your changes. Prerequisite is that you have cloned and setup required github repository in respective folder.

#!/bin/bash

set -e

cd /path/to/repo

BRANCH="main"
COMMIT_MSG=${1:-"Update"}

 if [[ -n $(git status --porcelain) ]]; then
    echo "Changes detected."
    git add -A
    git commit -m "$COMMIT_MSG"
    git push origin "$BRANCH"
    echo "Changes pushed successfully!"
else
    echo "No changes to commit."
fi

Cloning all the repositories of the user is not something that you would need very frequently but for personal repositories it comes very handy as I don't need to clone individual repositories. Similarly while working with any organization this saves lot of time of individual cloning. Having said that you may need required access and permission to the account and organization as we will going to use the user token to clone the repositories.

Generate Access Token

The first step is to create a personal token which can allow us to access our repositories through API.  We can generate the token from Settings > Developer Settings > Personal Access Token. Here we will going to use classic token for better understanding and simplicity.

Run script to Clone

Following script can be used to clone all the repositories. It uses jq command to process the response of the github API which you may need to install if not done already. Basic idea is to call the GitHub API, fetch list of repositories, iterate over the repositories and clone each in given directory.  Update GitHub username and token in following script and execute it.

#!/bin/bash
GITHUB_USERNAME=""
GITHUB_TOKEN=""
# GITHUB_ORG=""

API_URL="https://api.github.com/user/repos"
# For organization use following
# API_URL="https://api.github.com/orgs/$GITHUB_ORG/repos" 
PAGE=1
PER_PAGE=100

mkdir -p allrepos
cd allrepos || exit

while :; do
  REPOS_TO_CLONE=$(curl -s -u "$GITHUB_USERNAME:$GITHUB_TOKEN" "$API_URL?per_page=$PER_PAGE&page=$PAGE" | jq -r '.[].clone_url')
  
  if [ -z "$REPOS_TO_CLONE" ]; then
    break
  fi
  
  echo "$REPOS_TO_CLONE" | while read -r repo; do
    git clone "$repo"
  done
  
  PAGE=$((PAGE + 1))
done

echo "All repositories are cloned successfully!"

This script may take time depending on the number of repositories given user or oganization have. You will see success message once all repositories are cloned.