DEV Community: Audrey Kadjar

Google Cloud Run Hackathon: Building Lexi — a Multi-Agent AI Legal Assistant for Individuals

Audrey Kadjar — Fri, 07 Nov 2025 07:42:40 +0000

It all started when I was reviewing an employment contract for a new job offer and found that I was struggling to understand the legal jargon.

I realized how difficult it can be for individuals to truly understand complex legal language. Legal documents are often dense, time-consuming, and intimidating to review. Most people struggle to grasp key clauses and identify potential risks, particularly in employment or freelance agreements.

That’s where Lexi comes in: a multi-agent AI legal assistant designed to make contract analysis clear, accessible, and easy to understand for individuals. Built for the Google Cloud Run Hackathon, Lexi focuses on delivering accurate, structured insights without overwhelming the user.

Lexi’s vision is to help people understand any legal document, anywhere in the world. For now, it’s trained specifically on employment contracts in English under German law, as part of this project’s scope.

⚙️ How It Works

You upload your employment, freelance, or NDA contract.
Lexi analyzes each clause using multiple AI agents.
On the frontend, Lexi streams the analysis in real time for a smooth, interactive experience.
It highlights potential risks, compares clauses to standard legal documents, and explains everything in plain, human-friendly language.

In short, Lexi makes legal document understanding faster, clearer, and even enjoyable.

🧱 System Architecture

                           ┌───────────────────────────────┐
                           │        Frontend (React)       │
                           │-------------------------------│
                           │ • Upload contract (PDF/Text)  │
                           │ • View clause analysis (live) │
                           │                               │
                           └──────────────┬────────────────┘
                                          │
                             JSON POST /contracts/analyze
                                          │
                                          ▼
                            ┌───────────────────────────────┐
                            │         FastAPI Backend       │
                            │        (Runs on Cloud Run)    │
                            │-------------------------------│
                            │ 1️⃣ Receives contract payload  │
                            │ 2️⃣ Extracts text (if PDF)     │
                            │ 3️⃣ Sends to CoreOrchestrator  │
                            │ 4️⃣ Streams structured JSON     │
                            │     chunks back to frontend   │
                            └──────────────┬────────────────┘
                                           │
                                           ▼
                     ┌────────────────────────────────────────────┐
                     │       Google ADK Agent System (Vertex AI)  │
                     │--------------------------------------------│
                     │ 🧭 CoreOrchestrator (LLM)                  │
                     │     ├─ ClauseExtractorAgent (LLM)          │
                     │     ├─ StandardClauseRetriever (Embed)     │
                     │     ├─ ClauseComparisonAgent (LLM)         │
                     │     └─ RiskAnalysisAgent (LLM)             │
                     │                                            │
                     └────────────────────────────────────────────┘
                                           │
                                           ▼
                           Streamed JSON → FastAPI → React

🧩 Stack Overview

Frontend: React (Cloud Run)
Backend: FastAPI (Cloud Run)
Storage: Firestore (for embeddings)
LLMs: gemini-embedding-001, gemini-2.0-flash
OCR: In-memory PDF text extraction
Containerization: Docker
Deployment: Google Cloud Run

🤖 Multi-Agent System

Agent	Role
RootOrchestratorAgent	Coordinates all specialized agents
SequentialAgent	Ensures ordered clause processing
ClauseExtractorAgent	Extracts clauses from the contract
StandardClauseRetriever	Retrieves reference clauses from Firestore embeddings
ComparisonAgent	Detects deviations from standard clauses
RiskAnalysisAgent	Explains potential issues in plain language

All agents collaborate through an orchestrator and shared state — creating a flexible and extensible system for document intelligence.

🧠 What I Learned

How to orchestrate multi-agent systems using Google ADK
How to integrate embeddings with Firestore for semantic retrieval
How to deploy AI workloads on Google Cloud Run efficiently
How to design real-time streaming UIs with FastAPI and React

🏆 Accomplishments

Combining Gemini models, Google ADK, Firestore to create an AI app that improves a process and solves a real-world problem.
Using Cloud Run to deploy services seamlessly

🚀 What’s Next

🔹 Expand to more document types (leases, NDAs, terms of service)
🔹 Add conversational Q&A (“Ask Lexi about clause 5”)
🔹 Support multiple languages for global accessibility
🔹 Explore secure authentication and saved session histories

You can explore the project’s code on the GitHub repo—feel free to share any feedback. Wishing the best of luck to everyone!

📦 🐳 Explaining Docker to My Parents (With Visuals)

Audrey Kadjar — Mon, 02 Jun 2025 16:13:16 +0000

Over dinner during the last Christmas holiday, my cousin, who works in maritime logistics, explained his job managing shipping containers. The next day, during a car ride with my parents, I casually mentioned that software engineers also use the concept of "containers" to deliver applications.

My parents asked me to explain. That innocent question sparked an hour-long explanation of Docker in the backseat 😅

It turned out to be a rewarding experience because it challenged how well I understood it. So, I thought I'd recreate that conversation here (with visuals!) to help others understand Docker.

What's Docker?

“Docker? What's that?” my parents asked, intrigued.

Docker is a program you install on your computer. It lets you package your app and everything it needs (code, libraries, settings) into a unit of software called a container.

Developers use Docker to package applications so they can run reliably and consistently.

But why do we need Docker?

“Okay, that sounds interesting,” my parents asked, “but what problem does it actually solve?”

The main benefits of using Docker are consistency and speed.

In shipping logistics, containers are used to transport goods from one place to another. The point of using containers is consistency. No matter what’s inside (a couch, TVs, or shoes), it all fits into a standard-sized box that ships easily.

In software engineering, we have a similar concept.

When we deploy an application, we want to package everything it needs - its code, configuration, and dependencies (like libraries) - into a box that can run anywhere.

📦 Physical Container       🐳 Docker Container
────────────────────       ─────────────────────
🚢 Shipping Box            📦 Docker Container
🧾 Packing List            🧱 Docker Image
🖥️ TVs                     💻 App Code
👟 Shoes                   📚 Libraries
📘 Books                   ⚙️ Config Files
🍽️ Dishes                 🧪 Dependencies

🔒 Secure + Sealed         🔐 Isolated + Portable
🚚 Easy to Transport       📦 Easy to Deploy
🌍 Standard Size           📐 Consistent Environment

        ➡️ Goal: Standardize Delivery ⬅️
     🛳️ Goods               🧑‍💻 Software

We work with multiple environments in software engineering: for example, the test environment or the production environment with which customers interact. Docker ensures that your application behaves the same, no matter in which environment it runs.

Unlike older methods like Virtual Machines, Docker doesn’t need to simulate a full operating system, so it's fast.

Wait... What’s a Virtual Machine?

My mom looked back and said: “Virtual machine? You lost us there, honey.”

Fair enough! 😁

A virtual machine (VM) allows a physical computer to simulate multiple independent computers within itself. Each VM has its own operating system (OS), virtual CPU, memory, and storage. This setup provides complete separation but is resource-intensive.

Unlike VMs, Docker containers share the host’s operating system instead of running a full OS. Yet, they stay isolated from each other and the host using Linux features like namespaces (for separating processes and networks) and cgroups (for managing resources). This makes containers fast, lightweight, and secure, which is ideal for quick and consistent software deployment.

(image credit: this diagram was taken from Docker's website)

How is Docker used for delivery?

"Ok, but why do you use this? Why can't you just deploy your application directly?" Another solid question my dad raised with a frown.

In software engineering, we deploy applications to servers to make them accessible to users. A server is just another (usually powerful) computer, often hosted by cloud providers like AWS or Google Cloud. Deploying to a server involves copying your app’s code onto the machine and running it so that others can access your app.

You can deploy your app directly to a server—but that’s like shipping loose cargo. If the server’s environment is different from yours (like a different library version), your app might not work.

Docker lets you ship your app with its environment. So as long as the server supports Docker, your app runs exactly as it did on your computer.

Demo: How do you use Docker?

At this point, I wasn’t sure if my parents were impressed… or completely lost. Then my mom asked one last question: “So how do you use Docker? It sounds complicated.”

Using Docker is actually pretty straightforward:

Install Docker Desktop on your computer.
In your app’s folder, create a file called a Dockerfile. In this file, you describe how to package your app — specifying the base system, required dependencies, and how to start the app.

This is a simple Dockerfile for a Node.js app:

# Use an official Node.js runtime as the base image
FROM node:18

# Create and set the working directory inside the container
WORKDIR /app

# Copy package.json and package-lock.json
COPY package.json ./

# Install dependencies
RUN npm install

# Copy the rest of your application code
COPY . .

# Expose the port your app runs on
EXPOSE 3000

# Command to run your app
CMD ["node", "index.js"]

Build a Docker image:

   docker build -t my-app .

This command creates a Docker image. It’s not a picture but a set of files that contains everything needed to run your app (like a blueprint for creating the container). These files are stored inside Docker’s internal storage area.

Run the container:

   docker run my-app

This command starts a container, which is a running instance of the image you built in the previous step.

Your app is now running inside a container!

Hope this guide was helpful! Let me know in the comments what you thought of it and if you have any questions 😊

[Boost]

Audrey Kadjar — Tue, 11 Mar 2025 18:24:49 +0000

🛠️🧩 TypeScript Utility Types - a cheat sheet

Audrey Kadjar ・ Mar 7

#typescript #javascript #programming

🛠️🧩 TypeScript Utility Types - a cheat sheet

Audrey Kadjar — Fri, 07 Mar 2025 08:30:26 +0000

Utility types look complicated, but they are actually simple and super handy. Let's say you have a type and you want to customize it for a use case. Instead of duplicating that type and modifying it to fit that use case, you can use a utility type.

Here is a recap of some utility types. You can play with the examples on the TypeScript Playground.

Partial

This utility type makes all properties of a type optional. This is useful if you need to update or extend a type, but don't need to provide every property. However, TypeScript still enforces correct types for each property and does not allow arbitrary properties-all properties must be included in the type definition.

interface User {
  name: string;
  age: number;
}

const user1: Partial<User> = { name: "Audrey" }; // age is optional
const user2: Partial<User> = { age: 33 }; // name is optional
const user4: Partial<User> = { name: 33 }; // Error: Type 'number' is not assignable to type 'string'
const user5: Partial<User> = { whatever: 33 }; // Error: Object literal may only specify known properties
const user6: Partial<User> = {}; // can be empty since it makes all properties optional

Required

The opposite of Partial, it makes all properties of a type mandatory. This can be useful when you want to make sure that a type has all of its properties set, even if it was previously optional.

interface Shape {
  color?: string;
  width?: number;
}

const shape1: Required<Shape> = { color: "green", width: 40 }; // both properties are mandatory
const shape2: Required<Shape> = {color: "blue"} //Error: Property 'width' is missing in type '{ color: string; }' but required in type 'Required<Shape>'

Readonly

This makes all properties of a type read-only, meaning they can't be reassigned after creation.

interface User {
  name: string;
  age: number;
}

const user: Readonly<User> = { name: "Alice", age: 25 };
user.age = 26; // Error: Cannot assign to 'age' because it is a read-only property

Record

This creates an object type with keys of type K and values of type T. It’s useful when you want to enforce a shape for an object with dynamic keys.

type Role = "admin" | "user" | "guest";

const userRoles: Record<Role, string> = {
  admin: "Administrator",
  user: "Regular User",
  guest: "Guest User",
};

Pick

This type constructs a new type by picking a set of properties K from type T. It’s useful when you need a subset of properties from an existing type.

In this example, pickedUser object is correctly typed because it includes only the name property. It is then assigned to an object, which matches the expected type.

interface User {
  name: string;
  age: number;
}

const pickedUser: Pick<User, "name"> = { name: "Audrey" };
const pickedUser2: Pick<User, "name"> = { name: "Audrey", age: 33 }; // Error: 'age' does not exist in type 'Pick<User, "name">'

What do utility types compile to?

Because TypeScript is a superset of JavaScript, utility types exist only at compile time to enforce type safety and do not affect runtime output. The final JavaScript output is just plain JavaScript objects with no TypeScript type constraints.

The examples above compile to:

"use strict";
//Partial
const user1 = { name: "Audrey" }; 
const user2 = { age: 33 }; 
const user6 = {}; 

//Required
const shape1 = { color: "green", width: 40 };

//Readonly
const user = { name: "Alice", age: 25 };

//Record
const userRoles = {
    admin: "Administrator",
    user: "Regular User",
    guest: "Guest User",
};

//Pick 
const pickedUser = { name: "Audrey" };

Make your own utility types

TypeScript enables the creation of custom utility types using generics and mapped types. For instance, you can define your own version of Partial.

The keyof T type in TypeScript represents all the property names (keys) of T. In the example, [K in keyof T] iterates over each key, while T[K] ensures the property retains its original type, and ? makes each property optional.

The custom MyPartial<T> type behaves similarly to Partial<T>, making all properties optional.

type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

interface User {
  name: string;
  age: number;
}

const user: MyPartial<User> = { name: "Alice" }; // 'age' is optional

I hope this was helpful! You can find all the available utility types in the TypeScript documentation.

Feel free to reach out if you have any questions! You can also find me on Github, BlueSky, LinkedIn, and Instagram.

I've launched a new web app to generate colors with AI

Audrey Kadjar — Fri, 06 Dec 2024 08:57:22 +0000

I’ve just launched my year’s side project!

color spot - a web app where users can generate colors with AI, images and moods, as well as explore and save their favorites from the community collection.

Check it out and let me know what you think :) I would appreciate any feedback (positive or negative) as I'd like to improve the app.

If you like it, please follow the project on Instagram @colorspot.app.

🛠️📚 Classes with TypeScript - a cheat sheet

Audrey Kadjar — Wed, 16 Oct 2024 17:24:05 +0000

TypeScript enhances JavaScript classes by providing additional features that make it easier to enforce contracts and catch errors at compile time. It's important to note that these TypeScript-specific features are removed at compile time, resulting in standard JavaScript classes.

Here is a cheat sheet summarizing these additional features. You can play with the examples below in this TypeScript playground.

1 - Access modifiers

TypeScript introduced access modifiers for better control over class properties and methods.

public: used for properties that can be accessed inside the class, from instances of the class, and outside the class. By default, all class members are public in TypeScript if no access modifier is specified.
protected: used for properties that can only be accessed within the class and by subclasses, but not from outside instances of the class.
private: used for properties that can only be accessed within the class where they are defined and not by subclasses.

class Counter {
    public count: number;
    protected maxCount: number;
    private hasBeenResetCount: number;

    constructor(maxCount: number){
        this.count = 0
        this.maxCount = maxCount
        this.hasBeenResetCount = 0
    }

    increment():string | number {
        if(this.count === this.maxCount) return "Error: cannot increment passed maxCount"
        this.count+=1
        return this.count
    }

    decrement(){
        this.count--
    }

    reset(){
        this.count = 0
        this.hasBeenResetCount++
    }
}

const myCounter = new Counter(5)
myCounter.increment()
const count = myCounter.count

//Property 'maxCount' is protected and only accessible within class 'Counter' and its subclasses.
//myCounter.maxCount --> ERROR

//Property 'hasBeenResetCount' is private and only accessible within class 'Counter'.(2341)
//myCounter.hasBeenResetCount --> ERROR

2 - Parameter properties

TypeScript provides a shorthand for automatically declaring and initializing class properties in the constructor, which JavaScript does not have. Note that you have to use access modifiers to explicitly declare the parameters in the constructor as class properties; otherwise, you will get an error.

class Person {
    constructor(public name: string, public age: number){}
}

const person = new Person("Audrey", 30);
console.log(person.name); // "Audrey"
console.log(person.age);  // 30

3 - Creating contracts between classes and interfaces

TypeScript allows you to use interfaces to define contracts for classes. Interfaces promote loose coupling by separating the contract (interface) from its implementation (class). Implementing an interface doesn't provide any code to the class (unlike inheritance between classes); it only ensures that the class conforms to the contract, meaning the required methods and properties must be present. A class can implement multiple interfaces, allowing for more flexible design.

interface Shape {
    size: number;
    color: string;
}

interface Metadata {
    createdAt: Date;
}

class Square implements Shape, Metadata {
    size: number;
    color: string;
    createdAt: Date;

    constructor(size: number, color: string, createdAt: Date){
        this.size = size;
        this.color = color;
        this.createdAt = createdAt;
    }
}

4 - The abstract keyword

TypeScript allows you to define abstract classes and methods, providing a way to enforce a structure similar to interfaces but with additional functionality.

Abstract classes serve as blueprints for other classes. They cannot be instantiated directly (you cannot create an object of an abstract class).
An abstract method is a method defined in an abstract class without a body (implementation). It forces any derived class to implement that method. Abstract methods are like placeholders—they define the signature of the method but leave the implementation details to the subclasses.

abstract class Product {
    abstract getPrice():number;
    abstract getDescription(): string;

    //concrete method 
    getStore(){
        return 'My store'
    }
}

class RedDress extends Product {

    //inherits method getStore
   //implements abstract methods 

    getPrice(){
        return 40
    }

    getDescription(){
        return 'Red dress for cocktail parties'
    }
}


const myRedDress = new RedDress();
myRedDress.getStore() //"My store" 
myRedDress.getPrice() // 40 
myRedDress.getDescription() //"Red dress for cocktail parties"

I hope this was helpful!

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

🛠️ 📦 TypeScript Generics - a cheat sheet

Audrey Kadjar — Thu, 15 Aug 2024 16:17:19 +0000

Generics in TypeScript can seem daunting at first - what’s with all those capital letters and square brackets? 😅

But don’t worry, this cheat sheet helps demystify Generics and show you how they work with simple examples.

How Generics Works

Generics enable you to define a type variable that serves as a placeholder for a specific type to be provided later. This is the core strength of Generics: they allow you to define flexible, reusable types without sacrificing type safety.

The letter T is commonly used by convention to represent a generic type variable, but you can use any letter or descriptive name that fits your context (other commonly used letters include U, V, K).

Usage examples

Below are some practical examples that demonstrate how Generics work.

You can play with the examples below in this TypeScript playground.

Generics Functions

// A generic function that works with any data type
function identity<T>(arg: T): T {
    return arg;
}

// Using the generic function with different types
let num = identity<number>(42); // T is number
let str = identity<string>("Hello"); // T is string

//TS automatically infers the type so this also works:
//let num = identity(42); // T is number
//let str = identity("Hello"); // T is string

In this example, T is a type parameter that can represent any type. The actual type is determined when the function is called, whether it’s a number, string, or any other type.

Here, we've manually set the type to highlight how TypeScript handles different types with generics. However, it's important to remember that TypeScript typically infers the type automatically based on the argument provided. You don't need to manually specify the type unless you're overriding TypeScript's inference or dealing with complex types where explicit type annotations are necessary.

Generic Interfaces

Here, we define an interface Pair with two properties of different types. These types are specified when an instance is created and can be any type. The only constraint is that each property maintains its respective type.

interface Pair<T, K> {
  first: T;
  second: K;
}

let pair: Pair<string, number> = { first: "one", second: 2 }
let anotherPair: Pair<number, string> = { first: 1, second: "second" }
let otherPair: Pair<number, number> = { first: 1, second: 2 }

Generics Types

Generics can also be applied to custom types. The process is similar to interfaces: you define a shape with placeholder types, which are determined when the type is used. Generics enforce typing but do not dictate specific types.

type Person<T, K, V> = {
  name: T,
  age: K,
  isMarried: V
}

const person1: Person<string, number, boolean> = {
  name: 'Bob',
  age: 67,
  isMarried: false
}

Generic Classes

Generic classes allow you to define a blueprint where the data’s type is flexible, only being defined when an instance is created. In this example, the Box class can store content of any type (for example, a string, a number, or any other type).

class Box<T> {
  content: T

  constructor(content: T){
    this.content = content
  }

  getContent(): T {
    return this.content
  }
}

const letterBox = new Box('a')
const numberBox = new Box(1)

Constraints

Generics also support constraints, allowing you to limit the types that can be used. For example, if you only want to support types with a length property, you can enforce this constraint using the extends keyword. It restricts the generic type variable to be a subtype of a particular type or interface. This ensures that the generic type must have certain properties or structure.

type LengthType = {length: number}
function getLength<T extends LengthType>(args: T){
  return args.length
}

getLength('abc')
getLength([1, 2])

//this doesn't work:
//getLength(2)
//getLength({"a": "b"})

Utility types

Utility types in TypeScript use generics to create flexible and reusable type transformations. They simplify working with existing types by providing built-in operations.

interface User {
  name: string;
  age: number;
  location: string;
}

//makes all properties optional 
const partialUser: Partial<User> = {name: 'Alice'}

//allows to omit properties: here the name property is omitted
const omitUser: Omit<User, 'name'> = {location: 'Berlin', age: 33}

I hope this was helpful!

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

☁️ 🥇 Tips and free resources for passing the AWS Developer Associate Certification

Audrey Kadjar — Sun, 28 Jul 2024 11:39:22 +0000

A few months ago, I successfully passed the AWS Developer Associate certification. Here are some tips for preparing for and taking the exam!

Preparation

Here is a list of resources I used to prepare for the exam:

Resource Name	Price	Link
Official AWS Certification Information and Policies	Free	AWS Certification Information
Official AWS Sample Questions	Free	Official Mock Questions
AWS Free Practice Test Questions GitHub Repo	Free	GitHub Repo
AWS Bites Podcast	Free	AWS Bites Podcast
Tutorials Dojo	$14.99	Tutorials Dojo
A Cloud Guru	varies	A Cloud Guru

It took me about 2.5 months to prepare for the exam. I used A Cloud Guru's training and tried to study for at least 1 hour every day and 2-3 hours on the weekends. I like A Cloud Guru because it's a good mix of theoretical and hands-on training: they give you test accounts so you can practice on the real AWS console without using your personal account (and risk getting charged!). (I have no affiliation with A Cloud Guru!).

In my opinion, it is important to get as much hands-on experience as possible to understand how the services work and how to apply them to real-world scenarios. The exam includes scenario-based questions, so this is important. An in-depth understanding of the main services (including EC2, Lambda, API Gateway, S3, DynamoDB, CloudFront, Systems Manager Parameter Store, Secrets Manager, SQS) and how they work together is essential.

To deepen my knowledge, I listened to the AWS Bites podcast in my spare time, especially the episodes on Serverless, S3, Lambda, Cognito, and DynamoDB. The episodes are short and of good quality. I enjoyed listening to them and would definitely recommend the podcast.

When I finished A Cloud Guru's course, I took all of their sample exams. After each exam, I reviewed the questions I got wrong. A Cloud Guru gives you an explanation for each answer, so it is easy to see why you got it wrong.

As my exam date approached, I almost panicked when I checked reddit and people said that preparing with A Cloud Guru wasn't enough and recommended Tutorials Dojo's sample exams. I bought Tutorials Dojo and took a few. They are harder than the real exam, so don't be afraid if you score lower on them. They also have good in-depth explanations of the answers to the questions, so it's good to supplement your preparation.

The exam

I took the exam online with Pearson VUE. The experience was smooth, and I didn't have any problems. There is a check at the beginning, so before the exam, clear the room of any posters or unnecessary items. Just leave your computer on the table.

As for the exam itself, most of the questions are scenario-based, and you have multiple choices. It's important to read each question carefully, but don't overthink it. Try to understand the scenario and the problem, and then eliminate the choices that you are sure are incorrect. If you don't know the answer, use common sense. Try all the questions because there are no negative marks. There was a big focus on Serverless in my exam, and many questions revolved around Lambda, API Gateway, CloudFront, S3, and DynamoDB.

I hope this guide was helpful! Good luck on the exam! You can do it!

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

🧭 🇹 When to use the non-null assertion operator in TypeScript

Audrey Kadjar — Wed, 17 Jul 2024 16:11:12 +0000

Did you know that TypeScript has a non-null assertion operator?

The non-null assertion operator (!) is used to assert that a value is neither null nor undefined. It tells TypeScript's type checker to ignore the possibility that the value is null or undefined, thus bypassing type checking for these values.

When to use it

Use the non-null assertion operator when you are certain that a variable will be assigned a non-null value when you access it (for example, after a type guard).

In the example below, we use a non-null assertion operator (at user.email!) because we're certain that the value of the email property exists. Even though email is defined as an optional value in the User interface, we're checking for its existence with a type guard in the getEmail function, so we can be sure that it exists.

Feel free to check this example in the TypeScript Playground and play with it.

interface User {
  id: number;
  name: string;
  email?: string;
}

function getEmail(user: User): string {
  if (!user.email) return 'N/A';

  return user.email!;
}

const user: User = { id: 1, name: 'Alice', email: "alice@email.com"};
const email = getEmail(user);
console.log(`User's email: ${email}`);

Notice in this example that TypeScript would not throw an error if we removed the non-null assertion operator.

In TypeScript, while accessing optional properties like email without the non-null assertion operator is allowed, adding the non-null assertion operator can assert your understanding that the property is indeed present when accessed. This can be helpful for clarity and documentation, especially in large codebases or when working in teams. It also prevents TypeScript from warning you about potentially undefined values and allows you to treat the property as if it is always present, avoiding unnecessary runtime checks.

Hope this article has clarified the use of the intriguing non-null assertion operator in TypeScript!

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

📋 📝 Manage your clipboard in the CLI with Python

Audrey Kadjar — Mon, 01 Jul 2024 07:48:37 +0000

As someone who frequently copies and pastes content, I've often wondered about the inner workings of the clipboard and whether it was possible to manage it programmatically. I ended up writing a simple Python script that allows you to get the current value in the clipboard, clear it, and get its history via the command line interface (CLI).

How it Works

Here is a step-by-step guide to implementing this functionality:

Define a ClipboardManager class: The first step is to define a ClipboardManager class. This class will serve as the foundation for managing clipboard operations within the script. The __init__ method is the constructor: it sets up the initial state of the object when it is created. In this example, __init__ initializes history as an empty list and current_value as None.

   class ClipboardManager:
       def __init__(self):
           self.history = []
           self.current_value = None

Implement get clipboard and clear clipboard methods: Using the pyperclip module, we define methods within the ClipboardManager class to interact with the clipboard. These methods allow fetching the current clipboard value and clearing the clipboard. Every time we get the current clipboard value, we add it in the history list to keep track of it.

       def get_clipboard(self):
        value = pyperclip.paste()
        if value != self.current_value:
            self.history.append(value)
            self.current_value = value
        return value

        def clear_clipboard(self):
        pyperclip.copy('')
        self.current_value = ''
        print("Clipboard cleared.")

Implement the show history method: Next, we need to include a method that displays the history of clipboard values stored in self.history. In this method, we loop through the items in the list and use the enumerate built-in function to pair each value with an index, producing a numbered list. We set the starting index to 1 to make the output more user-friendly, aligning with the human convention of counting from 1, unlike computers which typically start counting from 0.

    def show_history(self):
        if self.history:
            for idx, value in enumerate(self.history, start=1):
                print(f"{idx}: {value}")
        else:
            print("No history available.")

Instantiate the class and provide options in the CLI: The last step is to implement the main execution logic of the script. We instantiate an object of ClipboardManager and create a user-friendly menu in the command-line interface to allow users to perform operations on the clipboard.

    if __name__ == "__main__":
    manager = ClipboardManager()

    while True:
        print("\nMenu:")
        print("1. Get current clipboard value")
        print("2. Show clipboard history")
        print("3. Clear clipboard")
        print("4. Exit")

        choice = input("Enter your choice (1-4): ")

        if choice == '1':
            current_value = manager.get_clipboard()
            print(f"Current clipboard value: {current_value}")

        elif choice == '2':
            manager.show_history()

        elif choice == '3':
            manager.clear_clipboard()

        elif choice == '4':
            print("Exiting...")
            break

        else:
            print("Invalid choice. Please enter a number from 1 to 4.")

This is the final script:

import pyperclip

class ClipboardManager:
    def __init__(self):
        self.history = []
        self.current_value = None

    def get_clipboard(self):
        value = pyperclip.paste()
        if value != self.current_value:
            self.history.append(value)
            self.current_value = value
        return value

    def show_history(self):
        if self.history:
            for idx, value in enumerate(self.history, start=1):
                print(f"{idx}: {value}")
        else:
            print("No history available.")

    def clear_clipboard(self):
        pyperclip.copy('')
        self.current_value = ''
        print("Clipboard cleared.")

if __name__ == "__main__":
    manager = ClipboardManager()

    while True:
        print("\nMenu:")
        print("1. Get current clipboard value")
        print("2. Show clipboard history")
        print("3. Clear clipboard")
        print("4. Exit")

        choice = input("Enter your choice (1-4): ")

        if choice == '1':
            current_value = manager.get_clipboard()
            print(f"Current clipboard value: {current_value}")

        elif choice == '2':
            manager.show_history()

        elif choice == '3':
            manager.clear_clipboard()

        elif choice == '4':
            print("Exiting...")
            break

        else:
            print("Invalid choice. Please enter a number from 1 to 4.")

Usage

To utilize this script, follow these steps:

Save the script into a file with a .py extension (e.g., clipboard-script.py).
Open a terminal and navigate to the directory containing the script.
Run the script by providing the script path. For example:

python3 <script-path>

python3 clipboard-script.py

Now, you can test the script by copying text from your command-line interface (CLI) and begin utilizing its functionality to manage clipboard operations effectively.✨

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

📁🐍 Automate File Renaming with Python

Audrey Kadjar — Wed, 06 Mar 2024 17:48:59 +0000

Renaming files can be a tedious task, especially if you have many. Last time I was sorting through my photos and found myself renaming them one by one, I decided to automate the task 👩🏻‍🔬

How it Works

Input Validation: The script begins by checking if the required arguments are provided via command-line input. If not, it prompts the user to provide the folder path and the new name for the files. The sys module is used to extract the command-line input.
File Enumeration: It then lists all the files in the specified folder. The script will iterate through all the eligible files in the folder, renaming them sequentially. The os module is used for file-related operations. A regular expression (file_extension_pattern variable) is defined using the re module. Its role is to match the file extension (eg. .png for a file named image.png).
Renaming Process: For each file with an image extension (e.g., JPEG, PNG), the script extracts the file extension using the regular expression pattern, generates a new name, and renames the file accordingly. The new name is formed by concatenating the name, an underscore _, and the count. For example, if the user provides image as the new name and the script processes 3 files, the new names would be: image_1, image_2, image_3. Feel free to adjust this pattern based on your needs.

import os
import sys
import re

if(len(sys.argv) < 3):
    print('Please provide a folder path and a new name.')
    sys.exit(1)

path = sys.argv[1]
name = sys.argv[2]

folder = os.listdir(path)
count = 1
image_extensions = ('jpeg', 'jpg', 'png', 'tiff', 'gif')
base_path = path + '/'
file_extension_pattern = r'\.[^.]+$'

for file in folder:
    if(file.lower().endswith(image_extensions)):
        match = re.search(file_extension_pattern, file)
        file_extension = match.group(0)
        new_name = f"{name}_{count}"
        old_path = base_path + file
        new_path = f"{base_path}{new_name}{file_extension}"
        os.rename(old_path, new_path)
        count+=1

Usage

To utilize this script, follow these steps:

Save the script into a file with a .py extension (e.g., rename_files.py).
Open a terminal or command prompt and navigate to the directory containing the script.
Run the script by providing the folder path and the desired new name as command-line arguments. For example:

python <script> <path> <new_name>

python3 rename_files.py /path/to/folder new_name

That's it! All your files should be automatically renamed ✨

Feel free to reach out if you have any questions! You can also find me on Github, LinkedIn, and Instagram.

👩‍💻🏆 5 tips for surviving (and winning!) a Hackathon

Audrey Kadjar — Tue, 16 Jan 2024 07:24:00 +0000

I recently participated in my third Hackathon (Hack for Impact in Berlin co-organized by Google, On, Adesso, Girls in Tech) and had so much fun! With my team, we developed an AI-powered app that allows users to scan the tags on their clothes to discover their sustainable impact. It was fun to develop a project from start to finish and see everyone's final pitches. In the end, we even won first prize for our project! 🏆

Hackathons are great opportunities to meet people and build innovative projects. Creating an entire project in a tight timeframe also shows you the incredible things you can accomplish with focused effort. Here are my 5 tips!

Finding a Hackathon

Before you dive in, research and choose a hackathon that matches your skills and interests. For example, don't sign up for a hackathon for Machine Learning engineers if you lack ML skills. Also, consider the tone and topics of the event to make sure they match your personality and interests. Check out events hosted by tech meetups and organizations. Devpost is also a great resource for finding Hackathons.

Set up your work environment

To save valuable time during the event, prepare your work environment ahead of time. Configure your IDE, install necessary packages, and set up boilerplate code. At my last Hackathon, I set up the project's boilerplate (a minimal Node.js backend with a PostgreSQL database along with a React frontend) before the event, which allowed us to focus on our project when the hackathon started.

Build a diverse team

Whether you sign up with a pre-formed team or team up with participants on the day of the hackathon, make diversity of skills a priority. At my last hackathon, our winning team met on the day of the event and had a balanced mix of 1 backend, 2 frontend, 1 UI designer, 1 UX designer, and 1 project manager. This diversity proved critical to our success, as each team member brought a unique contribution to the project.

Develop an innovative, feasible idea

At the beginning of the Hackathon, spend time brainstorming and selecting an idea. The challenge is to come up with an idea that's both innovative and feasible within the limited time frame. Give each team member room to contribute, and do your research to make sure your concept doesn't replicate existing applications. Focus on implementing 2 or 3 features well, rather than trying to implement 10 half-baked features.

Prioritize presentation and pitching

Don't underestimate the importance of a well-prepared presentation. During my first Hackathon, with my team we were so focused on coding that we only had 1 hour left to build the presentation, which led to a rushed pitch 😵 Make sure you spend enough time preparing the presentation and rehearsing the pitch (I recommend 2-3 hours). Showcase your process and your idea's unique selling point, and include engaging demos of your key features.

Good luck and have fun at your next Hackathon! Feel free to share your tips and Hackathon experiences in the comments ⭐

You can also find me on Github, LinkedIn, and Instagram.