Forem: Ky Huynh

Simplify Java and SpringBoot migration with OpenRewrite

Ky Huynh — Sun, 23 Mar 2025 12:28:51 +0000

Challenges of Migration

With older versions like Spring Boot 2.x reaching end-of-life and no longer receiving support, migrating to newer versions is essential for security, compatibility, and performance improvements. However, the migration process comes with several challenges:

1. Breaking Changes: Major version upgrades often introduce breaking changes. For example, Spring Boot 3.x requires Java 17 and migrates from javax.* to jakarta.* packages.

2. Deprecated APIs: Many commonly used APIs and patterns become deprecated and require replacements.

3. Manual Updates: Traditional migration requires manually updating dependencies, refactoring code, and fixing compatibility issues.

4. Time-Consuming: Large codebases may take weeks or months to migrate, increasing project costs and risks.

5. Testing Burden: Every change must be thoroughly tested to ensure functionality remains intact.

So, how can we simplify and accelerate the migration process? This is where OpenRewrite comes in handy.

OpenRewrite

OpenRewrite is an open-source tool for automated code refactoring, helping developers reduce technical debt. It provides prebuilt refactoring recipes for framework migrations, security fixes, and code styling, cutting down effort from hours to minutes.

Plugins for Gradle and Maven make it easy to apply these changes to repositories. Originally focused on Java, the OpenRewrite community is actively expanding support for more languages and frameworks.

Key Features

Automated Refactoring: Automatically updates code syntax, dependencies, and patterns
Recipe-based: Uses declarative recipes to define transformation rules
Style Preservation: Maintains original code formatting and comments
Large-Scale Changes: Can process entire codebases consistently
Extensible: Supports custom recipes for specific migration needs

How does it work?

OpenRewrite modifies Lossless Semantic Trees (LSTs), which represent your source code, and converts them back into source code.
You can review the changes and commit them as needed.
Modifications are made using Visitors, which are grouped into Recipes.
Recipes ensure changes are minimally invasive and maintain the original formatting.

Practice

In this post, I'll demonstrate how to migrate a simple CRUD Spring Boot application built with Java 8, Spring Boot 2.x, and JUnit 4 to Java 21, Spring Boot 3.3, and JUnit 5 using OpenRewrite.

Codebase

1) pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.14</version>
        <relativePath/>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot Migration</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        // dependencies: starter web, data-jpa, etc
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2) UserController.java

@RestController
@RequestMapping("/api/users")
public class UserController {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private UserService userService;

    @RequestMapping(method = RequestMethod.GET)
    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    @RequestMapping(method = RequestMethod.POST)
    public ResponseEntity<?> createUser(@Valid @RequestBody User user) {
        User savedUser = userRepository.save(user);
        return ResponseEntity.ok().build();
    }

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public ResponseEntity<User> getUserById(@PathVariable("id") Long id) {
        User user = userRepository.findById(id).orElse(null);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    @RequestMapping(value = "/username")
    public ResponseEntity<User> getUserByUsername(@RequestParam String username) {
        User user = userService.findByUsername(username);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

}

3) UserService.java

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public User findByUsername(String username) {
        return userRepository.findByUsernameNative(username);
    }
}

4) UserRepository.java

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    @Query(value = "SELECT * FROM users WHERE username = ?1", nativeQuery = true)
    User findByUsernameNative(String username);

}

5) User.java

import javax.persistence.*;
import javax.validation.constraints.NotNull;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @NotNull
    @Column(nullable = false)
    private String username;

    @Column
    private String email;

    // setter, getter
}

6) UserControllerTest.java

@RunWith(SpringRunner.class)
@SpringBootTest
@AutoConfigureMockMvc
public class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Autowired
    private UserRepository userRepository;

    @Before
    public void setup() {
        userRepository.deleteAll();
    }

    @Test
    public void testCreateUser() throws Exception {
        String userJson = "{\"username\":\"testuser\",\"email\":\"test@example.com\"}";

        mockMvc.perform(MockMvcRequestBuilders.post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(userJson))
                .andExpect(MockMvcResultMatchers.status().isOk());
    }

    @Test
    public void testGetUser() throws Exception {
        User user = new User();
        user.setUsername("testuser");
        user.setEmail("test@example.com");
        userRepository.save(user);

        mockMvc.perform(MockMvcRequestBuilders.get("/api/users/" + user.getId()))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.jsonPath("$.username").value("testuser"));
    }
}

Manually migration

Before using OpenRewrite, let's see what happens if we manually migrate to Java 21 and Spring Boot 3.3.

First, update pom.xml

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.3.10</version>
    <relativePath/>
</parent>

<properties>
    <java.version>21</java.version>
</properties>

Next, clean and build the project using Maven:

mvn clean install

There are several compilation errors

Okay, let's revert the changes and migrate using OpenRewrite.

Migration with OpenRewrite

Add OpenRewrite plugin

In pom.xml, add the OpenRewrite Maven plugin. If you're using Gradle, you can add the Gradle plugin.

<build>
    <plugins>
        <plugin>
            <groupId>org.openrewrite.maven</groupId>
            <artifactId>rewrite-maven-plugin</artifactId>
            <version>6.3.2</version>
        </plugin>
    </plugins>
</build>

Choose the Recipe for migration

To discover all the available recipes, you can check the Recipe catalog, which lists all the available recipes, including: Java, Spring Boot, Hibernate, Quarkus, Scala, .NET, Jenkins, etc.

In this showcase, I will use three recipes: Java 8 to 21, Spring 2 to 3, and JUnit 4 to 5.

Let’s add the recipes to the pom.xml; each recipe has its own dependency.

<plugin>
    <groupId>org.openrewrite.maven</groupId>
    <artifactId>rewrite-maven-plugin</artifactId>
    <version>6.3.2</version>
    <configuration>
        <exportDatatables>true</exportDatatables>
        <activeRecipes>
            <recipe>org.openrewrite.java.migrate.UpgradeToJava21</recipe>
            <recipe>org.openrewrite.java.spring.boot2.SpringBoot2JUnit4to5Migration</recipe>
            <recipe>org.openrewrite.java.spring.boot3.UpgradeSpringBoot_3_3</recipe>
        </activeRecipes>
    </configuration>
    <dependencies>
        <dependency>
            <groupId>org.openrewrite.recipe</groupId>
            <artifactId>rewrite-migrate-java</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>org.openrewrite.recipe</groupId>
            <artifactId>rewrite-spring</artifactId>
            <version>6.3.0</version>
        </dependency>
    </dependencies>
</plugin>

Now, run Maven to install the OpenRewrite plugin and its recipes:

mvn clean install

Preview Migration

OpenRewrite provides the dryRun mode, which allows developers to preview the changes before actually applying them by using:

mvn rewrite:dryRun

You can see the changes that will be used for the actual migration.

Apply the migration

Now, let’s do the migration

mvn rewrite:run

Use your IDE or a diff checker tool to review the changes.

1. Update pom.xml: It automatically update the SpringBoot version to 3.3.10 and Java to 21, remove JUnit4.

2. Update Controller:
Migrates from javax.* to jakarta.* packages, changing to use @GetMapping, @PostMapping for dedicated annotations.

3. Update Unit Test:
Replace @Before by @BeforeEach, update package name

Limitations

In this showcase, OpenRewrite successfully migrates to Java 21 and Spring Boot 3.3, but it still has some limitations.
Since OpenRewrite relies on predefined recipes, it supports many common frameworks but not all of them.

For example, if you need to migrate a third-party library like Ehcache2 to Ehcache3 (which is no longer supported in Spring 3.0), OpenRewrite does not provide a built-in recipe. In such cases, you must either write a custom recipe or perform the migration manually.

If you create a custom recipe, consider contributing it to the OpenRewrite community to help others with similar migrations.

Summary

OpenRewrite significantly simplifies the Java and Spring Boot migration process by:

Automating repetitive code changes
Reducing migration time and effort
Minimizing human errors
Standardizing the migration approach

While OpenRewrite doesn't eliminate the need for testing and validation, it reduces the manual effort required for migrations. This allows developers to focus on more complex migration aspects and business logic updates.

Related project: GitHub

References

Energy NFT Marketplace

Ky Huynh — Tue, 07 Jan 2025 15:28:12 +0000

Energy trading is being transformed by blockchain technology. This article delves into building a decentralized Energy NFT Marketplace on Base Sepolia, enabling users to tokenize energy production, trade energy NFTs, and earn loyalty points through an integrated rewards program.

The platform also supports seamless asset bridging between L2s and L1 networks that is powered by Across Protocol, showcasing the potential of blockchain to revolutionize energy markets.

The complete source code and installation guide are available on GitHub.

Architecture Overview

The project includes three-tier architecture:

Frontend Layer: TypeScript, React application with Web3 integration
Backend Layer: Spring Boot, Web3j service with caching and event handling
Blockchain Layer: Smart contracts deployed on EVM-compatible blockchain

The SmartGrid in this architecture is for simulation purpose only.

Key Features

Energy NFT minting and trading
Cross-chain bridge
Real-time blockchain event synchronization
Loyalty program for user engagement
Efficient caching system

Demonstration

Here is the demo video: Youtube

Implementation

Smart Contracts

The blockchain layer consists of three main contracts:

EnergyNFT.sol
EnergyMarketplace.sol
LoyaltyProgram.sol

EnergyNFT.sol

The EnergyNFT smart contract enables tokenization of energy as NFTs, allowing users to mint, trade, and transfer energy securely while maintaining individual energy balances

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract EnergyNFT is ERC721URIStorage, Ownable {
    uint256 private _tokenIds;
    mapping(address => uint256) public userEnergyBalances;
    mapping(uint256 => uint256) public tokenEnergyAmount;
    address public marketplaceAddress;

    event EnergyNFTMinted(uint256 tokenId, address owner, string ipfsHash);
    event EnergyBalanceUpdated(address user, uint256 newBalance);
    event EnergyProduced(address user, uint256 amount);
    event MarketplaceAddressUpdated(address newMarketplace);

    constructor() ERC721("Energy NFT", "ENFT") Ownable(msg.sender) {}

    modifier onlyMarketplace() {
        require(
            msg.sender == marketplaceAddress,
            "Only marketplace can call this function"
        );
        _;
    }

    function setMarketplaceAddress(
        address _marketplaceAddress
    ) external onlyOwner {
        require(
            _marketplaceAddress != address(0),
            "Invalid marketplace address"
        );
        marketplaceAddress = _marketplaceAddress;
        emit MarketplaceAddressUpdated(_marketplaceAddress);
    }

    //Note: this method should be interact with trusted oracle, currently it's just for demo purpose
    function produceEnergy(
        address user,
        uint256 _energyAmount
    ) external onlyOwner {
        userEnergyBalances[user] += _energyAmount;
        emit EnergyProduced(user, _energyAmount);
        emit EnergyBalanceUpdated(user, userEnergyBalances[user]);
    }

    function mint(
        address _from,
        string memory _tokenURI,
        uint256 _energyAmount
    ) external returns (uint) {
        require(_energyAmount > 0, "Energy value should be greater than 0");
        require(
            userEnergyBalances[_from] >= _energyAmount,
            "Insufficient energy balance!!!"
        );

        _tokenIds++;
        _safeMint(_from, _tokenIds);
        _setTokenURI(_tokenIds, _tokenURI);

        tokenEnergyAmount[_tokenIds] = _energyAmount;
        userEnergyBalances[_from] -= _energyAmount;

        emit EnergyNFTMinted(_tokenIds, _from, _tokenURI);
        emit EnergyBalanceUpdated(_from, userEnergyBalances[_from]);

        return (_tokenIds);
    }

    function transferEnergy(
        address _from,
        address _to,
        uint256 _tokenId
    ) external onlyMarketplace {
        require(
            ownerOf(_tokenId) == _to,
            "Energy can only be transferred to NFT owner"
        );

        uint256 energyAmount = tokenEnergyAmount[_tokenId];
        require(energyAmount > 0, "No energy associated with this NFT");

        userEnergyBalances[_to] += energyAmount;
        tokenEnergyAmount[_tokenId] = 0;

        emit EnergyBalanceUpdated(_from, userEnergyBalances[_from]);
        emit EnergyBalanceUpdated(_to, userEnergyBalances[_to]);
    }

    function getCurrentEnergy(address user) public view returns (uint256) {
        return userEnergyBalances[user];
    }
}

EnergyMarketplace.sol

The EnergyMarketplace smart contract facilitates the trading of energy NFTs, managing listings, purchases. It includes a commission system that adjusts based on user loyalty points.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import {EnergyNFT} from "./EnergyNFT.sol";
import {ILoyaltyProgram} from "./ILoyaltyProgram.sol";

contract EnergyMarketplace is ReentrancyGuard, Ownable {
    uint8 public constant DEFAULT_BASE_COMMISSION_RATE = 1;
    uint256 private constant PRECISION = 100;

    EnergyNFT public nftContract;
    ILoyaltyProgram public loyaltyProgram;

    uint256 public itemCount;
    uint8 public baseCommissionRate;

    struct Item {
        uint256 tokenId;
        uint256 price;
        uint256 energyAmount;
        address seller;
        bool isActive;
    }

    mapping(uint256 => Item) public items;

    event NFTMintedAndListed(
        uint256 tokenId,
        address seller,
        string ipfsHash,
        uint256 energyValue,
        uint256 price
    );
    event NFTSold(
        uint256 tokenId,
        address seller,
        address buyer,
        uint256 price,
        uint256 fee
    );
    event ListingUpdated(uint256 tokenId, uint256 newPrice);
    event ListingCancelled(uint256 tokenId);
    event CommissionRateUpdated(uint256 newFeePercentage);
    event Withdrawal(address recipient, uint256 amount);
    event LoyaltyProgramUpdated(address newLoyaltyProgram);

    constructor(
        address _nftContract,
        address _loyaltyProgram
    ) Ownable(msg.sender) {
        nftContract = EnergyNFT(_nftContract);
        loyaltyProgram = ILoyaltyProgram(_loyaltyProgram);
        baseCommissionRate = DEFAULT_BASE_COMMISSION_RATE;
    }

    function setLoyaltyProgram(address _loyaltyProgram) external onlyOwner {
        require(_loyaltyProgram != address(0), "Invalid address");
        loyaltyProgram = ILoyaltyProgram(_loyaltyProgram);
        emit LoyaltyProgramUpdated(_loyaltyProgram);
    }

    function calculateFee(
        uint256 price,
        address seller
    ) public view returns (uint256) {
        uint256 sellerPoints = loyaltyProgram.getLoyaltyPoints(seller);
        uint256 commissionRate = loyaltyProgram.getCommissionRate(
            sellerPoints,
            baseCommissionRate
        );
        return (price * commissionRate) / (100 * PRECISION);
    }

    function buyNFT(uint256 _tokenId) external payable nonReentrant {
        Item storage item = items[_tokenId];
        require(item.isActive, "NFT not for sale");
        require(msg.value >= item.price, "Insufficient payment");

        address seller = item.seller;
        uint256 price = item.price;
        uint256 fee = calculateFee(price, seller);
        uint256 sellerProceeds = price - fee;

        // Mark item as inactive before making transfers
        item.isActive = false;

        nftContract.transferFrom(seller, msg.sender, _tokenId);
        nftContract.transferEnergy(seller, msg.sender, _tokenId);

        // Update loyalty points based on energy amount
        loyaltyProgram.addLoyaltyPoints(seller, uint32(item.energyAmount / 10));

        payable(seller).transfer(sellerProceeds);

        emit NFTSold(_tokenId, seller, msg.sender, price, fee);
    }

    function updateCommissionRate(uint8 _newCommissionRate) external onlyOwner {
        require(
            _newCommissionRate > 0,
            "Commission rate cannot be less than 0"
        );
        baseCommissionRate = _newCommissionRate;
        emit CommissionRateUpdated(_newCommissionRate);
    }

    function mintAndList(
        string memory _tokenURI,
        uint256 _energyAmount,
        uint256 _price
    ) external returns (uint256) {
        uint256 newTokenId = nftContract.mint(
            msg.sender,
            _tokenURI,
            _energyAmount
        );
        items[newTokenId] = Item(
            newTokenId,
            _price,
            _energyAmount,
            msg.sender,
            true
        );
        emit NFTMintedAndListed(
            newTokenId,
            msg.sender,
            _tokenURI,
            _energyAmount,
            _price
        );
        itemCount++;
        return newTokenId;
    }

    function withdrawFees(uint256 _amount) external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance >= _amount, "Insufficient balance");

        (bool success, ) = payable(owner()).call{value: _amount}("");
        require(success, "Failed to withdraw fees");
        emit Withdrawal(owner(), _amount);
    }
}

LoyaltyProgram.sol

The LoyaltyProgram smart contract manages user loyalty points and commission rates. It includes a discount tier system that adjusts based on the number of loyalty points.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/access/Ownable.sol";
import "./ILoyaltyProgram.sol";

contract LoyaltyProgram is ILoyaltyProgram, Ownable {
    // use higher precision (2 decimal places in this case) - fixed-point arithmetic
    uint256 private constant PRECISION = 100;

    struct Discount {
        uint256 points;
        uint8 discountPercentage;
    }

    Discount[] public discountTiers;
    mapping(address => uint256) private userPoints;
    mapping(address => bool) public authorizedCallers;

    event DiscountTierAdded(uint256 points, uint8 discountPercentage);
    event DiscountTierUpdated(
        uint256 index,
        uint256 points,
        uint8 discountPercentage
    );
    event DiscountTierRemoved(uint256 index);
    event LoyaltyPointsAdded(address user, uint256 points);
    event CallerAuthorized(address caller);
    event CallerRevoked(address caller);

    modifier onlyAuthorized() {
        require(
            authorizedCallers[msg.sender] || msg.sender == owner(),
            "Not authorized"
        );
        _;
    }

    constructor() Ownable(msg.sender) {
        discountTiers.push(Discount(1000, 5));
        discountTiers.push(Discount(5000, 8));
        discountTiers.push(Discount(10000, 10));
    }

    function addAuthorizeCaller(address caller) external onlyOwner {
        authorizedCallers[caller] = true;
        emit CallerAuthorized(caller);
    }

    function revokeCaller(address caller) external onlyOwner {
        authorizedCallers[caller] = false;
        emit CallerRevoked(caller);
    }

    function getCommissionRate(
        uint256 loyaltyPoints,
        uint8 baseCommissionRate
    ) external view override returns (uint256) {
        uint256 discountPercentage = 0;

        for (uint256 i = 0; i < discountTiers.length; i++) {
            if (loyaltyPoints >= discountTiers[i].points) {
                discountPercentage = discountTiers[i].discountPercentage;
            } else {
                break;
            }
        }

        return
            (baseCommissionRate * PRECISION * (100 - discountPercentage)) / 100;
    }

    function addLoyaltyPoints(
        address user,
        uint32 points
    ) external override onlyAuthorized {
        userPoints[user] += points;
        emit LoyaltyPointsAdded(user, userPoints[user]);
    }

    function getLoyaltyPoints(
        address user
    ) external view override returns (uint256) {
        return userPoints[user];
    }

    function updateDiscountTier(
        uint256 index,
        uint256 points,
        uint8 discountPercentage
    ) external override onlyOwner {
        require(index < discountTiers.length, "Invalid tier index");
        require(discountPercentage <= 100, "Discount cannot exceed 100%");
        discountTiers[index] = Discount(points, discountPercentage);
        emit DiscountTierUpdated(index, points, discountPercentage);
    }

    function addDiscountTier(
        uint256 points,
        uint8 discountPercentage
    ) external override onlyOwner {
        require(discountPercentage <= 100, "Discount cannot exceed 100%");
        discountTiers.push(Discount(points, discountPercentage));
        emit DiscountTierAdded(points, discountPercentage);
    }

    function removeDiscountTier(uint256 index) external override onlyOwner {
        require(index < discountTiers.length, "Invalid tier index");
        for (uint256 i = index; i < discountTiers.length - 1; i++) {
            discountTiers[i] = discountTiers[i + 1];
        }
        discountTiers.pop();
        emit DiscountTierRemoved(index);
    }
}

Conclusion

This project demonstrates how blockchain can revolutionize energy trading by enabling secure tokenization, decentralized trading, and rewarding user participation. With features like dynamic commissions, loyalty rewards, and seamless energy transfers, it paves the way for scalable and transparent energy marketplaces, showcasing the power of blockchain in real-world applications.

Enjoying the project? Don’t forget to star it ⭐!

Stateless Password Generator: Secure and Hassle-Free Password Management

Ky Huynh — Mon, 09 Dec 2024 14:37:51 +0000

Managing multiple passwords across various platforms can be daunting. The Stateless Password Generator simplifies this process using a secure, stateless Master Password algorithm. This tool eliminates the need to store passwords while ensuring robust security. It’s available for installation on the Chrome Web Store, operating entirely offline for maximum privacy.

E.g: Generate passwords for Facebook

Key Features

Stateless Operation: No data is stored, and passwords are generated dynamically using your master password.
Customizable Preferences: Adjust password settings, including length and character requirements (uppercase, lowercase, numbers, special characters).
Offline Functionality: No external connections are needed, enhancing security.
Single Master Password: Memorize one master password for all accounts, simplifying password management.

How It Works

The Stateless Password Generator employs a cryptographic hash function to generate unique passwords for each website. The algorithm ensures the generated passwords adhere to the user-defined constraints, such as required character types and maximum length.

Core Algorithm

Here’s a breakdown of the password generation process:

User Input:

Domain name
Username
Master password
Additional preferences (e.g., password length, required character types)

Hashing: The inputs are combined into a single string and hashed using the SHA-256 algorithm. This ensures a unique and deterministic hash value for each set of inputs.
Password Construction:

Required character rules are extracted from the user’s preferences.
The hashed output is mapped to characters from defined sets (e.g., uppercase, lowercase, numbers, special characters).
The resulting password satisfies all constraints and is truncated to the specified length.

Code Highlights

Below are key functions that power the Stateless Password Generator:

Define Character Sets

const upperChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
const lowerChars = 'abcdefghijklmnopqrstuvwxyz';
const numberChars = '0123456789';
const specialChars = '!@#$%^&*()';
const CHARACTER_SETS = {
    uppercase: upperChars,
    lowercase: lowerChars,
    number: numberChars,
    special: specialChars,
};

Hashing Logic

async function hashPassword(userData) {
    const combinedString = userData.domain + userData.username + userData.masterPassword + userData.pwVersion;
    const encoder = new TextEncoder();
    const passwordHash = await crypto.subtle.digest('SHA-256', encoder.encode(combinedString));
    const passwordHashArray = Array.from(new Uint8Array(passwordHash));

    const allRequiredChars = getRequireChars(getRequireRules(
        userData.isRequiredUpperCase,
        userData.isRequiredLowerCase,
        userData.isRequiredNumber,
        userData.isRequiredSpecial
    ));

    let password = "";
    for (let i = 0; i < userData.maxLength; i++) {
        let byte = passwordHashArray[i % passwordHashArray.length];
        password += allRequiredChars[byte % allRequiredChars.length];
    }
    return password;
}

Character Rule Mapping

function getRequireRules(isRequiredUpperCase, isRequiredLowerCase, isRequiredNumber, isRequiredSpecial) {
    let rules = [];
    if (isRequiredUpperCase) rules.push('uppercase');
    if (isRequiredLowerCase) rules.push('lowercase');
    if (isRequiredNumber) rules.push('number');
    if (isRequiredSpecial) rules.push('special');
    return rules;
}

Benefits

Enhanced Security: Passwords are generated locally and never transmitted or stored.
Convenience: Only remember your master password to access all generated passwords.
Customizable: Tailor password generation to meet stringent security requirements.

Conclusion

The Stateless Password Generator is a powerful tool for managing passwords securely and efficiently. By leveraging cryptographic hashing and stateless algorithms, it offers robust protection without compromising usability. Install it from the Chrome Web Store!

Please checkout the GitHub for more details.

Enjoying the project? Don’t forget to star it ⭐!

From Headlines to YouTube: Crafting an AI-Powered News Video Generator

Ky Huynh — Mon, 28 Oct 2024 12:03:08 +0000

As content creation becomes more dynamic and competitive, automation tools powered by artificial intelligence (AI) are transforming the way creators, publishers, and news agencies generate media. In this tutorial, we’ll walk through how to build an AI-driven news video generator using SwarmZero AI and Livepeer AI.

This system automates the process of fetching news, narrating it, generating visuals, and uploading engaging video summaries to YouTube. With a seamless pipeline that incorporates news aggregation, audio narration, image generation, and video editing, this project provides a versatile tool for creators looking to produce informative content with minimal manual effort.

Overview of Our AI-Powered Workflow

The system we’re building is designed to simplify news video creation by integrating AI agents into a cohesive workflow. Below is a breakdown of each component in our pipeline:

1. News Aggregator Agent

Fetches the latest news from external APIs, such as TheNewsAPI, based on specified categories (e.g., business, technology, sports).

2. Audio Narration Agent

Converts the news descriptions into speech, adding an engaging human-like voice to each segment.

3. Script Writer Agent

Write a short visual script based on the summarization from the top news stories.

4. Scene Prompt Generator & Image Generator

Creates prompts for generating relevant visuals, then generates these images, providing a dynamic visual representation of the news story.

5. Image-to-Video Generator

Combines images and narration into short video segments using Livepeer AI.

6. Video Editor Agent

Merges multiple video segments into a complete, polished video, suitable for uploading.

7. YouTube Upload Agent

Automates the upload of the generated video to YouTube, completing the content creation process.

The system also incorporates SwarmZero AI, which allows users to choose their preferred large language model (LLM) from OpenAI (like GPT-4), Anthropic, or other open-source models by simply defining the model name in the configuration.

Prerequisites

To get started, ensure you have the following:

Python 3.11
API Keys for OpenAI or your chosen LLM provider
Livepeer API Key
Google API Client for YouTube
TheNewsAPI Key

Setting Up the Google API Client

Go to the Google API Console and create a new project.
Enable the YouTube Data API v3.
Set up OAuth 2.0 credentials:
- Configure the consent screen.
- Add valid redirect URIs (http://localhost:8088/ and http://localhost:8088/flowName=GeneralOAuthFlow).
Download the client_secret.json file and place it in the project’s root directory for secure OAuth authentication.

Project Setup

Step 1: Clone the Repository

Begin by cloning the project repository and navigating to the project directory:

git clone https://github.com/hgky95/video-news-ai.git
cd video-news-ai

Step 2: Define Environment Variables

Define the backend environment variables in .env:

MODEL=gpt-4-turbo-preview
OPENAI_API_KEY=
MISTRAL_API_KEY=
ANTHROPIC_API_KEY=
ENVIRONMENT=dev
SWARMZERO_LOG_LEVEL=INFO
SWARMZERO_DATABASE_URL=
PINECONE_API_KEY=
LIVEPEER_API_KEY=
NEWS_API_KEY=

Next, set up the frontend environment in ui/.env:

NEXT_PUBLIC_BACKEND_API=http://127.0.0.1:8000/chat/

Step 3: Run app

Docker simplifies setup and ensures all dependencies are in place. Run the following command to start the application:
docker-compose up

The application will be available at http://localhost:3000

Using the Application

The interface is simple and intuitive. Here’s how to get started:

1. Input a Prompt

You can start with something like, Create a short video from the two latest news
Optionally, specify categories like business, tech, or sports

2. Generate the Video

Click on the Generate button and wait a few minutes while the system processes the request

3. Check your Youtube Channel

Once complete, the video is automatically uploaded to your YouTube channel, where you can view and share it.

With just a few clicks, you’ve created a fully automated news video that’s ready to engage your audience!

Future Work

Implement a cron job for scheduled video publishing.
Expand distribution to TikTok and Twitter.
Add advanced editing features and human-like TTS.
Optimize the prompt to ensure the tool runs with stability.

Please checkout the GitHub for more details.
Enjoying the project? Don’t forget to star it ⭐!

Role Management In Solidity

Ky Huynh — Mon, 14 Oct 2024 19:47:37 +0000

In Solidity, managing permissions across multiple smart contracts can be challenging, especially when multiple contracts need to share role-based access control (RBAC). A common misconception when working with role management is misunderstanding how permissions are applied across different contracts and how the msg.sender behaves when calls are made through other contracts.

In this post, I’ll share a problem I encountered when trying to assign roles across two contracts (MilestoneManager and ProposalManager), and how I solved it using role delegation with an AdminManager contract.

The Problem: Misunderstanding Role Assignment Across Contracts

Initially, I had two contracts MilestoneManager.sol and ProposalManager.sol both inheriting from a parent contract RoleManager.sol that used Solidity’s AccessControl mechanism. The RoleManager contract defined roles such as STUDENT_ROLE and DEFAULT_ADMIN_ROLE. Both child contracts had methods to add students and committee members via their own versions of the addStudent and addCommittee functions.

contract RoleManager is AccessControl {
    bytes32 public constant STUDENT_ROLE = keccak256("STUDENT_ROLE");
    bytes32 public constant COMMITTEE_ROLE = keccak256("COMMITTEE_ROLE");

    constructor(address initialAdmin) {
        _grantRole(DEFAULT_ADMIN_ROLE, initialAdmin);
    }

    function addStudent(address student) public onlyRole(DEFAULT_ADMIN_ROLE) {
        _grantRole(STUDENT_ROLE, student);
    }

    function addCommittee(address member) public onlyRole(DEFAULT_ADMIN_ROLE) {
        _grantRole(COMMITTEE_ROLE, member);
    }
}

contract MilestoneManager is RoleManager {
    // Milestone-specific logic
}

contract ProposalManager is RoleManager {
    // Proposal-specific logic
}

I initially assumed that calling addStudent in ProposalManager would automatically assign the STUDENT_ROLE in both ProposalManager and MilestoneManager. I believed that because both contracts inherited from RoleManager, the student role would be applied across both.

However, this was incorrect for two reasons:

Role Assignments Are Contract-Specific: In Solidity’s AccessControl, roles are specific to the contract where they are granted. So, assigning a role in ProposalManager does not automatically assign that role in MilestoneManager, even though they share the same RoleManager base contract.
Sender Context (msg.sender): When I called the addStudent method on ProposalManager to assign a role in MilestoneManager, I overlooked the fact that msg.sender in MilestoneManager would be ProposalManager (the contract making the call), not the account that initiated the transaction. Since ProposalManager did not have admin permissions in MilestoneManager, the call failed.

The Solution: Role Delegation Using AdminManager

To resolve this issue, I needed a way to assign roles in both ProposalManager and MilestoneManager with a single call. The solution was to create a separate AdminManager contract that could manage roles across both contracts. By delegating the role management to AdminManager, I ensured that roles could be granted in both contracts simultaneously without running into msg.sender permission issues.

AdminManager Contract

The AdminManager contract is responsible for handling role assignments for both ProposalManager and MilestoneManager. This contract holds the DEFAULT_ADMIN_ROLE for both contracts and can manage student and committee roles as needed.

Here’s the implementation of the AdminManager contract:

contract AdminManager is AccessControl {
    MilestoneManager public milestoneManager;
    ProposalManager public proposalManager;

    constructor(
        address initialAdmin,
        address _milestoneManager,
        address _proposalManager
    ) {
        _grantRole(DEFAULT_ADMIN_ROLE, initialAdmin);
        milestoneManager = MilestoneManager(_milestoneManager);
        proposalManager = ProposalManager(_proposalManager);
    }

    function addStudent(address student) public onlyRole(DEFAULT_ADMIN_ROLE) {
        milestoneManager.addStudent(student);
        proposalManager.addStudent(student);
    }

    function addCommittee(
        address committee
    ) public onlyRole(DEFAULT_ADMIN_ROLE) {
        milestoneManager.addCommittee(committee);
        proposalManager.addCommittee(committee);
    }
}

Granting Permissions

To enable AdminManager to manage roles in both contracts, I needed to grant the DEFAULT_ADMIN_ROLE to the AdminManager contract in both MilestoneManager and ProposalManager.

// Deployer grants admin role to AdminManager in both contracts
milestoneManager.grantRole(DEFAULT_ADMIN_ROLE, address(adminManager));
proposalManager.grantRole(DEFAULT_ADMIN_ROLE, address(adminManager));

The Result

Now, when I call addStudentToBoth from AdminManager, the student role is applied in both MilestoneManager and ProposalManager simultaneously. This avoids the issue of contract-specific roles and bypasses the msg.sender issue by centralizing role assignment logic in a single contract.

Created a dApp storing data on Pinata - IPFS

Ky Huynh — Wed, 09 Oct 2024 23:57:19 +0000

What I Built

MilestoneMaker revolutionizes personalized learning by seamlessly integrating blockchain technology with AI-driven educational pathways. Our vision is to create a decentralized platform where learners can set their own goals, track their progress, and earn verifiable achievements, all while being guided by an intelligent AI agent.

At the heart of our platform lies IPFS, powered by Pinata, which serves as a crucial cornerstone for efficient, decentralized storage. This innovative approach not only reduces blockchain transaction costs but also enhances the overall user experience by leveraging Pinata's robust CDN and image optimization capabilities.

Demo

You can check this clip Youtube

AI-generated content is stored on IPFS
NFT metadata is stored on IPFS 3. The certificate (NFT) is stored on IPFS

My Code

Please check my GitHub repository:
Milestone-Maker

Architecture and Technologies

In this streamlined architecture, IPFS plays a crucial role in our decentralized learning platform:

Figure 1. High level architecture of Milestone Maker

dApp: Interacts with the backend, blockchain, and IPFS.
Backend Server: Manages AI agent and smart contract interactions.
Blockchain: Stores user learning progress via smart contracts.
IPFS: Serves as the decentralized storage layer for user learning content.

Tech stack:

IPFS Storage: Pinata's API
Frontend: Next.js with React and TypeScript, Tailwind CSS
Backend: Python
Smart Contract: Solidity
Blockchain Interaction: Web3.js
AI Integration: Hive-Agent Kit
Development Environment: Foundry

More Details

Our vision is to create a decentralized platform where learners can set their own goals, track their progress, and earn verifiable achievements, all while being guided by an intelligent AI agent. IPFS plays a pivotal role in this ecosystem by:

Optimizing Content Delivery: Utilizing Pinata's CDN ensures lightning-fast access to learning materials, regardless of a user's geographical location.
Enhancing Media Quality: Pinata's image optimization feature allows us to deliver high-quality visual content without compromising load times, crucial for an engaging learning experience.
Ensuring Data Integrity: IPFS's content-addressed storage guarantees that learning materials and NFT data remain tamper-proof and easily verifiable.
Facilitating Diverse File Support: Our platform leverages IPFS to store and manage a wide array of file types, including images, and documents, catering to various learning styles and content formats.
Improving Scalability: By offloading large data sets to IPFS, we significantly reduce on-chain storage requirements, making our platform more scalable and cost-effective.

This innovative use of IPFS through Pinata not only aligns with our goal of creating a decentralized and efficient learning ecosystem but also enhances the overall accessibility and usability of MilestoneMaker, setting a new standard in AI-driven educational platforms

I Created an AI to Personalize Your Learning—And It’s All on the Blockchain

Ky Huynh — Tue, 27 Aug 2024 16:22:27 +0000

Vision

MilestoneMaker aims to revolutionize personalized learning by combining blockchain technology with AI-driven educational pathways. Our vision is to create a decentralized platform where learners can set their own goals, track their progress, and earn verifiable achievements, all while being guided by an intelligent AI agent.

Introduction

In this post, we will create an innovative learning platform (called MilestoneMaker) that blends the power of blockchain technology with artificial intelligence to offer customized educational experiences. We've crafted an AI agent that autonomously creates personalized learning paths tailored to each user's input. These learning paths are securely recorded on the blockchain, ensuring transparent and immutable tracking of every learner's progress.

One of the standout features is the AI agent's ability to autonomously manage all interactions with smart contracts.By automating complex blockchain processes, the AI agent significantly reduces the entry barriers for users who are new to decentralized applications (dApps). This user-centric approach makes the platform accessible and fosters the mass adoption of Web3 technologies, opening up a world of possibilities for a broader audience.

Key Features

Personalized Learning Paths: The AI agent generates learning paths tailored to each user's needs and goals, while also managing interactions with smart contracts to ensure secure and efficient progress tracking.
Blockchain-Based Progress Tracking: All learning milestones are tracked on the blockchain, providing a transparent and immutable record of each learner's achievements.
NFT Minting for Achievements: Upon completing learning milestones, users can mint NFTs that serve as tangible proof of their skills and accomplishments.
Interactive User Interface: Learners can input their goals, monitor their progress, and manage their educational journey through an intuitive and interactive interface. The integration of the Hive-Agent Kit enables the AI to comprehend complex learning requirements and decompose them into actionable milestones, creating a powerful synergy between human intent and machine intelligence in education.

Workflow

Firstly, the user connects to the application with their wallet (e.g., MetaMask). They can then type any topics they want to learn, such as 'I want to learn basic HTML' or 'I want to learn advanced Python in ten days,' etc. Based on this prompt, the AI Agent generates a learning path suitable for the user's requirements. The content is stored on IPFS, and the CID (hash value from IPFS) is stored on the blockchain by AI Agent.

Now, users can learn from the AI-generated content. This content provides the tasks they need to complete and includes references that users can access at any time. When users check the checkbox, their progress is updated on the blockchain by AI Agent. Once all tasks are completed, they need to pass a short quiz to verify their understanding.

If users correctly answer 80% of the quizzes, they will pass it and be able to mint an NFT as an achievement. Once the NFT is successfully minted, they can view it in the achievement tab.

High Level Architecture

In this architecture, we have four main components:

dApp: A decentralized application that interacts with the backend server, smart contracts on the blockchain, and also stores data on IPFS.
Backend Server: Responsible for managing the AI agent and interacting with the smart contract. We use the SwarmZero Kit to integrate the AI agent with OpenAI, but it is not limited to this; you can use other LLMs such as LLaMA 3, Phi 3, etc.
Blockchain: The smart contract runs on the blockchain to store the status of the user's learning progress.
IPFS: Used for storing user learning content.

Set Up and Implementation

Please checkout the GitHub for more details.
Enjoying the project? Don’t forget to star it ⭐!

Enhancing Web Accessibility with Multi-Agent LLM for Visually Impaired Users

Ky Huynh — Fri, 02 Aug 2024 11:40:53 +0000

1. Introduction

The digital world is increasingly reliant on visual content, presenting a significant barrier for visually impaired users. SmartCaption AI (our tool's name) addresses this challenge by leveraging advanced Large Language Models (LLMs) and Multi-Agent framework to generate contextually relevant and accurate image captions. This innovative tool not only describes images but integrates them meaningfully into the web content, enhancing the browsing experience for visually impaired users.

2. The Challenge

Visually impaired users often struggle to access and interpret visual content on websites. Existing solutions typically describe images without context, leading to misunderstandings and inaccuracies. For instance, an image below depicts a person standing on a wooden staircase surrounded by dense greenery, pointing towards the rocky shoreline of an oceanfront property in West Vancouver. This image was incorrectly captioned by using an AI tool "a man standing on a ledge near a river" due to a lack of contextual understanding. Additionally, this caption does not provide any insight for the reader regarding why it would be used in the news.

Image source: https://www.cbc.ca/news/canada/british-columbia/west-vancouver-public-beach-access-1.7279886

3. The Solution

SmartCaption AI overcomes these limitations by first summarizing the article content to provide context for image analysis. This ensures that the generated captions are not only accurate but also contextually relevant. Implemented as a Chrome extension, the tool seamlessly integrates into the user's browsing experience, generating real-time image captions and enabling text-to-speech functionality.

4. Workflow

The picture above describes a workflow of the tool that includes:

User interaction:

Opens a news article (Step 1).
Clicks the Chrome extension icon (Step 2).
Once the user activates the extension, it conducts two tasks simultaneously:
- The application simplifies the article content using the Readability.js library such as advertisement poster and other unnecessary information (Step 2a).
- Sends the image URLs and the article URL to the server (Step 2b).
Disables the ‘Speak’ button (Step 3).

To enhance LLM capabilities:

Uses multi-agents, allowing LLM Agents to work together for better results.
The User Proxy Agent controls the backend workflow.
Upon receiving the information (Step 5), engages the Web Surfer Agent to summarize the article content (Step 6).
Sends this summary and the image URLs to the Image Agent through the User Proxy Agent, which generates image captions based on the summary (Step 7).

Once captions are generated:

The backend server responds to the User Interface (UI) (Step 8).
The UI appends a customized prefix and suffix to indicate AI generation and also displays them under the images and in the alternative text of the image (Step 4).
Enables the ‘Speak’ button to activate the Text-To-Speech (TTS) functionality (Step 9).
The ‘Speak’ button is initially disabled to ensure all images are captioned before TTS activation.

5. Implementation

The tech stack of this project including:

Frontend: HTML, CSS, Javascript
Backend: Python, Flask framework, Pyautogen
LLM Model: OpenAI 'gpt-4o'

For more details, visit the SmartCaption AI GitHub repository

6. Demonstration and Result

Here is the demonstration how the tool work:

In the demonstration, you could see the tool describe the image as:
"The image shows a person standing on a wooden staircase surrounded by dense greenery, pointing towards the rocky shoreline of an oceanfront property in West Vancouver. This staircase is part of a century-old public access path to Altamont Beach, which has recently been sold to a private buyer, sparking local outrage. The individual in the image appears to be discussing or reflecting on the significance of this now-restricted path, symbolizing the community's loss of access to a cherished public space."

The tool accurately describes the image and also provides relevant information related to the article for the reader, reflecting on the significance of this now-restricted path and symbolizing the community's loss of access to a cherished public space.

Enjoying the project? Don’t forget to star it ⭐!

7. Potential For Improvement

Optimizing processing times for initial loads.
Optimizing cost by switching to open source LLM such as LLaMA3, Phi3, and Llava.
Handling a wider range of web content types.

8. Acknowledgement

This project is an implementation of a research paper in which I work with Dr. Randy Lin (Algoma University) to leverage LLMs to generate accurate and relevant image captions. In addition, this paper has been accepted by the IEEE/ICCA'24 conference (Sixth Edition, BUE) and will be held from December 17 to 19, 2024, at The British University in Egypt.

How to handle multiple cache configurations in Spring?

Ky Huynh — Wed, 01 Nov 2023 04:23:26 +0000

Context

Despite not being tied to any particular cache implementation, Spring Framework offers an abstraction for typical caching cases.. However, defining specific configurations such as maximum size, expiration time (TTL), etc is not a part of this abstraction.

Let’s see the example below:

1) CacheConfiguration.java

@Configuration
@EnableCaching
public class CacheConfiguration {
}

2) ServiceA.java

class ServiceA {

    @Cacheable("stateCache")
    public State findState() {
       //do something
    }

    @Cacheable("jwksCache")
    public JWKS findJWKS() {
        //do something
    }

}

3) application.properties

spring.cache.type=CAFFEINE
spring.cache.cache-names=stateCache, jwksCache
spring.cache.caffeine.spec=maximumSize=5000,expireAfterWrite=10m

In this example, we’re using the Caffeine library to cache for two different types: state and jwks. The maximum size is 5000 items and each item will be expired after 10 minutes.

Requirement: If we want to custom the expiration time for the JWKS cache up to 60 minutes but keep the State cache still in 10 minutes. Obviously, we can’t update the application.properties because it will affect the State cache as well.

How could we deal with this case?

Solution

Customize the CacheConfiguration.java

With this step, we're creating two different CaffeinieCache objects with their own configuration such as maximum size, TTL

@Configuration
@EnableCaching
@AllArgsConstructor
public class CacheConfiguration {

    CacheProperties cacheProperties;

    @Bean
    public CacheManager cacheManager() {
        //Create the CaffeineCache for State cache with specific configuration
        CaffeineCache stateCache = buildCache(cacheProperties.getStateCacheName(),
                cacheProperties.getStateCacheTTL(), cacheProperties.getStateMaximumSize());
        //Create the CaffeineCache for JWKS cache with specific configuration
        CaffeineCache jwksTokenVerifyCache = buildCache(cacheProperties.getJwksTokenVerifyCacheName(),
                cacheProperties.getJwksTokenVerifyCacheTTL(), cacheProperties.getJwksMaximumSize());
        //Add two caches into the cache manager
        SimpleCacheManager manager = new SimpleCacheManager();
        manager.setCaches(Arrays.asList(stateCache, jwksTokenVerifyCache));
        return manager;
    }

    private CaffeineCache buildCache(String name, int minutesToExpire, int maximumSize) {
        return new CaffeineCache(name, Caffeine.newBuilder()
                .expireAfterWrite(minutesToExpire, TimeUnit.MINUTES)
                .maximumSize(maximumSize)
                .build());
    }

}

2) Define CacheProperties.java

@Configuration
@ConfigurationProperties(prefix = "cache")
public class CacheProperties {

    private String stateCacheName;

    private int stateMaximumSize;

    private int stateCacheTTL;

    private String jwksTokenVerifyCacheName;

    private int jwksMaximumSize;

    private int jwksTokenVerifyCacheTTL;

}

3) Define configuration for each type of cache in application.properties

Now, we switch to using the customized cache configuration with the prefix “cache”. Therefore, we safely delete the spring.cache.cache-names and spring.cache.caffeine.spec which is no longer used.

spring.cache.type=CAFFEINE

#spring.cache.cache-names=stateCache, tokenVerifyES256PublicKey
#spring.cache.caffeine.spec=maximumSize=5000,expireAfterWrite=10m

cache.stateMaximumSize=5000
cache.stateCacheName=stateCache
cache.stateCacheTTL=10
cache.jwksTokenVerifyCacheName=jwksTokenVerifyCache
cache.jwksMaximumSize=100
cache.jwksTokenVerifyCacheTTL=60

Summary

Although we can't customize the cache configuration on the abstraction layer. However, it's possible to create multiple cache objects that hold their own configuration and then add them back to the cache manager to catch the goal.

Enjoy coding and hope it helps.

How to encode and decode file to base64 offline

Ky Huynh — Tue, 18 Jul 2023 11:04:30 +0000

Although there are a number of websites that allow to convert file to base64 and vice versa. However, it could leads to data leak issue if these data from your working project.

Therefore, I would like to introduce a tip to convert file to base64 (and vice versa) offline.

1) Encode file (ex: pdf) to base64:

base64 -w 0 test1.pdf

2) Encode a file to base64 and write it to file:

base64 -w 0 test1.pdf > test1.txt

3) Decode base64 to file:

base64 -d test1.txt > test1.pdf

Tool need to use:

Linux: use the default cmd
Window: use the git bash which I believe all the developers already installed

My first journey on the Open source world

Ky Huynh — Mon, 02 Nov 2020 09:46:49 +0000

About me

Hi, guys! 👋
I am Ky Huynh.

Currently, I'm a Java developer and also a newcomer in the open-source community.

Chance 🚀

I encountered Hacktoberfest via my teammate. He encouraged me to join this event, he promised that I will get a ton of funs and also gain knowledge. Obviously, my eagerness growing rapidly. OK, Let's make a start !!!!

Contributions 🐇

Firstly, I'm a newcomer so I decided that I will take on some challenges which for the newbie. I research with the query:

"label:hacktoberfest is:issue is:open label:"good first issue""

to filter out it. If you also a newbie like me, for the 1st - 2nd issues, you can take an easy one but then you can challenge yourself without "good first issue".

Besides, I set the goal that I want to get more experience on this journey so I conducted to work on 4 different repositories. I finished three first PRs at the early of this month but the fourth PR is finished by the end of the month. In case you wish to get a T-shirt, you should have 4 pull requests in the middle of the month because the event will take 15 days to validate your PRs. Please note that!

Reflections ✨

It was an amazing event for us who are programmers. It is a playground where brings substantial benefits. I am elation after I completely finished the challenge for this year not about the award but also the mindset for contributing to open source. Certainly, I will join in next year.
Last but not least, thank you who created the Hacktoberfest event for us.
See you soon.