Forem: SARTHAK RANA

⚡Meet Ballerina: The Language that Makes Integration Beautiful

SARTHAK RANA — Fri, 17 Oct 2025 07:21:42 +0000

If you’ve ever struggled connecting services, managing APIs, or stitching together data pipelines, you know that integration logic can get messy fast. That’s where Ballerina comes in — a cloud-native programming language purpose-built for integration in the modern microservices world.

What is Ballerina?

Ballerina is an open-source programming language created by WSO2 and designed specifically for writing integrations as code. Unlike typical general-purpose languages, Ballerina natively understands network protocols, API definitions, and concurrent workflows — all the things integration developers wrestle with daily.

Introduced in 2016 and officially released in 2022, Ballerina takes the best parts of both programming languages and low-code integration tools — offering a mix of textual coding and visual representation (via sequence diagrams and flowcharts).

Think of it as the sweet spot between Java’s control and Node.js’s agility, enhanced with drag-and-drop clarity.

Where to Use Ballerina?

You can use Ballerina almost anywhere integration lives:

Building microservices: Create resilient, cloud-native microservices with built-in networking.
API orchestration: Connect REST, GraphQL, and gRPC endpoints into unified flows effortlessly.
Data transformation: Handle JSON, XML, and tabular data with type-safe, declarative queries.
Event-driven systems: Manage concurrent execution flows with built-in safety primitives.
Enterprise integrations: Replace aging ESB solutions with readable, code-first workflows.

With its cloud-native and data-oriented design, Ballerina is built for the Internet age — perfect for developers building integrations between dynamic, distributed services.

Why Use Ballerina?

Traditional tools either oversimplify integrations through rigid drag-and-drop UIs, or overcomplicate them by forcing you to manage every socket, thread, or async callback manually.

Ballerina’s beauty lies in balance — integration as code, but intuitive.

Here’s what makes it standout:

Cloud Native: Network primitives are first-class citizens — writing APIs or services feels natural.
Flexibly Typed: Its structural typing supports openness, ideal for dynamic service contracts.
Data Oriented: A query language built right into the language for JSON/XML handling.
Graphical and Textual: Every program can be viewed as code or as a sequence diagram.
Concurrent by Design: Concurrency is baked in — no async headaches, just safe, efficient threads.
Maintainable & Reliable: Explicit error handling and strong typing make integrations robust.

Getting Started With Ballerina

Setting up Ballerina is quick and seamless. Follow these simple steps to begin writing your first integration service.

Step 1. Install Ballerina

Download the Ballerina CLI from the official download page.
Then verify your installation in the terminal:

bal version

You should see the installed version printed, confirming that Ballerina is ready to use.

Step 2. Create Your First Project

Initialize a new project directory using the CLI:

bal new hello-ballerina
cd hello-ballerina

This command creates a workspace with the following structure:

hello-ballerina/
├── Ballerina.toml
└── main.bal

Here’s what each file does:

1. Ballerina.toml – Project Configuration
This file defines your project metadata, dependencies, and settings. Think of it like package.json in Node.js or pom.xml in Java.

Example:

[project]
org-name = "your-org"
name = "hello-ballerina"
version = "0.1.0"

2. main.bal – Source Code
This is where your integration logic lives — the runnable code

Step 3. Write a Simple Service

Open the main.bal file and replace its contents with this starter HTTP service:

import ballerina/http;

service /hello on new http:Listener(8080) {

    resource function get world() returns string {
        return "Hello, Ballerina!";
    }
}

Run your program:

bal run

Step 4. Test Your Service

Once running, open your browser or use curl to access:

http://localhost:8080/hello/world

You should see the output:

Step 5. Explore Further

You can edit the service logic, add routes, or connect APIs easily. Refer to the Ballerina Learn Page for more advanced examples and tutorials.

Fun Bonus: Code Meets Diagram

One of Ballerina’s coolest features is its automatically generated sequence diagrams. Every time you write code, Ballerina can visualize the logic as a flowchart — bridging the gap between developers and architects.

No more struggling to explain integration behaviors — your code is your diagram.

Hello World Visualized

Here’s how our earlier Hello, Ballerina! HTTP service looks as a sequence diagram:

import ballerina/http;

service /hello on new http:Listener(8080) {

    resource function get world() returns string {
        return "Hello, Ballerina!";
    }
}

Sequence Diagram:

How to Generate It Yourself

Install the Ballerina VS Code Extension
VS Code Marketplace link
Open your .bal file in VS Code.
View the diagram

Click the Visualize link above your service/function
Or click Show Visualizer in the editor toolbar

You’ll see a live, interactive diagram representing the flow of your service.

Ballerina isn’t just another programming language — it’s an integration revolution.

It empowers developers to build scalable, cloud-friendly, and visually intuitive systems while keeping the expressiveness of typed, reliable code.

Whether you build microservices, automate APIs, or craft event-driven systems, give Ballerina a spin and experience integrations done right.

Explore more at ballerina.io

From Confusion to Clarity: My AI Agent for Intern Prep in Big Tech

SARTHAK RANA — Sun, 15 Jun 2025 04:48:46 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

Being Student Preparing for highly competitive technical internships at top tech companies like Adobe, Google, Microsoft, Amazon, and others can be overwhelming. Aspiring candidates often struggle to understand the exact skill requirements, the nuances of the interview process, and how to build a structured, personalized study plan. This leads to wasted effort on irrelevant topics, missed application windows, and high stress levels.

To solve this, I built the Big Tech Intern Prep Agent, an autonomous AI workflow powered by Runner H. Starting from a single, detailed prompt, this agent researches a specific internship role at a leading tech company (e.g., Adobe Software Engineer Intern), analyzes the job requirements, studies common interview patterns, curates top study resources, and synthesizes all this into a personalized weekly study plan. It works like a smart, self-updating career coach and study planner, streamlining the entire prep journey for roles across companies.

Demo

Prompting Runner H with a detailed goal to generate a personalized study plan for a big tech software engineering internship

Runner H analyzing the official job description to extract required skills and responsibilities.

The final output is a comprehensive study plan in PDF format generated bt Runner H tailored to internship requirements, generated using the provided prompt and job description.

How I Used Runner H

I used Runner H to help me prepare for this.
Runner H’s autonomous capabilities allowed me to build this system without writing any code to interface with different websites. By giving it a single, structured prompt, the agent could:

Navigate to job of Adobe.
Parse job descriptions, required technologies (like Python, Java, C++, SDLC, etc.).
Scrape interview experiences from sites like GeeksforGeeks and Glassdoor.
Curate targeted learning paths from platforms like LeetCode, Coursera, and YouTube.
Generate a custom week-by-week study plan aligned with my goals, skill level, and schedule.

This process works not only for Adobe, but can easily be adapted for any big tech internship by simply updating the job URL and current skill level in the prompt.

Here's the exact prompt I used and how Runner H leveraged its capabilities:

Objective: Generate a highly targeted, comprehensive, and actionable study plan to maximize my chances of securing the Adobe 2025 Intern - Software Engineer (Job ID: R147746) position.

Phase 1: Deep Job Description & Company Research (Autonomous Observation & Information Gathering)

Analyze Official Job Description: Navigate directly to the provided job URL: https://careers.adobe.com/us/en/job/R147746/2025-Intern-Software-Engineer.

Thoroughly read and extract all required qualifications, preferred skills, core responsibilities, and technologies mentioned (e.g., Java, C++, JavaScript, Python, familiarity with SDLC, web/mobile app development).

Note down any specific soft skills or cultural aspects emphasized by Adobe (e.g., collaboration, communication, problem-solving, versatility, adaptability).

Adobe Interview Process Research: Research typical interview processes for Software Engineer interns at Adobe. Look for information on online assessments, technical screens, coding rounds, system design (if applicable for interns), and behavioral interviews. Identify common question types and difficulty levels. Prioritize insights from recent (2024-2025) interview experiences on platforms like Glassdoor, LeetCode discussion forums, GeeksforGeeks, and similar career blogs.

Understand Adobe's Product Areas: Briefly research the Creative Cloud, Document Cloud, and Experience Cloud to understand the scope of work an intern might engage in, looking for general technology trends within these areas.
Phase 2: Skill Gap Analysis & Resource Identification (Intelligent Filtering & Prioritization)

Current Skill Assessment: My current technical background is: [YOUR CURRENT PROGRAMMING LANGUAGES, DATA STRUCTURES/ALGORITHMS KNOWLEDGE, RELEVANT COURSEWORK, PROJECT EXPERIENCE, AND ANY SPECIFIC TECHNOLOGIES YOU ARE FAMILIAR WITH HERE. e.g., 'Intermediate Python, basic Java, familiar with fundamental data structures like arrays and linked lists, completed an intro to CS course, some experience with React/web development'].

Identify Critical Gaps: Based on the detailed requirements from Phase 1 and my current skills, identify the most critical technical and soft skill gaps I need to address for this specific Adobe role.

Curate Top Resources: For each identified skill gap or core requirement, find highly-rated and relevant online learning resources and practice platforms. Prioritize comprehensive and widely recognized resources.

Core Languages (Java, C++, JavaScript, Python): Find resources for strengthening proficiency in the languages mentioned in the job description that align with my current skills.

Data Structures & Algorithms (DSA): Identify structured courses and problem sets on platforms like LeetCode (focus on Easy/Medium Adobe-tagged problems if available), HackerRank, GeeksforGeeks.

Object-Oriented Programming (OOP): Find tutorials/courses specifically on OOP principles in the relevant language(s).

Software Development Lifecycle (SDLC): Identify resources explaining modern SDLC practices, agile methodologies, testing, and deployment basics for web/mobile apps.

System Design (Basic): Find beginner-friendly introductions to system design concepts, tailored for interns/junior engineers.

Behavioral & Communication: Identify resources for common behavioral interview questions, resume/project discussion tips, and general communication strategies.

Optional (Adobe-specific): If relevant, find introductory resources on Adobe's specific technologies (e.g., Creative Cloud APIs, general cloud concepts, big data basics if hinted at).

Phase 3: Personalized Weekly Study Plan Generation (Structured Output & Time Allocation)

Generate a structured weekly study plan for a duration of [YOUR DESIRED PREPARATION TIMELINE, e.g., '10 weeks' or '3 months']. If no timeline is specified, assume a balanced 12-week preparation.

Allocate Study Hours: Assume a daily study commitment of [YOUR SPECIFIED DAILY HOURS, e.g., '2-3 hours on weekdays, 4 hours on weekends'].

For each week, define:

Key Topics to Master: (e.g., "Week 1: Arrays, Strings, Basic OOP in Python"). Recommended Learning Path: Specific resource links from Phase 2 to use for that week's topics.

Practice Goals: Concrete coding problems to solve, behavioral questions to ponder, or concepts to review (e.g., "Solve 7 LeetCode Easy/Medium problems on Arrays," "Practice explaining a recent project using STAR method").

Mini-Project Ideas (Optional): Suggest 1-2 small project ideas that reinforce weekly learning or align with Adobe's product areas (e.g., a simple web app with a basic backend, a small image processing script).

Integrate Regular Review: Include dedicated slots for spaced repetition, reviewing previously learned material, and solving mixed problem sets.

Phase 4: Interview Simulation & Application Strategy (Actionable Preparation & Final Polish)

Mock Interview Preparation: Outline a strategy for conducting mock interviews (peer-to-peer or self-simulated). Suggest how to articulate technical thought processes clearly and concisely.

Resume/Project Discussion Tips: Provide advice on how to effectively discuss past projects and experiences during interviews, relating them to Adobe's values and the job description.

Behavioral Question Bank: Generate a small list of common behavioral questions for Adobe or general tech internships.

Application & Networking Guidance: Suggest steps for tailoring the resume/cover letter, and briefly mention looking for Adobe recruiters/engineers on LinkedIn for informational interviews (if time permits).
Phase 5: Output & Presentation (Clear & Actionable Report)

Present the entire study plan as a clear, well-formatted document (e.g., markdown or structured text output).

Include an initial summary of the Adobe job requirements and interview insights.

Ensure all resource links are clickable and organized by topic.

Conclude with actionable advice on tracking progress, maintaining motivation, and performing final interview preparations.

Goal: Deliver a self-contained, easy-to-follow roadmap that guides me from my current skill level to being well-prepared for the Adobe Software Engineer Intern role.

Use Case & Impact

The Intern Prep Agent has significant real-world applications and impact for aspiring software engineers:

Personalized & Targeted Preparation: Instead of generic study plans, this agent provides a roadmap directly tailored to the Software Engineer Intern role's specific requirements and the user's current skill set. This drastically improves study efficiency.
Time-Saving & Overwhelm Reduction: Manually researching job descriptions, interview processes, and finding relevant resources can take days, if not weeks. This agent automates that entire initial, tedious phase, allowing candidates to jump straight into focused studying. It reduces the common feeling of being overwhelmed by the sheer volume of information.
Increased Confidence & Effectiveness: By providing a clear, week-by-week plan with curated resources, the agent instills confidence and ensures a structured approach to preparation, leading to more effective learning and better interview performance.
Accessibility: It democratizes access to high-quality, personalized career preparation for competitive roles, benefiting students and career changers worldwide.

This solution truly exemplifies how Runner H can act as an intelligent, autonomous assistant, transforming a complex and time-consuming personal goal into an organized, achievable project.

Social Love

// Detect dark theme var iframe = document.getElementById('tweet-1938496597199098165-793'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1938496597199098165&theme=dark" }

🤝 Connect with Me

🕹️How I Built a 2D Endless Runner Game with Amazon Q CLI & PyGame

SARTHAK RANA — Tue, 03 Jun 2025 14:54:14 +0000

🎮 Introduction

As part of "Build Games with Amazon Q CLI," I decided to combine my creativity and coding skills to create a fun 2D Endless Runner Game using PyGame and Amazon Q CLI.
The result was so surprising A simple game that test our reflexes, With a player who run endlessly jumping over objects and score increasing!!
And the best part was? I built it just by chatting with Amazon Q CLI — an AI coding assistant that helps us create working code from natural language prompts. No chaos in setting up files and all.
Amazon Q CLI does everything for us!!

💡 Idea Behind the Game

I was always fascinated by the Chrome Dino Game and how it actually works so I decided to build a game something just like it.
I added mechanics like jumping to avoid obstacles, increasing the speed of the character after specific to increase the difficulty and make the game more surviving and adventurous.

🛠️ Tools & Tech & how I built it.

Amazon Q CLI – AI-powered coding assistant
Python – Programming language
PyGame – Library to handle graphics, events, and collisions
VS Code – Editor
GitHub – To host the code
Pixabay/Freesound – For free sound effects and background music

Here’s a breakdown of how I used it to build my 2D endless runner game:

Step 1: Setting Up the Environment:

To build my game, I used WSL (Windows Subsystem for Linux).
To Install WSL as Ubuntu open Powershell as Administrator and run:

 wsl --install -d Ubuntu

Step 2:🤖 Installing Amazon Q CLI

Next I installed Amazon Q CLI I did this by following the guide

📄 Installing Amazon Q for command line

Step 3:🚀 Starting Q Chat

Once Installed start the session by simply running

q chat

That's It! Now just give prompt to Amazon Q and our game is ready!!

My prompt was

"Help me create a simple 2D endless runner game using PyGame. I want a player character that can jump to avoid obstacles, a scrolling background or moving ground, and random obstacles appearing over time. When the player hits an obstacle, the game should end and display the final score. Also include basic scoring logic and key comments in the code."

Within minutes, Q generated a full Python script with:

Player and obstacle classes
Jump mechanics
Game loop with score tracking
Collision logic
Game over condition

The game generated by Amazon Q CLI used colored rectangles initially as placeholders for the player and obstacles.
This looked so boring,so I decided to add cool asset in game to make it visually appealing and engaging along with cool sound affects.
The sound effects which I added were

Jump sound
Crash sound
Background music

I took assests and sound from website like

Here's some snapshot and gameplay of my game

Welcome Screen

Player jumping to avoid an obstacle.

🎥 Watch the Game in Action

🔗 GitHub Repository

You can explore the full source code in my GitHub repo below:

👉 GitHub - Endless Runner Game using PyGame & Amazon Q CLI

Feel free to ⭐ star the repo or fork it to try your own version!

🎯 Learnings & Takeaways

Amazon Q CLI is really a very useful and cool tool for developers to build anything in minutes.
I Understood how endless runner games work—jump physics, obstacle spawning, speed scaling, and collision detection.
Learned to integrate sound effects and visuals to make the game more immersive and engaging.
Gained practical experience in using PyGame for handling graphics, events, and game loops.

Conclusion

I was a fun building a game using AmazonQ CLI and exploring game development.
It showed me how we can use AI for developemt by leaving space for creativity too..
Whether you're a beginner or experienced developer, I highly recommend giving Amazon Q CLI a try for your next creative coding idea.