Tables of contents:

1. Create a Next.js project.
2. Setting up the project dependencies. ( packages )
3. How to create an avatar using the readyplayer?
4. How do we use the created avatar in Next.js?
5. How to add a background image to enhance the scene?

Create a Next.js project:

To create a Next.js project, use the create-next-app CLI tool. Open a terminal, navigate to the directory where you want to create the project, and run npx create-next-app@latest.

Follow the prompts to name the project, choose whether to use TypeScript, ESLint, Tailwind CSS, and the App Router.

$ npx create-next-app@latest demo-avatar
$ cd demo-avatar

Setting up the project dependencies. ( packages ):

Here is how to set up the project dependencies for a talking avatar in Next.js.

Several libraries might be needed, depending on the approach for the talking avatar.

$ npm install @react-three/fiber @react-three/drei

⚛️ @react-three/fiber:

This package connects Three.js with React.

• Instead of writing complex three.js code manually,
• You can write 3D scenes like normal React components using JSX.

import { Canvas } from '@react-three/fiber';

export default function Home() {
  return (
    <Canvas>
      {/* 3D content goes here */}
      <mesh>
        <boxGeometry args={[1, 1, 1]} />
        <meshBasicMaterial color='orange' />
      </mesh>
    </Canvas>
  );
}

<Canvas /> is the root element that creates the 3D scene.

🧰 @react-three/drei:

This gives you so many ready-made components to save time.

• Things like camera controls, environment lighting, sky backgrounds, loading spinners, and even 3D text are included.

export default function Home() {
  return (
    <Canvas>
      {/* Enable camera orbit controls */}
      <OrbitControls enableRotate={false} enableZoom={false} />
      <Environment preset='sunset' />
      <ambientLight />
      <Text fontSize={1} color='hotpink' position={[0, 0, 0]}>
        Hello 3D!
      </Text>
    </Canvas>
  );
}

How to create an avatar using the readyplayer?

Creating a 3D avatar has never been easier, thanks to Ready Player Me — a free online platform that lets you build fully customizable avatars.

To create an avatar using Ready player me, you should first visit their website and create and account. Then you can use their Avatar Creator to customize your avatar, including choosing your gender, outfit and so on.

Ready Player Me Studio

Once you have created your desired avatar, you will receive a unique avatar URL.

To download the avatar as glb file, simply copy the avatar URL, paste it into your browser, and hit the Enter key, and it will start downloading automatically.

How do we use the created avatar in Next.js?

Now, in our project in public, create a new folder called models and drag and drop your avatar GLB file here.

public/
├── file.svg
├── globe.svg
├── models
│   └── avatar.glb
├── next.svg
├── vercel.svg
└── window.svg

1 directory, 6 files

And create the components directory inside the app directory.

app/
├── components
├── favicon.ico
├── globals.css
├── layout.tsx
└── page.tsx

1 directory, 4 files

To use this avatar in our project, we are going to use the gltfjsx tool.

What is gltfjsx?
gltfjsx is a tool that converts 3D model files (like .glb) into a React component.
This makes it easier to use 3D models directly in a React app.

$ npx gltfjsx public/models/avatar.glb -o app/components/Avatar.jsx -r public

• npx gltfjsxRuns the tool (version 6.5.3).
• public/models/new_avatar.glbThis is the 3D model you want to convert.
• -o src/components/renderings/TalkingAvatar/NewAvatar.jsxThis is where the React component will be saved.

app/components/
└── Avatar.jsx

0 directories, 1 file

Now you can see the Avatar.jsx component file inside the components directory.

Avatar.jsx

/*
Auto-generated by: https://github.com/pmndrs/gltfjsx
Command: npx gltfjsx@6.5.3 public/models/avatar.glb -o app/components/Avatar.jsx -r public 
*/

import React from 'react'
import { useGraph } from '@react-three/fiber'
import { useGLTF } from '@react-three/drei'
import { SkeletonUtils } from 'three-stdlib'

export function Model(props) {
  const { scene } = useGLTF('/models/avatar.glb')
  const clone = React.useMemo(() => SkeletonUtils.clone(scene), [scene])
  const { nodes, materials } = useGraph(clone)
  return (
    <group {...props} dispose={null}>
      <primitive object={nodes.Hips} />
      <skinnedMesh geometry={nodes.Wolf3D_Hair.geometry} material={materials.Wolf3D_Hair} skeleton={nodes.Wolf3D_Hair.skeleton} />
      <skinnedMesh geometry={nodes.Wolf3D_Body.geometry} material={materials.Wolf3D_Body} skeleton={nodes.Wolf3D_Body.skeleton} />
      <skinnedMesh geometry={nodes.Wolf3D_Outfit_Bottom.geometry} material={materials.Wolf3D_Outfit_Bottom} skeleton={nodes.Wolf3D_Outfit_Bottom.skeleton} />
      <skinnedMesh geometry={nodes.Wolf3D_Outfit_Footwear.geometry} material={materials.Wolf3D_Outfit_Footwear} skeleton={nodes.Wolf3D_Outfit_Footwear.skeleton} />
      <skinnedMesh geometry={nodes.Wolf3D_Outfit_Top.geometry} material={materials.Wolf3D_Outfit_Top} skeleton={nodes.Wolf3D_Outfit_Top.skeleton} />
      <skinnedMesh name="EyeLeft" geometry={nodes.EyeLeft.geometry} material={materials.Wolf3D_Eye} skeleton={nodes.EyeLeft.skeleton} morphTargetDictionary={nodes.EyeLeft.morphTargetDictionary} morphTargetInfluences={nodes.EyeLeft.morphTargetInfluences} />
      <skinnedMesh name="EyeRight" geometry={nodes.EyeRight.geometry} material={materials.Wolf3D_Eye} skeleton={nodes.EyeRight.skeleton} morphTargetDictionary={nodes.EyeRight.morphTargetDictionary} morphTargetInfluences={nodes.EyeRight.morphTargetInfluences} />
      <skinnedMesh name="Wolf3D_Head" geometry={nodes.Wolf3D_Head.geometry} material={materials.Wolf3D_Skin} skeleton={nodes.Wolf3D_Head.skeleton} morphTargetDictionary={nodes.Wolf3D_Head.morphTargetDictionary} morphTargetInfluences={nodes.Wolf3D_Head.morphTargetInfluences} />
      <skinnedMesh name="Wolf3D_Teeth" geometry={nodes.Wolf3D_Teeth.geometry} material={materials.Wolf3D_Teeth} skeleton={nodes.Wolf3D_Teeth.skeleton} morphTargetDictionary={nodes.Wolf3D_Teeth.morphTargetDictionary} morphTargetInfluences={nodes.Wolf3D_Teeth.morphTargetInfluences} />
    </group>
  )
}

useGLTF.preload('/models/avatar.glb')

I want to rename the component name from Model to Avatar.

And I have created one more component Experience.tsx inside the components directory. Inside this component, we will load our Avatar.

app/components/
├── Avatar.jsx
└── Experience.tsx

0 directories, 2 files

Experience.tsx

import React from 'react';
import { Environment, OrbitControls } from '@react-three/drei';

import { Avatar } from './Avatar';

const Experience = () => {
  return (
    <>
      <OrbitControls />
      <Environment preset='sunset' />
      <Avatar position={[0, -3, 5]} scale={2} />
    </>
  );
};

export default Experience;

The OrbitControls allow panning, rotating, and zooming. You can enable/disable each of these. The below JSX disables panning, rotation, and zooming. All three properties are true by default.

We have used the Environment helper, which produces a great effect.

<OrbitControls enablePan={false} enableZoom={false} enableRotate={false} />

Here in the Avatar component, we send some props like position and scale to bring our avatar close.

And then we can load Avatar through the Experience component into the Home component(page.tsx)

page.tsx

'use client';
import { Canvas } from '@react-three/fiber';
import Experience from './components/Experience';

export default function Home() {
  return (
    <Canvas shadows camera={{ position: [0, 0, 8], fov: 42 }}>
      <color attach='background' args={['#ececec']} />
      <Experience />
    </Canvas>
  );
}

Now you can see the 3D avatar in our application.

How to add a background image to enhance the scene?

Now we can add the background image to our avatar. I have generated the image using the AI tool. So we are going to use the following image for our avatar scene.

Create a new directory called assets inside the public directory to put the background image.

public/assets/
└── hospital-background.png

0 directories, 1 file

Experience.tsx

import React from 'react';
import { Environment, OrbitControls, useTexture } from '@react-three/drei';

import { Avatar } from './Avatar';
import { useThree } from '@react-three/fiber';

const Experience = () => {
  const texture = useTexture('assets/hospital-background.png');
  const viewport = useThree((state) => state.viewport);

  return (
    <>
      <OrbitControls
        enablePan={false}
        enableZoom={false}
        enableRotate={false}
      />
      <Environment preset='sunset' />
      <Avatar position={[0, -3, 5]} scale={2} />
      <mesh>
        <planeGeometry args={[viewport.width, viewport.height]} />
        <meshBasicMaterial map={texture} />
      </mesh>
    </>
  );
};

export default Experience;

The useTexture hook accepts a URL or an array of URLs as its argument. It returns an Texture object or an array of Texture objects. These textures can then be applied to materials in your 3D scene.

The useThree hook provides access to low-level Three.js objects like the viewport, camera, and scene. The hook will reactivate if you resize the browser.

You can get the entire code that we have done so far using the following git repository.

GitHub - Gibson-Joseph/demo-avatar

I hope you liked this article. In my upcoming article, we will learn how to add animation and lip sync to our avatar character.

How to build a talking avatar in a Next.js application #1. was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Set up an account in Google APIS.

Click the link and set up a Google account, then access the API services.

Then search in the service bar “calendar” and enable the calendar API. Consider the image below as a reference.

After the calendar is enabled, configure the authorised redirect URI for authorisation.

Once authorised with our Google account, it will redirect to the configured URL and give an access code. We need this access code for Google Calendar booking.

Define the Auth callback

import Fastify from 'fastify';

const fastify = Fastify({
  logger: true
});

// Declare a route
fastify.get('/auth', async function handler(request, reply) {
  console.log('request', request);
  return { hello: request.query };
});

try {
  await fastify.listen({ port: 3000 });
} catch (err) {
  fastify.log.error(err);
  process.exit(1);
}

The above code is just a Fastify application setup and configured with one route with the GET method. In request.query We can find the access code.

$ node server.js

Now we can run the application using the above command.

Generate Gemini API

Once the Google API is configured now we can generate the Gemini API key and configuration.

Click this link to generate an API key. After generating of API key, configure it in the .env file.

GEMINI_API_KEY=

Not only the Gemini API key, but we can also configure the following in .env

GOOGLE_CLIENT_ID=''
GOOGLE_CLIENT_SECRET=''
REDIRECT_URI=''

Install the required library in our application.

$ npm install @google/genai dotenv fastify googleapis --save

Run the above command to install all required libraries.

Create aindex.js file where we can write our code for calendar booking.

import { configDotenv } from 'dotenv';
configDotenv();

import { GoogleGenAI, FunctionCallingConfigMode } from '@google/genai';
import { google } from 'googleapis';
import * as readline from 'readline';

const { GEMINI_API_KEY, GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET, REDIRECT_URI } =
  process.env;

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

const genAI = new GoogleGenAI({ apiKey: GEMINI_API_KEY });
const geminiModel = genAI.models;

const oauth2Client = new google.auth.OAuth2(
  GOOGLE_CLIENT_ID,
  GOOGLE_CLIENT_SECRET,
  REDIRECT_URI
);

In the above, we import the library needed for the application and initialise the GoogleGenAI model and the oauthClient library.

We have used it readline for interaction with the node application via the terminal.

async function authenticate() {
  const authUrl = oauth2Client.generateAuthUrl({
    access_type: 'offline',
    scope: 'https://www.googleapis.com/auth/calendar.events'
  });
  console.log('Authorize this app by visiting this url:', authUrl);
  rl.question('Enter the code from that page here: ', async (code) => {
    try {
      const tokenResponse = await oauth2Client.getToken(code);
      tokens = tokenResponse.tokens;
      oauth2Client.setCredentials(tokens);
      calendar = google.calendar({ version: 'v3', auth: oauth2Client });
      console.log('Authentication successful!');
      queryGemini();
    } catch (err) {
      console.error('Error retrieving access token', err);
      rl.close();
    }
  });
}

The above function is for authentication with the Google API for calendar access.

rl.question It asks for our input via the terminal. Once we are authorised using authUrl, we can enter the code in our terminal or paste it.

This function generates a token for our further access. Then it will call queryGemini() function.

const chatHistory = [];

let isBooked = false;


async function queryGemini() {
  rl.question('Ask Gemini (or say "book calendar"): ', async (query) => {
    try {
      chatHistory.push({
        role: 'user',
        parts: [{ text: query }]
      });

      const result = await geminiModel.generateContent({
        model: 'gemini-2.0-flash-001',
        contents: chatHistory,
        config: {
          systemInstruction: `
You are a smart assistant that helps users with any kind of query.

If the user explicitly says they want to book a calendar, schedule a meeting, or talk to an agent, interpret it as a request to create a calendar event and use the \`create_calendar_event\` function (if enough information is available). Ask only the necessary missing details.

Once the calendar event is successfully created, return to normal assistant behavior. Do not continue suggesting or prompting about calendar bookings unless the user explicitly brings it up again.

For all other types of queries, respond normally as a helpful assistant.
`,
          toolConfig: {
            functionCallingConfig: {
              mode: FunctionCallingConfigMode.AUTO
            }
          },
          tools: tools
        }
      });

      const response = result;

      console.log('Gemini:', response.text);

      if (!isBooked && response.functionCalls?.length > 0) {
        const func = response.functionCalls[0];
        console.log('Function call received:');
        console.log('Function name:', func.name);
        console.log('Arguments:', func.args);
        const args = func.args;

        if (func.name === 'create_calendar_event') {
          await bookAEvent(
            args.title,
            args.date,
            args.time,
            args.email,
            args.timezone
          );
          isBooked = true;
        }
      } else if (response.text) {
        chatHistory.push({
          role: 'model',
          parts: [{ text: result.text }]
        });
      }
    } catch (error) {
      console.error('Error querying Gemini:', error);
    }
    queryGemini(); // Continue the REPL
  });
}

In the above code, using geminiModel.generateContent() We can interact with our Gemini LLM.

There are a few more things we configured with the generateContent method.

1. model — AI model name with version
2. contents — we are passing chat history — both user input and model response. We store those values chatHistory array.
3. config — In the config, we set up system instruction, toolConfig, and tools.
4. systemInstruction — It is a prompt message on how our system should act.

If you look at the system instructions, we mentioned the call create_calander_event function if the user requests a book an event or talk to an agent.

     toolConfig: {
            functionCallingConfig: {
              mode: FunctionCallingConfigMode.AUTO
            }

The above configuration defines the mode of function call, it can be AUTO or ANY.

If we set ANY it will call the time user chats, it AUTO means once matched with the system instruction.

Define the create calendar event function

onst tools = [
  {
    functionDeclarations: [
      {
        name: 'create_calendar_event',
        description: 'Create a calendar event based on user input.',
        parameters: {
          type: 'object',
          properties: {
            title: {
              type: 'string',
              description: 'The title of the event'
            },
            email: {
              type: 'string',
              description: "User's email of the event (e.g., edison@yavar.ai)"
            },
            date: {
              type: 'string',
              description: 'The date of the event (e.g., 2025-05-10)'
            },
            time: {
              type: 'string',
              description: 'The time of the event (e.g., 3:00 PM)'
            },
            timezone: {
              type: 'string',
              description:
                'The timezone of the event (e.g., Asia/Kolkata, America/New_York)'
            }
          },
          required: ['title', 'email', 'date', 'time', 'timezone']
        }
      }
    ]
  }
];

Using the above code, we defined functionDeclarations and set up a function named create_calendar_event and defined what the inputs are that we need to collect from the user for calendar booking.

Once the user enters the required fields for calendar booking, we can find values in response.functionCalls.

 if (response.functionCalls?.length > 0) {
      const func = response.functionCalls[0];
   console.log('func is', func);
   console.log('Function name:', func.name);
   console.log('Arguments:', func.args);
    const args = func.args;

  
   if (func.name === 'create_calendar_event') {
          await bookAEvent(
            args.title,
            args.date,
            args.time,
            args.email,
            args.timezone
          );
          isBooked = true;
        }
      } 
}

Now you can find values in the logs and call bookAEvent function.

async function bookAEvent(title, date, time, mail, timezone) {
  const startDateTime = new Date(`${date} ${time}`);
  const endDateTime = new Date(startDateTime.getTime() + 60 * 60 * 1000); // +1 hour

  const event = {
    summary: title, 
    start: {
      dateTime: startDateTime.toISOString(), 
      timeZone: timezone
    },
    end: {
      dateTime: endDateTime.toISOString(),
      timeZone: timezone
    },
    attendees: [
      { email: 'edisonj1996@gmail.com' },
      { email: mail }
      // Replace with extracted attendees
    ],
    conferenceData: {
      createRequest: {
        requestId: 'meet-' + Date.now(),
        conferenceSolutionKey: {
          type: 'hangoutsMeet'
        }
      }
    }
  };
  console.log('evet is', event);

  if (calendar) {
    const calendarResponse = await calendar.events.insert({
      calendarId: 'primary', // Use 'primary' for the user's main calendar
      auth: oauth2Client,      resource: event,
      conferenceDataVersion: 1
    });
    // console.log('bookAEvent is', calendarResponse);
  }
}

The above function is for creating an event in the calendar. We need to pass the following details in the resource.

1. summary — event tittle
2. start — start time with timezone
3. end—end time with timezone
4. attendees — email of all attendees.
5. confererceData — it is for generating a g-meet link

Now, calling node index.jsWe can run the application and chat with Gemini, and book an event in Google Calendar.

References:

Access full code — https://github.com/EdisonDevadoss/gemini-calendar-booking-node-example/tree/main

Google APIs — https://console.cloud.google.com/apis

Gemini API key — https://aistudio.google.com/apikey

Thank you for reading. Have a nice day!

Book a Google calendar by using Gemini LLM was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Human Innovation: Overcoming Limitations through Invention

Throughout history, human inventions have complemented our weaknesses and enhanced our capabilities in various ways:

🔥 Taming Fire — Fire provided warmth, protection, and a means to cook food, addressing our vulnerability to cold, predators, and raw, unsafe food.

🛞 The Wheel — The invention of the wheel facilitated transport and heavy lifting, overcoming human limitations in moving large objects and traveling long distances efficiently.

⚙️ Machines (Industrial Revolution) — Machines and steam engines augmented human physical labor, allowing for mass production and increased productivity, thus addressing our physical limitations and the inefficiencies of manual work.

💻 Computing — Early computing machines, like Babbage’s Analytical Engine and Turing’s theoretical models, performed complex calculations and data processing far beyond human capacity, addressing our cognitive limitations in handling large-scale computations and repetitive tasks.

🤖 Artificial Intelligence — AI systems mimic human intelligence and enhance our cognitive capabilities. They excel in data analysis, pattern recognition, and decision-making, complementing our limitations in processing vast amounts of information quickly and accurately. AI assists in fields such as healthcare, finance, and logistics, where it can identify trends, make predictions, and optimize operations beyond human ability.

These inventions collectively enhance human strengths and mitigate our weaknesses, enabling us to achieve more than we ever could alone.

The Evolution of Human Ability

In ancient times, survival relied on physical strength and hunting prowess. As societies progressed, technology replaced the need for such skills, ensuring that people could thrive regardless of their natural physical abilities.

The next wave of innovation aimed at reducing human labor. From household appliances to AI-powered automation, the focus shifted toward efficiency. Entertainment, too, evolved dramatically, from storytelling to digital media, reshaping how we spend our leisure time.

However, the most impactful advancements are those that bridge the gap between individuals, ensuring that no one is left behind due to differences in ability. These inventions foster a more inclusive and equitable society.

The Next Frontier: Intelligence & Emotion

✍️ Writing & Print — Once, beautiful handwriting was a valued skill, but the printing press changed that. Later, typing speed became critical, but speech-to-text technology made it less relevant.

🧠 Artificial Intelligence — Now, even critical thinking — the defining trait that sets humans apart from animals — is being supplemented by AI, leveling the playing field in decision-making and problem-solving.

❤️ Emotional Intelligence — As AI continues to evolve, the final frontier is replicating emotional intelligence. When technology can match or surpass human empathy, we will have redefined what it means to be human.

The Future of Innovation

With every invention, from fire to AI, we move closer to a world where ability differences no longer dictate one’s potential. The ultimate purpose of innovation should not be just to make life easier or more entertaining but to create a society where no one is left behind.

The Evolution of Human Ingenuity: Bridging the Gap was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

In multi-threaded or multi-process Python applications, race conditions can cause unpredictable behavior, leading to data corruption, inconsistent states, and hard-to-debug errors. If you’ve ever faced issues where shared resources behave unexpectedly in concurrent execution, a race condition might be the culprit.

In this article, we’ll explore what a race condition is, why it happens, and how to handle it effectively in Python with real-world examples.

What is a Race Condition?

A race condition occurs when multiple threads or processes access and modify a shared resource simultaneously, leading to inconsistent results. Since thread execution timing is unpredictable, different execution orders may produce different outputs, making bugs hard to reproduce and debug.

Example of a Race Condition

Let’s consider a simple Python script where multiple threads try to increment a shared counter.

import threading

counter = 0  # Shared resource
def increment():
    global counter
    for _ in range(100000):
        counter += 1

threads = []
for _ in range(5):  # Create 5 threads
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Final counter value: {counter}")

Expected Output:

Since each thread increments counter 100,000 times and there are 5 threads, the expected output should be:

Final counter value: 500000

Actual Output (Unreliable Result):

Depending on system scheduling, you may see:

Final counter value: 423768
Final counter value: 479543
Final counter value: 500000  # Rarely happens

Why? Because counter += 1 is not an atomic operation—it consists of:

1. Reading the current value of counter
2. Incrementing the value
3. Writing the updated value back

If two threads execute this sequence at the same time, one update may overwrite the other, causing lost increments.

How to Handle Race Conditions in Python?

There are several ways to handle race conditions and ensure thread-safe operations.

1. Using a Lock (Thread Synchronization)

A lock ensures that only one thread can modify a shared resource at a time.

import threading

counter = 0  # Shared resource
lock = threading.Lock()

def increment():
    global counter
    for _ in range(100000):
        with lock:  # Lock ensures only one thread modifies counter at a time
            counter += 1

threads = []
for _ in range(5):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Final counter value: {counter}")  # Always 500000

Why This Works:

• The with lock: statement ensures that only one thread at a time modifies counter.
• It prevents other threads from accessing counter until the current thread finishes updating it.

🔹 When to Use Locks?

• When modifying shared variables in multi-threaded applications.
• When working with shared resources like files or databases.

2. Using the Queue Module (Thread-Safe Data Structures)

Instead of manually managing locks, Python’s queue.Queue provides built-in thread safety.

import threading
import queue

q = queue.Queue()

for _ in range(100000):
    q.put(1)

def process_queue():
    global counter
    while not q.empty():
        q.get()
        q.task_done()

threads = []
for _ in range(5):
    t = threading.Thread(target=process_queue)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print("Processing complete!")

Why This Works:

• queue.Queue ensures only one thread accesses an item at a time.
• It eliminates the need for manual locks.

🔹 When to Use Queue?

• When handling producer-consumer problems.
• When working with task scheduling.

3. Using Multiprocessing (Process Isolation)

Python’s Global Interpreter Lock (GIL) prevents multiple threads from executing Python code in parallel. If you need real concurrency, use the multiprocessing module.

import multiprocessing

def increment(counter):
    for _ in range(100000):
        counter.value += 1

counter = multiprocessing.Value('i', 0)  # Shared variable
processes = []
for _ in range(5):
    p = multiprocessing.Process(target=increment, args=(counter,))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

print(f"Final counter value: {counter.value}")

Why This Works:

• Each process runs independently in its own memory space.
• multiprocessing.Value ensures safe inter-process communication.

🔹 When to Use Multiprocessing?

• When CPU-intensive tasks require real parallel execution.
• When running machine learning models, video processing, etc..

Final Thoughts

Race conditions can cause serious problems in concurrent applications. Fortunately, Python provides multiple solutions:

Solution Best For Locks (threading.Lock()) Ensuring atomic updates in multi-threading Thread-safe Queues (queue.Queue()) Task scheduling and producer-consumer problems Multiprocessing (multiprocessing.Value()) True parallel execution for CPU-bound tasks

By understanding and implementing these techniques, you can build reliable and thread-safe Python applications. 🚀

💡 Have You Faced a Race Condition?

If you’ve encountered race conditions in your projects, let me know in the comments! What strategies worked for you? 🔥

Understanding Race Conditions in Python and How to Handle Them was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

How It Started

I never planned to use Vim. It just happened. While working on a Linux server, I had no choice but to use Vim since it was the default editor. At first, I had just learned some basic commands for editing code. But I kept using it over time whenever I worked on the server.

The Turning Point

One day, I watched a senior colleague use Vim inside VS Code with incredible speed and efficiency. I had never seen Vim being used that way before, and it amazed me. I didn’t even know Vim had an extension for VS Code, so I immediately installed it and started experimenting.

I kept watching ThePrimeagen’s YouTube videos, paying close attention to his typing speed and techniques. I wasn’t just learning Vim; I was studying how an expert used it.

For those interested, here’s one of ThePrimeagen’s introductory videos on using Vim:

Why Vim Worked for Me

Even before using Vim, I loved working in the terminal, doing everything from turning Wi-Fi on/off to shutting down my system — all through keystrokes. Since Vim is also terminal-based, it fits perfectly into this workflow, letting me keep my hands on the keyboard and work even faster.

Boosting Productivity (And the Common Trap)

Vim made me feel more productive — moving around and editing code became easy. But there was a trap: spending too much time customizing Vim instead of coding.

Many times, I would keep changing my .vimrc, trying new plugins, or switching color schemes. Before I knew it, hours had passed, and I had done no real work.

The real danger? Over-optimization. When too much time goes into perfecting the workflow rather than getting things done, it defeats the purpose. If you have to battle your setup just to be productive, then you’re not being productive.

What specific productivity gains do Vim/Emacs provide over GUI text editors?

The Productivity Debate

There’s still an argument about whether Vim makes developers more productive. Some say the time spent learning Vim offsets any speed gains. Others believe that once mastered, Vim significantly improves efficiency.

I feel much faster using Vim, but it ultimately depends on how comfortable you are with it. In the end, the real productivity boost comes from using tools that fit your workflow, not just the fastest ones.

Vim won't make you a more productive developer

Switching to Neovim

At first, I used Vim inside VS Code. But as I got better, I switched to Neovim (LazyVim) for personal projects. Neovim’s speed and flexibility, customization made it a great choice.

Still, people argue online about whether Neovim is better than Vim. Some say Vim is stable and widely used, while others prefer Neovim’s modern improvements. But in my opinion, Neovim’s speed and customization make it worth using.

For beginners, Neovim (LazyVim) offers better defaults and modern features, making it easier to configure, while Vim is great for those who prefer stability and minimal dependencies.

A question for those of you still using vim. Why do you use it over Neovim (if y... | Hacker News

The Learning Curve

Let’s be honest — Vim is hard to learn. The start is frustrating, and it takes time to get used to. In fact, the struggle is so real that one of the most upvoted Stack Overflow posts ever is just about how to exit Vim! But each small improvement makes things easier.

Some people debate whether Vim’s learning curve is worth it. Some argue that the time spent learning Vim could be better spent using a more intuitive editor. Others believe that once Vim is mastered, the benefits outweigh the effort. I think it’s worth it. Once you get comfortable, it becomes a powerful tool.

Learning Tmux Alongside Vim

While learning Vim, I also picked up Tmux, and it completely changed how I work. Instead of opening multiple tabs, I can run everything in a single terminal with multiple panes and switch between them easily. It’s highly customizable, and after tweaking it to fit my workflow, it became an essential tool.

Using Vim and Tmux together makes my setup smooth, and more efficient. But again, just having a fancy setup doesn’t mean real productivity — it’s only productive if it helps you get work done, not just manage your tools.

Final Thoughts

Vim wasn’t something I planned to use, but now I can’t imagine coding without it. At first, it felt unfamiliar, but every small improvement made a big difference. Sure, I’ve lost hours tweaking my config, but the speed and efficiency make it all worth it.

Would I recommend learning Vim? Absolutely — just don’t spend more time configuring it than actually coding!

If you’re new to Vim or want to learn some useful commands, I’ve written an article that might help.

Vim Essential Commands & Techniques

Are you using Vim or Neovim? Do you think the learning curve is worth it?

📌 Connect with me on LinkedIn.

I Never Planned to Use Vim — Now I Can’t Imagine Coding Without It was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

LLM Challenges in Networking and SD-WAN

Large Language Models face a few key challenges when applied to networking and SD-WAN environments:

• Lack of up-to-date knowledge: LLMs are trained on static datasets, meaning they don’t have real-time updates on networking trends or SD-WAN configurations.
• Generic responses: Out-of-the-box LLMs may not provide precise answers tailored to specific network architectures or troubleshooting scenarios.

What is RAG (Retrieval-Augmented Generation)?

RAG improves LLMs by retrieving relevant external data and incorporating it into the response generation process. It works in three key stages:

1. Retrieval: Fetching up-to-date data from a database or knowledge base.
2. Augmentation: Structuring and feeding the retrieved data into the LLM as context.
3. Generation: Producing a response based on the combined input from the user and retrieved data.

Use Case: RAG for SD-WAN Troubleshooting

Imagine a network engineer using an SD-WAN chatbot for troubleshooting. The chatbot doesn’t store fixed responses but instead retrieves real-time configuration logs, recent vendor documentation, and support tickets before generating a precise solution. This approach ensures:

• Dynamic updates from SD-WAN product documentation.
• Context-aware answers that are relevant to the latest firmware and configurations.

What is Fine-Tuning?

Fine-tuning involves training the LLM with specific labeled datasets, making it more precise and efficient in a given domain. This approach is useful when we need to reinforce particular patterns and industry-specific knowledge.

Use Case: Fine-Tuning for SD-WAN Policy Recommendations

Suppose an SD-WAN solution requires automatic policy recommendations based on past configurations. By fine-tuning an LLM with historical configuration templates and best practices, it can provide:

• Faster responses tailored to enterprise network policies.
• Consistent recommendations aligned with industry standards.

When to Use RAG vs. Fine-Tuning in Networking and SD-WAN?

Feature RAG Fine-Tuning Data Freshness Real-time retrieval of current data Static, pre-trained knowledge Customization Uses external data dynamically Learns from labeled datasets Use Case Handling product updates, chatbot responses Summarizing past SD-WAN logs, policy recommendations Implementation Complexity Easier to implement (connect to a knowledge base) Requires extensive labeled training data

Combining RAG and Fine-Tuning for SD-WAN Optimization

A hybrid approach can deliver the best of both worlds. For instance:

• Fine-tune an LLM with historical network outage data to recognize recurring patterns.
• Use RAG to fetch real-time SD-WAN performance metrics before generating a troubleshooting guide.

This combination ensures:

• Speed and accuracy by leveraging fine-tuned knowledge.
• Up-to-date insights by dynamically retrieving relevant information.

Conclusion

Both RAG and Fine-Tuning have their place in networking and SD-WAN implementations. While RAG is ideal for dynamic, real-time knowledge retrieval, fine-tuning is excellent for structured, domain-specific intelligence. By leveraging both approaches, network engineers and SD-WAN administrators can build powerful AI-driven solutions that enhance automation, troubleshooting, and decision-making.

RAG vs. Fine-Tuning: Understanding the Differences in the Context of SD-WAN and Networking was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Understanding Internal Network in VirtualBox

An Internal Network in VirtualBox allows VMs to communicate with each other but not with the host or the internet. To provide internet access, we need to introduce a VM that acts as a router between the Internal Network and an external network (such as NAT or Bridged Adapter).

Method: Using a Router VM (NAT + Internal Network)

The easiest way to enable internet access for Internal Network VMs is to configure one VM as a router that has:

• NAT Adapter (to access the internet)
• Internal Network Adapter (to communicate with other VMs)

Step 1: Configure Network Adapters

1. Select the VM that will act as the router and go to Settings → Network.
2. Adapter 1:

• Set Attached to: NAT
• This adapter will provide internet access.

3. Adapter 2:

• Set Attached to: Internal Network
• Name the network (e.g., intnet).
• This will connect to other VMs in the Internal Network.

Step 2: Enable IP Forwarding on the Router VM

If your router VM runs Linux, enable IP forwarding:

sudo sysctl -w net.ipv4.ip_forward=1

To make it permanent, edit /etc/sysctl.conf and add:

net.ipv4.ip_forward = 1

Then apply the changes:

sudo sysctl -p

Step 3: Configure NAT with iptables

Set up Network Address Translation (NAT) so Internal Network VMs can access the internet through the router:

sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

Replace eth0 with the interface name of the NAT adapter (use ip a to check interface names).

Step 4: Assign IPs to Internal Network VMs

1. Assign a static IP to the router VM’s Internal Network interface (e.g., 192.168.100.1/24).
2. Assign IPs to other Internal Network VMs in the same subnet (e.g., 192.168.100.10/24).
3. Set the router VM’s IP (192.168.100.1) as the Default Gateway on Internal Network VMs.

Step 5: Test Connectivity

On an Internal Network VM, try:

ping 8.8.8.8

If this works, but ping google.com doesn’t, configure DNS:

echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

Bonus: Set Up DHCP with dnsmasq (Optional)

To avoid manually assigning IPs, you can install dnsmasq on the router VM to serve DHCP:

sudo apt install dnsmasq

Edit /etc/dnsmasq.conf:

dhcp-range=192.168.100.50,192.168.100.100,12h
dhcp-option=3,192.168.100.1
dhcp-option=6,8.8.8.8,8.8.4.4

Restart dnsmasq:

sudo systemctl restart dnsmasq

Now, Internal Network VMs will get an IP, gateway, and DNS automatically.

Conclusion

By setting up a router VM with NAT and an Internal Network, you can provide internet access to VMs while keeping them isolated from the host. This setup is useful for testing, security, and private lab environments. With additional configurations like dnsmasq, you can automate IP allocation for a seamless experience.

Have you tried this setup? Let me know in the comments! 🚀

How to Enable Internet Access for an Internal Network in VirtualBox was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

Managing network data across multiple sources can be challenging. Keeping configurations consistent between databases, monitoring tools, and network devices requires an efficient way to compare and synchronize changes. This is where DiffSync comes in!

In this blog, we’ll explore DiffSync, a powerful Python library that helps synchronize network data by detecting and resolving differences between datasets. We’ll walk through a real-world example of managing network devices using DiffSyncModel.

What is DiffSync?

DiffSync is a Python library designed for comparing and synchronizing structured data across multiple sources. It allows you to:

• Define models representing your data.
• Track changes between different datasets.
• Synchronize data efficiently.

It’s widely used in networking automation tools like Nautobot and Network Importer.

Installing DiffSync

To get started, install DiffSync using pip:

pip install diffsync

Building a Network Device Inventory with DiffSync

Let’s create a DeviceModel to represent network devices and a NetworkInventory to manage multiple devices.

Defining the Device Model

from diffsync import DiffSync, DiffSyncModel

class DeviceModel(DiffSyncModel):
    """Represents a network device."""
    _modelname = "device"  # Unique model identifier
    _identifiers = ("name",)  # Unique fields
    _attributes = ("ip", "role")  # Fields to compare
    
    def __init__(self, name: str, ip: str, role: str):
        super().__init__(name=name, ip=ip, role=role)

Creating the Inventory

We now define NetworkInventory, which holds multiple devices and manages synchronization.

class NetworkInventory(DiffSync):
    """Represents a collection of network devices."""
    device = DeviceModel  # Registering the model
    
    def __init__(self, name: str):
        super().__init__()
        self.name = name

Comparing and Synchronizing Data

Now, let’s create two inventories: a source (representing the correct state) and a destination (which has outdated or incorrect data).

# Create inventories
source_inventory = NetworkInventory(name="Source")
dest_inventory = NetworkInventory(name="Destination")

# Add devices to source inventory
source_inventory.add(DeviceModel(name="Router1", ip="192.168.1.1", role="Core"))
source_inventory.add(DeviceModel(name="Switch1", ip="192.168.1.2", role="Access"))

# Add devices to destination inventory with different data
dest_inventory.add(DeviceModel(name="Router1", ip="192.168.1.1", role="Distribution"))  # Role is different
dest_inventory.add(DeviceModel(name="Switch2", ip="192.168.1.3", role="Access"))  # Different device

# Compute Differences
diff = dest_inventory.diff_from(source_inventory)

# Print Differences
print(diff.dict())  # Shows added, removed, or modified devices

Expected Output (Before Sync)

{
  "adds": {"device": [{"name": "Switch1"}]},
  "removes": {"device": [{"name": "Switch2"}]},
  "changes": {"device": [{"name": "Router1", "role": {"old_value": "Distribution", "new_value": "Core"}}]}
}

Synchronizing Data

Once differences are detected, we can synchronize the destination inventory to match the source.

dest_inventory.sync_from(source_inventory)
print("Synchronization Completed!")

Why Use DiffSync?

• Automation: Reduce manual configuration errors.
• Data Consistency: Ensure all systems have up-to-date information.
• Flexibility: Works with various data sources like APIs, databases, and YAML files.

Conclusion

DiffSync is a powerful tool for managing network configurations and keeping data consistent across different sources. By defining structured models, detecting differences, and synchronizing changes, you can automate tedious tasks and improve network reliability.

Give DiffSync a try in your next automation project! 🚀

Have you used DiffSync before? Share your experiences in the comments below! 👇

Synchronizing Network Data in Python with DiffSync was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

What is Quantum Networking?

Quantum networking is an advanced form of communication that leverages the unique properties of quantum bits (qubits), which can exist in multiple states simultaneously. This allows for more efficient data transmission and introduces new levels of security that are impossible to achieve with classical networks.

Key Principles of Quantum Networking

🔹 Quantum Entanglement — Two or more particles become entangled, meaning any change to one particle is instantly reflected in the other, regardless of distance. This could enable near-instantaneous communication across vast distances.

🔹 Quantum Superposition — Unlike classical bits, a qubit can exist as 0 and 1 at the same time, vastly increasing computational and networking capabilities.

🔹 Quantum Key Distribution (QKD) — A revolutionary cryptographic technique that allows secure key exchange. If an eavesdropper tries to intercept the key, the quantum state collapses, immediately notifying both parties of the security breach.

🔹 No-Cloning Theorem — Quantum information cannot be copied, meaning that any interception attempt results in the destruction of the data, preventing unauthorized access.

Real-World Applications of Quantum Networking

The implications of quantum networking go far beyond theory. Here are some key areas where it is already making an impact:

✅ Ultra-Secure Communications — Governments, financial institutions, and defense organizations can use quantum networks to ensure completely secure messaging and data transfers.

✅ The Quantum Internet — A futuristic concept where quantum computers and devices communicate securely across a global quantum network.

✅ Distributed Quantum Computing — Multiple quantum computers can be interconnected to work as a unified system, solving complex problems much faster than classical computers.

✅ Cloud Security Enhancement — Protecting sensitive cloud-stored data with quantum-encrypted channels that prevent unauthorized access.

Challenges Facing Quantum Networking

Despite its promise, quantum networking faces several hurdles:

⚠️ Hardware Limitations — Quantum communication requires highly sophisticated quantum processors and extreme cooling environments.

⚠️ Signal Loss & Noise — Quantum states are delicate and can be easily disrupted, leading to challenges in long-distance communication.

⚠️ Limited Infrastructure — Today’s fiber-optic and satellite networks are not yet optimized for quantum data transmission.

The Future of Quantum Networking

Tech giants like Google, IBM, and China’s Quantum Research Group are already working towards developing large-scale quantum networks. The race is on to create the Quantum Internet, where quantum computers and secure communication channels will redefine global cybersecurity, finance, and cloud computing.

While still in its early stages, quantum networking is poised to reshape the future of secure communication. As advancements continue, we can expect to see widespread adoption in the coming decades, leading to a safer and more efficient digital world.

What are your thoughts on quantum networking? Do you think it will become mainstream soon? Let’s discuss in the comments! 🚀

The Future of Secure Communications: An Introduction to Quantum Networking was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.

The world is shifting fast. AI is automating jobs, the economy is uncertain, and the entire software industry is feeling the pressure. Layoffs, hiring freezes, and constant change make it easy to feel stuck. But here’s the truth: some of the greatest innovations happen during hard times.

Struggle Fuels Greatness

Think about history — powerful literature, groundbreaking inventions, and game-changing businesses often emerge from adversity. Tough times force us to rethink, rebuild, and evolve. The same applies to software professionals, leaders, entrepreneurs, and investors today.

Some of the biggest tech companies we admire — Airbnb, Uber, and WhatsApp — were founded during economic downturns. Why? Because challenges push people to innovate. This is your time to rise.

Comfort You Must Give Up to Grow

Growth doesn’t happen in comfort. In uncertain times, we need to adapt, upskill, and step outside our safe zones. Here are some comforts you might need to give up:

1. The Expectation of Immediate Job Security

For freshers and employees, long-term stability isn’t always guaranteed. Instead of relying solely on job security, focus on career security — continuously learning, networking, and staying adaptable.

2. The Fear of Rejections & Failures

For job seekers and startups, rejection is part of the journey. Every setback is a lesson. Whether it’s a job application, a funding pitch, or a failed product, learn, refine, and keep pushing forward.

3. The Comfort of Old Business Models

For companies and leaders, AI and automation are shifting the landscape. Traditional business models may no longer work — embrace agility, invest in emerging technologies, and foster innovation within your teams.

4. Work-Life Balance (Temporarily)

For entrepreneurs and professionals, balancing work and personal life is crucial, but certain periods require extra effort. Investing time in learning, upskilling, and networking can position you ahead in the evolving market.

What You Can Do Now

Instead of worrying about the future, take action today:
✅ Upskill — Learn AI-related tools, automation, and cloud computing. Platforms like Coursera, Udemy, and YouTube have excellent resources.
✅ Build — Work on real-world projects, contribute to open-source, or create innovative solutions.
✅ Network — Engage with industry professionals, attend tech meetups, and build strong connections.
✅ Stay Adaptable — Be open to new technologies, job roles, and business opportunities.

The Future Belongs to the Builders

The tech landscape is shifting, but that doesn’t mean opportunity is gone. It simply means opportunity looks different. The software professionals, leaders, and entrepreneurs who embrace change, stay curious, and keep building will lead the next wave of innovation.

This isn’t the time to sit back. This is the time to build. 🚀🔥

Great Work is Born from Struggle — A Message for All Stakeholders in the Software Industry was originally published in YavarTechWorks on Medium, where people are continuing the conversation by highlighting and responding to this story.