DEV Community: ansurfen

Hulo Programming Language: Module System Delayed, but Batch/PowerShell Integration & Initial Interpreter Release

ansurfen — Sat, 26 Jul 2025 06:03:27 +0000

It's time for the weekly Hulo update!

This v0.3.0 update has evolved Hulo from a "simple transpiler" into a "modern programming language with compile-time evaluation capabilities."

Sounds cool, right? Let me tell you what's actually been updated this time.

🚀 Major Updates This Week

1. Full Platform Transpiler Officially Complete!

Yes, you read that right! Hulo now supports four major platforms for script transpilation:

✅ VBScript (.vbs) - Classic Windows scripting
✅ Bash (.sh) - Linux/macOS Shell scripting
✅ Batch (.bat/.cmd) - Windows batch processing
✅ PowerShell (.ps1) - Modern Windows scripting

This means you can use the same modern syntax to generate scripts for all mainstream platforms!

Currently supports basic statement conversion, with more advanced features under development

2. Compile-time Evaluation System - `comptime` is Here!

This is the biggest highlight of this update! Hulo now supports compile-time evaluation, allowing code execution during compilation and generating different ASTs based on results.

Let's look at some practical examples:

Compile-time Computation

let a = comptime {
    let sum = 0
    loop $i := 0; $i < 10; $i++ {
        echo $i;
        $sum += $i;
    }
    return $sum
}

// Compile-time computation result: a = 45
echo $a

Conditional Compilation

comptime when $TARGET == "powershell" {
    Write-Host "Hello, PowerShell"
} else when $TARGET == "batch" {
    echo "Hello, Batch"
} else when $TARGET == "bash" {
    echo "Hello, Bash"
} else when $TARGET == "vbs" {
    MsgBox "Hello, VBScript"
}

Generated PowerShell code:

Write-Host "Hello, PowerShell"

Generated Batch code:

echo "Hello, Batch"

Generated Bash code:

echo "Hello, Bash"

Generated VBScript code:

MsgBox "Hello, VBScript"

🔧 Technical Architecture Upgrade

Compile-time Evaluation Engine

The new comptime system provides:

Runtime evaluation - Execute code during compilation
AST transformation - Modify syntax trees based on computed results
Dynamic code generation - Generate different code based on conditions

🚧 Next Steps

Module System - Support for third-party library imports (delayed to v0.4.0)
Command Gymnastics - Smarter cross-platform command adaptation
Package Publishing System - Allow community to share and reuse code
Language Server - Better IDE support

💭 Final Thoughts

This update has transformed Hulo from a simple transpiler into a modern programming language with compile-time evaluation capabilities. The addition of the comptime system brings unlimited possibilities to Hulo.

Although the module system has been delayed, the technology stack is more complete and powerful. We believe that in v0.4.0, the module system will be presented to everyone in a more elegant way.

Project address: https://github.com/hulo-lang/hulo

If you find this project interesting, feel free to raise issues or participate in discussions on GitHub! Give it a Star to support and let more people see this project.

What do you think about this "compile-time evaluation + multi-platform transpilation" approach? Any suggestions or thoughts?

After a Week of Work, My Programming Language Hulo Adds Bash Transpiler and Package Management Tool

ansurfen — Sat, 19 Jul 2025 09:06:14 +0000

Hey, script developers!

Remember that modern programming language Hulo I introduced last week that can compile to VBScript? This week it has major updates!

🚀 This Week's Major Updates

1. Bash Transpiler Officially Launched!

Yes, you read that right! Hulo now supports not only VBScript but also Bash!

This means you can use the same modern syntax to generate scripts for both Windows and Linux/macOS:

// main.hl
class User {
    pub name: str
    pub age: num

    pub fn to_str() -> str {
        return "User(name: $name, age: $age)"
    }

    pub fn greet(other: str) {
        MsgBox "Hello, $other! I'm $name."
    }
}

let u = User("John", 20)
MsgBox $u.to_str();
$u.greet("Jane");

Execute the hulo main.hl command in the working directory where the file is located to get two transpiled files (of course, the Hulo command also supports other features and reads configuration from huloc.yaml, which I won't list here one by one - you can check with hulo -h or consult the official documentation).

Generated Bash code:

#!/bin/bash
function create_user() {
  local name=$1
  local age=$2
  declare -A user
  user["name"]=$name
  user["age"]=$age
  echo "$(declare -p user)"
}
function user_to_str() {
  eval "declare -A user=${1}"
  echo "User(name: $name, age: $age)"
}
function user_greet() {
  eval "declare -A user=${1}"
  local other=$2
  MsgBox "Hello, $other! I'm $name."
}

u=$(create_user "John" 20)
MsgBox $(user_to_str $u)
user_greet $u "Jane"

Generated VBScript code:

Class User
  Public name
  Public age
  Public Function to_str()
    to_str = "User(name: " & name & ", age: " & age & ")"
  End Function
  Public Function greet(other)
    MsgBox("Hello, " & other & "! I'm " & name & ".")
  End Function
End Class
Set u = New User
u.name = "John"
u.age = 20
MsgBox(u.to_str())
u.greet("Jane")

So far, everything looks normal, right? Unfortunately, the code on the Bash platform cannot run normally - it will error due to missing MsgBox, because we're using MsgBox instead of echo in our Hulo code. Therefore, if you want it to run normally, you need to change MsgBox to echo before transpiling. But doesn't this conflict with Hulo's cross-platform promotion? Haha, the reason is that syntax sugar like use MsgBox = If<$platform == "vbs", MsgBox, If<$platform == "powershell", Write-Host, echo>> hasn't been completed yet, causing a disconnect where commands can't be transpiled. Hulo also doesn't want to force command conversion in the transpiler through hardcoding, which brings a poor development experience. This feature will be implemented in future versions - please give Hulo some time.

Ps. Hulo calls this feature "command gymnastics." To implement this feature, Hulo has absorbed all the advantages of TypeScript's type gymnastics, which means this system will include powerful type utilities like Omit, Pick, Exclude, etc., to form a powerful command system.

2. Package Management Tool HLPM is Here!

The core functionality of hlpm is to distribute third-party libraries. Since import doesn't support module resolution yet, although hlpm's core functionality is already developed, running modules is still not supported. However, you can use it to initialize projects first and write hulo.pkg.yaml and huloc.yaml files to control the project's compilation process. This is somewhat similar to the role of package.json and tsconfig.json.

# Initialize new project
hlpm init my-script

# Run script
hlpm run test

# Run file, equivalent to hulo main.hl
hlpm run main.hl

3. Interactive Development Environment Hulo-REPL

Added the hulo-repl command:

[x] Code completion
[x] Theme settings
[ ] Real-time lexical analysis and syntax analysis debugging (coming soon)
[ ] Real-time transpilation (coming soon)

PS C:\hulo> hulo-repl

  Hulo-REPL dev

  ➜  Type help for commands, exit to quit

>>> e
      else    Else statement
      enum    Enum declaration
      extend  Extend declaration
      exit    Exit the REPL

🔧 Technical Improvements

Refactored VBScript Transpiler

Cleaner code structure, easier to maintain
Fixed the echo "Hello World" string transpilation issue

This update is a breaking change - some functionality implemented in v0.1.0 may not work in v0.2.0. Especially regarding import, the module design will be closer in the next update.

Configuration System Upgrade

The hulo command now supports reading configuration from huloc.yaml in the working directory
More flexible project configuration management

🚧 Next Steps

Batch Transpilation Support - Make Hulo more powerful on Windows
Package Publishing System - Let the community share and reuse code
Import System - Support third-party library imports
Command Gymnastics - Smarter code generation

💭 Final Words

Project repository: https://github.com/hulo-lang/hulo

If you find this project interesting, feel free to open issues on GitHub or join the discussion! Give it a Star to support the project and let more people see it.

What do you think about this "write once, run on multiple platforms" script development approach? Any suggestions or ideas?

Hulo: Write clean, modern code that compiles to VBScript

ansurfen — Sun, 13 Jul 2025 02:38:19 +0000

Hey VBScript enthusiasts! 👋

So I've been working on a compiler/transpiler project and wanted to tackle something that could actually be useful. You know what's the most frustrating thing about VBScript? Writing complex logic with that verbose syntax and limited features!

That's when I thought - what if we could write scripts in a clean, modern language and have it compile to VBScript? Enter Hulo!

What is Hulo?
A modern, type safety programming language that transpiles to VBScript, making it much easier to write complex automation scripts for Windows.

Quick example:

Simple message box:

MsgBox "Hello, World!"

Functions with types:

fn sayHello(name: str) -> void {
    MsgBox "Hello, $name!"
}

fn add(a: num, b: num) => $a + $b

sayHello "Hulo";
MsgBox add(5, 3);

Classes and objects:

class User {
    pub name: str
    pub age: num

    pub fn greet(other: str) {
        MsgBox "Hello, $other! I'm $name."
    }
}

let u = User("John", 25)
$u.greet("Jane")

Control flow and user input:

let n = InputBox("Input a number:")

if $n < 0 {
    MsgBox("The number is negative.")
} else {
    MsgBox("The number is positive.")
}

Lists and loops:

let arr: list<num> = [1, 2, 3, 4, 5]

loop $item in $arr {
    MsgBox $item
}

loop $i in [0, 1, 2] {
    MsgBox $i
}

More examples available in the examples/ directory!

No more struggling with VBScript's verbose syntax or limited features - just write clean code and let Hulo handle the VBScript generation!

Would love to hear your thoughts on this approach. Is this something you'd find useful for your VBScript development? Any feedback or suggestions are welcome!

Check it out: https://github.com/hulo-lang/hulo

What do you think?

My First AI Project: A Journey of Building RAG Knowledge Base from Scratch

ansurfen — Mon, 07 Jul 2025 03:00:25 +0000

Project Background

I'm a beginner in AI application development. In the past, I've been focused on traditional frontend, backend, and toolchain development, with very limited knowledge about AI.

Recently, I've been working on a toolchain project and writing documentation for it. Suddenly, an idea occurred to me - I could use the MCP protocol to tell AI about the project details and let it help me write code.

Let's get started! After discussing with GPT, I decided to adopt the following technology stack:

Backend Framework: FastAPI + Python - Chose FastAPI for its async capabilities and automatic API documentation generation
Vector Database: ChromaDB (with memory fallback) - Supports persistent storage while providing memory mode for development and testing
Embedding Model: Sentence Transformers - Lightweight and effective embedding model
Large Language Model: Local Qwen2.5-7B via Ollama - Completely local deployment, privacy protection
Architecture Pattern: RAG (Retrieval-Augmented Generation) - Combines document retrieval with LLM generation

Learning Journey

Document Chunking Strategy

Initially, I wanted to directly vectorize entire documents, but considering model token limitations and document structure, this approach seemed difficult to implement.

Therefore, GPT told me I had to split documents into chunks before vectorization. My documents are written in Markdown format, containing many h2, h3, h4 headers, which created conditions for chunking.

It took about half an hour to implement a chunking strategy based on Markdown headers rather than simple line-by-line splitting.

# Header-based chunking strategy
def create_chunks_by_headers(self, content: str, metadata: Dict) -> List[Chunk]:
    chunks = []
    lines = content.split('\n')
    current_chunk = []
    current_title = metadata.get('title', '')

    for line in lines:
        if line.startswith('#'):
            # Save current chunk
            if current_chunk:
                chunks.append(Chunk(
                    content='\n'.join(current_chunk),
                    metadata={**metadata, 'title': current_title}
                ))
            current_chunk = [line]
            current_title = line.lstrip('#').strip()
        else:
            current_chunk.append(line)

    # Save the last chunk
    if current_chunk:
        chunks.append(Chunk(
            content='\n'.join(current_chunk),
            metadata={**metadata, 'title': current_title}
        ))

    return chunks

The Dilemma of Similarity Search

After document vectorization was complete, I could use input queries to search the vector database and return results based on similarity.

When I eagerly tested similarity search, the results were disappointing. The problem was that many keywords didn't explicitly appear in the original text, making it impossible to match relevant information.

For example, searching for "function definition" but the document might say "function declaration" or "how to create a function" - there are many cases where semantics are similar but vocabulary differs.

GPT told me I could use multi-round retrieval to solve this problem.

Multi-round Retrieval Improvement

Later, I learned about the concept of multi-round retrieval and decided to try it.

First Round: Low threshold (0.3) broad search to capture more candidates
Second Round: High threshold (0.7) refined search to filter high-quality results
Merge and Deduplicate: Combine results and remove duplicates

def search_with_context(self, query: str, max_results: int = 5) -> Tuple[List[SearchResult], str]:
    # First round: broad search
    broad_results = self.vector_store.search(query, max_results * 2, threshold=0.3)

    # Second round: refined search
    refined_results = self.vector_store.search(query, max_results, threshold=0.7)

    # Merge results and deduplicate
    all_results = self._merge_and_deduplicate(broad_results, refined_results)

    # Build context
    context = self._build_context(all_results[:max_results])

    return all_results[:max_results], context

The results did improve, though not perfect, but at least it could match better than before.

Smooth LLM Integration

Compared to the bumpy data preprocessing, LLM integration was quite smooth. I called the local Qwen2.5-7B model through Ollama, and with appropriate prompt templates, the results were acceptable.

def answer_question(self, context: str, query: str) -> str:
    prompt = f"""Based on the following document content, answer the question. If there's no relevant information in the documents, please state that no answer can be found.

Document content:
{context}

Question: {query}

Answer:"""

    return self.llm_provider.generate(prompt, context, query)

The advantage of local models is complete privacy protection, and the response speed is also acceptable.

The MCP Nightmare

The most headache-inducing part was the practice of the MCP protocol. GPT generated a lot of "dirty code" for me, including:

Tedious access chains with any types everywhere
Invalid function signatures
Incorrect parameter passing
Confused type definitions

Even worse, my commonly used Cursor IDE has poor MCP integration support. After struggling for half an hour without results, I finally took AI's advice and used HTTP calls instead of MCP.

Summary

This project gave me a deeper understanding of AI development. The RAG architecture is indeed powerful, but the quality of data preprocessing directly affects the final results. Multi-round retrieval is a good improvement idea, and while the MCP protocol has good concepts, its practical use still needs to mature.

Why I Chose Astro After Trying VuePress, Hugo, and Hexo

ansurfen — Sat, 24 May 2025 16:15:22 +0000

I’m about to graduate recently, and I wanted to organize some of my past experiences.
So I came up with the idea of building a personal blog.
I also want to document the whole process from choosing the framework to deployment, hoping it can help others who are just starting out like me.

🛠️ Framework Selection

VuePress → Better for documentation, weaker blog ecosystem 📄
- Documentation-friendly but limited blog features
- Theme choices lean toward technical documentation style
Hugo → Complex configuration (extended version requires GCC), breaking changes ⚠️
- Requires GCC toolchain for compilation
- Version updates often lack backward compatibility
- Theme dependencies on specific versions cause runtime failures
Hexo → Node.js ecosystem friendly, but limited theme selection 🌀
- Simple Node.js-based development environment
- But the themes are highly homogeneous and lack eye-catching designs.
Astro → Final choice! ✨
- Easy configuration and flexible UI
- Downside: Need to learn its unique hybrid rendering model

💡 Astro Rendering Explained:
Astro uses a distinctive "static generation + on-demand hydration" approach. By default all components are server-side rendered (SSR) to static HTML. When interactivity is needed, specific components can be selectively hydrated for client-side rendering (CSR). This "islands architecture" ensures fast initial loading while providing necessary interactivity.

After all that technical talk, actual development mainly involves writing TypeScript mixed with Markdown. When styling is needed, you write the CSS yourself and then apply Markdown content to those styled components.

The tradeoff? What could have been simple Markdown-based blogging now requires writing Astro files to control UI styling for that flexibility. But for non-coding-newbies, the customization payoff seems worth it. I even wrote Vitest unit tests for my blog's utility functions :).

🎢 Development Journey

It took me two full days to build a blog I'm somewhat satisfied with.

Initially I wanted to use VuePress since it's my usual go-to, but after browsing themes I realized it's better suited for documentation. Like using a screwdriver to tighten nuts - it works but isn't ideal.

Then I discovered Hugo but found configuration troublesome - the themes I liked required the extended version, which needed GCC toolchain installation.

After finally setting up the environment, I learned Hugo updates often introduce breaking changes without backward compatibility, making my chosen template fail. Game over.

Next I tried Hexo. Compared to Hugo, its Node.js foundation made development friendlier, but I still couldn't find any appealing themes after extensive searching.

After consulting AI, I discovered Astro. After browsing many free blog templates, I finally found one that was acceptable.

I was excited at first, but the implementation process proved challenging. I initially thought the --- syntax was just sugar coating for <script>, but later realized it's Astro's critical marker separating server-side from client-side code. Server code executes at build time, client code runs in browsers.

The multilingual implementation also felt unintuitive - instead of having all content under en_us/zh_cn directories, the official demo splits languages across content directories. After much compromise, I ended up with a barely acceptable solution.

🚀 Deployment Experience

GitHub Workflow and Pages provide great convenience for developers, but writing YAML scripts often feels restrictive and awkward.

To deploy both my blog and metrics generation, I made over 20 commits of trial-and-error adjustments. The final solution involved creating a separate repository for metrics.

My requirements were somewhat special - I needed to generate GitHub Metrics images and reference them from my blog, with both deployed under the same URL.

Initially AI generated two YAML files that would overwrite each other when run together. Merging them with filename declarations somehow broke metrics.svg generation.

Ultimately I had to split the workflows across two repositories. At least the problem got solved.

DEV Community: ansurfen

Hulo Programming Language: Module System Delayed, but Batch/PowerShell Integration & Initial Interpreter Release

🚀 Major Updates This Week

1. Full Platform Transpiler Officially Complete!

2. Compile-time Evaluation System - comptime is Here!

Compile-time Computation

Conditional Compilation

🔧 Technical Architecture Upgrade

Compile-time Evaluation Engine

🚧 Next Steps

💭 Final Thoughts

After a Week of Work, My Programming Language Hulo Adds Bash Transpiler and Package Management Tool

🚀 This Week's Major Updates

1. Bash Transpiler Officially Launched!

2. Package Management Tool HLPM is Here!

3. Interactive Development Environment Hulo-REPL

🔧 Technical Improvements

Refactored VBScript Transpiler

Configuration System Upgrade

🚧 Next Steps

💭 Final Words

Hulo: Write clean, modern code that compiles to VBScript

My First AI Project: A Journey of Building RAG Knowledge Base from Scratch

Project Background

Learning Journey

Document Chunking Strategy

The Dilemma of Similarity Search

Multi-round Retrieval Improvement

Smooth LLM Integration

The MCP Nightmare

Summary

Why I Chose Astro After Trying VuePress, Hugo, and Hexo

🛠️ Framework Selection

🎢 Development Journey

🚀 Deployment Experience

2. Compile-time Evaluation System - `comptime` is Here!