Forem: Isaac Tonyloi - SWE

Great resource for build awesome projects

Isaac Tonyloi - SWE — Wed, 29 Oct 2025 08:07:27 +0000

5 must know open-source repositories to build cool AI apps

Ankur Tyagi ・ Oct 29

#ai #opensource #agents #vision

[Boost]

Isaac Tonyloi - SWE — Tue, 17 Jun 2025 05:58:00 +0000

Isaac Tonyloi - SWE

Sep 3 '24

Learn the basics of Spring Security

Comments

5 min read

Caching and How AWS DynamoDB DAX Works

Isaac Tonyloi - SWE — Wed, 19 Feb 2025 15:15:12 +0000

Introduction to Caching

Imagine you own a coffee shop. Every time a customer orders a cappuccino, you grind fresh beans, steam milk, and prepare the drink from scratch. While this ensures freshness, it also slows down service. Now, imagine pre-steaming milk and grinding beans in advance—customers get their drinks faster, and you reduce workload. This is exactly how caching works in computing.

Caching is a technique used to store frequently accessed data in a fast-access layer, reducing the need to repeatedly fetch the same data from a slower backend like a database. By storing copies of data closer to the user, caching speeds up performance, improves responsiveness, and reduces system load.

Now, let’s see how AWS DynamoDB Accelerator (DAX) takes caching to the next level.

What is AWS DynamoDB DAX?

Amazon DynamoDB Accelerator (DAX) is an in-memory caching layer for DynamoDB that significantly improves read performance for applications. It allows millisecond-level responses for queries that would typically take milliseconds or longer if fetched directly from DynamoDB.

DAX is fully managed, meaning AWS takes care of its deployment, scaling, and maintenance. Unlike traditional caching solutions like Redis or Memcached, which require additional infrastructure setup, DAX is seamlessly integrated with DynamoDB.

How AWS DAX Works

At a high level, DAX sits between your application and DynamoDB as an intelligent caching layer. Instead of your application directly querying DynamoDB, it first checks with DAX.

The Workflow

Application Requests Data – When your app makes a GetItem, BatchGetItem, Query, or Scan request, it first goes to DAX.
Cache Hit (Data is Found in Cache) – If the requested data is already in DAX, it returns the response instantly without querying DynamoDB.
Cache Miss (Data is Not in Cache) – If the data is not in DAX, it retrieves the data from DynamoDB, stores it in the cache, and then returns it to the application.
Data Expiry and Updates – Cached data follows a Time to Live (TTL) policy (default is 5 minutes). If data expires or is updated in DynamoDB, DAX ensures consistency by refreshing the cache.

This process drastically reduces the need to query DynamoDB directly, improving response times and reducing costs.

DAX Clusters and Nodes

DAX operates as a cluster of nodes. Each node is an instance of the DAX software that helps store and manage cached data.

Types of Nodes in DAX

Primary Node – The main node that handles both read and write requests.
Read Replicas – Additional nodes that store copies of cached data, used to distribute read traffic.

DAX automatically synchronizes read replicas with the primary node to ensure consistency.

How DAX Handles Different Types of Requests

Read Operations (Fetching Data)

DAX can process these DynamoDB read operations:

GetItem
BatchGetItem
Query
Scan

What Happens When You Fetch Data?

Eventually Consistent Read (Default Behavior)
- First, DAX checks if the item exists in cache.
- If found (cache hit) → Returns data immediately.
- If not found (cache miss) → Fetches from DynamoDB, stores it in cache, and returns to the app.
Strongly Consistent Read
- DAX bypasses caching and fetches fresh data from DynamoDB.

DAX optimizes for eventually consistent reads, making it ideal for applications that don't need real-time updates.

Write Operations (Updating Data)

DAX supports write-through caching, meaning every write operation updates both DynamoDB and the DAX cache.

Supported write operations:

PutItem
UpdateItem
DeleteItem
BatchWriteItem

How it works:

Data is first written to DynamoDB.
Then, it is immediately updated in the DAX cache.
This ensures that the latest values are always available.

DAX does not support DynamoDB table management operations (like CreateTable, UpdateTable, or DeleteTable). These must be performed directly on DynamoDB.

DAX Caching Mechanisms

Item Cache (For Individual Items)

Stores responses from GetItem and BatchGetItem queries.
Stored by primary key values.
Default TTL: 5 minutes (configurable).
Uses Least Recently Used (LRU) eviction, meaning older, unused data gets removed when the cache fills up.

Example:

You query a user profile: GetItem("user_123")
DAX checks if it’s in cache:
- If yes → Returns instantly.
- If no → Fetches from DynamoDB, stores it, and returns.

Query Cache (For Query and Scan Results)

Stores result sets from Query and Scan operations.
Stored by query parameters.
TTL-based and LRU eviction applies.

Example:

You run Query to fetch all products in a category.
If cached → DAX returns it.
If not → DynamoDB processes it, DAX stores the results, and then returns them.

Handling High Traffic: DAX Auto Scaling & Rate Limiting

If too many requests hit a DAX cluster, it may become overloaded.

Auto Scaling

DAX can dynamically add more nodes to handle increased load.
Read replicas help distribute traffic.

Rate Limiting

If request volume exceeds a node’s capacity, DAX throttles requests by returning a ThrottlingException.
You can monitor ThrottledRequestCount in Amazon CloudWatch to detect bottlenecks.

Why Use DAX?

DAX is ideal for read-heavy workloads where fast responses are critical. Here’s why you should consider it:

Ultra-fast reads – Millisecond response times.
Less load on DynamoDB – Saves on read capacity costs.
Fully managed – No need to maintain a separate caching infrastructure.
Seamless integration – Works with existing DynamoDB API calls.
Automatic scaling – Grows as your traffic increases.

When NOT to Use DAX

If your app requires strong consistency – DAX caches only eventually consistent data.
For write-heavy workloads – Since writes still go to DynamoDB, it doesn’t speed up inserts/updates.
If you need complex queries – DAX only caches individual items and query results, not joins or aggregations.

How to Get Started with DAX

Step 1: Create a DAX Cluster

Open the AWS Management Console.
Navigate to DAX.
Click Create cluster.
Configure the instance type, node count, and VPC settings.
Click Launch.

Step 2: Connect Your Application

Install the AWS SDK with DAX Client.
Change your DynamoDB SDK calls to use the DAX endpoint.

Step 3: Monitor and Optimize

Use Amazon CloudWatch to track performance.
Adjust TTL settings and scaling policies as needed.

Conclusion

AWS DynamoDB Accelerator (DAX) is an in-memory caching service that supercharges DynamoDB read performance. It’s perfect for read-intensive applications like recommendation engines, gaming leaderboards, and IoT platforms.

By automatically caching frequent queries, DAX minimizes latency and optimizes costs, making your application much more efficient and scalable.

Getting Started with CI/CD: A Beginner's Guide to Automating Your First Pipeline (With Github Actions)

Isaac Tonyloi - SWE — Tue, 11 Feb 2025 07:51:43 +0000

Continuous Integration and Continuous Deployment (CI/CD) are essential for modern software development, enabling teams to automate the process of building, testing, and deploying applications. A well-designed CI/CD pipeline ensures faster releases, improved code quality, and more efficient collaboration among developers.

In this guide, we’ll explore GitHub Actions, a powerful CI/CD tool that seamlessly integrates with GitHub repositories. Whether you’re an individual developer or part of a large team, GitHub Actions provides a flexible and scalable solution for automating software workflows. This guide will take you through the entire process of setting up a CI/CD pipeline using GitHub Actions—from creating workflows to deploying applications.

What is CI/CD?

Before diving into GitHub Actions, let’s break down the key components of CI/CD.

Continuous Integration (CI)

Continuous Integration is the practice of frequently integrating code changes into a shared repository. Every code commit triggers an automated process that builds, tests, and validates the application.

Key benefits:

Frequent Code Merges: Developers push code changes often, reducing integration issues.
Automated Testing: Code is tested automatically after each commit.
Early Bug Detection: Issues are identified and fixed before deployment.

Continuous Delivery (CD)

Continuous Delivery extends CI by ensuring that code is always in a deployable state. Code changes pass through automated testing and are prepared for deployment.

Key benefits:

Reliable Releases: Code is always tested and packaged for production.
Manual Approval for Production: Deployment is automated up to the staging environment but requires human approval for production.
Fast Feature Releases: Teams can release updates more frequently.

Continuous Deployment

Continuous Deployment takes things further by automating deployments to production without manual approval. Every successful code change is deployed immediately.

Key benefits:

Zero Manual Intervention: If all tests pass, the change is deployed instantly.
Faster Software Releases: New features and bug fixes reach users quickly.
Efficient DevOps Process: Developers can focus on writing code rather than deploying it.

Benefits of Using GitHub Actions for CI/CD

GitHub Actions provides a native CI/CD experience directly within GitHub repositories, offering several advantages:

✅ Tight GitHub Integration: Workflows run directly in your GitHub repository, reducing the need for third-party tools.

✅ Easy-to-Use YAML Configuration: Define workflows using simple YAML files.

✅ Pre-Built Actions & Marketplace: Access a vast collection of pre-configured actions for various tasks.

✅ Scalability & Flexibility: Run workflows on different environments, including Linux, Windows, and macOS.

✅ Event-Driven Triggers: Workflows can be triggered by push events, pull requests, issue creation, and more.

Now, let’s set up a CI/CD pipeline with GitHub Actions for a sample application.

How to Set Up a CI/CD Pipeline with GitHub Actions

Step 1: Set Up a GitHub Repository

Before configuring GitHub Actions, ensure your project is stored in a GitHub repository.

Go to GitHub and create a new repository.
Clone the repository to your local machine:

   git clone https://github.com/your-username/my-ci-cd-project.git
   cd my-ci-cd-project

Add your project files (e.g., a Node.js application with package.json and a test directory).
Commit and push your code:

   git add .
   git commit -m "Initial commit"
   git push origin main

Step 2: Create a GitHub Actions Workflow

GitHub Actions workflows are defined using YAML files stored in the .github/workflows/ directory.

Inside your project, create a new directory:

   mkdir -p .github/workflows

Create a new file named ci-cd-pipeline.yml:

   touch .github/workflows/ci-cd-pipeline.yml

Step 3: Define the CI/CD Workflow

Now, let’s define a basic CI/CD pipeline for a Node.js application.

Open ci-cd-pipeline.yml and add the following configuration:

name: CI/CD Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build-test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Set Up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '18'

      - name: Install Dependencies
        run: npm install

      - name: Run Tests
        run: npm test

  deploy:
    needs: build-test
    runs-on: ubuntu-latest

    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Deploy to Production
        run: echo "Deploying application..."

Breaking Down the Workflow

Triggers (on): The workflow runs when code is pushed or a pull request is created on the main branch.
Jobs:
- build-test job:
- Checks out the repository.
- Sets up Node.js.
- Installs dependencies.
- Runs tests.
- deploy job:
- Runs only if build-test succeeds.
- Deploys the application (replace this with actual deployment steps).

Step 4: Push the Workflow to GitHub

After adding the workflow, commit and push the changes:

git add .github/workflows/ci-cd-pipeline.yml
git commit -m "Add GitHub Actions workflow"
git push origin main

Step 5: Monitor Workflow Execution

Once you push the changes, GitHub Actions automatically triggers the pipeline.

Go to Your GitHub Repository.
Click on the "Actions" tab.
You will see your workflow running.
Click on the workflow run to see detailed logs.

Deploying the Application to a Cloud Platform

To deploy the application to Heroku, modify the deploy step:

- name: Deploy to Heroku
  env:
    HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }}
  run: |
    heroku git:remote -a your-heroku-app
    git push heroku main

Setting Up GitHub Secrets

Go to Your GitHub Repository → Settings → Secrets → New Repository Secret.
Add a secret with the name HEROKU_API_KEY and paste your Heroku API key.
Now, when the workflow runs, it deploys the application to Heroku.

Best Practices for CI/CD Pipelines with GitHub Actions

🔹 Automate Testing – Ensure unit, integration, and end-to-end tests are automated.

🔹 Use Caching – Speed up workflows by caching dependencies using the actions/cache action.

🔹 Secure Secrets – Use GitHub Secrets for API keys and credentials.

🔹 Fail Fast – Detect failures early by running tests at the beginning of the pipeline.

🔹 Keep Workflows Simple – Avoid overly complex pipelines. Start small and expand as needed.

Conclusion

GitHub Actions is a powerful, flexible, and easy-to-use CI/CD tool for automating software development workflows. In this guide, we covered:
✔ Setting up a GitHub repository for CI/CD.

✔ Writing a GitHub Actions workflow for building, testing, and deploying a Node.js application.

✔ Deploying applications to Heroku using GitHub Secrets.

✔ Best practices for maintaining efficient CI/CD pipelines.

[Boost]

Isaac Tonyloi - SWE — Mon, 10 Feb 2025 09:25:36 +0000

Why Java Developers Should Choose the Spring Framework

Isaac Tonyloi - SWE ・ Feb 6

#java #spring #springboot

Understanding the Different Types of Gateways in AWS

Isaac Tonyloi - SWE — Mon, 10 Feb 2025 05:55:21 +0000

Gateways in AWS play a crucial role in routing traffic between different networks, enabling secure communication, and optimizing connectivity for cloud and hybrid cloud environments. As shown in the image, AWS provides multiple gateway types, including:

Internet Gateway (IGW)
NAT Gateway
Egress-Only Internet Gateway (EIGW)

Each type serves a distinct purpose in managing network traffic, particularly for IPv4 and IPv6 connectivity within Amazon Virtual Private Cloud (VPCs).

Internet Gateway (IGW)

An Internet Gateway (IGW) is a highly available AWS-managed component that enables instances in a public subnet to communicate with the internet. It provides bidirectional traffic flow, meaning resources in a public subnet can send and receive traffic from the internet.

How IGW Works

IGW translates private IP addresses used within AWS into public IP addresses if Elastic IPs are assigned.
It allows direct internet access for instances without requiring NAT.
Route tables must be updated to direct outbound traffic to the IGW.

Key Features

Supports both IPv4 and IPv6 traffic.
Enables bidirectional communication between AWS and the internet.
Requires instances to have public IPs or Elastic IPs (EIPs) to access the internet.

Use Cases

Hosting public-facing applications such as web servers.
Allowing direct internet connectivity for development and testing environments.
Providing internet access to AWS Lambda functions or containerized applications in EKS/ECS.

Route Table Configuration for a Public Subnet

Destination	Target
10.0.0.0/16	local
2001:db8:1234:1a00::/56	local
0.0.0.0/0	igw-id
::/0	igw-id

NAT Gateway

A NAT Gateway allows instances in a private subnet to access the internet while preventing the internet from initiating connections to these instances. This means instances can send requests to the internet but remain hidden from inbound traffic.

How NAT Gateway Works

NAT Gateway only supports outbound traffic.
It is associated with a public subnet but serves private subnets.
It uses an Elastic IP (EIP) to allow outbound requests to the internet.
Traffic from private subnets is routed through NAT Gateway before reaching the IGW.

Key Features

Prevents inbound access to private instances from the internet.
Supports IPv4 traffic only and does not work with IPv6.
AWS-managed and scalable up to 45 Gbps throughput.

Use Cases

Allowing private EC2 instances to download updates, access APIs, or send logs to the internet.
Enabling private subnets to interact with internet services securely.
Preventing external threats by restricting inbound traffic.

Route Table Configuration for a Private Subnet

Destination	Target
10.0.0.0/16	local
2001:db8:1234:1a00::/56	local
0.0.0.0/0	nat-gateway-id
::/0	eigw-id

Egress-Only Internet Gateway (EIGW)

An Egress-Only Internet Gateway (EIGW) is designed specifically for IPv6 traffic. It functions similarly to a NAT Gateway but for IPv6 instances, enabling outbound communication to the internet while blocking inbound traffic.

How EIGW Works

Unlike NAT Gateway, which only supports IPv4, EIGW exclusively supports IPv6.
It allows instances in private subnets to initiate outbound internet connections.
Internet-originated traffic is blocked, ensuring that IPv6 resources remain private.

Key Features

Supports IPv6 traffic exclusively.
Provides outbound-only access to the internet.
Ensures security by blocking unsolicited inbound connections.

Use Cases

Allowing IPv6-enabled private instances to communicate with the internet.
Securing IPv6 workloads while enabling internet access for updates or API calls.
Enabling IPv6 instances to send logs or telemetry data to external services.

Route Table Configuration for a Private Subnet with IPv6

Destination	Target
10.0.0.0/16	local
2001:db8:1234:1a00::/56	local
0.0.0.0/0	nat-gateway-id
::/0	eigw-id

Comparison of AWS Gateways

Feature	Internet Gateway (IGW)	NAT Gateway	Egress-Only Internet Gateway (EIGW)
Traffic Flow	Bidirectional (inbound & outbound)	Outbound only	Outbound only
Supports	IPv4 & IPv6	IPv4 only	IPv6 only
Requires Elastic IP?	No	Yes	No
Use Case	Hosting public applications	Allowing private instances to reach the internet	IPv6-based outbound internet access
Security	Public instances exposed to the internet	Private instances protected from inbound traffic	Blocks inbound connections

Conclusion

AWS provides different types of gateways to facilitate internet access, security, and network management. Choosing the right gateway depends on your network requirements:

Use Internet Gateway (IGW) for publicly accessible instances.
Use NAT Gateway for outbound-only internet access in private subnets.
Use Egress-Only Internet Gateway (EIGW) for outbound IPv6 internet access.

By properly configuring route tables and security groups, you can ensure secure and efficient internet connectivity for your AWS workloads.

Enhancing Network Performance with ECMP Routing in AWS Transit Gateway

Isaac Tonyloi - SWE — Mon, 10 Feb 2025 05:30:22 +0000

Equal-Cost Multi-Path (ECMP) routing is a networking strategy that enables the distribution of traffic across multiple paths of equal cost, enhancing bandwidth utilization and providing redundancy. In Amazon Web Services (AWS), ECMP is primarily implemented using the AWS Transit Gateway, allowing for efficient scaling and improved network resilience.

Understanding ECMP in AWS

AWS Transit Gateway supports ECMP routing, enabling the aggregation of bandwidth across multiple VPN tunnels. Each individual VPN tunnel has a maximum throughput of 1.25 Gbps. By configuring multiple VPN tunnels between your on-premises environment and the Transit Gateway, and enabling ECMP, you can scale your VPN throughput beyond this single-tunnel limit. This setup requires the use of dynamic routing protocols, such as Border Gateway Protocol (BGP), to facilitate the distribution of traffic across the available paths.

Implementing ECMP with AWS Transit Gateway

To effectively implement ECMP in your AWS environment, follow these steps:

Create a Transit Gateway: Begin by creating a Transit Gateway in your AWS account. Ensure that you enable VPN ECMP support during the creation process. This setting allows the Transit Gateway to utilize multiple VPN tunnels for load balancing.
Attach VPCs and VPN Connections: Attach your Amazon Virtual Private Clouds (VPCs) and Site-to-Site VPN connections to the Transit Gateway. When setting up the VPN connections, opt for dynamic routing by configuring BGP. Static routing does not support ECMP.
Configure Customer Gateway: On your on-premises customer gateway device, ensure that BGP is configured to perform ECMP for outbound traffic to AWS. Set equal local preference values or weights on all VPN tunnels to facilitate equal-cost path selection. Additionally, advertise your on-premises prefixes to AWS with the same BGP AS PATH attributes to ensure consistent route selection.
Set Up Transit Gateway Route Tables: Create and associate route tables for your Transit Gateway attachments. Ensure that routes are propagated appropriately between your VPCs and VPN connections to enable seamless traffic flow.

Considerations for ECMP Deployment

When deploying ECMP with AWS Transit Gateway, keep the following in mind:

Dynamic Routing Requirement: ECMP necessitates the use of dynamic routing protocols like BGP. Static routing configurations are incompatible with ECMP.
Device Compatibility: Verify that your on-premises customer gateway devices support ECMP and are configured correctly to handle multiple VPN tunnels.
Traffic Distribution: ECMP uses a hashing algorithm based on the packet's 5-tuple (source IP, destination IP, source port, destination port, and protocol) to distribute traffic. This method may lead to uneven load distribution if the traffic flows are not diverse.
Monitoring and Maintenance: Regularly monitor the performance of your VPN connections and adjust configurations as needed to maintain optimal performance and reliability.

Benefits of ECMP in AWS

Implementing ECMP with AWS Transit Gateway offers several advantages:

Increased Bandwidth: By aggregating multiple VPN tunnels, ECMP allows for higher aggregate bandwidth, surpassing the limitations of a single VPN tunnel.
Enhanced Redundancy: Distributing traffic across multiple paths provides redundancy, ensuring continuous network availability even if one path fails.
Scalability: ECMP facilitates horizontal scaling of network resources, allowing for efficient handling of increased traffic loads.

Conclusion

Equal-Cost Multi-Path routing in AWS, facilitated through the Transit Gateway, is a powerful method for enhancing network performance and reliability. By carefully configuring dynamic routing protocols and ensuring compatibility across devices, organizations can leverage ECMP to achieve higher bandwidth, redundancy, and scalability in their AWS environments.

Why Java Developers Should Choose the Spring Framework

Isaac Tonyloi - SWE — Thu, 06 Feb 2025 11:39:34 +0000

Java remains one of the most powerful and widely used programming languages, supporting applications across various domains, from enterprise solutions to microservices and cloud-based applications. While Java provides a rich ecosystem of libraries and tools, developers often need a framework to streamline development, enforce best practices, and reduce boilerplate code. This is where Spring Framework stands out.

Spring has evolved into the go-to framework for Java developers, offering an extensive ecosystem, modular architecture, and seamless integration capabilities. In this article, we explore why Spring should be your framework of choice and what makes it an indispensable tool for Java development.

Why Use a Framework?

Before diving into Spring specifically, it’s essential to understand why using a framework is beneficial:

Reduces Boilerplate Code: A framework helps developers focus on core logic rather than spending time on repetitive infrastructure code.
Encapsulates Best Practices: Frameworks are designed based on industry-standard design patterns and architecture best practices.
Improves Maintainability: Code written with frameworks follows structured guidelines, making it easier to debug, test, and scale.
Enhances Security & Compliance: Many frameworks, including Spring, provide built-in security measures and compliance features.

That being said, Spring offers all these advantages and more, making it the most widely adopted framework for Java development.

The Spring Ecosystem

Spring started in 2003 as a lightweight Inversion of Control (IoC) container to simplify Java Enterprise applications. Over time, it has grown into a vast ecosystem with various projects covering different aspects of software development.

1. Spring Framework (Core)

The foundation of Spring consists of multiple modules, allowing developers to pick and use only what they need. Key features include:

Dependency Injection (DI): Simplifies object creation and management, making applications more testable and modular.
Aspect-Oriented Programming (AOP): Enables separation of cross-cutting concerns such as logging and security.
Internationalization & Validation: Provides built-in support for localization and data validation.
Data Access Layer: Supports JDBC, JPA, and transaction management.

2. Spring Boot

Spring Boot revolutionized Spring development by offering opinionated defaults and auto-configuration. Benefits of Spring Boot include:

Fast Application Setup: Use Spring Initializr to generate projects with predefined dependencies.
Embedded Servers: No need for an external Tomcat, Jetty, or Undertow server.
Production-Ready Features: Includes health monitoring, logging, and externalized configuration.
Microservices-Friendly: Ideal for building scalable, cloud-native applications.

3. Spring Cloud

Spring Cloud provides tools for building resilient distributed systems, offering:

Service Discovery: Integration with Eureka, Consul, and Kubernetes.
Circuit Breakers: Prevents cascading failures using Netflix Hystrix.
API Gateway: Spring Cloud Gateway for managing API routing and authentication.

4. Spring Security

Security is a crucial concern in modern applications, and Spring Security makes it easy to implement authentication and authorization. It supports:

Declarative Security Rules: Secure endpoints with minimal configuration.
OAuth2 and JWT Authentication: Seamless integration with identity providers.
CSRF Protection: Prevents cross-site request forgery attacks.

5. Spring Data

Spring Data simplifies database interactions by offering:

Spring Data JPA: Reduces boilerplate code for database access.
Spring Data MongoDB & Redis: Seamless support for NoSQL databases.
Pagination and Sorting: Built-in repository support for handling large datasets efficiently.

6. Spring Batch

For enterprise-level batch processing, Spring Batch provides:

Job Scheduling and Processing: Supports retry, skip, and transaction management.
Scalability: Efficiently processes large datasets with parallel processing.

Spring in Action: A Simple REST API

To illustrate how Spring simplifies development, let’s build a simple RESTful API for managing employees.

1. Define the Entity (JPA)

@Entity
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @NotNull
    private String firstName;

    @NotNull
    private String lastName;

    // Getters and Setters
}

2. Define the Repository

Spring Data JPA automatically implements basic CRUD operations.

public interface EmployeeRepository extends CrudRepository<Employee, Long> {
    List<Employee> findAll();
}

3. Create the REST Controller

@RestController
@RequestMapping("/employees")
public class EmployeeController {

    @Autowired
    private EmployeeRepository repository;

    @GetMapping
    public List<Employee> getEmployees() {
        return repository.findAll();
    }
}

4. Add Security with Spring Security

@EnableWebSecurity
public class WebSecurityConfig {
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers(HttpMethod.GET, "/employees").permitAll()
            .anyRequest().authenticated()
            .and().httpBasic();
        return http.build();
    }
}

5. Run the Application

Spring Boot comes with an embedded Tomcat server, so you can run your application with a single command:

mvn spring-boot:run

Why Choose Spring Over Other Java Frameworks?

1. Ease of Use

Spring simplifies Java development with auto-configuration, dependency injection, and modular design.

2. Modularity and Flexibility

Unlike monolithic frameworks, Spring allows you to choose only the required components, making it suitable for a variety of applications.

3. Enterprise-Grade Features

From transaction management to security and cloud-native support, Spring is built for modern enterprise applications.

4. Strong Community and Documentation

Spring has an active open-source community, extensive documentation, and long-term support from VMware (Pivotal).

5. Testability

Spring promotes Test-Driven Development (TDD) and includes built-in support for mocking, integration testing, and dependency injection.

6. Cloud-Native and Microservices Ready

With Spring Boot and Spring Cloud, developers can easily build, deploy, and scale microservices.

When Not to Use Spring?

While Spring is a powerful framework, it may not be the best fit for every project. Here are cases where you might reconsider:

Simple Applications: If your application is small and doesn’t require extensive configuration, a lightweight framework like Micronaut or Quarkus may be more efficient.
Limited Resources: Spring applications have a larger memory footprint compared to minimalistic frameworks like Guice or Play Framework.
Learning Curve: Although Spring is well-documented, new developers may find it overwhelming at first due to its vast ecosystem.

Conclusion

If you're a Java developer looking to streamline development, reduce boilerplate code, and leverage enterprise-grade features, Spring is the best choice. With continuous innovation and a strong community, Spring will continue to be the dominant framework in the Java ecosystem for years to

Different Types of Web Hosting Explained

Isaac Tonyloi - SWE — Mon, 13 Jan 2025 18:34:21 +0000

As you plan to launch or upgrade your website, one of the most important decisions you'll make is choosing the right type of web hosting. Each type of hosting offers different features, advantages, and potential drawbacks. Let’s explore the most common types of web hosting and how they fit various needs.

1. Shared Hosting

Shared hosting is the most popular and affordable option for beginners. In this scenario, your website shares a single server and its resources (CPU, RAM, and bandwidth) with many other websites.

Pros:

Cost-Effective: Low monthly or annual fees.
Ease of Use: Usually comes with user-friendly control panels and one-click installers for popular apps like WordPress.

Cons

Resource Limitations: Performance can be affected by other websites on the same server, especially during traffic spikes.
Limited Control: Less flexibility for server configuration and software installations.

2. Virtual Private Server (VPS) Hosting

A VPS offers a middle ground between shared and dedicated hosting. While still sharing the server hardware, a VPS partitions your space with dedicated resources and a separate environment.

Pros

Improved Performance: More reliable than shared hosting as resources are allocated specifically.
Greater Control: Root access for custom configurations and installations.

Cons

Cost: More expensive than shared hosting, but still affordable.
Management Required: You might need some technical knowledge, unless you opt for managed VPS hosting.

3. Dedicated Hosting

Dedicated hosting means you rent an entire server exclusively for your website. This option is ideal for high-traffic sites with specific performance or security needs.

Pros

Full Resources: No sharing means optimal speed, performance, and reliability.
Complete Control: Full root access allows tailored configurations and software.

Cons

Higher Cost: Much more expensive than shared or VPS hosting.
*Complex Management: * Requires technical expertise or a managed service plan for maintenance and security.

4. Cloud Hosting

Cloud hosting leverages a network of servers to host your website. Resources are scalable, making this option highly flexible.

Pros

Scalability: Easily handles traffic fluctuations by allocating resources on demand.
Reliability: Redundancy across multiple servers minimizes downtime.

Cons

Complex Pricing: Costs can vary based on resource usage, making budgeting a bit challenging.
Technical Complexity: May require more sophisticated management depending on the provider.

5. Managed WordPress Hosting

This is a specialized hosting service tailored specifically for WordPress websites. It handles routine tasks such as updates, backups, and security.

Pros

Optimized Performance: Servers are fine-tuned for WordPress.
Hands-Off Management: Automatic updates, backups, and robust security features.
Cons:

Limited Flexibility: Less control over server settings and software beyond WordPress.
Higher Cost: More expensive than general shared hosting, though it offers extra value for WordPress sites.

Choosing the Right Type

Your choice depends on factors such as budget, technical skill level, website traffic, and specific requirements (e.g., custom software, high security). For a personal blog or small business, shared or managed WordPress hosting may suffice. As your site grows or if you need more control, VPS, dedicated, or cloud hosting might become necessary.

What is Web Hosting and How Does It Work?

Isaac Tonyloi - SWE — Mon, 13 Jan 2025 18:26:27 +0000

A strong online presence is essential for businesses, bloggers, and creators. But what powers a website and allows it to be accessed worldwide? The answer lies in web hosting.

What is Web Hosting?

Web hosting is a service that provides the technologies and resources needed to store a website on the internet and make it accessible to users. When you create a website, all of its content—HTML files, images, videos, databases, and scripts—needs to reside on a physical server.

Web hosting companies rent out space on these servers, along with the necessary tools and support, so your website can be viewed by anyone at any time.

How Does Web Hosting Work?

Server Infrastructure: Web hosting providers maintain powerful computers, known as servers, that store websites' files and data. These servers are connected to high-speed internet networks to ensure quick access and uptime.

**Domain Name and DNS: **Your domain name (e.g., www.isaactonyloi.com) points to the IP address of the server where your website is hosted. The Domain Name System (DNS) translates human-friendly domain names to machine-readable IP addresses, so browsers know where to find your website.

Hosting Environment: Once a user types your website's URL into their browser, a series of events occur:

The browser sends a request to the server for your website.
The server processes the request, retrieves the appropriate files, and sends them back to the browser.

The browser then renders these files into the visible webpage for the user.

Server Management: Web hosting involves not just space allocation, but also management of server software, security, backups, scalability, and performance optimization.

Managed hosting services can take care of these tasks, while unmanaged hosting leaves more control (and responsibility) in your hands.

Types of Web Hosting:

There are various types of web hosting to suit different needs:

Shared Hosting: Multiple websites share the same server resources. It's cost-effective but may have limitations on performance during high traffic periods.

VPS (Virtual Private Server) Hosting: Still shares a server, but with dedicated portions of resources. It offers more power and customization than shared hosting.

Dedicated Hosting: You rent an entire server exclusively for your website, providing maximum control, security, and performance.
Cloud Hosting: Websites are hosted on a network of servers, improving reliability and scalability. Resources are allocated dynamically based on demand.

Managed WordPress Hosting: Specialized hosting environments optimized for WordPress sites, taking care of updates, security, and performance tuning.

Why Web Hosting Matters

The quality of your web hosting can impact website speed, security, and reliability—key factors for user experience and search engine optimization (SEO). Choosing the right hosting service involves balancing cost, technical requirements, support, scalability, and your website's goals.

How to deploy a static React site to AWS Amplify

Isaac Tonyloi - SWE — Mon, 13 Jan 2025 12:03:09 +0000

So, in the past month, I decided to level up my cloud knowledge. I’ve taken a few courses, earned the AWS Cloud Practitioner certification, and am currently preparing for the AWS Solutions Architect Associate exam. In this journey, I’ve been experimenting with various AWS services, and today, I’m excited to share a project I recently built—a static website hosted on AWS Amplify!

This project is perfect for beginners who want to learn how to host a static website with modern CI/CD workflows and minimal overhead. Let’s dive into it.

What You’ll Learn

In this guide, you’ll learn how to:

Deploy a static website using AWS Amplify.
Set up continuous deployment from a Git-based repository.
Understand the benefits of using Amplify for hosting static sites.

Step 1: Set Up Your Local Environment

To kick things off, let’s create a simple React application using Vite. Open your terminal and run the following commands:

npm create vite@latest staticwebsite -- --template react
cd staticwebsite
npm install
npm run dev

Here is the React application I have built:

You can find the code here: https://github.com/isaactony/TungaWeb

Once done, open the local development server link to confirm the app is running.

Step 2: Push Your Code to GitHub

Sign in to GitHub and create a new repository named **tungaio**.Or any other name you want
Initialize Git in your local project folder:

   git init
   git add .
   git commit -m "Initial commit"
   git branch -M main
   git remote add origin <your-repo-url>
   git push -u origin main

This step ensures that your code is available in a repository that AWS Amplify can connect to.

Step 3: Start Building with AWS Amplify

Sign in to the AWS Amplify Console.
Click ** Deploy App** and select GitHub as the source provider.

Select GitHub as the source provider and click Next.

Authenticate with GitHub when prompted and grant AWS Amplify the necessary permissions to access your repository.

Step 4: Configure and Deploy

Choose your repository and branch (e.g., main) in Amplify.

Keep the default build settings (Amplify will auto-detect your framework and build commands).
Click Next.

Click Save and Deploy to start the deployment process.

AWS Amplify will automatically build and host your site on a global CDN. The build process typically takes 2–5 minutes.

Step 5: Visit Your Live Website

Once the build completes, you’ll see a Visit deployed URL button. Click it to view your live static website! Each time you push changes to your repository, Amplify will automatically deploy updates.

Why AWS Amplify?

AWS Amplify is a fantastic choice for hosting static websites because:

It offers a Git-based CI/CD workflow for seamless deployments.
Your website is delivered via Amazon CloudFront, ensuring fast and reliable performance.
Amplify provides low-cost hosting, often within AWS Free Tier limits.

The site is now live

Now that your site is live, you can explore adding features like:

Custom domains.
Serverless backend using AWS Amplify’s API, Auth, or Storage modules.

Feel free to share your deployment experience or ask questions in the comments below. Happy building!

What is Database Normalization- With an Example

Isaac Tonyloi - SWE — Tue, 10 Dec 2024 17:35:46 +0000

Database normalization is a design process aimed at organizing data within a database to eliminate redundancy, improve integrity, and enhance scalability. By systematically applying normalization principles, you create a database structure that is more efficient, reduces anomalies, and ensures consistency in your data.

This article provides a detailed breakdown of normalization, taking you through unnormalized data to the third normal form (3NF) with illustrative examples and tables.

Why Normalize a Database?

Normalization is vital for designing efficient databases. Here are some key objectives:

Avoid Redundancy: Prevent duplicate data storage to save space.
Eliminate Update Anomalies: Ensure changes in data occur consistently across the database.
Improve Query Performance: Facilitate easier data retrieval and manipulation.
Ensure Data Integrity: Prevent inconsistencies caused by improper data dependencies.
Enhance Scalability: Create flexible structures that can handle growing datasets.

Normalization consists of several forms (or stages), with each step building on the previous one to further refine the structure.

Step 1: Unnormalized Form (UNF)

Characteristics:

Contains redundant data.
May include multi-valued attributes or repeating groups.
Offers no guarantees of consistency or integrity.

Example of an Unnormalized Table:

Doctor ID	Doctor Name	Patient ID	Patient Name	Region	Council	Postcode	Surgery Number	Slot ID	Total Cost
D1	Dr. Smith	P1	John	East	Council1	12345	101	S1	200
D1	Dr. Smith	P2	Alice	East	Council1	12345	101	S2	300
D2	Dr. Doe	P3	Bob	West	Council2	67890	102	S3	150

This table is unnormalized because:

It contains repeating groups like multiple Slot IDs.
Non-atomic values could exist in certain fields.

Issues with UNF:

Redundant information (e.g., Doctor Name is repeated for D1).
Difficult to update or query due to mixed information.

Step 2: First Normal Form (1NF)

Characteristics of 1NF:

Data is organized into rows and columns.
Each column contains atomic values (no arrays or sets).
Each record is uniquely identified using a primary key.

Transformation to 1NF:
To achieve 1NF:

Remove repeating groups by creating separate tables.
Ensure that all attributes have atomic values.
Introduce a primary key for each table.

Resulting Tables:

Patients Table (1NF):

Patient ID	Patient Name	Slot ID	Total Cost
P1	John	S1	200
P2	Alice	S2	300
P3	Bob	S3	150

Doctors Table (1NF):

Doctor ID	Doctor Name
D1	Dr. Smith
D2	Dr. Doe

Surgery Table (1NF):

Doctor ID	Region	Council	Postcode	Surgery Number
D1	East	Council1	12345	101
D2	West	Council2	67890	102

Step 3: Second Normal Form (2NF)

Characteristics of 2NF:

Satisfies all requirements of 1NF.
Removes partial dependencies, i.e., non-key attributes must depend on the entire primary key.

Key Observations:
In the Surgery table from 1NF, the Region depends only on the Council, not the entire primary key. This violates 2NF.

Transformation to 2NF:
To remove partial dependencies:

Create a new table for Council and Region.
Ensure all attributes depend solely on the primary key.

Resulting Tables:

Appointments Table (2NF):

Appointment ID	Slot ID	Total Cost
A1	S1	200
A2	S2	300
A3	S3	150

Council Table (2NF):

Council	Region
Council1	East
Council2	West

Step 4: Third Normal Form (3NF)

Characteristics of 3NF:

Satisfies all requirements of 2NF.
Removes transitive dependencies, i.e., non-key attributes must not depend on other non-key attributes.

Key Observations:
In the Surgery table from 2NF, Postcode and Surgery Number have a transitive dependency, where Postcode indirectly depends on Surgery Number.

Transformation to 3NF:
To eliminate transitive dependencies:

Create a new table for Postcode and Surgery Number.
Ensure all attributes depend directly on the primary key.

Resulting Tables:

Surgery Table (3NF):

Postcode	Surgery Number
12345	101
67890	102

Final Database Structure

After normalization, the database consists of the following well-structured tables:

Patients Table:
Stores patient information with atomic fields.
- Patient ID, Patient Name
Appointments Table:
Links Slot ID with Total Cost.
- Appointment ID, Slot ID, Total Cost
Doctors Table:
Contains details about doctors.
- Doctor ID, Doctor Name
Council Table:
Maps Council to Region.
- Council, Region
Surgery Table:
Connects Postcode to Surgery Number.
- Postcode, Surgery Number

Why Stop at 3NF?

While 3NF is sufficient for most practical purposes, further normalization forms exist:

Boyce-Codd Normal Form (BCNF): Ensures stricter elimination of redundancy.
Fourth Normal Form (4NF): Addresses multi-valued dependencies.
Fifth Normal Form (5NF): Eliminates redundancy arising from join dependencies.

For most real-world applications, 3NF strikes the right balance between performance and data integrity.

Conclusion

Normalization is a critical process for designing databases that are efficient, scalable, and easy to maintain. By following the steps outlined above, you can create a well-structured database that minimizes redundancy, prevents anomalies, and simplifies data operations.