DEV Community: Akash Jana

TARDIS-SN : My Pre-GSoC Journey, Codebase & Guide

Akash Jana — Sat, 03 May 2025 13:16:31 +0000

Getting Started with TARDIS: A Friendly Guide for New Contributors

Have you ever looked up at the night sky and wondered how we decode the light from exploding stars? That’s exactly what TARDIS helps scientists do. In this post, we’ll explore what TARDIS is, how it works, and how you, as a future contributor, can become part of this open-source project.

Graphic element from Tardis website

TL;DR:

In this blog, I share my journey exploring and contributing to TARDIS-SN and CARSUS, open-source astrophysics tools used to simulate supernova spectra. I explain how TARDIS works in simple layman language, how Carsus supports it by generating atomic data, and detail my first contribution to Carsus through a pre-GSoC pull request. I also reflect on my GSoC interview experience where I excelled in behavioral questions but miserably failed with technical ones yet how it motivated me to keep learning and growing. This post is both a technical guide and a personal story for future contributors.

+ The storytelling will be written in this format or in quotes. 
- If you want to skip my journey and focus only on technicals
+ feel free to do so. 
+ However, I humbly request you read through all of it.

🌌 What Is TARDIS?

TARDIS (Temperature And Radiative Diffusion In Supernovae) is an open-source Python-based radiative transfer code designed to simulate supernova spectra. Its primary aim is to provide a fast, flexible tool for researchers studying the light emitted by supernovae (stellar explosions).

Think of it as a virtual lab where you can recreate and analyze how a supernova would shine through space based on the physics of radiation, matter, and atomic interactions.

TARDIS : An open-science software to simulate and analyse supernovae and other transients

While exploring potential GSoC projects, I initially shortlisted exciting options like OHC and Google DeepMind. However, when I stumbled upon TARDIS, my childhood dream of diving into the mysteries of space and the cosmos reignited. As a Sci-Fi enthusiast, I felt an irresistible pull towards this project, convincing me that this is where I truly belong, channeling my passion for starry adventures into meaningful work.
I have mentioned this in my proposal as well.

Lets get back to some core concepts.

Core Concepts

Here are a few core concepts that TARDIS is built upon:

Radiative Transfer guides the journey of light through cosmic chaos.
The Monte Carlo Method harnesses the power of randomness to unravel these stellar explosions.
Atomic Data the blueprint for understanding the interactions between photons and atoms.

Together, these concepts help us decode the celestial light show that reaches our telescopes. Lets understand them in detail.

🔁 Radiative Transfer

What is it?
Radiative transfer is the physical process that describes how light (or more generally, radiation) travels through a medium like the gas ejected from a supernova interacting with particles along the way.

Why it matters:
When a supernova explodes, it releases an enormous amount of energy in the form of photons. These photons travel through layers of hot, expanding gases, where they can be:

Absorbed by atoms (which raises them to an excited state),
Re-emitted at different energies (wavelengths),
Scattered in different directions.

Understanding these interactions is key to interpreting what we see in a telescope. By simulating radiative transfer, we can recreate what a supernova’s light would look like from Earth and match it against real observations.

🎲 Monte Carlo Method

What is it?
The Monte Carlo method is a computational technique that uses random sampling to simulate complex processes. In TARDIS, it’s used to model the behavior of photon packets.

How TARDIS uses it:

Imagine a huge number of photon packets being released from the core of a supernova.
Each packet moves through the ejecta (outer layers of the star), and at each step, a random decision determines whether it’s absorbed, scattered, or continues on its path.
These decisions are based on probabilities derived from physical laws and atomic data.

By simulating the paths of millions of these packets, TARDIS builds a statistical picture of the emerging spectrum—what an observer would see. It’s a powerful and efficient way to model the highly random, chaotic nature of radiative processes in space.

⚛️ Atomic Data

What is it?
Atomic data includes fundamental information about atoms and ions, such as:

Ionization energies : How much energy it takes to remove an electron.
Energy levels : The specific energies electrons can have.
Transition probabilities : How likely it is for an electron to jump from one level to another.
Spectral lines : The wavelengths of light emitted or absorbed when these transitions happen.

Why it’s crucial:
Without accurate atomic data, TARDIS wouldn’t know how photons should behave when they encounter different atoms in the supernova ejecta. Carsus plays a vital role here by compiling, cleaning, and formatting this data so TARDIS can use it.

This data lets TARDIS:

Predict which colors of light will be emitted or absorbed.
Simulate spectral lines that appear in real telescope observations.
Help astronomers identify the chemical composition of the supernova.

TARDIS-SN Architecture

This architectural diagram has been generated using GitDiagram and reflects my current understanding and interpretation. For authoritative information, reference to official documentation or direct consultation with project maintainers is recommended.

Key Components and their Interactions:

Model System: Defines the basic attributes of the supernova environment, including geometry, matter composition, and decay handling.
Plasma Physics System: Focuses on detailed plasma calculations such as equilibrium calculations, rate equations, level populations, and radiation field characterization.
Transport System: Utilizes the Monte Carlo method to simulate how photons travel through the supernova's ejecta, performing geometric calculations, packet tracking, and frame transportation.
Core Components:

Model Layer: Integrates data from the Model System and Plasma Physics System, guiding the simulation process.
Transport Layer: Handles photon transport based on inputs from the Plasma Physics System.
Spectrum Generation: Converts simulated photon interactions into observable spectra.
Supporting Systems: Provide essential utilities for efficient simulation, including configuration management, input/output handling, visualization, and analysis tools.

🧩 Modular Design

TARDIS is neatly divided into modules:

simulation: Coordinates the overall simulation.
plasma: Manages physical states like ionization and temperature.
transport: Handles Monte Carlo radiative transport.
io: Reads and validates configuration and atomic data.
spectrum: Produces and stores the final synthetic spectrum.
visualization: Offers helpful plots and interactive widgets.

Each module is independently testable and designed for plug & play enhancements, making it ideal for contributors.

🛠 How TARDIS Works -> A Simple Workflow

Here’s a high-level overview of what happens when TARDIS runs:

1️⃣ Input Setup:

Users prepare a YAML configuration file describing the supernova model: density, composition, time since explosion, etc.

TARDIS also uses external atomic data provided in HDF5 format.

HDF5 (Hierarchical Data Format version 5) is a file format and set of tools designed for managing complex data. It allows you to store large amounts of numerical data and metadata in a single, highly organized file that's both scalable and efficient. HDF5 supports a variety of data types and is ideal for handling large datasets, making it widely used in fields like scientific research, engineering, and data analysis. Key features include support for multidimensional arrays, efficient storage and retrieval, data compression, and the ability to store metadata alongside the data.

2️⃣ Initialization:

The model grid (usually 1D spherical shells) and plasma conditions are set up.

Photon packets are initialized with starting positions and directions.

3️⃣ Monte Carlo Simulation:

These packets are tracked as they interact with the matter: being absorbed, re-emitted, or scattered.

This process continues until the packet escapes the system or its energy is fully absorbed.

4️⃣ Spectrum Generation:

The emergent photon packets are collected to form a synthetic spectrum.

This output can then be compared with actual observations.

5️⃣ Output & Analysis:

Users can analyze the generated spectra, convergence behavior, and plasma states.

TARDIS provides utilities for visualization and diagnostic plots

▶️ A small Demo for TARDIS

Installation

1) Install Miniconda (if not already installed):
Download from https://docs.conda.io/en/latest/miniconda.html and follow the installation instructions for your operating system.

2) Create a new conda environment:

   conda create -n tardis-env python=3.10
   conda activate tardis-env

3) Install TARDIS:

   pip install tardis-sn

Note: For the latest development version or to contribute, consider cloning the repository from GitHub: https://github.com/tardis-sn/tardis

Running a Basic Simulation

1) Download a sample configuration file:

   wget https://raw.githubusercontent.com/tardis-sn/tardis/master/tardis/io/configuration/tests/data/tardis_configv1.yml

2) Run the simulation:

   tardis tardis_configv1.yml

This command will process the configuration and generate a synthetic spectrum based on the provided parameters.

3) Visualize the output:
After the simulation completes, you can visualize the generated spectrum using Python:

   import matplotlib.pyplot as plt
   from tardis.io.output import read_spectrum

   spectrum = read_spectrum('tardis_configv1.yml')
   plt.plot(spectrum.wavelength, spectrum.luminosity_density_lambda)
   plt.xlabel('Wavelength (Angstrom)')
   plt.ylabel('Luminosity Density')
   plt.title('Synthetic Spectrum')
   plt.show()

Ensure you have matplotlib installed in your environment. If not, install it using pip install matplotlib.

📚 Learn More

For detailed guidance on customizing simulations, understanding configuration parameters, and exploring advanced features, refer to the official TARDIS documentation: https://tardis-sn.github.io/

✨ Do give it a star: TARDIS-SN ⭐

CARSUS: The Atomic Data Engine Behind TARDIS

If TARDIS is the telescope through which we view supernovae, Carsus is the database behind the lens.

🧾 What Is Carsus?

Carsus is a Python package designed to process, standardize, and output atomic data for use in radiative transfer simulations, especially those run by TARDIS. It is a package to manage atomic datasets. It can read data from a variety of sources and output them to file formats readable by radiative transfer codes.

It acts as the bridge between raw atomic datasets (from databases like NIST, Kurucz, Chianti, CMFGEN, etc.) and the HDF5-formatted atomic files that TARDIS understands.

🔍 Why Is It Important?

Supernova simulations require precise atomic data: energy levels, line transitions, ionization potentials, and more. These values affect how light moves through supernova ejecta, and therefore, how accurately we can model spectra.

Carsus ensures:

♻️ Consistency across data sources,
⚙️ Customizability for research needs,
💾 Output in HDF5 format for TARDIS,
📚 Provenance and reproducibility with citation tracking and version control.

CARSUS Architecture

Key Components:

Carsus Core: The central component that orchestrates data processing, ensuring seamless interaction between utilities and the data module.
Data Module: Responsible for accessing and organizing atomic data from various sources, such as chianti, Kurucz, NIST, and others.
Utilities: Provides auxiliary functions that aid in data manipulation and processing, integrating closely with the Carsus Core.
Carsus IO: Handles input/output operations, facilitating the conversion of raw data from multiple repositories into a usable form.
CARSUS Architecture: Ensures data reliability through testing and validation, along with continuous integration, continuous deployment (CI/CD), and documentation processes.

How Carsus Works —> A Simplified Workflow

1) Data Parsing:

Carsus supports multiple databases (e.g., NIST, Kurucz, CMFGEN, Chianti).
Parsers in carsus/io/ read raw data and convert it into Pandas DataFrames.

2) Data Transformation:

Values are cleaned, standardized, and sometimes enhanced (e.g., adding weights, correcting formats).
Intermediate DataFrames are managed with clear units and structure.

3) Output Generation:

The cleaned and unified data is exported into HDF5 files using carsus.io.output.
These files include levels, lines, ionization energies, collisions, macro-atom data, and more.

Integration with TARDIS:

Once the data is exported, TARDIS can load these files to run radiative transfer simulations.

🗂 Carsus Codebase

io: Home to all input/output parsers (e.g. chianti_, kurucz, nist, vald, cmfgen).
io/output: Generates final HDF5 datasets.
data: Contains test and default input data.
util: Helper functions for logging, hashing, unit management, and more.
tests: Ensures reliability via pytest-based unit tests.

✨ Do give it a star: CARSUS ⭐

Note: I haven’t explored the STARDIS module yet, but if I do in the future, I’ll be sure to update this blog with my insights.

My Pre-GSoC Contribution

The Problem statement / Idea

The Solution

How I approached the problem
1) Understanding the Data Structure: Delving into the HDF5 atomic data files to comprehend how ionization energies are stored and accessed.
2) Function Implementation: Writing the functions required to perform the tasks.

3) Testing and Validation: Ensuring the function's reliability through unit tests and comparing results with known values.

[GSOC]-Metadata for atomic data #442

AkashJana18 posted on Mar 29, 2025

📝 Description

Type: 🚀 feature Implements metadata support for Carsus atomic data outputs as specified in the first project objective:

Metadata Table
- New MetadataHandler class stores:
  - Physical units (validated via Astropy, e.g., "angstrom", "Hz")
  - Journal article references (DOIs, manual entry)
  - Git commit hashes (automated when run in a repository)
Output Formats
- HDF5: Metadata stored in /metadata group (units, references, git info)
- Pandas DataFrame: Metadata accessible via read_hdf_with_metadata()
Automation (Bonus)
- Git commit hash auto-detection
- Unit validation (rejects invalid units like "not_a_unit")

📜 Example Usage

from carsus.io import save_to_hdf, MetadataHandler

# Initialize with manual metadata
handler = MetadataHandler(data_source="NIST")
handler.add_units("wavelength", "angstrom")  # Physical unit
handler.add_reference(
    doi="10.1051/0004-6361/201526937",      # Journal article DOI
    description="NIST Atomic Spectra Database"
)

# Save to HDF5 (or use with Pandas)
save_to_hdf(
    df=atomic_data, 
    path="output.h5",
    metadata_handler=handler
)

🚦 Testing

Unit Tests: pytest tests/test_metadata.py (100% coverage)

Manual Verification:

Confirmed HDF5 metadata structure with h5ls
Validated unit enforcement
Verified reference persistence

☑️ Checklist

[x] Requested reviewers: @AndreasFlörs @AndrewFullard
[x] I updated the documentation according to my changes
[x] Added comprehensive docstrings

Note: If you are not allowed to perform any of these actions, ping (@) a contributor.

View on GitHub

In March, I embarked on an exciting journey by raising a PR and eagerly seeking feedback on Gitter. Determined to make a mark, I tried tackling additional issues and launched into crafting my GSoC proposal. With the proposal being a pivotal factor for selection, I devoted more than 25 hours over several days to ensure it was robust and compelling.

Cover Page of Proposal

My confidence surged when I received the delightful news that I was shortlisted for an interview.

Interview Confirmation mail

But my excitement quickly turned to disappointment; although I aced the behavioral questions, I stumbled over the technical ones even those that were straightforward.

The technical questions included:

What library is used to interact with HDF5 files?
What is an HDF5 file?
What is a subprocess in Python?
What are class methods in Python?
Which functions are used to read, write, and perform other operations on HDF5 files?

The behavioral inquiries were such as:

What would you do if you believe there's a better solution to a problem than the one suggested by the maintainer?
How do you approach fixing bugs and errors?
How would you handle a situation where differing opinions within the team lead to conflict?

After the interview, I felt disheartened and spent the entire day grappling with the thought that I could have performed better. I should have focused more on strengthening my Python skills instead of solely diving deep into the codebase. My advice: don't repeat this mistake. The next day, surrounded by thoughts of wasted effort and missed opportunities, clarity struck

What was the true purpose? It wasn't just about GSoC; the true aim was to contribute to something meaningful, impactful, and genuinely valuable.

This realization lifted my spirits, and I decided to pen this blog post, hoping future contributors won't make the same mistakes.

If you're working on the Carsus metadata component, I'd be happy to share my proposal with you. Regardless of the outcome of the GSoC results, my commitment remains strong as I will continue to contribute in the true spirit of open source. And with renewed focus and determination, I'm confident that I will succeed in next year's selection.

Planned Metadata ecosystem

I'm always open to lending a hand, whether you have questions, need guidance, or just want to chat about your own experiences. Feel free to reach out to me with any inquiries or requests for assistance as you navigate your own path within the open-source community. Together, we can learn, grow, and make meaningful contributions. I look forward to hearing from you!

Connect on X

If you are looking to learn oops concept in fun way do check this out!

Akash Jana — Sat, 12 Apr 2025 17:04:29 +0000

Akash Jana

Apr 10 '25

Object-Oriented Emotions

#programming #learning #cpp #oop

Comments 7

4 min read

Object-Oriented Emotions

Akash Jana — Thu, 10 Apr 2025 18:54:37 +0000

📝 Intro: Why OOP Needs a Rebrand

Let’s be honest most people learn Object-Oriented Programming (OOP) from textbooks that feel like they were written by robots for other robots. Dry terms. Boring examples. Zero vibes.

But OOP is literally how the world works. Humans are objects, our behaviors are methods, and our feelings? Encapsulated, of course.

This blog is my attempt to bring some fun and feels into OOP through a quirky message my bbg sent me, a little decoding, and a whole lot of creativity. Whether you’re new to programming or a seasoned dev, I promise this will be the most emotionally intelligent OOP guide you’ve read.

🧶 A Little Backstory

So the yesterday, my bbg sent me a message. It said:

At first, I sat there blinking at my phone like a compiler stuck in an infinite loop. Was this a poetic cry for help… or just the nerdiest way to say “I’m in my feels”?

After a few minutes of hardcore mental parsing (and a smile ofc), I realized: this is gold. After a few minutes of decoding and appreciation, it hit me: this is brilliant. Not just as a one-liner, but as the perfect metaphor to explain Object-Oriented Programming (OOP) in a way that’s real, hilarious, and surprisingly accurate.

So this blog? Yeah, it was inspired by that message. Because let’s be honest OOP is way more fun when explained through emotions.

Because the world needs to know that OOP isn’t just a programming concept — it’s how we all live.

Love, Logic, and Line-by-Line Debugging

Let’s face it, understanding Object-Oriented Programming (OOP) can be... dry. Words like encapsulation and polymorphism sound like spells from a wizarding school for witchcraft computers.

But what if I told you you're already an OOP master? Yes, you, the emotionally complex human reading this. Because we all live like objects full of state, behaviors, and yes... emotions.

💬 Meet `class Human`

class Human {
private:
    Emotion emotion;

public:
    Human() {
        emotion = Emotion::Neutral;
    }

    void receiveMessage(std::string msg) {
        if (msg == "Hi :)") {
            emotion = Emotion::Happy;
        } else if (msg == "We need to talk.") {
            emotion = Emotion::Anxious;
        }
        react();
    }

    void react() {
        switch (emotion) {
            case Emotion::Happy:
                std::cout << "Smiles and replies instantly!" << std::endl;
                break;
            case Emotion::Anxious:
                std::cout << "Seen at 2:33 PM, no reply." << std::endl;
                break;
            default:
                std::cout << "Typing..." << std::endl;
        }
    }
};

You're a walking, talking class. And you’re encapsulated.

🔐 What is Encapsulation?

Encapsulation is like putting your emotions behind a secure API.

You don’t let people directly access your private emotion variable.
You do give them public methods like receiveMessage() to interact with you.
If someone tries to call a random function like poke(), it’ll still go through the emotion check.

In real life? That’s like saying:

“You can talk to me, but how I feel about it will be handled internally. My emotion functions are running silently in the background. Good luck guessing the return value.”

😮 Inheritance? Oh honey, that's family drama

Sorry for the cringe lines T_T but its fun so why not XD

class Developer : public Human {
public:
    void writeCode() {
        std::cout << "Crying in Git commits." << std::endl;
    }
};

Just like in life, children (subclasses) inherit traits and behavior from their parents (base classes), but also have their own quirks. A Developer still feels emotions (inherited from Human) but also has special abilities like writeCode() or ragePushToProd().

🌀 Polymorphism – One Interface, Many Feelings

You say “good morning” to both:

Your boss (class Manager)
Your crush (class Babygirl)

Both respond differently, even though you called the same function: sayGoodMorning().

That’s polymorphism. One function, many behaviors — determined by the object receiving it.

Manager* m = new Manager();
Babygirl* b = new Babygirl();

m->sayGoodMorning(); // "Let’s discuss your progress."
b->sayGoodMorning(); // "Aww, finally! 😘"

🧼 Abstraction: Hiding the Mess

You don’t need to know how someone handles emotions internally, you just know that when you say something nice, they smile. That’s abstraction.

In code:

You call react() without knowing the emotional algorithm behind it.

In life:

You send a meme. They laugh. That’s all you need.

✨ Final Thoughts: Be Like an Object

So next time someone asks why you're taking time to reply, you can say:

“Sorry babe, I’m encapsulated with some emotional member functions right now. Input received, response coming after exception handling.”

Object-Oriented Programming isn’t just about code it’s a metaphor for life. Encapsulate your emotions. Abstract the noise. Inherit good traits. And be polymorphic enough to adapt.

🔁 TL;DR

Encapsulation: Emotions are private. Interact through safe functions.
Inheritance: Traits passed down with added spice.
Polymorphism: Same function, different reactions.
Abstraction: Hide the internal chaos. Smile on the outside.

If this post made you chuckle and learn, share it with a friend who still thinks OOP is boring. Or better yet, fork yourself into class Influencer and spread the joy.

Want a Part 2 with class Relationship, Exception Handling (BreakUps), or Design Patterns of a Clingy Coder? Hit me up 😄

Conquering the Setup Loop with Daytona

Akash Jana — Fri, 27 Dec 2024 16:12:28 +0000

How I Started Using Daytona 🛠️

As a developer juggling multiple projects, I often found myself stuck in the dreaded "setup loop." Every new project meant 30-40 minutes sometimes hours configuring environments to match different dependencies and tooling requirements. It felt like I was spending more time setting up than actually coding... for fixing small bugs in massive repositories. 😩

Quira Quest 023 introduced a hidden gem: Daytona. Intrigued, I gave it a quick search and discovered its promise of creating Workspaces preconfigured development environments that just work. Could this be the end of my setup nightmares? Spoiler alert: It was.

What is Daytona? 🤔

Daytona is an open-source tool that helps developers create, manage, and use ready-to-go coding environments called Workspaces. Think of it as a magic wand 🪄 for your development setups. It works seamlessly with container tech (like Docker) and popular tools like Git and Visual Studio Code.

Key Features That Won Me Over 🎉

🔒 Secure Access: No more messy port forwarding. Daytona sets up a secure connection between your machine and the remote server effortlessly.

💻 IDE Support: Whether you're a Visual Studio Code fan or a JetBrains loyalist, Daytona has your back.
🔗 Seamless Git Integration: Pull, push, or commit directly from the Workspace without ever leaving your flow.

📂 Multi-Project Workspaces: Managing microservices? Multiple repositories? Daytona makes it a breeze.

🌐 Easy Sharing: Share your Workspace over public or restricted networks with just a few clicks.
🔧 Customizable: Extend functionality with Go plugins or integrate with tools you love.

In short, Daytona takes the hassle out of setup and lets you focus on what you do best: coding.

Link to the flow chart: Daytona Features flowchart

A Quick Vocabulary Lesson 📘

Here are some terms I picked up while getting to know Daytona:

Dev Container: A pre-configured environment that contains all the tools and settings you need. Think of it as your development Swiss army knife. 🛠️
Workspace: Your digital playground where files, code, and projects live harmoniously. 🏞️
Git Providers (SCMs): Tools like GitHub, GitLab, and Bitbucket that help you host and collaborate on codebases. {SCMs: Source Code Managers}
Target: The destination for your development setup local machine, remote server, or the cloud. ☁️

Let’s Get Started 🚀

For this tutorial, I’ll show you how I used Daytona to integrate GlobalSync, a frontend project using Aceternity UI.

✨ Do give it a star: GlobalSync Frontend ⭐

Step 1️⃣: Installing Daytona 🖥️

For Windows, run the following in PowerShell:

$architecture = if ($env:PROCESSOR_ARCHITECTURE -eq "AMD64") { "amd64" } else { "arm64" }
md -Force "$Env:APPDATA\bin\daytona"; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]'Tls,Tls11,Tls12';
Invoke-WebRequest -URI "https://download.daytona.io/daytona/v0.50/daytona-windows-$architecture.exe" -OutFile "$Env:APPDATA\bin\daytona\daytona.exe";
$env:Path += ";" + $Env:APPDATA + "\bin\daytona"; [Environment]::SetEnvironmentVariable("Path", $env:Path, [System.EnvironmentVariableTarget]::User);
daytona serve;

📝 For other OS (Linux, macOS, Homebrew, Nix), check out Daytona Installation Guide.

Step 2️⃣: Setting Up a Dev-Container 📦

Create a folder named .devcontainer in your repository. (Yes, the dot is important. Don’t skip it!)
Inside, add a devcontainer.json file.

Here’s how mine looks:

{
    "name": "GlobalSync Development Container",
    "image": "mcr.microsoft.com/devcontainers/javascript-node",
    "forwardPorts": [
      3000
    ],
    "customizations": {
      "vscode": {
        "settings": {
          "eslint.enable": true,
          "editor.formatOnSave": true
        },
        "extensions": [
          "esbenp.prettier-vscode",
          "dbaeumer.vscode-eslint",
          "ms-vscode.vscode-typescript-tslint-plugin"
        ]
      }
    },
    "postCreateCommand": "npm install"
}

Pro Tip: You can generate this file with DevContainer.ai to save time! ⏳

Step 3️⃣: Configuration ⚙️

1. Connect Daytona to Your Git Repositories 🛠️
First things first connect Daytona to your version control system! Whether you’re working with GitHub, GitLab, or any other Git provider, Daytona makes it seamless to manage your repositories. Just run this command in your terminal:

daytona git-providers add

Once done, Daytona will ask you to authenticate with your chosen Git provider. A few clicks, and voilà! You’re ready to fetch code, push commits, and manage branches directly from your Workspace. No more hunting down SSH keys or copy-pasting HTTPS URLs Daytona handles it all for you. 🎉

2. Install a Cloud Provider ☁️
Next up, let’s set up a cloud provider. If you’re deploying your Workspace on platforms like AWS, Azure, or Google Cloud, this step is essential. Installing a provider ensures Daytona can interact with these platforms smoothly.

Run this command:

daytona provider install

Daytona will guide you through the setup adding credentials, configuring access, and more. Don’t worry, it’s all secure and straightforward. By the end, your cloud environments will be ready for action, making collaboration and scalability a breeze.

3. Set a Target 🎯

A "Target" is simply where your development environment will live. It could be:

Local Docker instance (great for personal projects).
Remote servers (ideal for team collaborations).
Cloud platforms like AWS or GCP.

To define your target, use this command:

daytona target set

Daytona will ask a few questions like which platform to use and any specific configurations. Once set, it’ll remember your target, so you can jump into coding without worrying about the underlying setup. 💪

4. Choose Your IDE 💻
Let’s face it, we all have our go to IDE. Whether you’re a VS Code enthusiast, an IntelliJ master, or someone who swears by Vim, Daytona has you covered. To link your favorite IDE to Daytona, run:

daytona ide

Daytona will configure your IDE to work seamlessly with the Workspaces. This means you’ll have all the power of your IDE debugging, extensions, and custom shortcuts working in harmony with your remote environment. It’s like bringing the comfort of home to your cloud setup! 🏡✨

Ready to Code! 🚀
With your Git provider, cloud platform, target, and IDE set up, you’re all set to unleash the magic of Daytona. No more wasting time on repetitive configurations just run a command and get straight into solving the next big problem!

Step 4️⃣: Create Your Workspace 🖇️

Finally, create your Workspace with this command:

daytona create <REPO_URL>

Run your project locally using:

npm run dev

My View 🤓

I didn't have any issue using Daytona for my development workflow. From eliminating the headaches of environment setup to simplifying multi-repo management, it feels like having a personal assistant for coding.

So, if you’re tired of wasting hours in the "setup loop" ⏳, give Daytona a shot. Trust me, your future self will thank you! 🙌

And hey, don’t forget to give Daytona and GlobalSync a star while you’re at it. Who knows, it might inspire your next big project! 💡✨

daytonaio / daytona

Daytona is a Secure and Elastic Infrastructure for Running AI-Generated Code

Run AI Code
Secure and Elastic Infrastructure for Running Your AI-Generated Code

Documentation · Report Bug · Request Feature · Join our Slack · Connect on X

Installation

Python SDK

pip install daytona

TypeScript SDK

npm install @daytonaio/sdk

Ruby SDK

gem install daytona

Go SDK

go get github.com/daytonaio/daytona/libs/sdk-go

Features

Lightning-Fast Infrastructure: Sub-90ms Sandbox creation from code to execution.
Separated & Isolated Runtime: Execute AI-generated code with zero risk to your infrastructure.
Massive Parallelization for Concurrent AI Workflows: Fork Sandbox filesystem and memory state (Coming soon!)
Programmatic Control: File, Git, LSP, and Execute API
Unlimited Persistence: Your Sandboxes can live forever
OCI/Docker Compatibility: Use any OCI/Docker image to create a Sandbox

Quick Start

Create an account at app.daytona.io
Generate a new API key
Follow documentation to start using Daytona

Creating your first Sandbox

Python SDK

from daytona import Daytona, DaytonaConfig
config = DaytonaConfig(

…

View on GitHub

And before I sign off, here are some useful links:

A big shoutout to the incredible folks behind Quira and Daytona. Your innovation has made our developer lives a whole lot easier and dare I say a bit more fun!

Kudos to the entire team, and here’s to many more seamless setups and productive coding sessions! 🚀

My Tech Journey - Web Dev | DSA | Open Source

Akash Jana — Fri, 20 Dec 2024 08:37:16 +0000

Let me take you on a rollercoaster🎢 ride through my tech journey – a tale of code💻, chaos😵, and occasional caffeine☕-induced enlightenment.

- Disclaimer :
+ These are my personal experiences and thoughts.
+ I’m always open to healthy criticism and constructive feedback.
+ Let’s keep it positive and productive!

💻 The Great Leap into Coding

It all started in the second year of college.
Picture this: a clueless sophomore staring at a screen full of cryptic text, wondering if C was just a letter or a secret language from the Matrix. Turns out, it’s both.

After struggling with C, I decided to explore other languages. Java? Check. Python? Check. A bit of C++ for flavor? Sure, why not? By the end of it, I felt like a polyglot of programming – or at least a jack of all trades, master of none.

But hey, the goal wasn’t mastery . It was about getting an overall view of coding, like a tourist hopping between countries without learning the local language. Mission accomplished! 🌎

🌐 Web Development: Love at First <div>

Web development was my next major exploration. It began with learning HTML and CSS, the foundational tools for creating websites. Following this, I ventured into JavaScript. However, I regret not dedicating sufficient time to thoroughly understand its concepts. Instead, I quickly transitioned to React faster than a coder Googling “How to center a div.”

React became an immediate favorite as I delved deeper into it. I expanded my skills further by learning Node.js and Express, along with a basic understanding of MongoDB, eventually working towards becoming a so called MERN Stack Developer. The real game-changer, however, was discovering Next.js. This framework elevated my development experience and quickly became my preferred tool. Learnt Typescript & Tailwind.

✨ Got my tech stack ready: ✨

Stuck on tutorial hell for number of times (But you don't need to... the solution is given further in blog)

With Next.js, I built projects, hosted them on GitHub, and shared them with the world. The world’s response? Cricket noises 🦗[Dead drop silence]. Well, except for my friends, who gave me some compliments. Thanks, guys. You’re the real MVPs. 🥇

Maybe you want to check them out!

AkashJana18 (Akash Jana) · GitHub

Always seems impossible until its done. . AkashJana18 has 57 repositories available. Follow their code on GitHub.

github.com

👿 DSA: The Necessary Evil

Towards the end of my second year, I got the DSA ~~fever~~ FOMO (that’s Data Structures and Algorithms, for the uninitiated). It’s the golden ticket to a tech job, they said. So, I plunged headfirst into the grind, solving over 500 questions across various platforms.

But let’s be real – DSA is ~~exhausting, tiresome, boring as hell~~ demanding and rigorous. The reward? Zero, unless you’re at the very top. It’s like training for a marathon and realizing halfway through that there’s no finish line. I tried to stay consistent, but the monotony was soul-crushing. 😫

But here's my Leetcode profile:

Pro tip :
DSA is great for your resume & job, but don’t let it kill your love for coding.

👑 Open Source: The Late Bloomer’s Redemption

Fast forward to my final year, September 2024. I discovered open source, and it was a game-changer. Why didn’t I start earlier? Because I doubted myself. 😔

But once I got started, there was no looking back. Open source was everything I’d been missing: recognition, validation, help from a global community, and yes – actual cash. It is solution to tutorial hell as you apply your knowledge in real. I won swags, built credibility, and finally felt like I was making a difference.

The only regret? Not starting sooner. If you’re reading this and thinking about open source, ✔ just do it. The rewards are worth it. ✨

Some suggestions to get started: Quira

🪁 024: CoAgents v0.2 release

CopilotKit is an open-source tool that makes it extremely easy to integrate AI copilots into your React apps. Imagine in-app context-aware chatbots, AI-enhanced text fields, or in-app AI agents that interact seamlessly with both your application and its users. Currently, CopilotKit is working on Co-Agents a new product that provides infrastructure for connecting LangGraph agents to humans in the loop.

This December, CopilotKit is releasing CoAgents v0.2 which includes LangGraph Cloud Support, LangGraph JS, and improved documentation. The challenge is to work on a CoAgents demo to help the CopilotKit team stress-test CoAgents and helping them find bug fixes.

🪁 CoAgent Quest ✨

023: 𝐓𝐚𝐤𝐞 𝐃𝐚𝐲𝐭𝐨𝐧𝐚 𝐟𝐨𝐫 𝐚 𝐬𝐩𝐢𝐧

Daytona is an open-source Development Environment Manager (DEM) licensed under the Apache License 2.0. Daytona allows you to manage and deploy Workspaces — reproducible development environments based on standard OCI containers, with built-in support for the Dev Container standard.

Your mission, if you choose to accept it, is to create a sample project for Daytona using your preferred tech-stack.

💻 Daytona Quest ✨

There are 100 prizes of $50 which will be awarded to the first 100 valid submissions! And an extra $1000 prize pool to reward to exceptional samples!

🎐 Winding up

My tech journey has been a mixed bag of mistakes, milestones, and moments of pure joy. If there’s one thing I’ve learned, it’s this: tech is as much about the journey as the destination. So, embrace the chaos, learn from your mistakes, and most importantly, have fun along the way. 🎮

What’s your tech journey like? Share it in the comments below. Let’s swap stories and grow together. Happy coding! 🚀

From Zero to Merge: Building a JSON Renaming Field Component in Go

Akash Jana — Tue, 12 Nov 2024 19:00:51 +0000

Introduction to Instill-ai

Working on Instill’s pipeline-backend project was like solving a jigsaw 🧩 puzzle—except some pieces kept changing names! My mission? To create a component that could rename JSON fields without creating conflicts. Join me as I share my journey through learning Go, studying Instill’s well-organized docs, and creating a solution that’s now merged and ready to roll! 🎉

The Challenge

Instill needed a way to rename fields in JSON data structures dynamically. The twist? We had to handle cases where a renamed field might clash with an existing field. Without a conflict resolution system, chaos would reign supreme!

Checkout the Issue here:

[JSON] Support Rename Fields for JSON operator #1133

ShihChun-H posted on Oct 09, 2024

Issue Description

Current State

It is very difficult to manipulate JSON data with JSON operator.

Proposed Change

Please fetch this JSON Schema to implement the functions.
Manipulating JSON data

JSON schema pseudo code

JsonOperator:
  Task: Rename fields
  
  Input:
    data: 
      type: object
      description: Original data, which can be a JSON object or array of objects.
    fields: 
      type: array
      description: An array of objects specifying the fields to be renamed.
      items:
        type: object
        properties:
          currentField: 
            type: string
            description: The field name in the original data to be replaced, supports nested paths if "supportDotNotation" is true.
          newField: 
            type: string
            description: The new field name that will replace the currentField, supports nested paths if "supportDotNotation" is true.
#    supportDotNotation:
#      type: boolean
#      default: true
#      description: Determines whether to interpret field names as paths using dot notation. If false, fields are treated as literal keys.
    conflictResolution:
      type: string
      enum: [overwrite, skip, error]
      default: overwrite
      description: Defines how conflicts are handled when the newField already exists in the data.
  
  Output:
    data:
      type: object
      description: The modified data with the specified fields renamed.

Key Features: conflictResolution: Handling conflicts when renaming fields in JSON, especially when working with nested objects and dot notation, is critical to avoid data loss or unexpected behavior. Allow users to specify how they want conflicts to be resolved (e.g., via a parameter such as conflictResolution: 'overwrite'|'skip'|'error'),

Provides flexibility and control to the user.
Adapts to different use cases.

Here are different strategies to manage conflicts and some considerations for each.

1. Overwrite the Existing Field (Default Behavior)

Description: If the newField already exists in the object, overwrite its value with the value from currentField. Pros:

Simple and straightforward.
Useful when the intention is to replace the existing value. Cons:
Can lead to data loss if not used carefully.

Implementation:

if new_key in obj:
    obj[new_key] = obj.pop(current_key)
else:
    obj[new_key] = obj.pop(current_key)

2. Skip the Renaming Operation

Description: If the newField already exists, skip the renaming operation for that particular field. Pros:

Prevents accidental overwriting of data.
Safeguards against potential conflicts without altering the existing data. Cons:
The currentField remains unchanged, which might not be the desired outcome.

Implementation:

if new_key in obj:
    # Skip renaming if new_key already exists
    continue
else:
    obj[new_key] = obj.pop(current_key)

3. Merge Values

Description: If both currentField and newField exist and contain objects or arrays, merge the two values. This approach is more complex but can be very powerful. Pros:

Preserves both sets of data.
Useful for combining information rather than choosing one over the other. Cons:
Can be complex to implement, especially if the data types of currentField and newField differ.
May require custom logic depending on how you want to merge the data (e.g., combining arrays, merging objects, etc.).

Implementation:

if new_key in obj:
    if isinstance(obj[new_key], dict) and isinstance(obj[current_key], dict):
        # Merge dictionaries
        obj[new_key].update(obj.pop(current_key))
    elif isinstance(obj[new_key], list) and isinstance(obj[current_key], list):
        # Merge lists
        obj[new_key].extend(obj.pop(current_key))
    else:
        # Handle other types (overwrite, append, etc.)
        obj[new_key] = obj.pop(current_key)
else:
    obj[new_key] = obj.pop(current_key)

4. Rename with a Suffix or Prefix

Description: If the newField already exists, rename the new field by appending a suffix or prefix (e.g., _1, _conflict) to avoid conflicts. Pros:

Both original and new data are preserved.
Easy to track conflicts. Cons:
The resulting data structure may become less predictable or harder to work with if many conflicts occur.

Implementation:

suffix = 1
original_new_key = new_key
while new_key in obj:
    new_key = f"{original_new_key}_{suffix}"
    suffix += 1
obj[new_key] = obj.pop(current_key)

5. Return an Error or Warning

Description: If a conflict is detected, stop the operation and return an error or warning to the user. This forces the user to address the conflict before proceeding. Pros:

Prevents accidental data overwriting.
Makes the user aware of potential issues immediately. Cons:
Halts the process, which might be undesirable in automated workflows.

Implementation:

if new_key in obj:
    raise ValueError(f"Conflict detected: '{new_key}' already exists.")
else:
    obj[new_key] = obj.pop(current_key)

Summary:

Overwrite: Simple and effective, but can lead to data loss.
Skip: Safe but may leave data unchanged.
Error/Warning: Forces user intervention; best for critical operations. Choose the strategy that best aligns with your application's needs and the user's expectations. Implementing a combination of these strategies, such as providing a default behavior with options for customization, can offer the best balance between usability and robustness.

Example Usage:

Scenario: Input data as JSON object

// input { "data": { "name": "John Doe", "age": 30, "address": { "street": "123 Main St", "city": "Anytown", "state": "CA" }, "state": "conflict" }, "fields": [ {"currentField": "address.street", "newField": "address.road"}, {"currentField": "state", "newField": "address.state"} ], // "supportDotNotation": true, "conflictResolution": "overwrite" }

Conflict Resolution Scenarios: 1. Overwrite (Default):

The state field in data would be moved to address.state, overwriting the existing address.state field.
Final output:

{
  "data": {
    "name": "John Doe",
    "age": 30,
    "address": {
      "road": "123 Main St",
      "city": "Anytown",
      "state": "conflict"
    }
  }
}

2. Skip:

The renaming of state to address.state would be skipped, so both state and address.state remain unchanged.
Final output:

{
  "data": {
    "name": "John Doe",
    "age": 30,
    "address": {
      "road": "123 Main St",
      "city": "Anytown",
      "state": "CA"
    },
    "state": "conflict"
  }
}

3. Error:

The process would raise an error, stopping execution, because address.state already exists. ValueError: Conflict detected: 'address.state' already exists.

Scenario: Input Data as an Array of Objects

If the input data is an array of objects, the logic needs to be adapted to handle each object in the array individually. The schema and the function would process each object within the array according to the specified fields and conflictResolution rules.

Below is an example demonstrating how the "Rename Fields" operation would work with input data that is an array of objects.

Input

{
  "data": [
    {
      "name": "John Doe",
      "age": 30,
      "address": {
        "street": "123 Main St",
        "city": "Anytown",
        "state": "CA"
      },
      "contacts": [
        {
          "type": "email",
          "value": "john.doe@example.com"
        }
      ]
    },
    {
      "name": "Jane Smith",
      "age": 28,
      "address": {
        "street": "456 Oak St",
        "city": "Othertown",
        "state": "NY"
      }
      // Note: Jane Smith does not have a "contacts" field
    }
  ],
  "fields": [
    {"currentField": "name", "newField": "fullName"},
    {"currentField": "address.street", "newField": "address.road"},
    {"currentField": "contacts.0.value", "newField": "contacts.0.contactInfo"},
    {"currentField": "age", "newField": "yearsOld"}
  ],
//  "supportDotNotation": true,
  "conflictResolution": "skip"
}

Explanation:

Field "name": The "name" field will be renamed to "fullName" for each object in the array.
Field "address.street": The "street" field inside the "address" object will be renamed to "road" for each object.
Field "contacts.0.value": The "value" field inside the first element of the "contacts" array will be renamed to "contactInfo" for the first object, but this step will be skipped for the second object because the "contacts" field does not exist.
Field "age": The "age" field will be renamed to "yearsOld" for each object.

Output:

{
  "data": [
    {
      "fullName": "John Doe",
      "yearsOld": 30,
      "address": {
        "road": "123 Main St",
        "city": "Anytown",
        "state": "CA"
      },
      "contacts": [
        {
          "type": "email",
          "contactInfo": "john.doe@example.com"
        }
      ]
    },
    {
      "fullName": "Jane Smith",
      "yearsOld": 28,
      "address": {
        "road": "456 Oak St",
        "city": "Othertown",
        "state": "NY"
      }
      // The "contacts" field is not present, so no renaming occurs for "contacts.0.value"
    }
  ]
}

Rules for the Component Hackathon

Each issue will only be assigned to one person/team at a time.
You can only work on one issue at a time.
To express interest in an issue, please comment on it and tag @kuroxx, allowing the Instill AI team to assign it to you.
Ensure you address all feedback and suggestions provided by the Instill AI team.
If no commits are made within five days, the issue may be reassigned to another contributor.
Join our Discord to engage in discussions and seek assistance in #hackathon channel. For technical queries, you can tag @chuang8511.

Component Contribution Guideline | Documentation | Official Go Tutorial

View on GitHub

First time in my life, saw such a detailed issue ☠️ which is a good thing but quite overwhelming!

As I got into the issue, I realized that this wasn’t just a simple renaming task. It was like trying to change a tire while the car is still driving! 🚗💨 But the challenge was exactly what I needed to level up my coding skills.

Step 1️⃣: Learning Go and Exploring Instill’s Codebase

Since I was absolutely new to Go, I spent the first four days studying both the language and Instill’s codebase (huge shoutout to their amazing documentation 📚). Whether it’s the architecture, contribution guidelines, README documentation, or anything else, everything is very well defined 📝.
Moderators Anni and ChunHao were a huge help—Anni provided moral support 😃, while ChunHao patiently provided the technical 💻guidance I needed.

I was like, "Go what now?" But after a few days, Go went from "~~Golly, Oh no!~~" to "Great Opportunity" 💡. Their docs made it easy to dive into the Instill pipeline, and ChunHao’s clear instructions on the JSON schema were a huge help.

A Glimpse of Instill pipeline-backend:

instill-ai / pipeline-backend

⇋ A REST/gRPC server for Instill VDP API service

pipeline-backend

pipeline-backend manages all pipeline resources within Instill Core to streamline data from the start component, through AI/Data/Application components and to the end component.

Concepts

Pipeline

In Instill Core, a pipeline is a DAG (Directed Acyclic Graph) consisting of multiple components.

flowchart LR
s[Trigger] --> c1[OpenAI Component]
c1 --> c2[Stability AI Component]
c1 --> c3[MySQL Component]
c1 --> e[Response]
c2 --> e

Component

A Component serves as an essential building block within a Pipeline.

See the component package documentation for more details.

Recipe

A pipeline recipe specifies how components are configured and how they are interconnected.

Recipes are defined in YAML language:

variable
  # pipeline input fields
output:
  # pipeline output fields
component:
  <component-id>:
    type: <component-definition-id>
    task: <task-id>
    input:
      # values for the input fields
    condition: <condition> # conditional statement to execute or bypass the component
    setup:

…

View on GitHub

To be honest, I was starting to doubt if I could solve this issue, but then Anni dropped the perfect message that kept me going.

Once I got comfortable, ChunHao, who had crafted a JSON schema for this task, gave me the green light🚦 to start coding. And so, the journey began!

Step 2️⃣: Designing the Solution

The key requirements were:

Dynamic Renaming: Fields should be renamed without disturbing the JSON structure.
Conflict Detection: We needed to spot any conflicts between the original and renamed fields.
Conflict Resolution: A smooth solution, like appending a suffix, would prevent name clashes.

Step 3️⃣: Building the Component

Armed with coffee☕ and courage💪, I got down to coding. Here’s a sneak peek at the core logic:

Mapping Fields

First, I created a mapping system to track old and new field names. This was key to detecting conflicts.

func mapFields(fields map[string]string) map[string]string {
    newFieldMap := make(map[string]string)
    for oldName, newName := range fields {
        // Check for conflict
        if _, exists := newFieldMap[newName]; exists {
            newName += "_conflict" // Add suffix for conflicts
        }
        newFieldMap[oldName] = newName
    }
    return newFieldMap
}

Any time a conflict was detected, the function added "_conflict" to the new name. It’s a simple trick that ensures our JSON fields stay unique and, most importantly, friendly to each other! ✌️

Renaming Fields

Once the field mappings were in place, the next step was applying them to our JSON data.

func renameFields(data map[string]interface{}, fieldMap map[string]string) map[string]interface{} {
    renamedData := make(map[string]interface{})
    for key, value := range data {
        newKey := fieldMap[key]
        renamedData[newKey] = value
    }
    return renamedData
}

Here’s the logic that applies the mapped names to our JSON data. The result? Our data’s neatly renamed, conflicts resolved, and structure intact. 🔥

After creating the component dropped the draft PR & got a comment:

Step 4️⃣: Testing and Refinement

After familiarizing myself with Instill's testing methods and learning how to create effective test cases, I proceeded further.

Testing time! 🧪 I wrote tests covering everything from simple renames to complex edge cases with nested JSON fields. Each round of testing led to further refinements.

{
    name: "ok - rename fields with overwrite conflict resolution",
    // Test where renaming conflicts are resolved by overwriting the existing field.
    // Expected outcome: "newField" holds "value1", overwriting any previous value.
},

{
    name: "ok - rename fields with skip conflict resolution",
    // Test where conflicts are resolved by skipping the rename if the target field already exists.
    // Expected outcome: "newField" remains "value2" without overwrite.
},

{
    name: "nok - rename fields with error conflict resolution",
    // Test with "error" strategy, which should raise an error on conflict.
    // Expected outcome: Error message "Field conflict."
},

// Additional cases for missing required fields and invalid conflict resolution strategy

Here’s where I’d love to share a personal reflection: Testing was the hardest part of this project 😮‍💨. There were times when I thought, "Is this test even doing what it’s supposed to?"

Just then, I ran into a lint issue—

He pointed out the problem and even provided the solution. All I had to do was implement it, but it was a reminder that even the smallest details matter in making the code work smoothly.

Once I got past those initial hurdles, testing became my safety net. It gave me the confidence to know that my code would work across different scenarios 🕵️‍♂️. It also showed me that testing isn’t just a step to check off—it’s a way to ensure my code is reliable and resilient.

Step 5️⃣: CI Check and Final Adjustments

After completing my tests, I pushed my code, ready for the review process. However, our CI (Continuous Integration) checks didn’t pass.

Anni’s comment gave me a gentle reminder to double-check my test cases:

“Hey @AkashJana18, could you check your test cases? Our CI check shows it has not passed here. Please test it locally first before pushing it to the PR. Whenever you push your commit, we’ll trigger the checks so you can spot any issues before our engineers review your code. Thanks!”

That’s when I realized I had to run the tests locally before submitting.

ChunHao also added:

"Please run and pass it before you request the review. Run $ go test ./pkg/component/operator/json/v0/... to check it locally."

I quickly ran the tests locally, identified the issues, and fixed them.

A little moment of celebration 🥳

This process made me appreciate the importance of local testing even more, as it ensured everything was solid before submitting for review.

Before merging, ChunHao did a final review, made a few tweaks, QAed Test Recipe and updated the documentation to reflect the new changes. Big thanks to Anni for her ongoing support throughout the process—it made a huge difference. 🙌

👥 Reflection on the Collaborative Process 🫱🏼‍🫲🏼

One of the biggest lessons I learned was how collaboration and mentorship can make or break a project. Instill's moderators, Anni and ChunHao, provided me with the guidance I needed when I was lost in Go syntax or struggling with the right approach. Working together, we turned a complex problem into a clean, functional solution.

I’ll be honest, there were moments I felt like I had bitten off more than I could chew. But the constant encouragement from Anni, combined with the clear direction from ChunHao, kept me on track.

⏭️ Next Steps and Future Improvements

Another step could be expanding this approach to other parts of the pipeline that require dynamic field name handling—because who doesn’t love a little bit of automation⚙️?

🛠️ Tools & Resources 🪛

Go Documentation: For diving into Go syntax and understanding core concepts.
Instill Docs: A goldmine of well-organized resources to understand the Instill pipeline.
Go Testing Framework: The built-in testing package in Go for writing unit tests, ensuring everything works as expected, and integrating with CI tools.
Golangci-lint: A Go linters aggregator to identify issues and enforce code quality during development and CI checks.

🧑🏻‍💻🗒️ My Learning

With Instill’s rock-solid documentation, guidance from ChunHao, and Anni's moral support, this project became a fantastic learning experience. I went from knowing nothing about Go to implementing a fully functional feature ready for production (and I have the merged PR to prove it 😉).

Proof:

feat(json): Support Rename Fields for JSON operator #813

AkashJana18 posted on Nov 05, 2024

Because

we want to manipulate JSON data

This commit

provide the function to rename the json key with different strategies.

View on GitHub

Whether you're tackling JSON renaming, learning Go, or just love a good coding puzzle, I hope this blog sheds light on the process of solving conflicts, one field at a time. 🌈

📓✍🏻 Your Learning

1️⃣ How to Approach New Challenges: Whether it’s a new language or a complex feature, learn how to break down problems and solve them step by step, just like I did with this project.

2️⃣ The Power of Documentation: Discover how clear, organized documentation (like Instill’s) can be a game changer when working on complex projects.

3️⃣ Persistence and Moral Support: Understand the importance of perseverance and the value of support from your peers when tackling challenging tasks.

4️⃣ How to implement conflict resolution strategies: Learn how to handle various scenarios like overwrite, skip, and error conflict resolutions while renaming JSON fields.

🌱 My 1st Hacktoberfest Experience: A Journey of Code, Challenges, and Community

Akash Jana — Mon, 28 Oct 2024 19:58:34 +0000

This is a submission for the 2024 Hacktoberfest Writing Challenge: Contributor Experience

Hello, world! 🌍 Hacktoberfest has been an absolute blast! Imagine a whole month dedicated to coding, learning, and sharing ideas with the open-source community. If you haven’t heard, Hacktoberfest is an annual event where developers from all over come together to contribute to open-source projects, brush up on skills, and maybe win some cool swag (aka stickers, tees 👕, and hoodies)! 🎁 Here’s a recap of my journey this year, sprinkled with some of the quirks, challenges, and triumphs along the way. 🚀👨‍💻

🚀 Why I Joined Hacktoberfest / Devfest.ai / oss.gg

It is more than just an event; it’s a way to:

Sharpen my skills on real projects. 🛠️
Engage with the open-source community and learn from seasoned developers. 🤝
Make meaningful contributions to projects that matter in the dev world. 🌐✨

💡 Picking My Targets (or “Repos”)

Deciding on projects took some thoughtful browsing, meme-worthy decision-making 🤔😂, and a good bit of scrolling through GitHub issues. Here’s how I finally narrowed it down:

Match Interests: I love JavaScript, React, and frontend design, so I hunted for issues aligned with these interests. 💻
Look for “good first issues”: These are designed to be beginner-friendly, helping me ease into the projects. 👍
Contribution Guidelines: This saved me from going down the rabbit hole. Knowing each project’s rules kept things smooth and straightforward (mostly!). 😅

💻 The PRs That Made the Cut 🎯

Postiz - My PR for Postiz fixed a frontend bug. A must-have, if you ask me, because who doesn’t want to level up their social game? 📅💪
CopilotKit - Contributing to CopilotKit was pure joy 🎉. Not only did I add to the magic of task automation here, but it was also the most fun project of all! (Spoiler alert: CopilotMate was born from these efforts! Click on CopilotMate to know more about it). 🤖🚀
DocsGPT 1 - My first PR to DocsGPT aimed at enhancing UI tabs (because even docs need a little TLC sometimes!). 📑✨
DocsGPT 2 - My second PR further fine-tuned the UX for tables as per design! 📈🔧
CopilotKit Again - Another CopilotKit contribution. Let’s just say CopilotKit and I became BFFs this Hacktoberfest! 😊 Looking forward to contributing even more in the future! 🎉

🎉 DevFest.AI Triumph: 7th Place out of 1626

DevFest.AI added an extra thrill by diving into AI-specific open-source contributions. Our team secured an impressive 7th place, adding a fun, competitive edge to our contributions. Working alongside, we tackled unique challenges and picked up some advanced skills in the process. The experience not only boosted our coding journey but also strengthened our teamwork and strategy. Here’s to more ranks and rewards next year! 🏆🤖

Quira : October Mega Quest and Hacktoberfest with MindsDB

Quira made it more fun and challenging. Pushing my boundaries to learn more and earn more...
With MindsDB tried out many different things for the 1st time the end results are :

Built JS sdk for mindsDB
Manual tested some integration for mindsDB Looking forward to do more as well

🎉 OSS.GG Side Quests: Memes, GIFs, Billboards, and Secret Quests 🤫

Hacktoberfest wasn’t just about code this year; OSS.GG took things to a whole new level with epic side quests. From making memes that capture dev life (yep, we all need to laugh at those late-night coding sessions! 😴) to crafting GIFs and even designing a billboard 🛣️, these side quests added a whole new layer of fun. Completing them felt like leveling up my creativity 🎨, and, honestly, they were a great mental break from the code grind. 😎 Here are a few things I created (Trust me, it was way too fun 🧨):

Update : Ranked 23 out of 4723 in oss.gg

🛠️ Hurdles, Debugging, and That Sweet Moment of “It Works!” 🥳

It wasn’t all smooth sailing. 🌊 From understanding codebases to testing (and re-testing), every contribution came with its own learning curve 📈↗️:

💻 Complex Codebases: Jumping into established projects can feel like trying to read a novel from the middle 📖. But with patience and some serious documentation deep-dives, I managed to get into the groove. 💪
🐛 Unexpected Bugs: A memorable one is the time-zone issue in Taipy due to Plotly (Issue still unresolved. Want to give it a try? Click here). Who knew time zones could be so… temperamental? 🕒
🗿 Persistence: Some PRs took a few reviews before they were merged, but every bit of feedback helped refine my skills. 💡 Each push, pull, and merge was a step forward, and the “approved” messages made it all worth it! 🙌

👥 Community Vibes 🎶

Hacktoberfest wouldn’t be the same without the community. 💜 From GitHub discussions to Discord threads and online meetups, I got to interact with amazing developers, maintainers, and contributors. Working on issues and joining project forums introduced me to brilliant devs from all over the world 🌎 — plus, it made the experience way more fun than solo coding. 😄

🎉 The Ultimate Lessons from Hacktoberfest 2024 📚

This year’s Hacktoberfest experience taught me a lot, and here are the big takeaways:

Open-source isn’t just about code: It’s about contributing, reviewing, and helping make code accessible and maintainable for everyone. 👥🌍 Each contribution is like a piece of a larger puzzle that the whole community builds together!
Feedback is crucial: Every code review 🔍 opened my eyes to new ways of optimizing code, thinking creatively🌈, and approaching problems from different angles.
Persistence pays off: Four PRs may sound simple, but making meaningful contributions takes time, patience, and commitment. 🕰️💪 Hacktoberfest reinforced that the path to growth lies in sticking with it, even when it feels challenging.

🛠️ The CopilotMate Moment 🚀🤖

Of all the projects, CopilotKit was hands-down the most fun! Working on it while creating CopilotMate felt like a mini passion project inside Hacktoberfest. Imagine an AI assistant that helps track tasks, manage calendars, and quiz you on random facts (because why not? 😆). CopilotMate has become my unofficial Hacktoberfest sidekick, and it’s just the beginning of what I hope will be a super useful AI assistant! 🎉
Do give a 🌟to CopilotMate

🎁 Wrapping Up 🎁

Hacktoberfest 2024 has been incredible. 🌈 From each PR to the inspiring community, it’s made me a better developer and given me a stronger sense of the open-source spirit. If you’ve been thinking about joining Hacktoberfest, or even just contributing to open-source, I say go for it! 🚀 You’ll learn, grow, and probably laugh at yourself a few times along the way. 😅

Here’s to many more pull requests, open-source collaborations, and maybe an endless supply of stickers! Happy coding! 🧑‍💻🌟

🎆 Don't forget to share or comment your Hacktoberfest experience below! Let’s keep the open-source spirit alive! 🎆

Bye-bye Passwords: Embracing Secure, Hassle-Free Passkeys

Akash Jana — Sun, 27 Oct 2024 16:32:09 +0000

Introduction

Say goodbye to forgotten passwords, endless reset emails, and risky sticky notes on monitors! 🤦‍♂️ Today, we’re diving into the world of passkeys—a passwordless, user-friendly, and highly secure way to log in, making stolen credentials a thing of the past. 💫

With Hanko's flexible configurations, setting up passkeys is easier than ever. Let's explore how passkeys work, dive into Conditional UI, and see how to let users securely delete their passwords. Plus, we’ll look at how passkeys can either replace or enhance traditional multi-factor authentication (MFA).

1. Why Passkeys? The Good, the Bad, and the Secure 🔑

Advantages of Passkeys:

🚫 No More Passwords: Say goodbye to “Password123!” Passkeys let users authenticate securely without a password.
🛡️ High-Level Security: Passkeys are phishing-resistant since there’s no password to steal. They’re device-based, stored locally and securely.
🏎️ Smooth User Experience: One-tap access offers a frictionless experience.

How to Implement Passkey Authentication with Hanko

Here’s a simple flow using Hanko’s SDK to implement passkey login:

   import { generatePasskey, verifyPasskey } from 'hanko-sdk';

   // Step 1: Generate a passkey during user registration
   async function registerUser(username) {
      const passkey = await generatePasskey(username);
      return passkey; // Send this to the client for storage
   }

   // Step 2: Authenticate using the passkey
   async function loginWithPasskey(username, passkey) {
      const result = await verifyPasskey(username, passkey);
      if (result) {
         console.log("Authentication successful! 🎉");
      } else {
         console.log("Authentication failed! 🚫");
      }
   }

Disadvantages (Because Nothing’s Perfect 🤷‍♂️):

📲 Device Dependency: Passkeys are tied to devices, so if a device is unavailable, the user may be unable to log in. Hanko recommends offering backup options.
🌐 Cross-Platform Compatibility: Although evolving, passkey support is still expanding.

2. Passkey Autofill: Conditional UI to the Rescue 🦸‍♂️

What’s Conditional UI?

Conditional UI is a UX design pattern that presents different login options depending on device compatibility. If the user’s device supports passkeys, they’ll be presented with this option automatically, creating a seamless experience.

How to Implement Passkey Autofill (Conditional UI)

Here’s an example of a conditional UI setup for passkeys:

   async function showLoginOptions(user) {
      if (window.PublicKeyCredential) { // Passkey-supported device
         displayOption('passkey');
      } else {
         displayOption('password');
      }
   }

   function displayOption(option) {
      if (option === 'passkey') {
         console.log("Displaying passkey login 🔑");
         // Display passkey-based login UI
      } else {
         console.log("Displaying password login 🔒");
         // Display traditional password-based login UI
      }
   }

   // Call the function when the login screen loads
   showLoginOptions();

Why Developers and Users Love It

Users get a fast, secure login flow tailored to their device, and developers don’t have to maintain multiple login flows manually.

3. Making Passwords Optional: Handle with Care 🧤

Why Allow Users to Delete Passwords?

Letting users delete their passwords adds convenience and security. Passkeys offer secure, one-tap access, but there are some key considerations before ditching passwords.

Best Practices for Deleted Passwords:

Confirm Passkey Setup 🧐: Verify a passkey is set up before allowing password deletion.
Recovery Options 🆘: Provide backup options for account recovery.

Example Workflow for Password Deletion

   async function deletePassword(userId) {
      const hasPasskey = await checkPasskey(userId);
      if (!hasPasskey) {
         throw new Error("Cannot delete password without a passkey. Please set up a passkey first.");
      }

      // Proceed to delete the password if a passkey is set up
      const result = await removePassword(userId);
      if (result.success) {
         console.log("Password deleted successfully! 👋");
      } else {
         console.log("Failed to delete password. 😕");
      }
   }

   // Helper functions
   async function checkPasskey(userId) {
      // Check if a passkey exists for the user
      return await hankoClient.checkPasskey(userId);
   }

   async function removePassword(userId) {
      // Remove password from user's account
      return await hankoClient.deletePassword(userId);
   }

Designing a User-Friendly Deletion Flow

Use a clear interface to explain the implications of deleting passwords and encourage users to set up a passkey first.

4. Passkeys as Password Replacements vs. MFA: Who Wins? ⚔️

Passkeys as MFA? Absolutely!

Passkeys can enhance MFA, offering an easy, secure way to verify identity beyond just a password. Here’s how Hanko supports this setup:

Setting Up Passkeys as MFA with Hanko

   async function setupMFA(userId) {
      const mfaOption = await hankoClient.createMFA(userId, {
         type: 'passkey',
      });

      if (mfaOption.success) {
         console.log("MFA with passkey set up! 🛡️");
      } else {
         console.log("Failed to set up MFA. 🤔");
      }
   }

   async function authenticateWithMFA(userId, passkey) {
      const isAuthenticated = await hankoClient.verifyMFA(userId, passkey);
      if (isAuthenticated) {
         console.log("MFA login successful! 🎉");
      } else {
         console.log("MFA login failed! 🚫");
      }
   }

With Hanko, you can configure passkeys as an additional layer of security or a primary replacement. The versatility of passkeys makes them a strong contender for both roles.

Conclusion

Passkeys represent a shift to a more secure, frictionless login experience. With Hanko’s tools, implementing passkeys is straightforward, making password-free logins accessible to users and developers alike. Ready to get started? Hanko is here to help you leave forgotten passwords in the past! 👋💫

🚀 Want to know more? Feel free to check out hanko docs

How I Built CopilotMate with Copilotkit ai🚀🤖✨

Akash Jana — Mon, 07 Oct 2024 16:01:07 +0000

Hey there, fellow tech enthusiasts! Today, I’m super excited to share my journey of integrating CopilotKit AI into my personal assistant project, CopilotMate. This integration has taken my project to a whole new level of awesomeness, transforming it into a dynamic tool for task management, study assistance, and so much more! Let’s dive into the magic of this journey together! 🌟

🛠️ Tech Stack Overview

Before we jump into the nitty-gritty, let’s quickly check out the tech stack that powers CopilotMate:

🌐 Next.js for seamless frontend development, allowing for lightning-fast builds and dynamic routing. ⚡

🎨 React combined with Tailwind CSS to create a beautiful, responsive UI that users love and framer motion for animations.

🤓 CopilotKit for AI-driven features with its amazing SDKs that make everything possible.

🦙 GROQ and Langchain for handling queries and leveraging powerful LLMs (like the fabulous Llama models).

📦 Why CopilotKit?

You might be wondering why I chose CopilotKit. Here are my top three reasons:

💡 Modularity: Its clean modular design allowed me to pick and choose features without cluttering my project. Less mess, more finesse!

🎯 Built for Generative AI: CopilotKit comes with tools specifically designed for projects involving coagents, which aligns perfectly with my vision for CopilotMate.

🎛️ Customization: The rich SDK made it a breeze to create custom coagents tailored to specific tasks, like managing to-do lists and assisting with studies.

🧠 Step 1: Setting Up the CopilotKit Core

The first step in this exciting adventure was to set up the CopilotKit core in my project. I installed the necessary packages, setting the stage for the magical AI interactions to come. It was like planting the seeds for a blooming garden of AI capabilities! 🌼🌱

🧑‍💻 Step 2: Creating Custom Coagents

I knew I wanted CopilotMate to feel personal and responsive. So, I crafted custom coagents—my virtual assistants with unique personalities and tasks. Check out these cool coagents I created:

🎉 To-Do Assistant: Your friendly task manager! It helps users categorize (todo/completed), and manage tasks like a pro.

📚✨ StudyBuddy: This coagent is a total study wizard! It breaks down complex concepts, generates summaries, and answers questions to help users ace their studies.

💰💡 Expense Tracker: A budgeting guru! This coagent categorizes expenses and offers helpful budgeting tips to keep finances in check.

Each coagent is powered by CopilotKit but can be customized to fit user needs perfectly. How cool is that? 😎

🛠️ Step 3: Building the Frontend Components

With the coagents in place, it was time to create intuitive user interfaces where users could interact with them. Using Next.js for routing, I built individual pages for each feature, ensuring that the design was cohesive and super user-friendly. 🎈

🤯 Step 4: Handling Queries with GROQ

To make CopilotMate smarter, I integrated GROQ for intelligent interactions. This allowed me to craft queries that provided context for each coagent, ensuring they could generate accurate and personalized responses. It’s like giving my coagents a brain boost! 🧠💥

🔄 Step 5: Making CopilotMate User-Friendly

One of my main goals was to create an intuitive experience for users. I embraced Tailwind CSS to design a sleek dark theme with a trendy glass effect UI, adding a touch of elegance to every interaction. 🌌✨ Plus, I implemented loading states to enhance user experience while waiting for those AI-generated responses. Patience is key! ⏳

🚀 The Results

With CopilotKit integrated, CopilotMate has transformed into an AI-powered personal assistant that can tackle a wide array of tasks, from managing to-do lists to providing study assistance and tracking expenses. 🎊 The AI agents make the experience interactive and dynamic, allowing users to enjoy automation while keeping control of their tasks. It’s like having a personal assistant in your pocket! 📲💪

💡 Takeaways

Integrating CopilotKit wasn’t just about adding AI—it was about making CopilotMate more intelligent, responsive, and user-friendly. By leveraging CopilotKit, I could focus on building features that matter while letting the AI handle the complexity. A true win-win! 🥳

So, that’s how CopilotKit supercharged CopilotMate! If you’re embarking on your own AI-powered projects, I highly recommend giving CopilotKit a try. It’s flexible, powerful, and a total blast to work with! 🎉

Got questions or want to share your own experiences? Drop a comment or connect with me on social media! I’d love to hear from you! 😊💬

Do checkout the Github repo and give a star: https://github.com/AkashJana18/copilotmate
Another blog: DEV
Youtube Demo : Link

Thanks for joining me on this journey! Until next time, keep innovating and creating! 🚀✨

Future of Productivity: Meet CopilotMate! 🚀

Akash Jana — Sun, 06 Oct 2024 11:22:53 +0000

Hello, fellow tech enthusiasts and productivity lovers! Today, I’m excited to introduce you to my latest brainchild: CopilotMate! 🤖✨

🛠️ How Did CopilotMate Come to Life?

Picture this: it’s a busy Monday morning, and my to-do list looks like a novel! 📜 I had so many tasks that even my coffee needed a coffee! ☕ I thought to myself, "There must be a better way to tackle this madness."

So, I put on my thinking cap (a.k.a. my coding hat 🧢) and decided to build CopilotMate, a personal assistant designed to help me manage my daily grind like a pro! But hey, it’s not just for me—everyone deserves a little extra help, right?

🎯 Why CopilotMate?

The idea behind CopilotMate is simple: to make your life easier. Whether you’re juggling tasks, planning a project, or trying to keep your social life intact (yes, we all have friends…somewhere), CopilotMate is here to help you stay organized without losing your mind! 😅

💡 The Inspiration

While building this tool, I was inspired by various productivity apps but noticed they often lacked a personal touch. So, I thought, "Why not create an assistant that’s not just smart, but also a little quirky?" 🤪

🚀 Features That Will Make You Say “WOW!”

Let’s dive into some of the coolest features CopilotMate has to offer:

To-Do Assistant ✅
Tired of writing the same tasks over and over? CopilotMate’s To-Do Assistant lets you create, edit, and manage tasks effortlessly. And yes, it will remind you to take breaks…because we all need them! 🧘‍♂️
Expense Tracker 💰
Want to know where your money went? Our Expense Tracker features a dark theme with a glass effect UI that makes tracking expenses as fun as scrolling through memes! Just don’t forget to stop after 3 hours! 😂
Calendar Integration 📅(work in progress)
Keep your schedule in check! CopilotMate syncs with your calendar, ensuring you never miss an important meeting. Just think of it as your digital secretary—minus the coffee runs! ☕️
Chatbot Feature 💬
Have questions? CopilotMate’s chatbot feature is like having a mini-you in your pocket! Ask it anything, and it’ll respond faster than you can say “artificial intelligence”! 🤖
Study Tools 📚
Studying can be tough, but CopilotMate makes it easier with tools designed for note-taking, quizzes, and more. It’s like having a study buddy who actually knows stuff (and doesn’t eat your snacks)! 🍕

🎥 Check Out the Demo! Link

I’ve made a demo video to showcase all the amazing features of CopilotMate. Watch it here on YouTube! Don’t forget to like and subscribe for more updates! 📹✨

🗳️ Vote for CopilotMate on Quira!

If you love what you see and want to support CopilotMate, please take a moment to vote for us on Quira! Every vote counts and helps us reach more people who could benefit from this awesome tool! Click here to vote! 🙌

😂 A Dash of Humor

Let’s be real: we all have those days when productivity feels like an uphill battle. 🏔️ So, why not tackle it with a smile? Here’s a little humor for you:

Why did the computer go to therapy? Because it had too many tabs open! 🖥️

Why did the task break up with the procrastinator? Because it just couldn’t handle the waiting game! 🎮

🎉 Join the CopilotMate Community!

I’m thrilled to share CopilotMate with all of you! It’s open-source, so feel free to contribute or check out the code. Let’s make productivity fun together! 🎈

If you’d like to try it out, head over to the GitHub repository and get started! And don’t forget to let me know your thoughts—I promise I won’t bite! (Unless you have snacks… then all bets are off!) 😜

🌟 Final Thoughts

So there you have it: CopilotMate is here to revolutionize the way you tackle your tasks and stay organized. Remember, productivity doesn’t have to be boring—let’s make it a little more entertaining! 🎊

Until next time, keep smiling and coding! Happy organizing! 🎈

DEV Community: Akash Jana

TARDIS-SN : My Pre-GSoC Journey, Codebase & Guide

Getting Started with TARDIS: A Friendly Guide for New Contributors

TL;DR:

🌌 What Is TARDIS?

Core Concepts

🔁 Radiative Transfer

🎲 Monte Carlo Method

⚛️ Atomic Data

TARDIS-SN Architecture

Key Components and their Interactions:

🧩 Modular Design

🛠 How TARDIS Works -> A Simple Workflow

1️⃣ Input Setup:

2️⃣ Initialization:

3️⃣ Monte Carlo Simulation:

4️⃣ Spectrum Generation:

5️⃣ Output & Analysis:

▶️ A small Demo for TARDIS

Installation

Running a Basic Simulation

📚 Learn More

CARSUS: The Atomic Data Engine Behind TARDIS

🧾 What Is Carsus?

🔍 Why Is It Important?

CARSUS Architecture

Key Components:

How Carsus Works —> A Simplified Workflow

🗂 Carsus Codebase

My Pre-GSoC Contribution

The Problem statement / Idea

The Solution

[GSOC]-Metadata for atomic data #442

📝 Description

📜 Example Usage

🚦 Testing

☑️ Checklist

If you are looking to learn oops concept in fun way do check this out!

Object-Oriented Emotions

Object-Oriented Emotions

📝 Intro: Why OOP Needs a Rebrand

🧶 A Little Backstory

Love, Logic, and Line-by-Line Debugging

💬 Meet class Human

🔐 What is Encapsulation?

😮 Inheritance? Oh honey, that's family drama

🌀 Polymorphism – One Interface, Many Feelings

🧼 Abstraction: Hiding the Mess

✨ Final Thoughts: Be Like an Object

🔁 TL;DR

Conquering the Setup Loop with Daytona

How I Started Using Daytona 🛠️

What is Daytona? 🤔

Key Features That Won Me Over 🎉

A Quick Vocabulary Lesson 📘

Let’s Get Started 🚀

Step 1️⃣: Installing Daytona 🖥️

Step 2️⃣: Setting Up a Dev-Container 📦

Step 3️⃣: Configuration ⚙️

Step 4️⃣: Create Your Workspace 🖇️

My View 🤓

daytonaio / daytona

Daytona is a Secure and Elastic Infrastructure for Running AI-Generated Code

Run AI Code Secure and Elastic Infrastructure for Running Your AI-Generated Code

Installation

Python SDK

TypeScript SDK

Ruby SDK

Go SDK

Features

Quick Start

Creating your first Sandbox

Python SDK

My Tech Journey - Web Dev | DSA | Open Source

💻 The Great Leap into Coding

🌐 Web Development: Love at First <div>

AkashJana18 (Akash Jana) · GitHub

👿 DSA: The Necessary Evil

👑 Open Source: The Late Bloomer’s Redemption

Some suggestions to get started: Quira

💬 Meet `class Human`

Run AI Code
Secure and Elastic Infrastructure for Running Your AI-Generated Code