Callback trace contracts in the TD2 compare lane

The latest TD2 port checkpoint promotes the first callback-backed compare fixture on top of the existing pixel and PPU-state checks.

What changed

• Added td2_contracts.* to resolve callback_state_contracts.jsonc from the scene path and load validated intro checkpoints by frame.
• The runtime now seeds a bootstrap callback/state shadow for covered frames.
• Compare bundles now emit callback_contract next to state_contract.
• frame_01093 is promoted as the first callback-backed fixture in the default smoke.

Why this matters

This closes the representation gap between archaeology outputs and the SDL runtime. The port can now carry validated callback/state checkpoints in-band with visual compare output instead of treating them as a separate offline report.

Validation

• make -C port test
• frame300_compare: exact pixels, exact PPU-state parity, no callback contract expected
• frame1086_compare: exact pixels, exact PPU-state parity, no callback contract expected
• frame1093_compare: exact pixels, exact PPU-state parity, and 8 callback checks loaded from the validated 01:9FE5 contract with 0 failures

Next gate

The next step is replacing the seeded callback shadow with real callback/state execution for the front-end family and expanding callback-backed fixtures beyond frame 1093.

What is an Array?

An array is a collection of items stored in a single variable.

Think about a box of fruits 🍎🍌🍇
Instead of storing each fruit in a separate variable, we store all in one array.

Example without Array
let fruit1 = “Apple”;
let fruit2 = “Banana”;
let fruit3 = “Mango”;

❌ Problem: Too many variables

Example with Array
let fruits = [“Apple”, “Banana”, “Mango”];

✅ Easy and clean!

Index Concept (Important)

Array starts from index 0.

How does it work?

To keep things organized, an array gives every item a number. This number is called an Index.

The Golden Rule: In the world of computers, we always start counting from 0, not 1.

So, the first item is at position 0, the second is at 1, and the third is at 2.

Homogeneous (The Same Type)

Usually, an array likes to hold the same kind of things. If it’s a list of names, keep it all names. If it’s a list of numbers, keep it all numbers.
Contiguous (All Together)

In the computer’s memory, the items in an array sit right next to each other in a perfect row. There are no gaps or empty spaces between them.

Fixed vs. Dynamic Size

Fixed Size: Some languages require you to decide the size of the list at the start. You cannot add more later.

Dynamic Size: Modern languages (like JavaScript) let the list grow as long as you want!

ADDING VALUES;

let fruits = [“Apple”, “Banana”];

fruits.push(“Mango”);

console.log(fruits);

Adds value to end

REMOVING VALUES

fruits.pop();

Removes last value

LOOPING ARRAY

let fruits = [“Apple”, “Banana”, “Mango”];

for (let i = 0; i < fruits.length; i++) {
console.log(fruits[i]);
}

Prints all values

FOR LOOP

=> This is for loop first condition let i = 0 is what the i value while start
=> second condition is i < fruits.length , in this case fruits length is 3, so it will consider that condition as i<3, this condition is for to limit the loop, the loop is run only less than 3, but index start with 0 , so we have space to fit three value in this loop.
=> third condition how the i will increase , i want to increase like 2 4 6 then put i+=2 instead of i++;

Why Arrays are Important?

Array is a powerful and simple way to store multiple values in one place.
Easy to manage data
Used in almost all programs
Arrays can store any type (number, string, object)

How I Built an AI-Powered Portfolio Assistant with Google Gemini

TL;DR: I built an AI assistant into my portfolio at hailamdev.space that can answer questions about my skills, projects, and experience — powered by Google Gemini 2.0. Here’s exactly how I did it.

The Problem

As a Fullstack Developer based in Ho Chi Minh City, Vietnam, I wanted my portfolio to stand out. Traditional portfolios are passive — visitors scroll, look at screenshots, and leave. I wanted something interactive.

What if recruiters and potential clients could ask questions about my experience and get instant, intelligent answers?

The Architecture

User Question → Intent Detection (local) → Gemini API → Structured Response → Rich UI Card

Key Components

1. Intent Detection Layer — Detects common patterns locally before hitting the API
2. System Prompt Engineering — Provides Gemini with full context about my profile, projects, and skills
3. Structured Output — Gemini returns JSON with answer, highlights, quickFacts, skillsMatrix
4. Rich Response Cards — React components render structured data beautifully

Tech Stack

Intent Detection — Saving API Calls

Before calling Gemini, I detect common intents locally:

// chatIntents.js - Local intent detection
export const detectIntent = (message) => {
  const lower = message.toLowerCase();

  if (/cv|resume|download/.test(lower)) return 'cv';
  if (/contact|email|hire/.test(lower)) return 'contact';
  if (/project|portfolio|work/.test(lower)) return 'projects';
  if (/skill|technology|stack/.test(lower)) return 'skills';

  return null; // Falls through to Gemini
};

This handles ~40% of questions without API calls, reducing latency and costs.

Structured Prompt Engineering

The secret sauce is the system prompt. Instead of letting Gemini generate free-form text, I instruct it to return structured JSON:

const systemPrompt = `
You are an AI assistant for Nguyễn Xuân Hải's portfolio.
Always respond in JSON format:
{
  "answer": "Natural language answer",
  "highlights": ["Key point 1", "Key point 2"],
  "quickFacts": [{"label": "Experience", "value": "2+ years"}],
  "skillsMatrix": [{"skill": "React", "level": "advanced", "evidence": "5+ projects"}]
}
`;

This gives me full control over the UI while letting Gemini handle the intelligence.

Features I’m Proud Of

1. Multi-Language Support

The assistant handles both Vietnamese and English seamlessly, detecting language from user input.

2. Job Description Analysis

HR recruiters can upload a JD and the assistant analyzes fit against my profile — showing matching skills, gaps, and recommendations.

3. Slash Commands

Power users can use commands like /cv, /pdf, /clear for quick actions.

4. Response Styles

Users can switch between brief, detailed, and fit modes for different use cases.

Results

Since deployment:

• Average session duration increased significantly
• Recruiters spend more time interacting vs. just scrolling
• The assistant handles questions I’d normally answer via email

Try It Yourself

Chat with my AI Assistant — ask it anything about my skills, projects, or availability.

Full Portfolio — explore my projects, experience, and 3D animations.

About the Author

Nguyễn Xuân Hải is a Fullstack Developer based in Ho Chi Minh City, Vietnam, specializing in React, .NET Core, Node.js, and AI integration. His commercial projects include Great Link Mai House (B2B real estate platform), English Community Hub (educational platform), and VN Media Hub (CMS platform).

📫 Contact: [email protected] | GitHub | Portfolio

I kept breaking apps because of missing env variables… so I built this.

Hey everyone 👋

I’ve lost count of how many times this happened:

• App crashes in production
• Turns out → missing or invalid .env variable
• Or worse… typo like DATABSE_URL 😅

So I built a small utility to fix this problem:

👉 strict-env-validator

🔗 https://www.npmjs.com/package/strict-env-validator

🔧 What it does

• Automatically loads .env files
• Validates all environment variables at startup
• Throws clear errors if something is missing or invalid
• Prevents your app from running with bad config

✨ Why I built it

I tried existing tools, but I wanted something:

• Simpler to use
• Strict by default
• Works out of the box without too much setup

Most tools validate env variables, but I wanted something that fails fast and clearly before your app even starts.

⚡ Example

Instead of writing validation manually:

const PORT = process.env.PORT;
if (!PORT) throw new Error("Missing PORT");

You get:

import "strict-env-validator";

And it handles everything for you ✅

🎯 Goal

Make .env handling:

• predictable
• safe
• impossible to mess up

🙌 Feedback

This is still early, so I’d really appreciate:

• feedback
• feature ideas
• criticism

If you’ve faced similar issues, I’d love to hear how you handle env validation.

Thanks!