Forem: Jacky

Build a Website Application for Free in 2 Hours with Vibe Coding

Jacky — Mon, 03 Nov 2025 10:08:00 +0000

Seriously, AI is a game-changer. It makes the stuff we used to do easy, now automatic. The hard stuff? Way easier. And those impossible-sounding tasks? They’re now just fun challenges we can totally crush.

I’m one of those people who uses Telegram for everything — especially notes. It’s just so quick, easy to access, and light. That habit actually sparked a fun idea: Why not build my own note-taking app? Plus, it was the perfect excuse to play around with the newest tech.

A lazy, rainy weekend rolled around, and my personal Hackathon officially kicked off… 💡

After a few minutes of coffee-fueled brainstorming, here’s the stack I decided to run with:

Cloudflare Pages: Hosting my React Native frontend app. Easy-peasy.
Cloudflare Workers: My backend service, built super-fast with Hono.
Cloudflare D1: A simple, sweet little SQL database.
Cloudflare R2: Object storage for saving user pictures and canvas drawings.
Claude Code (Anthropic): My main AI sidekick for actually building the thing.

This is my design architecture for working on this project

I gotta give props to Cloudflare here. It’s ridiculously convenient for getting started, and they have an awesome FREE tier. Seriously, it’s clutch. Plus, their built-in rules for DDOS and bot protection make it easy to keep your site safe from the start.

My AI Squad Workflow: Building the App in 6 Steps

To make sure my AI buddies didn’t just wander off and do their own thing, I set up a super clear, step-by-step workflow for every task:

Draft Design: I’d ask the frontend AI Agent to whip up a draft design, making sure it follows my basic system-design guidelines.
Review & Full Design: I’d quickly check the draft. If it looked good, I’d tell Claude to make the full design and an API design request (in a neat Markdown file) that matched the look.
Backend Deployment: That API request goes into my Knowledge Base Repository. Then, the Backend AI Agent grabs it, reads the specs, and starts building all the APIs.
Final API Docs: Once the APIs are ready, the AI creates a final, detailed API document (with cURL examples, endpoints, etc.) and saves it in the Knowledge Base Repository.
Frontend Integration: The Frontend AI Agent uses that final API documentation from step 4 to connect everything to the backend.
The Final Check: My job? Just reviewing the finished product after the whole loop is complete.

🎉 And Here’s The Finished App!

Check it out! That’s the final result. I literally went from nothing to a test-ready app in just 2 hours, and the development cost was zero dollars for the entire platform.

P.S. Oh, wait. I did drop $10 to snag the domain name… C’est la vie! 😂

Real-World TDD with Claude AI: Building a User Registration System in Java

Jacky — Thu, 29 May 2025 08:01:31 +0000

Let’s walk through a complete Test-Driven Development cycle using Claude AI assistance, from initial requirements to fully tested code. We’ll build a user registration system that demonstrates how AI can accelerate and improve your TDD workflow.

The Requirements

Our product manager provides these requirements for a user registration feature:

“We need a user registration system that accepts email and password. Email must be valid format and unique in our system. Password must be at least 8 characters with one uppercase, one lowercase, and one number. We should hash passwords before storing and return appropriate error messages for validation failures.”

Step 1: Translating Requirements to Test Cases with Claude

First, I asked Claude: “Based on these requirements, what test cases should I write for a UserRegistrationService?”

Claude suggested these test scenarios:

Valid registration with proper email and password
Invalid email formats (missing @, invalid domain, empty)
Duplicate email registration attempts
Password validation (too short, missing uppercase/lowercase/number)
Password hashing verification
Proper error message returns

Step 2: Setting Up the Test Structure

Let’s start with our test class structure:

package com.example.registration;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
public class UserRegistrationServiceTest {

    @Mock
    private UserRepository userRepository;

    @Mock
    private PasswordHasher passwordHasher;

    private UserRegistrationService registrationService;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        registrationService = new UserRegistrationService(userRepository, passwordHasher);
    }
}

Step 3: Writing Failing Tests (Red Phase)

Claude helped me write comprehensive failing tests:

@Test
void shouldRegisterUserWithValidEmailAndPassword() {
    // Arrange
    String email = "john.doe@example.com";
    String password = "SecurePass123";
    String hashedPassword = "hashed_password_here";

    when(userRepository.existsByEmail(email)).thenReturn(false);
    when(passwordHasher.hash(password)).thenReturn(hashedPassword);

    // Act
    RegistrationResult result = registrationService.registerUser(email, password);

    // Assert
    assertTrue(result.isSuccess());
    assertNull(result.getErrorMessage());
    verify(userRepository).save(any(User.class));
}

@Test
void shouldRejectInvalidEmailFormat() {
    // Arrange
    String invalidEmail = "not-an-email";
    String password = "ValidPass123";

    // Act
    RegistrationResult result = registrationService.registerUser(invalidEmail, password);

    // Assert
    assertFalse(result.isSuccess());
    assertEquals("Invalid email format", result.getErrorMessage());
    verify(userRepository, never()).save(any(User.class));
}
@Test
void shouldRejectDuplicateEmail() {
    // Arrange
    String existingEmail = "existing@example.com";
    String password = "ValidPass123";

    when(userRepository.existsByEmail(existingEmail)).thenReturn(true);

    // Act
    RegistrationResult result = registrationService.registerUser(existingEmail, password);

    // Assert
    assertFalse(result.isSuccess());
    assertEquals("Email already registered", result.getErrorMessage());
    verify(userRepository, never()).save(any(User.class));
}
@Test
void shouldRejectWeakPassword() {
    // Arrange
    String email = "test@example.com";
    String weakPassword = "weak";

    when(userRepository.existsByEmail(email)).thenReturn(false);

    // Act
    RegistrationResult result = registrationService.registerUser(email, weakPassword);

    // Assert
    assertFalse(result.isSuccess());
    assertEquals("Password must be at least 8 characters with uppercase, lowercase, and number", 
                result.getErrorMessage());
    verify(userRepository, never()).save(any(User.class));
}
@Test
void shouldHashPasswordBeforeStoring() {
    // Arrange
    String email = "secure@example.com";
    String password = "MySecurePass123";
    String hashedPassword = "hashed_version";

    when(userRepository.existsByEmail(email)).thenReturn(false);
    when(passwordHasher.hash(password)).thenReturn(hashedPassword);

    // Act
    registrationService.registerUser(email, password);

    // Assert
    ArgumentCaptor<User> userCaptor = ArgumentCaptor.forClass(User.class);
    verify(userRepository).save(userCaptor.capture());
    User savedUser = userCaptor.getValue();

    assertEquals(email, savedUser.getEmail());
    assertEquals(hashedPassword, savedUser.getPasswordHash());
    assertNotEquals(password, savedUser.getPasswordHash()); // Ensure it's hashed
}

Step 4: Creating Supporting Classes

Claude helped me identify the needed supporting classes:

// RegistrationResult.java
public class RegistrationResult {
    private final boolean success;
    private final String errorMessage;

    private RegistrationResult(boolean success, String errorMessage) {
        this.success = success;
        this.errorMessage = errorMessage;
    }

    public static RegistrationResult success() {
        return new RegistrationResult(true, null);
    }

    public static RegistrationResult failure(String errorMessage) {
        return new RegistrationResult(false, errorMessage);
    }

    public boolean isSuccess() { return success; }
    public String getErrorMessage() { return errorMessage; }
}

// User.java
public class User {
    private String email;
    private String passwordHash;

    public User(String email, String passwordHash) {
        this.email = email;
        this.passwordHash = passwordHash;
    }

    // Getters
    public String getEmail() { return email; }
    public String getPasswordHash() { return passwordHash; }
}
// UserRepository.java (interface)
public interface UserRepository {
    boolean existsByEmail(String email);
    void save(User user);
}
// PasswordHasher.java (interface)  
public interface PasswordHasher {
    String hash(String password);
}

Step 5: Implementing the Service (Green Phase)

Now let’s make the tests pass with the minimal implementation:

package com.example.registration;

import java.util.regex.Pattern;
public class UserRegistrationService {
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");

    private static final Pattern PASSWORD_PATTERN = 
        Pattern.compile("^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,}$");

    private final UserRepository userRepository;
    private final PasswordHasher passwordHasher;

    public UserRegistrationService(UserRepository userRepository, 
                                 PasswordHasher passwordHasher) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
    }

    public RegistrationResult registerUser(String email, String password) {
        // Validate email format
        if (!isValidEmail(email)) {
            return RegistrationResult.failure("Invalid email format");
        }

        // Check for duplicate email
        if (userRepository.existsByEmail(email)) {
            return RegistrationResult.failure("Email already registered");
        }

        // Validate password strength
        if (!isValidPassword(password)) {
            return RegistrationResult.failure(
                "Password must be at least 8 characters with uppercase, lowercase, and number");
        }

        // Hash password and save user
        String hashedPassword = passwordHasher.hash(password);
        User user = new User(email, hashedPassword);
        userRepository.save(user);

        return RegistrationResult.success();
    }

    private boolean isValidEmail(String email) {
        return email != null && EMAIL_PATTERN.matcher(email).matches();
    }

    private boolean isValidPassword(String password) {
        return password != null && PASSWORD_PATTERN.matcher(password).matches();
    }
}

Step 6: Refactoring with Claude’s Help

Claude suggested several improvements for the refactor phase:

Extract validation logic into separate validator classes
Add more specific password validation messages
Create custom exceptions for different error types
Here’s the refactored version:

// EmailValidator.java
public class EmailValidator {
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[A-Za-z0-9+_.-]+@([A-Za-z0-9.-]+\\.[A-Za-z]{2,})$");

    public ValidationResult validate(String email) {
        if (email == null || email.trim().isEmpty()) {
            return ValidationResult.invalid("Email is required");
        }

        if (!EMAIL_PATTERN.matcher(email).matches()) {
            return ValidationResult.invalid("Invalid email format");
        }

        return ValidationResult.valid();
    }
}

// PasswordValidator.java
public class PasswordValidator {
    public ValidationResult validate(String password) {
        if (password == null || password.length() < 8) {
            return ValidationResult.invalid("Password must be at least 8 characters");
        }

        if (!password.matches(".*[a-z].*")) {
            return ValidationResult.invalid("Password must contain lowercase letter");
        }

        if (!password.matches(".*[A-Z].*")) {
            return ValidationResult.invalid("Password must contain uppercase letter");
        }

        if (!password.matches(".*\\d.*")) {
            return ValidationResult.invalid("Password must contain a number");
        }

        return ValidationResult.valid();
    }
}
// Updated UserRegistrationService
public class UserRegistrationService {
    private final UserRepository userRepository;
    private final PasswordHasher passwordHasher;
    private final EmailValidator emailValidator;
    private final PasswordValidator passwordValidator;

    public UserRegistrationService(UserRepository userRepository,
                                 PasswordHasher passwordHasher,
                                 EmailValidator emailValidator,
                                 PasswordValidator passwordValidator) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
        this.emailValidator = emailValidator;
        this.passwordValidator = passwordValidator;
    }

    public RegistrationResult registerUser(String email, String password) {
        ValidationResult emailValidation = emailValidator.validate(email);
        if (!emailValidation.isValid()) {
            return RegistrationResult.failure(emailValidation.getErrorMessage());
        }

        if (userRepository.existsByEmail(email)) {
            return RegistrationResult.failure("Email already registered");
        }

        ValidationResult passwordValidation = passwordValidator.validate(password);
        if (!passwordValidation.isValid()) {
            return RegistrationResult.failure(passwordValidation.getErrorMessage());
        }

        String hashedPassword = passwordHasher.hash(password);
        User user = new User(email, hashedPassword);
        userRepository.save(user);

        return RegistrationResult.success();
    }
}

Step 7: Additional Test Cases with Claude

Claude suggested edge cases I hadn’t considered:

@Test
void shouldRejectNullEmail() {
    RegistrationResult result = registrationService.registerUser(null, "ValidPass123");
    assertFalse(result.isSuccess());
    assertEquals("Email is required", result.getErrorMessage());
}

@Test
void shouldRejectEmptyPassword() {
    RegistrationResult result = registrationService.registerUser("test@example.com", "");
    assertFalse(result.isSuccess());
    assertEquals("Password must be at least 8 characters", result.getErrorMessage());
}
@Test
void shouldHandleRepositoryExceptions() {
    String email = "test@example.com";
    String password = "ValidPass123";

    when(userRepository.existsByEmail(email)).thenReturn(false);
    when(passwordHasher.hash(password)).thenReturn("hashed");
    doThrow(new RuntimeException("Database error")).when(userRepository).save(any(User.class));

    assertThrows(RuntimeException.class, () -> {
        registrationService.registerUser(email, password);
    });
}

Key Benefits of AI-Assisted TDD

Through this real-world example, Claude AI provided several advantages:
Comprehensive Test Coverage: Claude identified edge cases like null inputs and database exceptions that I might have missed initially.
Better Code Structure: The AI suggested extracting validators into separate classes, improving maintainability and single responsibility principle adherence.
Realistic Mock Scenarios: Claude helped create meaningful mock interactions that truly test the service behavior.
Progressive Refinement: As requirements evolved, Claude helped adapt tests and suggest improvements without breaking existing functionality.

Conclusion

This practical example demonstrates how Claude AI transforms TDD from a sometimes tedious process into an efficient, comprehensive development approach. By leveraging AI assistance for test generation, edge case identification, and code structure suggestions, developers can focus on business logic while ensuring robust test coverage.

The key is treating Claude as a knowledgeable pair programming partner who helps you think through scenarios, suggests improvements, and catches potential issues early in the development cycle. The result is higher-quality, well-tested code delivered more efficiently than traditional manual TDD approaches.

System Design Interview: Replacing Redis with Own Application in Spring Boot

Jacky — Thu, 24 Apr 2025 09:29:52 +0000

It was a Wednesday afternoon when I stepped into the virtual meeting room for my senior Java backend developer interview. After the usual introductions and technical questions, the lead architect leaned forward with a challenging gleam in her eye.

“Let’s discuss a system design problem,” she said. “Imagine we’re looking to replace our Redis caching layer with a solution built directly into our Spring Boot microservices. How would you approach this?”

I took a moment to gather my thoughts, recognizing this as an opportunity to demonstrate my architectural thinking.

“Before diving into implementation details,” I started, “could you tell me more about the current microservices ecosystem and how Redis is being used?”

“Good question,” she replied.

“We have about a dozen microservices, each responsible for specific business domains. Redis currently acts as a centralized caching layer accessed by all services for performance optimization and to reduce database load. We’re particularly interested in exploring alternatives that might reduce operational complexity.”

I nodded and began outlining my solution.

Understanding the Microservice Caching Requirements

“First, let’s identify what we need from our replacement caching solution in a microservices context,” I said.

Distributed consistency — Ensuring cache coherence across service instances
Independent scaling — Each service managing its own cache needs
Resilience — Preventing cascading failures if caching issues arise
Performance — Maintaining similar or better performance than Redis
Observability — Monitoring cache effectiveness across services

The Architecture Approach

“I propose a two-tiered architecture,” I continued. “Each microservice will maintain its own local cache, but we’ll implement a synchronization mechanism to maintain consistency where needed.”

I sketched out a diagram showing:

Individual Spring Boot microservices with embedded caching components
An event-driven synchronization layer for cross-service cache invalidation
Optional persistence mechanisms per service

Core Implementation

“For the foundation, we’ll use Spring’s cache abstraction,” I explained. “This gives us flexibility to implement different caching strategies per microservice based on their specific needs.”

@Configuration
@EnableCaching
public class CachingConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(Duration.ofMinutes(30))
            .maximumSize(10000)
            .recordStats());
        return cacheManager;
    }

    @Bean
    public CacheMetrics cacheMetrics(CacheManager cacheManager) {
        return new CacheMetrics(cacheManager, meterRegistry);
    }

“I’m using Caffeine as the local cache provider since it offers excellent performance characteristics similar to Redis,” I explained. “Each microservice can configure its own cache policies based on its specific access patterns and data freshness requirements.”

Distributed Cache Invalidation

“The key challenge in a microservices architecture is maintaining cache consistency,” I continued. “When one service updates data, other services’ caches might become stale.”

“For this, I recommend an event-driven approach using a lightweight message broker like RabbitMQ or Kafka, which you likely already have in your microservices ecosystem.”

@Service
public class CacheInvalidationService {

    @Autowired
    private CacheManager cacheManager;

    @Autowired
    private EventPublisher eventPublisher;

    public void invalidateCache(String cacheName, String key) {
        // Local invalidation
        Cache cache = cacheManager.getCache(cacheName);
        if (cache != null) {
            cache.evict(key);
        }

        // Publish invalidation event for other services
        eventPublisher.publish(new CacheInvalidationEvent(cacheName, key));
    }

    @EventListener
    public void handleInvalidationEvent(CacheInvalidationEvent event) {
        Cache cache = cacheManager.getCache(event.getCacheName());
        if (cache != null) {
            cache.evict(event.getKey());
        }
    }
}

“This approach allows for targeted cache invalidation across services. Only the specific keys that have changed are invalidated, rather than flushing entire caches.”

Service-Specific Caching Strategies

“A key advantage of moving caching into each microservice is the ability to tailor caching strategies to each service’s needs,” I explained.

“For example, a product catalog service might cache items with long TTLs, while a pricing service might use shorter TTLs or implement cache-aside with database triggers for invalidation.

@Service
public class ProductCatalogService {

    @Cacheable(value = "products", key = "#productId", unless = "#result == null")
    public Product getProduct(String productId) {
        return productRepository.findById(productId);
    }

    @CachePut(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        Product updated = productRepository.save(product);
        // Notify other services about this update
        cacheInvalidationService.notifyUpdate("products", product.getId());
        return updated;
    }
}

Near Cache Pattern Implementation

“For frequently accessed data that’s shared across services, I’d implement a near cache pattern,” I suggested.

“Each service maintains its local cache, but also subscribes to a topic for updates from authoritative services. This gives us the best of both worlds: local cache speed with reasonable consistency.”

@Service
public class NearCacheService {

    @Autowired
    private CacheManager cacheManager;

    @Autowired
    private MessageListener messageListener;

    @PostConstruct
    public void init() {
        // Subscribe to cache update events for domains this service cares about
        messageListener.subscribe("cache.updates.products", this::handleProductUpdate);
    }

    private void handleProductUpdate(CacheUpdateEvent event) {
        // Update local cache with fresh data
        Cache cache = cacheManager.getCache("products");
        if (cache != null) {
            cache.put(event.getKey(), event.getValue());
        }
    }
}

Resilience Patterns

“In a distributed system, we need to ensure cache failures don’t impact service availability,” I noted. “I’d implement circuit breakers around cache operations to gracefully degrade to direct database access if needed.”

@Service
public class ResilientCacheService {

    @Autowired
    private CacheManager cacheManager;

    @Autowired
    private CircuitBreakerFactory circuitBreakerFactory;

    public Object getWithFallback(String cacheName, String key, Supplier<Object> dataLoader) {
        CircuitBreaker circuitBreaker = circuitBreakerFactory.create("cache");

        return circuitBreaker.run(() -> {
            Cache cache = cacheManager.getCache(cacheName);
            Object value = cache.get(key);
            if (value != null) {
                return value;
            }

            // Cache miss or error, load from source
            Object freshData = dataLoader.get();
            if (freshData != null) {
                cache.put(key, freshData);
            }
            return freshData;
        }, throwable -> {
            // Circuit open or error, direct fallback to data source
            return dataLoader.get();
        });
    }
}

Monitoring and Observability

“For monitoring, we’ll implement comprehensive metrics collection,” I continued. “This is especially important in a distributed caching system to identify inefficiencies or inconsistencies.”

@Component
public class CacheMetrics {

    private final CacheManager cacheManager;
    private final MeterRegistry meterRegistry;

    public CacheMetrics(CacheManager cacheManager, MeterRegistry meterRegistry) {
        this.cacheManager = cacheManager;
        this.meterRegistry = meterRegistry;

        registerMetrics();
    }

    private void registerMetrics() {
        cacheManager.getCacheNames().forEach(cacheName -> {
            Cache cache = cacheManager.getCache(cacheName);
            if (cache instanceof CaffeineCache) {
                com.github.benmanes.caffeine.cache.Cache nativeCache =
                    ((CaffeineCache) cache).getNativeCache();

                // Register various metrics for this cache
                Gauge.builder("cache.size", nativeCache, c -> c.estimatedSize())
                    .tag("cache", cacheName)
                    .register(meterRegistry);

                // Add more metrics for hits, misses, etc.
            }
        });
    }
}

Migration Strategy

“Replacing Redis across a microservices ecosystem requires careful planning,” I said. “I recommend a phased approach:

Implement the new caching solution alongside Redis in non-critical services first
Use feature flags to control traffic between the two caching systems
Monitor performance, errors, and consistency issues closely
Gradually migrate services from least to most critical
Maintain Redis as a fallback until confidence is high in the new solution

Conclusion

This approach offers several advantages in a microservices context,

I summarized:

Reduced operational complexity — No separate Redis cluster to maintain
Service autonomy — Each service controls its own caching behavior
Improved resilience — No single point of failure for the entire caching system
Tailored performance — Cache configurations aligned with specific service needs
Simplified deployment — No external cache dependencies for development or testing

The interviewer nodded thoughtfully.

What about the drawbacks? When would you recommend keeping Redis instead?

“Great question,” I replied. “I’d recommend keeping Redis if:

Your services need advanced data structures like sorted sets or geospatial indexes
The volume of cached data is extremely large and would strain service memory
You need centralized rate limiting or distributed locking features
Your architecture requires centralized caching policies for compliance reasons
The overhead of implementing and maintaining cache synchronization exceeds Redis operational costs”

Okay, … part of the interview, wait for good results from me.

original my article from Medium

Mastering Java 17 Streaming API: A Complete Guide

Jacky — Tue, 18 Mar 2025 06:03:51 +0000

From Basics to Advanced Patterns - Everything You Need to Know

Hey fellow developers!

After spending years working with Java streams, I wanted to share a comprehensive guide that I wish I had when I started. Java's Stream API has evolved significantly since its introduction in Java 8, and Java 17 brings even more power to this incredible feature. Let's dive deep into mastering streams!

Why Streams Matter

Before we dive into the technical details, let's clarify why the Stream API is worth mastering:

Declarative programming: Focus on "what" rather than "how"
Pipeline operations: Chain multiple operations together
Parallel execution: Leverage multi-core processors with minimal effort
Reduced boilerplate: Write cleaner, more readable code

Stream API Fundamentals

Creating Streams

There are numerous ways to create streams:

// From Collections
List<String> names = Arrays.asList("Alex", "Beth", "Charlie");
Stream<String> streamFromList = names.stream();

// From arrays
String[] array = {"Alex", "Beth", "Charlie"};
Stream<String> streamFromArray = Arrays.stream(array);

// Stream.of
Stream<String> streamOf = Stream.of("Alex", "Beth", "Charlie");

// Empty stream
Stream<String> emptyStream = Stream.empty();

// Infinite streams
Stream<Integer> infiniteIntegers = Stream.iterate(0, n -> n + 1);
Stream<Double> infiniteRandoms = Stream.generate(Math::random);

Stream Operations

Stream operations fall into two categories:

Intermediate operations: Return a new stream (lazy evaluation)
Terminal operations: Produce a result or side-effect (trigger evaluation)

Common Intermediate Operations

// Filter elements based on a predicate
Stream<String> filtered = names.stream()
    .filter(name -> name.startsWith("A"));

// Map elements to something else
Stream<Integer> lengths = names.stream()
    .map(String::length);

// FlatMap for flattening nested collections
List<List<Integer>> nestedLists = Arrays.asList(
    Arrays.asList(1, 2), 
    Arrays.asList(3, 4)
);
Stream<Integer> flattened = nestedLists.stream()
    .flatMap(Collection::stream); // yields 1, 2, 3, 4

// Sort elements
Stream<String> sorted = names.stream()
    .sorted();

// Custom sort
Stream<String> customSorted = names.stream()
    .sorted(Comparator.comparing(String::length));

// Distinct elements
Stream<String> distinct = names.stream()
    .distinct();

// Limit number of elements
Stream<String> limited = names.stream()
    .limit(2);

// Skip elements
Stream<String> skipped = names.stream()
    .skip(1);

// Peek (for debugging)
Stream<String> peeked = names.stream()
    .peek(name -> System.out.println("Processing: " + name));

Common Terminal Operations

// Collect to a collection
List<String> collected = names.stream()
    .collect(Collectors.toList());
Set<String> asSet = names.stream()
    .collect(Collectors.toSet());
Map<Integer, String> asMap = names.stream()
    .collect(Collectors.toMap(
        String::length,      // key mapper
        Function.identity(), // value mapper
        (existing, replacement) -> existing // merge function
    ));

// Count elements
long count = names.stream().count();

// Find elements
Optional<String> any = names.stream().findAny();
Optional<String> first = names.stream().findFirst();

// Check conditions
boolean allMatch = names.stream()
    .allMatch(name -> name.length() > 2);
boolean anyMatch = names.stream()
    .anyMatch(name -> name.startsWith("A"));
boolean noneMatch = names.stream()
    .noneMatch(name -> name.contains("X"));

// Reduction
Optional<String> reduced = names.stream()
    .reduce((a, b) -> a + ", " + b);
String reducedWithIdentity = names.stream()
    .reduce("Names: ", (a, b) -> a + b);

// ForEach (for side effects)
names.stream().forEach(System.out::println);

// Min/Max
Optional<String> min = names.stream()
    .min(Comparator.naturalOrder());
Optional<String> max = names.stream()
    .max(Comparator.comparing(String::length));

// ToArray
String[] array = names.stream().toArray(String[]::new);

Java 17 Stream Enhancements

Enhanced Null Handling

Java 17 builds on earlier improvements for handling null values in streams:

// Creating a stream that may contain nulls
Stream<String> nullableStream = Stream.of("a", null, "b");

// Filter out nulls
Stream<String> nonNullsOnly = nullableStream.filter(Objects::nonNull);

// Using Optional to handle potential nulls
Optional.ofNullable(possiblyNull)
    .stream()
    .forEach(System.out::println);

Performance Improvements

Java 17 includes internal optimizations for streams, particularly for parallel processing. These improvements are transparent but result in better performance compared to earlier versions.

Advanced Stream Patterns

Grouping and Partitioning

// Grouping by a classifier
Map<Integer, List<String>> groupedByLength = names.stream()
    .collect(Collectors.groupingBy(String::length));

// Grouping with downstream collector
Map<Integer, Long> countByLength = names.stream()
    .collect(Collectors.groupingBy(
        String::length,
        Collectors.counting()
    ));

// Partitioning (special case of grouping by boolean)
Map<Boolean, List<String>> partitioned = names.stream()
    .collect(Collectors.partitioningBy(name -> name.length() > 4));

Custom Collectors

Create your own collectors for specialized aggregation:

class StringJoiner {
    private StringBuilder sb = new StringBuilder();
    private String delimiter;

    public StringJoiner(String delimiter) {
        this.delimiter = delimiter;
    }

    public void add(String element) {
        if (sb.length() > 0) {
            sb.append(delimiter);
        }
        sb.append(element);
    }

    public StringJoiner merge(StringJoiner other) {
        if (other.sb.length() > 0) {
            if (sb.length() > 0) {
                sb.append(delimiter);
            }
            sb.append(other.sb);
        }
        return this;
    }

    @Override
    public String toString() {
        return sb.toString();
    }
}

Collector<String, StringJoiner, String> customJoiner = Collector.of(
    () -> new StringJoiner(", "),  // supplier
    StringJoiner::add,             // accumulator
    StringJoiner::merge,           // combiner
    StringJoiner::toString         // finisher
);

String joined = names.stream().collect(customJoiner);

Stream Processing Strategies

Sequential vs Parallel

// Sequential processing (default)
long sequentialCount = names.stream().count();

// Parallel processing
long parallelCount = names.parallelStream().count();
// OR
long alsoParallelCount = names.stream().parallel().count();

When to Use Parallel Streams

Parallel streams can significantly improve performance, but they're not always the right choice:

Use when: Processing large datasets with independent operations
Avoid when: Operations have side effects, are stateful, or the overhead of splitting outweighs benefits
Consider: The characteristics of your data source (e.g., ArrayList splits well, LinkedList doesn't)

Debugging Streams

Streams can be challenging to debug due to their lazy evaluation nature. Here are some techniques:

// Using peek for debugging
List<String> result = names.stream()
    .filter(name -> name.length() > 3)
    .peek(name -> System.out.println("After filter: " + name))
    .map(String::toUpperCase)
    .peek(name -> System.out.println("After map: " + name))
    .collect(Collectors.toList());

// Breaking down complex pipelines
Stream<String> filtered = names.stream()
    .filter(name -> name.length() > 3);
// Inspect filtered if needed
Stream<String> mapped = filtered.map(String::toUpperCase);
// Inspect mapped if needed
List<String> result = mapped.collect(Collectors.toList());

Performance Considerations

Memory Efficiency

Streams can help reduce memory usage through lazy evaluation:

// Instead of storing intermediate results:
List<String> longNames = new ArrayList<>();
for (String name : names) {
    if (name.length() > 5) {
        longNames.add(name);
    }
}
List<String> upperCaseLongNames = new ArrayList<>();
for (String name : longNames) {
    upperCaseLongNames.add(name.toUpperCase());
}

// Use a stream without intermediate collections:
List<String> result = names.stream()
    .filter(name -> name.length() > 5)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

Short-Circuiting Operations

Some operations can terminate the stream early:

// anyMatch, allMatch, noneMatch
boolean hasLongName = names.stream()
    .anyMatch(name -> name.length() > 10); // Stops at first match

// findFirst, findAny
Optional<String> firstLongName = names.stream()
    .filter(name -> name.length() > 5)
    .findFirst(); // Stops after finding the first element

// limit
List<String> firstThree = names.stream()
    .limit(3)
    .collect(Collectors.toList()); // Processes at most 3 elements

Real-World Examples

Processing JSON Data

// Assuming you have a list of User objects parsed from JSON
List<User> users = jsonParser.parseUsers(jsonString);

// Find active premium users
List<User> activePremiumUsers = users.stream()
    .filter(User::isActive)
    .filter(user -> user.getSubscriptionType() == SubscriptionType.PREMIUM)
    .collect(Collectors.toList());

// Get statistics about user ages
DoubleSummaryStatistics ageStats = users.stream()
    .mapToDouble(User::getAge)
    .summaryStatistics();
System.out.println("Average age: " + ageStats.getAverage());
System.out.println("Max age: " + ageStats.getMax());

File Processing

// Read and process lines from a file
try (Stream<String> lines = Files.lines(Paths.get("data.txt"))) {
    Map<String, Long> wordFrequency = lines
        .flatMap(line -> Arrays.stream(line.split("\\s+")))
        .map(word -> word.replaceAll("[^a-zA-Z]", "").toLowerCase())
        .filter(word -> !word.isEmpty())
        .collect(Collectors.groupingBy(
            Function.identity(),
            Collectors.counting()
        ));

    // Find top 10 most frequent words
    wordFrequency.entrySet().stream()
        .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
        .limit(10)
        .forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue()));
} catch (IOException e) {
    e.printStackTrace();
}

Data Transformation for APIs

// Transform domain objects to DTOs
List<UserDTO> userDTOs = users.stream()
    .map(user -> new UserDTO(
        user.getId(),
        user.getFullName(),
        user.getEmail()
    ))
    .collect(Collectors.toList());

// Create summary reports
Map<Department, DoubleSummaryStatistics> salaryStatsByDept = employees.stream()
    .collect(Collectors.groupingBy(
        Employee::getDepartment,
        Collectors.summarizingDouble(Employee::getSalary)
    ));

Best Practices

Keep streams readable: Break complex operations into meaningful steps
Avoid side effects: Streams work best with pure functions
Be careful with infinite streams: Always use limiting operations
Use parallel streams judiciously: Test performance before committing
Favor method references: They're more readable than lambdas for simple cases
Reuse stream pipeline components: Extract complex predicates and functions
Handle nulls properly: Use Optional or Objects.nonNull

Common Pitfalls

Reusing streams: Streams can only be consumed once

   Stream<String> stream = names.stream();
   long count = stream.count(); // Stream is consumed here
   // This will throw IllegalStateException:
   List<String> list = stream.collect(Collectors.toList());

Excessive intermediate operations: Each operation adds overhead
Improper parallel stream usage: Can be slower than sequential for small datasets
Ignoring checked exceptions: Streams don't handle checked exceptions well
Non-associative operations in parallel streams: Can lead to incorrect results

Conclusion

Mastering Java's Stream API opens up a world of elegant, efficient, and expressive code. Java 17 continues to refine this powerful API, making it even more valuable for modern Java development. I hope this guide helps you take your streaming skills to the next level!

What aspects of Java streams have you found most useful in your projects? Any advanced patterns I missed? Share in the comments below!

Building a Chatbot For Travel Booking Assistant with OpenAI Integration

Jacky — Mon, 21 Oct 2024 14:24:28 +0000

Building a Retrieval-Augmented Generation (RAG) system for a chat application that recommends flights and hotels involves integrating information retrieval (from your database) with natural language processing (NLP) for user interaction. In this context, a RAG system uses retrieval-based methods to fetch relevant information (like flights and hotels) based on a user's query, then generates responses by combining that data with a language model (e.g., OpenAI GPT).

Here’s how to build such a system:

1. Overview of Architecture

The RAG system will have two key parts:

1. Retrieval Component: This fetches relevant flight and hotel data from your database using a query processor. This could involve SQL or a more complex search engine setup (e.g., Elasticsearch for faster querying).
2. Generation Component: After retrieving the relevant data, a language model generates a human-like response using that data to reply to the user in the chat.

2. System Workflow

Here’s the step-by-step process of how the system will work:

1. User Query: The user types a natural language query in the chat, like “I want to fly to Singapore from Hanoi, Vietnam.”
2. NLP Parsing: Use an NLP model to extract key entities from the user query (departure city, destination city, dates).
3. Database Search: Based on the parsed query, run a SQL query or Elasticsearch search to retrieve relevant flight and hotel options.
4. Response Generation: Once you have the flight or hotel data, pass it to the language model (like GPT-3) to generate a conversational response that lists options for the user.
5. User Interaction: The user selects a flight, and based on that choice, you run a new search for hotels. The system retrieves the hotels and generates another response with the best options.
6. Book or Recommend: Once the user chooses a hotel or flight, you can proceed to the booking flow (through the chat interface).

3. Components of the RAG System

3.1 Retrieval Component: Query Matching

Example Use Case: Parsing User Query for Flights

When a user types a message like: "I want to fly to Singapore from Hanoi next week",you want to extract key pieces of information like:

Departure city: Hanoi
Destination city: Singapore
Date or time: next week

3.2. Using OpenAI to Parse Keywords

You can create a prompt that instructs OpenAI to extract the desired information. Here’s an example approach:

Prompt Design for Flight Information Extraction

import openai

# Function to extract key details using OpenAI
def extract_flight_info(user_query):
    prompt = f"""
    The user has provided the following query: "{user_query}"

    Extract the following information from the user's request:
    1. Departure city
    2. Destination city
    3. Travel date or time (if mentioned)

    Provide the results in the following format:
    - Departure City: [Extracted departure city]
    - Destination City: [Extracted destination city]
    - Date/Time: [Extracted date or time]
    If any information is missing, return "Unknown" for that field.
    """

    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "system", "content": prompt}]
    )
    return response['choices'][0]['message']['content']

# Example query
user_query = "I want to fly to Singapore from Hanoi next week"
extracted_info = extract_flight_info(user_query)
print(extracted_info)

Expected Output

When you run the above code with the user query "I want to fly to Singapore from Hanoi next week", the output might look something like this:

- Departure City: Hanoi
- Destination City: Singapore
- Date/Time: next week

This way, OpenAI can help break down natural language input into structured components that your application can then use to perform further actions, like database searches.

3.3. Further Enhancements for Parsing

To handle more complex scenarios (e.g., when the user provides partial information), you can adjust the prompt to better fit various cases:

Handling Flexible Queries

You might need to parse different types of queries, such as:

"Find me a hotel in Singapore this weekend"
"What flights are available from New York to London tomorrow?"

Here’s an example prompt that adapts to both flights and hotels:


def extract_travel_info(user_query):
    prompt = f"""
    The user has provided the following query: "{user_query}"

    Extract the following information from the user's request:
    1. Type of request (flight or hotel)
    2. Departure city (for flights) or city (for hotels)
    3. Destination city (for flights) or "N/A" (for hotels)
    4. Travel date or time (if mentioned)

    Provide the results in the following format:
    - Request Type: [flight or hotel]
    - Departure City: [Extracted departure city]
    - Destination City: [Extracted destination city] or "N/A"
    - Date/Time: [Extracted date or time]
    If any information is missing, return "Unknown" for that field.
    """

    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "system", "content": prompt}]
    )
    return response['choices'][0]['message']['content']

# Example for a hotel request
user_query = "Find me a hotel in Singapore this weekend"
extracted_info = extract_travel_info(user_query)
print(extracted_info)

# Example for a flight request
user_query = "I want to fly from New York to London tomorrow"
extracted_info = extract_travel_info(user_query)
print(extracted_info)

Expected Output for Hotel Request

For the query "Find me a hotel in Singapore this weekend", the output might be:


- Request Type: hotel
- Departure City: N/A
- Destination City: Singapore
- Date/Time: this weekend

Expected Output for Flight Request

For the query "I want to fly from New York to London tomorrow", the output might be:


- Request Type: flight
- Departure City: New York
- Destination City: London
- Date/Time: tomorrow

3.4. Next Steps: Using Extracted Data for Database Query

Once you have the extracted information (like departure and destination cities, dates, and request type), you can pass these into your database query to retrieve relevant flights or hotels.

For example, if the extracted data shows the request is for a flight:

Departure City: New York
Destination City: London
Date: tomorrow

You can construct a SQL or Elasticsearch query to search your flights table for relevant results.


SELECT * FROM flights
WHERE departure_city = 'New York'
AND arrival_city = 'London'
AND departure_date = '2024-10-22';

3.5. Handling Ambiguities and Errors

In some cases, the user's query may be ambiguous or lack sufficient detail. You can modify the prompt to ask follow-up questions or handle missing information:

If the user doesn’t specify a date, the model can prompt: "Could you please provide the date of your travel?"
If the departure or destination city is unclear, it can ask: "Where would you like to fly from?"

This approach ensures a smooth interaction and helps fill in any gaps in the query.

Generation Component: Response Building

After retrieving the relevant data, integrate a language model (like GPT) to generate responses using the retrieved data.

Generate Chat Responses:

You can use OpenAI's GPT model to craft natural-sounding responses by passing the retrieved data (e.g., flight options or hotel recommendations) into the prompt. For example:


prompt = f"""
The user wants to fly from {from_city} to {to_city}. Here are some flight options:

1. {flight1_details}
2. {flight2_details}

Which one would you like to choose? Once selected, we will suggest some hotels in {to_city}.
"""

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "system", "content": prompt}]
)

This will generate a conversational reply using the flight or hotel data you pass in.

4. Additional Features

Personalization: Tailor recommendations based on user history (preferred airlines, hotel types, etc.).
Filter Options: Allow users to filter results (price, ratings, amenities).
Feedback Loop: Collect user feedback to improve search relevance over time.

5. Scaling and Production Considerations

Real-time Processing: Ensure low-latency in retrieving data and generating responses, possibly using a message broker like RabbitMQ.
Caching: Use caching for frequently requested flights and hotels to optimize performance.
Error Handling: Gracefully handle cases where no results match the user's query by suggesting alternatives

By integrating retrieval from your flight and hotel databases with a language model for generation, this RAG system will offer users a seamless, conversational experience for booking travel options directly through a chat interface.

How We Can Self-Study with ChatGPT (P1)

Jacky — Mon, 14 Oct 2024 07:45:00 +0000

You will have more 24 hours day, why not?

As AI becomes increasingly popular with applications like ChatGPT, Claude, and Gemini, many people worry that AI might replace human jobs, potentially leading to unemployment.

However, I disagree.

From my experience using various Large Language Models (LLMs), I’ve found that they can effectively give us “more than 24 hours per day.” I believe AI will become an indispensable part of our lives, enhancing them rather than replacing us.

To be honest, I wrote this article myself, focusing on the main ideas and structure. I used AI as an assistant to review it, check grammar, and offer suggestions to improve sentences. And it’s free, unlike Grammarly! There are several ways I’ve been using ChatGPT and Claude recently to boost my work performance.

In fact, the very first project I built with AI was Helik – Your AI-Powered English Learning Assistant, designed to help learners improve their English, especially for IELTS preparation. More on that later, but now let's explore how AI can be an incredible tool for personal growth.

Improving English, especially for IELTS

I grew up in a developing country where English wasn’t a common part of the education system, even though it plays an essential role in career development. We didn’t spend as much time learning English as we did on science subjects, which left us with weaker language skills. Of course, this has changed for today’s Gen Z, with English becoming a second language in many places.

These days, I work in a multinational corporation with colleagues from various countries, so English is crucial for communication. Even with a busy schedule, I’ve realized the importance of dedicating time to improve my language skills, especially as I’m aiming for IELTS certification. While online English courses are helpful, teachers often can’t provide personalized feedback for every student, especially when it comes to writing and speaking, which require direct guidance.

That’s where ChatGPT comes in as a personalized learning assistant. It helps me review my essays, corrects grammar mistakes, and gives advice tailored to my writing style. This feels like the beginning of a new chapter in my learning journey!

Here are some use cases and prompts I’ve found helpful in my experience:

1. Essay Writing and Review

Use Case: Write IELTS Task 2 essays and get feedback.

I have written an IELTS Task 2 essay. Could you review it and suggest improvements for grammar and coherence?

Example Prompt:

"Here's my essay: [Insert your essay]. Could you provide feedback on grammar, sentence structure, and ideas?"

Benefits: ChatGPT offers detailed suggestions to improve clarity, corrects grammatical errors, and helps expand vocabulary.

2. Practicing Speaking with Role-Playing

Use Case: Simulate IELTS speaking questions to practice fluency and confidence.

ChatGPT, let’s practice an IELTS Speaking Part 2 question. You play the role of the examiner and ask me the question. After I answer, provide a transcript of my response and give me advice on how I can improve

Example Prompt:

"Describe a time when you helped someone. You should say: who you helped, what you did, why you helped them, and how you felt about it.”

My response:

“I once helped my friend move to a new apartment. It was a busy weekend, but I wanted to assist because they had no other help. We spent the day packing and transporting things, and in the end, they were really grateful. It made me feel good to help a friend in need.”

ChatGPT Feedback:
”Your answer is clear and structured, but you can improve fluency by using linking words such as 'firstly,' 'then,' and 'finally.' You could also add more detail about what you packed and how the experience affected your friendship”

Benefits: ChatGPT offers follow-up questions and evaluates your speaking abilities, helping to build confidence before the actual test.

3. Vocabulary Building

Use Case: Expand your vocabulary to improve both speaking and writing skills.

Give me a list of advanced vocabulary related to technology (or any other topic), and explain how to use each word in a sentence.

Example Prompt:

"I want to improve my vocabulary for IELTS Writing. Can you suggest advanced words I can use for the topic of 'environmental protection'?"

Benefits: AI helps you learn new words in context, making it easier to remember and apply them in your writing and speaking.

4. Improving Grammar and Sentence Structure

Use Case: Correct complex sentences for fluency and grammatical accuracy.

Here is a complex sentence I wrote. Can you check its grammar and suggest a more natural way to phrase it?

Example Prompt:

"Here’s my sentence: 'Despite of the fact that I was tired, I went to the gym.' Could you correct it and explain why?"

Benefits: ChatGPT identifies errors in sentence construction and provides easy-to-understand explanations, making you aware of common mistakes.

A Lesson from the Past: The Third Industrial Revolution

As we face the rise of AI today, it's easy to fear being replaced. But this is not the first time humanity has faced such a challenge. During the Third Industrial Revolution in the late 20th century, when machines and computers began automating tasks, people worried they would lose their jobs. Factories filled with automated arms and computers that could process data at incredible speeds, leaving many workers unsure of their future.

But the world didn’t stop. Instead, those who adapted, learned new skills, and embraced the machines found themselves more valuable than ever before. They weren’t replaced—they evolved. Elena, a factory worker, was one such person. Instead of fearing automation, she learned how to operate and manage the machines, making her indispensable in her role.

The lesson is clear: AI, like the machines of the past, won’t replace us. It will transform the way we work and live, offering new opportunities for those who are ready to embrace and learn from it.

So, just like in the past, we must adapt. AI can free us from repetitive tasks, allowing us to focus on creativity, strategy, and innovation. And by using tools like ChatGPT, we can enhance our skills, making ourselves even more valuable in this ever-changing world.

In brief, By using AI tools like ChatGPT and Claude, I’ve found incredible ways to enhance my learning, streamline tasks, and boost productivity. This article marks the beginning of a series on how to use ChatGPT effectively across different areas of life—from learning new skills to improving work performance. Stay tuned for more insights and practical tips in the upcoming posts!

Follow my original article in Medium

Building an Orders Processing Service with ChatGPT (contribute 70–80% efforts) and Finished in 2 Days

Jacky — Wed, 25 Sep 2024 07:38:14 +0000

AI has contributed to changing and increasing efficiency in my daily work

As a developer, building an orders processing service can sometimes feel overwhelming when you have a limited timeframe. However, with the power of AI-driven development tools like ChatGPT, you can significantly speed up the process by generating code, designing entities, and solving problems step by step. In this article, I’ll walk you through how I used ChatGPT to build a fully functional orders processing service in just 2 days, from gathering requirements to completion.

Honestly, there are many small threads and prompts for different small tasks that I can't summarize into a complete project, but overall... it helped me 70 - 80%. Additionally, here is some of the original code, after I reviewed it, it may have been modified by hand, so you may not find this function on github that I shared.

Day 1: Understanding Requirements and Setting Up

Step 1: Gather and Clarify Requirements

The first thing I did was list down the core features required for the service. Here are the primary functionalities I needed:

User Registration: Allow users to register using their mobile number and address.
Franchise Location Search: Enable customers to view and find coffee franchises nearby.
Order Placement: Customers can place an order with multiple items from a menu.
Queue Management: Track a customer’s position in a queue and provide expected wait time.
Order Cancellation: Customers can exit the queue and cancel their order at any time.

Step 2: Generate API Endpoints with ChatGPT

I asked ChatGPT to help me design the API structure for the requirements. Here’s an example of the first prompt I used:

Prompt:

Create API endpoints for a user registration system using Spring Boot, where users can register with their name, mobile number, and address.

Result: ChatGPT generated several endpoints:

POST /users/register: To register a new user.
GET /franchises/nearby: To find nearby coffee franchises based on latitude and longitude.
POST /orders: To place an order with multiple items.
GET /orders/{orderId}/queue-position: To check the user’s position in the queue.
DELETE /orders/{orderId}: To cancel the order and exit the queue.

Step 3: Entity Design

For the order processing service, we needed entities for User, Franchise, Order, Queue, and OrderItem. I used ChatGPT to define these entities with the necessary fields.

Prompt:

Design the User entity for the system. The user can have a mobile number, address, and a role (like CUSTOMER).

Result: ChatGPT provided a simple User entity using JPA:

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

    @Column(nullable = false, unique = true)
    private String username;
    @Column(nullable = false)
    private String password;
    private String mobileNumber;
    private String address;
    private UserRole role; // CUSTOMER, ADMIN
}

I repeated this process for the Franchise, Order, and Queue entities.

Day 2: Implementing Business Logic

Step 4: Order Placement Logic

Once the basic API and entities were set up, I moved on to implementing business logic for order placement. This was the critical part of the service since it needed to handle multiple items from the menu and manage queue positions.

Prompt:

Implement the logic for placing an order with multiple items, where each item is linked to a specific menu in the Franchise.

Result: ChatGPT guided me through designing an OrderService to handle this. Here’s part of the implementation:

public Order createOrder(UUID customerId, UUID franchiseId, List<OrderItemDTO> items) {
    Order order = new Order();
    order.setCustomer(userRepository.findById(customerId).orElseThrow());
    order.setFranchise(franchiseRepository.findById(franchiseId).orElseThrow());

    List<OrderItem> orderItems = items.stream()
        .map(itemDto -> new OrderItem(menuItemRepository.findById(itemDto.getMenuItemId()), itemDto.getQuantity()))
        .collect(Collectors.toList());
    order.setItems(orderItems);
    order.setQueuePosition(findQueuePositionForFranchise(franchiseId));
    return orderRepository.save(order);
}

Step 5: Queue Management

Next, I asked ChatGPT to help me design the logic for placing a customer in the queue and tracking their position.

Prompt:

How can I calculate the queue position and waiting time for an order in a coffee franchise system?

Result: ChatGPT suggested creating a QueueService that tracks orders and assigns them positions based on timestamps. I implemented it as follows:

public int findQueuePositionForFranchise(UUID franchiseId) {
    List<CustomerQueue> queue = customerQueueRepository.findAllByFranchiseId(franchiseId);
    return queue.size() + 1;
}

It also provided guidance on estimating waiting times based on the average order processing time.

Step 6: Order Cancellation

Finally, I implemented the logic for allowing customers to cancel their orders and exit the queue:

public void cancelOrder(UUID orderId) {
    Order order = orderRepository.findById(orderId).orElseThrow();
    queueService.removeFromQueue(order.getQueue().getId(), order.getId());
    orderRepository.delete(order);
}

Finalizing the Project

By the end of Day 2, I had a fully functional service that allowed customers to:

Register using their mobile number and address.
View nearby franchises.
Place orders with multiple items from the menu.
Check their queue position and waiting time.
Cancel their order at any time.

Key Takeaways

Leverage AI for Routine Tasks: ChatGPT sped up repetitive tasks like designing APIs, generating boilerplate code, and implementing common business logic patterns.
Divide and Conquer: By breaking the project into small, manageable tasks (such as user registration, queue management, and order placement), I was able to implement each feature sequentially.
AI-Assisted Learning: While ChatGPT provided a lot of code, I still had to understand the underlying logic and tweak it to fit my project’s needs, which was a great learning experience.
Real-Time Debugging: ChatGPT helped me solve real-time issues by guiding me through errors and exceptions I encountered during implementation, which kept the project on track.

I have a few more steps to create the documentation, use liquidbase and have chatGPT generate sample data for easier testing.

Conclusion

Building an order processing system for a coffee shop in 2 days may sound daunting, but with AI assistance, it’s achievable. ChatGPT acted like a coding assistant, helping me transform abstract requirements into a working system quickly. While AI can provide a foundation, refining and customizing code is still an essential skill. This project taught me how to maximize the value of AI tools without losing control of the development process.

By following the steps I took, you can speed up your own projects and focus on higher-level problem-solving, leaving the routine code generation and guidance to AI.

Full source Github

How to Implement Rate Limiting in Spring Boot APIs Using Aspect-Oriented Programming

Jacky — Mon, 09 Sep 2024 07:02:26 +0000

What I learned doing side projects…

Introduction: Aspect-Oriented Programming (AOP) is a powerful technique in Spring Boot for separating cross-cutting concerns from the main application logic. One common use case of AOP is implementing rate limiting in APIs, where you restrict the number of requests a client can make within a certain period. In this article, we’ll explore how to leverage AOP to implement rate limiting in Spring Boot APIs, ensuring optimal performance and resource utilization.

1. Understanding Aspect-Oriented Programming (AOP)

Aspect-Oriented Programming is a programming paradigm that aims to modularize cross-cutting concerns in software development. Cross-cutting concerns are aspects of a program that affect multiple modules and are difficult to modularize using traditional approaches. Examples include logging, security, and transaction management.

AOP introduces the concept of aspects, which encapsulate cross-cutting concerns. Aspects are modular units that can be applied across different parts of the application without modifying the core logic. AOP frameworks, such as Spring AOP, provide mechanisms for defining aspects and applying them to specific join points in the application’s execution flow.

2. Implementing Rate Limiting with AOP in Spring Boot

Rate limiting is a common requirement in web APIs to prevent abuse and ensure fair usage of resources. With AOP in Spring Boot, we can implement rate limiting by intercepting method invocations and enforcing restrictions on the number of requests allowed within a certain time frame.

To implement rate limiting with AOP in Spring Boot, we typically follow these steps:

Define a custom annotation to mark methods that should be rate-limited.
Create an aspect class that intercepts method invocations annotated with the custom annotation.
Use a rate limiter component to track and enforce rate limits.
Handle rate limit exceeded scenarios gracefully, such as by throwing a custom exception.

3. Example: Rate Limiting in a Spring Boot API

Implementing rate limiting in a Spring Boot API can be achieved using various techniques. One common approach is to use Spring AOP (Aspect-Oriented Programming) to intercept incoming requests and enforce rate limits.

Step 1 - Define Rate Limiting Configuration: Create a configuration class where you define the rate limit parameters such as the number of requests allowed and the time period.

@Configuration
public class RateLimitConfig {
    @Value("${rate.limit.requests}")
    private int requests;

    @Value("${rate.limit.seconds}")
    private int seconds;

    // Getters and setters
}

Step 2 — Create a Rate Limiting Aspect: Implement an aspect using Spring AOP to intercept method calls and enforce rate limits.

@Aspect
@Component
public class RateLimitAspect {
    @Autowired
    private RateLimitConfig rateLimitConfig;

    @Autowired
    private RateLimiter rateLimiter;

    @Around("@annotation(RateLimited)")
    public Object enforceRateLimit(ProceedingJoinPoint joinPoint) throws Throwable {
        String key = getKey(joinPoint);
        if (!rateLimiter.tryAcquire(key, rateLimitConfig.getRequests(), rateLimitConfig.getSeconds())) {
            throw new RateLimitExceededException("Rate limit exceeded");
        }
        return joinPoint.proceed();
    }

    private String getKey(ProceedingJoinPoint joinPoint) {
        // Generate a unique key for the method being called
        // Example: method signature, user ID, IP address, etc.
        // You can customize this based on your requirements
    }
}

Step 3 — Define RateLimited Annotation: Create a custom annotation to mark the methods that should be rate-limited.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
  public @interface RateLimited {
}

Step 4 — Implement Rate Limiter: Create a rate limiter component to manage rate limits using a token bucket algorithm or any other suitable algorithm.

@Component
public class RateLimiter {
    private final Map<String,RateLimitedSemaphore> semaphores = new ConcurrentHashMap<>();

    public boolean tryAcquire(String key, int requests, int seconds) {
        // Get the current timestamp
        long currentTime = System.currentTimeMillis();

        // Calculate the start time of the time window (in milliseconds)
        long startTime = currentTime - seconds * 1000;

        // Remove expired entries from the semaphore map
        cleanupExpiredEntries(startTime);

        // Get or create the semaphore for the given key
        RateLimitedSemaphore semaphore = semaphores.computeIfAbsent(key, k -> {
            RateLimitedSemaphore newSemaphore = new RateLimitedSemaphore(requests);
            newSemaphore.setLastAcquireTime(currentTime); // Set last acquire time
            return newSemaphore;
        });

        // Check if the semaphore allows acquiring a permit
        boolean acquired = semaphore.tryAcquire();
        if (acquired) {
            semaphore.setLastAcquireTime(currentTime); // Update last acquire time
        }
        return acquired;
    }

    private void cleanupExpiredEntries(long startTime) {
        Iterator<Map.Entry<String, RateLimitedSemaphore>> iterator = semaphores.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, RateLimitedSemaphore> entry = iterator.next();
            String key = entry.getKey();
            RateLimitedSemaphore semaphore = entry.getValue();
            if (semaphore.getLastAcquireTime() < startTime) {
                iterator.remove();
            }
        }
    }

    private class RateLimitedSemaphore extends Semaphore {
        private volatile long lastAcquireTime;

        public RateLimitedSemaphore(int permits) {
            super(permits);
        }

        public long getLastAcquireTime() {
            return lastAcquireTime;
        }

        public void setLastAcquireTime(long lastAcquireTime) {
            this.lastAcquireTime = lastAcquireTime;
        }
    }
}

Step 5 — Annotate Controller Methods: Annotate the controller methods that should be rate-limited with @RateLimited.

@RestController
public class MyController {
    @RateLimited
    @GetMapping("/api/resource")
    public ResponseEntity<String> getResource() {
        // Implementation
    }
}

Step 6 — Configure Rate Limit Properties: Configure the rate limit properties in your application.properties or application.yml.

rate.limit.requests=10
rate.limit.seconds=60

Futhermore…

To limit requests by IP address, you can extract the IP address from the incoming request and use it as the key for rate limiting. Here’s how you can modify the getKey method to generate a unique key based on the IP address:

private String getKey(HttpServletRequest request) {
    // Get the IP address of the client making the request
    String ipAddress = request.getRemoteAddr();
    return ipAddress; // Use IP address as the key
}

You will also need to modify the enforceRateLimit method in the RateLimitAspect class to pass the HttpServletRequest object to the getKey method:

@Around("@annotation(RateLimited)")
public Object enforceRateLimit(ProceedingJoinPoint joinPoint) throws Throwable {
    // Get the current request from the JoinPoint
    ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    HttpServletRequest request = requestAttributes.getRequest();

    String key = getKey(request);
    if (!rateLimiter.tryAcquire(key, rateLimitConfig.getRequests(), rateLimitConfig.getSeconds())) {
        throw new RateLimitExceededException("Rate limit exceeded");
    }
    return joinPoint.proceed();
}

In this example, we define a custom annotation @RateLimited to mark methods that should be rate-limited. We then create an aspect RateLimitAspect that intercepts method invocations annotated with @RateLimited. Inside the aspect, we enforce rate limits using a RateLimiter component.

4. Conclusion

In this article, we’ve explored how to implement rate limiting in Spring Boot APIs using Aspect-Oriented Programming (AOP). By separating cross-cutting concerns such as rate limiting from the core application logic, we can ensure better modularity, maintainability, and scalability of our applications. AOP provides a powerful mechanism for addressing such concerns, allowing developers to focus on building robust and efficient APIs.

By following the steps outlined in this article and leveraging AOP capabilities in Spring Boot, developers can easily implement rate limiting and other cross-cutting concerns in their applications, leading to more resilient and high-performing APIs.

Top 5 Design Patterns in Java Spring Boot: Best Practices and Examples

Jacky — Fri, 16 Feb 2024 10:14:49 +0000

As a seasoned Java backend developer immersed in the world of Spring Boot and Spring Framework for a decade, I’ve come to realize the crucial role that design patterns play in building robust and scalable applications. In this article, we’ll delve into five essential design patterns and explore the best practices for applying them effectively in your Spring Boot projects. Each pattern will be accompanied by a practical example to demonstrate its implementation.

Singleton Pattern

The Singleton pattern ensures that a class has only one instance and provides a global point of access to it. This is particularly useful for managing resources such as database connections or caching objects. Here’s how you can implement it in Spring Boot:

public class DatabaseConnection {
    private static DatabaseConnection instance;

    private DatabaseConnection() {
        // Private constructor to prevent instantiation
    }
    public static synchronized DatabaseConnection getInstance() {
        if (instance == null) {
            instance = new DatabaseConnection();
        }
        return instance;
    }
}

Factory Method Pattern

The Factory Method pattern provides an interface for creating objects in a superclass, allowing subclasses to alter the type of objects that will be created. This is useful for decoupling object creation logic from client code. Let’s see an example in Spring Boot:

public interface PaymentProcessor {
    void processPayment();
}

public class CreditCardProcessor implements PaymentProcessor {
    @Override
    public void processPayment() {
        // Process credit card payment logic
    }
}
public class PayPalProcessor implements PaymentProcessor {
    @Override
    public void processPayment() {
        // Process PayPal payment logic
    }
}
public interface PaymentProcessorFactory {
    PaymentProcessor createPaymentProcessor();
}
@Component
public class PaymentProcessorFactoryImpl implements PaymentProcessorFactory {
    @Override
    public PaymentProcessor createPaymentProcessor() {
        // Logic to determine which processor to create (based on configuration, etc.)
        return new CreditCardProcessor();
    }
}

Observer Pattern

The Observer pattern defines a one-to-many dependency between objects, ensuring that when one object changes state, its dependents are notified and updated automatically. This is commonly used in event-driven systems. Let’s implement it in Spring Boot:

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class OrderListener implements ApplicationListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        // Handle order event
    }
}

public class OrderEvent extends ApplicationEvent {
    public OrderEvent(Object source) {
        super(source);
    }
}

@Component
public class OrderService {
    private ApplicationEventPublisher eventPublisher;
    public OrderService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    public void placeOrder() {
        // Logic to place order
        // Publish order event
        eventPublisher.publishEvent(new OrderEvent(this));
    }
}

Decorator Pattern

The Decorator pattern allows behavior to be added to objects dynamically, without affecting the behavior of other objects from the same class. This is useful for adding features such as logging, caching, or encryption to existing classes. Let’s implement it in Spring Boot:

public interface DataService {
    void fetchData();
}

@Component
public class DataServiceImplementation implements DataService {
    @Override
    public void fetchData() {
        // Fetch data implementation
    }
}
@Component
public class LoggingDecorator implements DataService {
    private DataService delegate;
    public LoggingDecorator(DataService delegate) {
        this.delegate = delegate;
    }
    @Override
    public void fetchData() {
        // Logging logic before fetching data
        delegate.fetchData();
        // Logging logic after fetching data
    }
}

Strategy Pattern

The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This is useful when you have multiple algorithms that can be used interchangeably. Let’s implement it in Spring Boot:

public interface CompressionStrategy {
    void compress(String file);
}

@Component
public class ZipCompressionStrategy implements CompressionStrategy {
    @Override
    public void compress(String file) {
        // Zip compression logic
    }
}
@Component
public class RarCompressionStrategy implements CompressionStrategy {
    @Override
    public void compress(String file) {
        // RAR compression logic
    }
}
@Component
public class CompressionContext {
    private CompressionStrategy strategy;
    public CompressionContext(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    public void setStrategy(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    public void compressFile(String file) {
        strategy.compress(file);
    }
}

Conclusion

Design patterns are indispensable tools in the arsenal of any Java backend developer, particularly when working with frameworks like Spring Boot. By mastering these patterns and applying them judiciously in your projects, you can achieve code that is not only more maintainable and scalable but also easier to understand and extend.

Take a sip of coffee… ☕︎ ☕︎ ☕︎

Best Practices for Recording Clear and Distinct Log Results in Java Application

Jacky — Sun, 03 Dec 2023 02:12:12 +0000

Logging plays a crucial role in the development and maintenance of any software application. In a Spring Boot environment, effective logging is essential for debugging, monitoring, and maintaining the health of the application. This article explores best practices for recording log results clearly and distinctly in Spring Boot applications.

1. Use Descriptive Logging Statements:

When logging events or actions, it's important to use descriptive log statements that provide a clear understanding of what is happening. Include relevant information such as method names, parameters, and any significant variable values.

logger.info("Processing order for user {} in method {}", userId, methodName);

2. Log Levels:

Utilize different log levels appropriately to distinguish between various types of messages. Common log levels include INFO for general information, DEBUG for debugging, WARN for potential issues, and ERROR for error messages.

logger.debug("Received request: {}", request);
logger.warn("Failed to process order for user {}", userId);
logger.error("Unexpected error occurred", exception);

3. Structured Logging:

Consider adopting structured logging to make logs more readable and analyzable. This is particularly helpful when dealing with a large volume of logs and using tools like the ELK stack (Elasticsearch, Logstash, Kibana).

logger.info("Order processed: orderId={}, amount={}", orderId, amount);

4. Include Context Information:

Enhance your logs by including relevant context information, such as session IDs, request/response details, and user information. This helps in tracing and understanding the flow of the application.

MDC.put("sessionId", sessionId);
logger.info("User {} logged in", userId);
MDC.clear();

5. Exception Logging:

When logging exceptions, provide detailed information such as stack traces and any additional context that can aid in debugging.

try {
    // code that may throw an exception
} catch (Exception e) {
    logger.error("An error occurred while processing the request", e);
}

6. Log Configuration:

Configure your logging framework (e.g., Logback, Log4j) according to your application's needs. Adjust log levels, log file locations, and patterns to strike a balance between informativeness and performance.

7. Use Parameterized Logging:

Opt for parameterized logging to improve performance and readability. This avoids unnecessary string concatenation and ensures that log statements are concise and efficient.

logger.info("Processing order for user {} in method {}", userId, methodName);

8. Log Formatting:

Maintain a consistent log formatting style across your application. Use a logging library that supports formatting options to enhance readability and make logs easier to analyze.

9. Log Rotation:

Implement log rotation to prevent log files from growing indefinitely. Proper log rotation is crucial for managing disk space and ensuring that logs remain manageable.

10. Audit Logs:

For security-sensitive operations, consider incorporating audit logs to keep track of important activities in your application. This can provide a valuable trail for monitoring and compliance purposes.

In conclusion, adopting best practices for logging in a Spring Boot application is essential for effective troubleshooting, debugging, and maintaining the overall health of the software. By following these guidelines, developers can ensure that log results are clear, distinct, and provide valuable insights into the behavior of the application.

Implementing Multiple Authentication Methods in a Spring Boot 3

Jacky — Wed, 29 Nov 2023 04:22:55 +0000

Authentication is a critical aspect of securing your Spring Boot applications. In some projects, you might encounter the need to support multiple authentication methods for different parts of your application.

In my ongoing Spring Boot side project, I've encountered a fascinating and common challenge related to authenticating APIs using various methods. Specifically, when dealing with internal APIs prefixed with /api/internal, I opt for user authentication via API Key embedded in the header. Conversely, for web application user interfaces, the preferred authentication method is HttpBasic. Managing multiple authentication mechanisms within a single project has proven to be a noteworthy aspect.

In this discussion, I'll provide an illustrative example of how to implement these diverse authentication approaches.

1. Project Setup

Ensure you have the necessary dependencies in your build.gradle (for Gradle) or pom.xml (for Maven) file:

Gradle:

implementation 'org.springframework.boot:spring-boot-starter-security'

Maven:


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

2. Security Configuration

Create a SecurityConfig class to configure Spring Security. You can have multiple SecurityConfigurerAdapter classes for different parts of your application.

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;
import org.springframework.security.authentication.AuthenticationProvider;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.access.channel.ChannelProcessingFilter;
import org.springframework.security.web.util.matcher.AntPathRequestMatcher;

@EnableWebSecurity
@Configuration
public class SpringSecurityConfig {

    @Autowired
    public APIAuthenticationErrEntrypoint apiAuthenticationErrEntrypoint;

    @Value("${internal.api-key}")
    private String internalApiKey;

    @Bean
    @Order(1)
    public SecurityFilterChain filterChainPrivate(HttpSecurity http) throws Exception {
        http
            .securityMatcher("/api/internal/**")
            .addFilterBefore(new InternalApiKeyAuthenticationFilter(internalApiKey), ChannelProcessingFilter.class)
            .exceptionHandling((auth) -> {
                auth.authenticationEntryPoint(apiAuthenticationErrEntrypoint);
            })
            .cors(AbstractHttpConfigurer::disable)
            .csrf(AbstractHttpConfigurer::disable);

        return http.build();
    }

    @Bean
    @Order(2)
    public SecurityFilterChain filterChainWebAppication(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests(authz -> authz
                .requestMatchers("/login").permitAll()
                .requestMatchers("/**").authenticated()
                .anyRequest().authenticated()
        );

        http.formLogin(authz -> authz
                .loginPage("/login").permitAll()
                .loginProcessingUrl("/login")
        );

        http.logout(authz -> authz
                .deleteCookies("JSESSIONID")
                .logoutRequestMatcher(new AntPathRequestMatcher("/logout"))
        );

        http.csrf(AbstractHttpConfigurer::disable);

        return http.build();
    }

    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authenticationProvider = new DaoAuthenticationProvider();
        authenticationProvider.setUserDetailsService(userDetailsService());
        return authenticationProvider;
    }

    @Bean
    public InMemoryUserDetailsManager userDetailsService() {
        UserDetails user = User.withDefaultPasswordEncoder()
                .username("user")
                .password("password")
                .roles("USER")
                .build();
        return new InMemoryUserDetailsManager(user);
    }

}

3. Implement Authentication Filters

Create a custom filter for API Key authentication:

public class InternalApiKeyAuthenticationFilter implements Filter {

    private final String internalApiKey;

    InternalApiKeyAuthenticationFilter(String internalApiKey) {
        this.internalApiKey = internalApiKey;
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;

        String apiKey = httpServletRequest.getHeader("x-api-key");

        if (apiKey == null) {
            unauthorized(httpServletResponse);
            return;
        }

        if (!internalApiKey.equals(apiKey)) {
            unauthorized(httpServletResponse);
            return;
        }

        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {

    }

    private void unauthorized(HttpServletResponse httpServletResponse) throws IOException {
        httpServletResponse.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
        httpServletResponse.setStatus(401);
        Map<String, Object> response = Map.of("message", "SC_UNAUTHORIZED");
        String responseBody = new ObjectMapper().writeValueAsString(response);
        httpServletResponse.getWriter().write(responseBody);

    }

}

Some requests with pattern /api/internal/** will go through InternalApiKeyAuthenticationFilter and get API key from request header and compare with constant key to verify.

4. Usage in Controller

In your controllers, use @PreAuthorize annotation to specify the required roles for different endpoints.

@RestController
@RequestMapping(value = "/api/internal")
public class InternalAPIController {

    @GetMapping(value = "/health")
    public ResponseEntity internalHealthCheck() {
        return ResponseEntity.ok("ok");
    }
}

@Controller
@RequestMapping(value = "/")
public class HomeController {

    @GetMapping
    public String homePage(Model model) {
        return "home";
    }
}

Conclusion

Implementing multiple authentication methods in a Spring Boot project allows you to cater to different parts of your application with specific security requirements. By leveraging Spring Security and custom filters, you can seamlessly integrate API key authentication and HTTP basic authentication within the same project.

Remember to customize the authentication filter to suit your specific use case, and implement validation logic according to your security requirements. This flexible approach to authentication ensures that your application remains secure while accommodating diverse authentication needs.

Full code demo: https://github.com/jackynote/springboot3-multi-authenticate

Implementing Auto-Scaling for Improved Performance: A Backend Engineer's Journey

Jacky — Mon, 27 Nov 2023 04:51:58 +0000

As a backend engineer, my side project involved building a scalable web application hosted on a Virtual Private Server (VPS). The challenge was to ensure that the application could handle varying loads efficiently without manual intervention. To address this, I decided to implement an auto-scaling model using Docker and custom scripts. In this article, I'll walk you through the steps I took to achieve this.

I was at the limit of my cloud knowledge and the project needed to be cost-effective, well... cost-effective

Dockerizing the Application

The first step was to containerize my application using Docker. This allowed me to package the application along with its dependencies, ensuring consistency across different environments. I created a Dockerfile that defined the application's environment, dependencies, and configurations. Additionally, I used Docker Compose to manage multiple services within my application.

version: '3'
services:
  web:
    image: my-web-app:latest
    ports:
      - "8080:80"
    deploy:
      replicas: 3  # Initial number of replicas

Setting Up Auto-Scaling with Docker

Auto-Scaling Script

To achieve auto-scaling, I developed a custom bash script (scale.sh) that periodically monitored the CPU usage of my Docker containers and adjusted the number of replicas based on predefined thresholds.

#!/bin/bash

# Define scaling conditions based on metrics (e.g., CPU usage)
SCALE_UP_THRESHOLD=80
SCALE_DOWN_THRESHOLD=20

# Get current CPU usage
CPU_USAGE=$(docker stats --format "{{.CPUPerc}}" $(docker ps --format "{{.Names}}" | grep "my-web-service") | awk -F. '{print $1}')

# Scale up if CPU usage is above the threshold
if [ "$CPU_USAGE" -gt "$SCALE_UP_THRESHOLD" ]; then
  docker service scale my-web-service=$(($(docker service inspect --format='{{.Spec.Mode.Replicated.Replicas}}' my-web-service) + 1))
  echo "$(date): Scaling up due to high CPU usage: $CPU_USAGE%" >> scaling.log
fi

# Scale down if CPU usage is below the threshold
if [ "$CPU_USAGE" -lt "$SCALE_DOWN_THRESHOLD" ]; then
  docker service scale my-web-service=$(($(docker service inspect --format='{{.Spec.Mode.Replicated.Replicas}}' my-web-service) - 1))
  echo "$(date): Scaling down due to low CPU usage: $CPU_USAGE%" >> scaling.log
fi

Scheduling the Auto-Scaling Script

I utilized cron jobs to schedule the execution of the auto-scaling script at regular intervals. This ensured that the application's performance was consistently monitored and adjusted as needed.

*/5 * * * * /path/to/scale.sh

Monitoring with Prometheus and Grafana

To gain insights into the performance metrics of my application, I set up Prometheus and Grafana. Docker Compose was used to orchestrate these monitoring services.

version: '3'
services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus:/etc/prometheus
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    ports:
      - "3000:3000"
    depends_on:
      - prometheus

Custom Dashboards and Logging

Grafana provided a user-friendly interface to create custom dashboards that visualized key metrics. The auto-scaling activities were logged to a file (scaling.log) for future analysis and auditing.

Testing the Auto-Scaling Script

Ensuring the reliability of the auto-scaling script is crucial for the smooth operation of your application. Here, I'll outline how I approached testing to verify that the script performs as expected.

1. Unit Testing:

Before deploying the script in a live environment, I conducted unit testing to validate its core functionality. This involved creating a test environment with a simulated workload to mimic varying CPU usage scenarios.

Sample Unit Test Script (test_scale.sh):

#!/bin/bash

# Mock CPU usage for testing
mock_cpu_usage() {
  echo "50"  # Adjust as needed for different scenarios
}

# Source the auto-scaling script
source scale.sh

# Set the CPU usage to simulate a scenario
CPU_USAGE=$(mock_cpu_usage)

# Test scaling up
SCALE_UP_THRESHOLD=80
SCALE_DOWN_THRESHOLD=20

echo "Testing scaling up..."
$CPU_USAGE=85
./scale.sh
# Validate that the script scaled up the replicas appropriately

# Test scaling down
echo "Testing scaling down..."
$CPU_USAGE=15
./scale.sh
# Validate that the script scaled down the replicas appropriately

echo "Unit tests completed successfully!"

2. Integration Testing:

Integration testing involved deploying the application and the auto-scaling script in a controlled environment that closely resembled the production setup. This allowed me to observe how the script interacted with the Docker services in a more realistic scenario.

Sample Integration Test Script (integration_test.sh):

#!/bin/bash

# Set up the test environment
# Deploy your application using Docker Compose
docker-compose up -d
docker-compose -f docker-compose-monitoring.yml up -d

# Source the auto-scaling script
source scale.sh

# Monitor the logs to observe scaling activities
tail -f scaling.log &

# Trigger the script manually or wait for the cron job to execute

# Observe the logs and verify that scaling activities are logged correctly

# Clean up the test environment
docker-compose down
docker-compose -f docker-compose-monitoring.yml down

echo "Integration tests completed successfully!"

3. Continuous Integration (CI) Pipeline:

To automate testing in my development workflow, I integrated the script testing into a continuous integration pipeline. This pipeline would execute the unit and integration tests whenever changes were pushed to the version control repository. This ensured that any modifications to the script were thoroughly tested before deployment.

By incorporating these testing practices, I gained confidence in the reliability of the auto-scaling script. Regular testing helped catch potential issues early in the development process, reducing the risk of disruptions in the production environment.

Conclusion

Implementing auto-scaling for my side project on a VPS using Docker, custom scripts, and monitoring tools significantly improved the application's performance. The ability to dynamically scale resources based on real-time metrics allowed me to optimize resource usage and enhance user experience. This experience underscores the importance of automation in maintaining a responsive and efficient backend infrastructure.

As a backend engineer, this project not only expanded my knowledge of containerization and orchestration but also highlighted the value of proactive performance management. The combination of Docker, auto-scaling scripts, and monitoring tools proved to be a robust solution for achieving scalability and ensuring a reliable user experience in a dynamic environment.

In future iterations, I plan to explore more advanced auto-scaling techniques, integrate additional monitoring solutions, and fine-tune the scaling thresholds for optimal performance. The journey continues as I strive to keep pace with the evolving landscape of backend engineering and cloud infrastructure.