DEV Community: Kamaleshwar A

PostgreSQL ALTER

Kamaleshwar A — Thu, 27 Aug 2026 11:16:59 +0000

ALTER TABLE:

We want to add a column named color to our cars table.

When adding columns we must also specify the data type of the column. Our color column will be a string, and we specify string types with the VARCHAR keyword. we also want to restrict the number of characters to 25

postgres=# ALTER TABLE car 
ADD color VARCHAR(25); 

ALTER TABLE

UPDATE TABLE:

The UPDATE statement is used to modify the value(s) in existing records in a table.

postgres=# UPDATE car 
SET color = 'red'
WHERE brand = 'Volvo'; 

UPDATE 1

postgres=# select * from car;
 brand  |  model  | year | color 
--------+---------+------+-------
 Ford   | Mustang | 1964 | 
 BMW    | M1      | 1978 | 
 Toyota | Celica  | 1975 | 
 Volvo  | p1800   | 1968 | red
(4 rows)

ALTER COLUMN:

We want to change the data type of the year column of the cars table from INT to VARCHAR(4).

To modify a column, use the ALTER COLUMN statement and the TYPE keyword followed by the new data type:

postgres=# ALTER TABLE car 
ALTER COLUMN year TYPE VARCHAR(4); 

ALTER TABLE

We also want to change the maximum number of characters allowed in the color column of the cars table.

Use the same syntax as above, use the ALTER COLUMN statement and the TYPE keyword followed by the new data type:

postgres=# ALTER TABLE car 
ALTER COLUMN color TYPE VARCHAR(30);

ALTER TABLE

DROP COLUMN

We want to remove the column named color from the cars table.
To remove a column, use the DROP COLUMN statement:

postgres=# ALTER TABLE car 
DROP COLUMN color; 

ALTER TABLE

DELETE

The DELETE statement is used to delete existing records in a table.

postgres=# DELETE FROM car 
WHERE brand = 'Volvo'; 

DELETE 1

Delete All Records

It is possible to delete all rows in a table without deleting the table. This means that the table structure, attributes, and indexes will be intact.

The following SQL statement deletes all rows in the cars table, without deleting the table:

postgres=# DELETE FROM car; 

DELETE 3

DROP TABLE

The DROP TABLE statement is used to drop an existing table in a database.

postgres=# DROP TABLE car; 
DROP TABLE

Reference:

https://www.w3schools.com/postgresql/postgresql_drop_table.php

Constructors in Java

Kamaleshwar A — Thu, 27 Aug 2026 10:51:50 +0000

Constructors:

A constructor in Java is a special member that is called when an object is created. It initializes the new object’s state. It is used to set default or user-defined values for the object's attributes
A constructor in Java is a special method that is automatically called when an object of a class is created. Its main purpose is to initialize the object's data.

A constructor has the same name as the class.
It does not have a return type, not even void.
It can accept parameters to initialize object properties.

Rules:

Constructor name must be the same as the class name.
It does not have a return type (not even void).
It is called automatically when you create an object using the new keyword.
A class can have multiple constructors (constructor overloading).

Example

class Student {

    String name;
    int age;

    Student() {
        name = "Kamalesh";
        age = 22;
    }

    void display() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {

        Student s1 = new Student();

        s1.display();
    }
}

Output:

Kamalesh
22

Constructor Overloading

Constructor overloading means having multiple constructors in the same class with different parameter lists.

Example

class Student {

    String name;
    int age;

    // Constructor 1
    Student() {
        name = "Unknown";
        age = 0;
    }

    // Constructor 2
    Student(String n) {
        name = n;
        age = 0;
    }

    // Constructor 3
    Student(String n, int a) {
        name = n;
        age = a;
    }

    void display() {
        System.out.println(name + " " + age);
    }

    public static void main(String[] args) {

        Student s1 = new Student();
        Student s2 = new Student("Kamalesh");
        Student s3 = new Student("Raju", 21);

        s1.display();
        s2.display();
        s3.display();
    }
}

Output

Unknown 0
Kamalesh 0
Raju 21

Here have a three constructors

Student()
Student(String n)
Student(String n, int a)

this Keyword

Once you understand constructors, this becomes much easier.
The this keyword refers to the current object.
The most common use is when the instance variable and constructor parameter have the same name.

Without this

class Student {

    String name;
    int age;

    Student(String name, int age) {

        name = name;
        age = age;
    }
}

this with constructors

class Student {

    String name;
    int age;

    Student(String name, int age) {

        this.name = name;
        this.age = age;
    }

    void display() {
        System.out.println(this.name);
        System.out.println(this.age);
    }

    public static void main(String[] args) {

        Student s1 = new Student("Kamalesh", 22);

        s1.display();
    }
}

Output

Kamalesh
22

References:

https://www.geeksforgeeks.org/java/constructors-in-java/
https://www.w3schools.com/java/java_constructors.asp
https://www.programiz.com/java-programming/constructors

PostgreSQL

Kamaleshwar A — Wed, 26 Aug 2026 17:36:13 +0000

PostgreSQL:

PostgreSQL is often called Postgres, an open-source relational database management system (RDBMS). The postgreSQL support the standard SQL query and its syntax are similar. This database runs on all major operating systems that contain Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64), and Windows. PostgreSQL supports both relational (SQL) and non-relational (JSON) queries.
That stores and manages data in structured tables using SQL.

Designed to manage structured data with high reliability and consistency.
Supports advanced SQL features, transactions, indexes, and stored procedures.
Handles relational, JSON, array, and custom data types efficiently.
Used by banking, e-commerce, healthcare, and enterprise applications to manage large volumes of data securely.

CREATE TABLE:

postgres=#  create table car (
  brand Varchar(25),
  model Varchar(25),
  year int
);

CREATE TABLE

INSERT TABLE:

--> Single row inserted in the table.

To insert data into a table in PostgreSQL, we use the INSERT INTO statement.

postgres=# INSERT INTO car (brand, model, year)
VALUES ('Ford', 'Mustang', 1964);

INSERT 0 1

--> Multiple row inserted in the table.

To insert multiple rows of data, we use the same INSERT INTO statement, but with multiple values:

postgres=# INSERT INTO car (brand, model, year)
VALUES
  ('Volvo', 'p1800', 1968),
  ('BMW', 'M1', 1978),
  ('Toyota', 'Celica', 1975); 

INSERT 0 3

DISPLAY THE TABLE:

To check the result we can display the table with this SQL statement:

postgres=# select * from car;
 brand  |  model  | year 
--------+---------+------
 Ford   | Mustang | 1964
 Volvo  | p1800   | 1968
 BMW    | M1      | 1978
 Toyota | Celica  | 1975
(4 rows)

PostgreSQL

Kamaleshwar A — Wed, 26 Aug 2026 09:30:03 +0000

PostgreSQL:

Designed to manage structured data with high reliability and consistency.
Supports advanced SQL features, transactions, indexes, and stored procedures.
Handles relational, JSON, array, and custom data types efficiently.
Used by banking, e-commerce, healthcare, and enterprise applications to manage large volumes of data securely.

CREATE TABLE:

postgres=#  create table car (
  brand Varchar(25),
  model Varchar(25),
  year int
);

CREATE TABLE

INSERT TABLE:

--> Single row inserted in the table.

To insert data into a table in PostgreSQL, we use the INSERT INTO statement.

postgres=# INSERT INTO car (brand, model, year)
VALUES ('Ford', 'Mustang', 1964);

INSERT 0 1

--> Multiple row inserted in the table.

To insert multiple rows of data, we use the same INSERT INTO statement, but with multiple values:

postgres=# INSERT INTO car (brand, model, year)
VALUES
  ('Volvo', 'p1800', 1968),
  ('BMW', 'M1', 1978),
  ('Toyota', 'Celica', 1975); 

INSERT 0 3

DISPLAY THE TABLE:

To check the result we can display the table with this SQL statement:

postgres=# select * from car;
 brand  |  model  | year 
--------+---------+------
 Ford   | Mustang | 1964
 Volvo  | p1800   | 1968
 BMW    | M1      | 1978
 Toyota | Celica  | 1975
(4 rows)

Basic concepts of Java

Kamaleshwar A — Tue, 25 Aug 2026 08:30:55 +0000

Java Oop's

Object-Oriented Programming (OOP) is a programming paradigm based on the concept of objects that contain data (fields) and behavior (methods). It focuses on designing software that closely represents real-world entities. It is used to:

Improves code reusability
Enhances maintainability and scalability
Makes programs easier to understand and manage
Closely models real-world entities

Class

A Class in Java is a blueprint or template used to create objects. It defines the properties (data) and behaviors (methods) that objects of that class will have.

A class is a user-defined data type.
It contains variables (fields) and methods.
Multiple objects can be created from a single class.

Object

An Object in Java is an instance of a class that represents a real-world entity. It is used to access the variables and methods defined inside a class.

State: Represents the current data or attributes of an object.
Behavior: Represents the actions that an object can perform.
Identity:Every object has a unique identity in memory that distinguishes it from other objects, even if they contain the same data.

Abstraction

Abstraction in Java is the process of hiding implementation details and showing only the essential features of an object. It helps users focus on what an object does rather than how it does it.

Hides complexity: Internal implementation details are hidden from the user.
Improves maintainability: Changes in implementation do not affect the user code.
Enhances flexibility: Supports loose coupling through abstract classes and interfaces.

Encapsulation

Encapsulation is the process of wrapping data and methods into a single unit, usually a class, and restricting direct access to the data. It acts as a protective shield that prevents data from being accessed directly from outside the class.

Data members are hidden using the private access modifier.
Access to data is provided through public getter and setter methods.
It improves data security, maintainability, and controlled access.

Inheritance

Inheritance is a core OOP concept in Java that allows one class to acquire the fields and methods of another class using the extends keyword. It represents an “is-a” relationship between classes.

The class being inherited is called the superclass, and the inheriting class is the subclass.
A subclass can use existing features of the superclass and also add its own.
Inheritance promotes code reusability and reduces redundancy.

Polymorphism

Polymorphism means “many forms”, where a single entity can behave differently in different situations. In Java, it allows the same method or object to show different behavior based on context.

Same method, different behavior depending on the object
Achieved through method overloading and method overriding

Java Data types:

Java data types define the type of data a variable can store in a program. They help the compiler allocate memory efficiently and ensure type safety. Java provides two main categories: primitive and non-primitive data types.

Memory allocation determines how much memory is required for each variable
Operations support defines what operations can be performed on data
Each data type has a default value when not initialized

Primitive Data Types: Store simple values directly in memory.
Non-Primitive (Reference) Data Types: Store memory references to objects.

References:

https://www.geeksforgeeks.org/java/object-oriented-programming-oops-concept-in-java/
https://www.geeksforgeeks.org/java/java-data-types/

Kick-starting Java....🚀

Kamaleshwar A — Mon, 24 Aug 2026 17:01:19 +0000

JAVA

Java is a high-level, object-oriented programming language used to build web apps, mobile applications, and enterprise software systems.
It was introduced in 1995 by James Gosling.

Java is a platform-independent language, which means code written in Java can run on any device that supports the Java Virtual Machine (JVM).
Syntax and structure are similar to C-based languages like C++ and C#.

Platform: Any hardware or software environment in which a program runs is known as a platform. Since Java has a runtime environment (JRE) and API, it is called a platform.

Why Learn Java?

Used to build Android apps, desktop and web apps, enterprise backend systems, and cloud-based software.
In high demand with many job opportunities in software development.
Has popular frameworks like Spring and Hibernate which makes it powerful for enterprise applications.
Supports object-oriented programming for clean, maintainable and reusable code.
Top companies like Amazon, Netflix, and LinkedIn use Java.

Example:

public class Home
{
public static void main (String[] args)
{
    System.out.println("Hello world");
}
}

It is used for:

Mobile applications (specially Android apps)
Desktop applications
Web applications
Web servers and application servers
Games
Database connection

Java Features:

Object Oriented
Platform Independent
Simple
Secure
Architecture-neutral
Portable
Robust
Multi-threaded
Interpreted
High Performance
Distributed
Dynamic

Object Oriented:

In Java, everything is an Object. Java can be easily extended since it is based on the Object model. As a language that has the Object-Oriented feature, Java supports the following fundamental concepts of OOPs −

Polymorphism
Inheritance
Encapsulation
Abstraction
Classes
Objects
Instance
Method
Message Passing

Platform Independent:

Unlike many other programming languages including C and C++, when Java is compiled, it is not compiled into platform specific machine, rather into platform independent byte code. This byte code is distributed over the web and interpreted by the Java Virtual Machine (JVM) on whichever platform it is being run on.

Java is designed in Write Once, Run Anywhere (WORA) way. Code written in Java is not directly dependent on the type of machine it is running. A code is Java is compiled in ByteCode which is platform independent. Java Virtual Machine, JVM can understand the byte code. Java provides platform specific JVMs. It is the responsibility of platform specific JVM to interpret the byte code correctly thus developers are free to write code without worrying about platforms like windows, linux, unix, Mac etc. This feature makes Java a platform neutral language.

As byte code can be distributed over the web and interpreted by the Virtual Machine (JVM) on whichever platform it is being run on. It makes java code highly portable and useful for application running on multiple platforms.

Simple:

Java is designed to be easy to learn. If you understand the basic concept of OOP Java, it would be easy to master.

Java is very easy to learn. It inherits many features from C, C++ and removes complex features like pointers, operator overloading, multiple inheritance, explicit memory allocation etc. It provides automatic garbage collection. With a rich set of libraries with thousands of useful functions, Java makes developers life easy.

Secure:

With Java's secure feature it enables to develop virus-free, tamper-free systems. Authentication techniques are based on public-key encryption.

Java is by design highly secure as it is not asking developers to interact with underlying system memory or operation system. Bytecode is secure and several security flaws like buffer overflow, memory leak are very rare. Java exception handling mechanism allows developers to handle almost all type of error/exceptions which can happen during program execution. Automatic garbage collection helps in maintaining the system memory space utilization in check.

Architecture-neutral:

Java compiler generates an architecture-neutral object file format, which makes the compiled code executable on many processors, with the presence of Java runtime system.

Java compiler generates an architecture-neutral object file format, which makes the compiled code executable on many processors, with the presence of Java runtime system. With advancement in processor architectures or machine specific processors, java code remains independent of any specific requirement of a processor. As java is an open standard, even a specific JVM can be prepared for a custom architecture. As in today's time, we've JVM available for almost all popular platforms, architectures, java code is completely independent. For example, a java program created in Windows machine can run on linux machine without any code modification.

Portable:

Being architecture-neutral and having no implementation dependent aspects of the specification makes Java portable. Compiler in Java is written in ANSI C with a clean portability boundary, which is a POSIX subset.

Due to this portability, java was an instant hit since inception. It was particulary useful for internet based application where platforms varied from place to place and same code base can be used across multiple platform. So collaboration between developers was easy across multiple locations.

Robust:

Java makes an effort to eliminate error prone situations by emphasizing mainly on compile time error checking and runtime checking. Automatic garbage collection, strong memory management, no pointers, no direct access to system memory, exception handling, error handling are some of the key features which makes Java a Robust, strong language to rely on.

Multi-threaded:

With Java's multi-threaded feature it is possible to write programs that can perform many tasks simultaneously. This design feature allows the developers to construct interactive applications that can run smoothly.

A multi-threaded program contains two or more parts that can run concurrently and each part can handle a different task at the same time making optimal use of the available resources specially when your computer has multiple CPU's.

By definition, multitasking is when multiple processes share common processing resources such as a CPU. Multi-threading extends the idea of multitasking into applications where you can subdivide specific operations within a single application into individual threads. Each of the threads can run in parallel. The OS divides processing time not only among different applications, but also among each thread within an application.

Multi-threading enables you to write in a way where multiple activities can proceed concurrently in the same program.

Interpreted:

Java byte code is translated on the fly to native machine instructions and is not stored anywhere. The development process is more rapid and analytical since the linking is an incremental and light-weight process.

JVM sits in between the javac compiler and the underlying hardware, the javac (or any other compiler) compiler compiles Java code in the Bytecode, which is understood by a platform specific JVM. The JVM then compiles the Bytecode in binary using JIT (Just-in-time) compilation, as the code executes.

High Performance:

With the use of Just-In-Time compilers, Java enables high performance. JVM uses JIT compiler to improves the execution time of the program. Below are some general optimizations that are done by the JIT compilers

Method inlining
Dead code elimination
Heuristics for optimizing call sites
Constant folding

Distributed:

Java is designed for the distributed environment of the internet.

Dynamic:

Java is considered to be more dynamic than C or C++ since it is designed to adapt to an evolving environment. Java programs can carry extensive amount of run-time information that can be used to verify and resolve accesses to objects on run-time.

References:

www.tpointtech.com/java-tutorial
https://www.geeksforgeeks.org/java/java/
https://www.tutorialspoint.com/java/java-features.htm

From Dev to Ops Meetup!🚀

Kamaleshwar A — Sat, 22 Aug 2026 13:48:17 +0000

🚀 A Great Learning Experience at the From Dev to Ops Meetup!

Today, I had the opportunity to attend the From Dev to Ops Meetup, conducted at Comcast, Chennai. It was a wonderful experience filled with learning, networking, and fun.

🔹 Platform Engineering 101 by Mohammad Salmaan

🔹 There Is No Agent by Parani and Ansari

Both sessions provided valuable insights and introduced interesting perspectives on the evolving world of technology and operations.

Apart from the technical sessions, one of the best parts of the meetup was the opportunity to connect and network with fellow tech enthusiasts. The organizing team also conducted fun and engaging activities for all the attendees, making the event even more interactive and enjoyable.

Overall, it was a great experience with the perfect combination of learning, networking, and engagement. Looking forward to attending more community meetups and continuing my learning journey! 🚀

Linkedin: https://lnkd.in/p/gEdSGpcb

#FromDevToOps #TechMeetup #Comcast #PlatformEngineering #DevOps #Networking #CommunityLearning #ContinuousLearning

Python practiced programs

Kamaleshwar A — Fri, 21 Aug 2026 16:56:25 +0000

1. Strong Number:

def find_factorial(no):
    factorial = 1
    while no > 0:
        factorial *= no 
        no-=1 
    return factorial 

def digits(no): 
    total = 0
    while no > 0:
        digit = no % 10
        factorial = find_factorial(digit) 
        total += factorial 
        no = no//10
    return total 

number = int(input("Enter number: "))
result = digits(number) 
if result == number: 
    print("Strong Number")
else:
    print("Not a strong number")

Output:

Enter number: 143
Not a strong number


Enter number: 145
Strong number

2. Neon Number:

def sum_of_digits(no):
    sum = 0
    while no > 0:
        sum = sum + no%10
        no = no//10
    return sum

number = 9 
square = number ** 2  
sum = sum_of_digits(square)
if number == sum: 
    print('Neon Number')
else:
    print('Not a Neon Number')

Output:

Neon Number

3. Automorphic Number:

no = 25
square = no ** 2 
last_two_digits = square % 10**2
if no == last_two_digits:
    print('Automorphic Number')
else:
    print('No Automorphic Number')

Output:

Automorphic Number

Introduction to Database in PostgreSQL

Kamaleshwar A — Fri, 07 Aug 2026 12:25:14 +0000

In database there is SQL - Structured Query Language is standard programming language for connect with and manage the database management system.

Query data — retrieve specific information from a database (e.g., SELECT * FROM users)
Insert, update, delete data — modify records within tables
Define database structure — create or alter tables, set relationships between them
Control access — manage permissions for who can read or modify data

DBMS - DATABASE MANAGEMENT SYSTEM

A Database Management System (DBMS) is software used to manage data from a database. It acts as an interface between the database and end users or applications, ensuring data is consistently organized, easily accessible, and secure.

A database is a structured collection of data that is stored in an electronic device. The data can be text, video, image, or any other format.
A relational database stores data in the form of tables, and a NOSQL database stores data in the form of key-value pairs.
A DBMS is a software that allows to create, update, and retrieval of data in an organized way. It also provides security to the database.
Examples of relational DBMS are MySQL, Oracle, Microsoft SQL Server, PostgreSQL, and Snowflake.
Examples of NOSQL DBMS are MongoDB, Cassandra, DynamoDB, and Redis.

PostgreSQL

In first postgres name was ingres that is Interactive Graphic and Research. After that name is postgres.

I was learned about how to install in the linux terminal and used in terminal.

sudo apt install postgresql postgresql-contrib

After installation open the terminal,

sudo -i -u postgres

Here,
sudo - super user do or substitute user do
-i - start to login shell
-u - user
postgres - username.

Then put this command in your terminal

psql

Then you have postgres shell to do practice SQL and administer the database with your terminal.

Table create:

cinemas=# create table students(stud_id int, stud_name varchar(20), course_name varchar(20));
CREATE TABLE

Insert Values:

cinemas=# insert into students values(11, 'Vignesh', 'Java full stack'),(23, 'Kamalesh', 'Python full stack'),(15, 'Dhanush', 'Full stack'),(28, 'Madhan', 'Full stack');
INSERT 0 4

cinemas=# insert into students values(16, 'Vidhya', 'Java full stack'),(22, 'Karthick', 'Data analytics'),(24, 'Karthiga', 'Python full stack'),(32,'Saravanan', 'Mern full stack');
INSERT 0 4

The above database are created for myself to practice and learn the SQL.

Tasks done in Looping concept in python

Kamaleshwar A — Thu, 06 Aug 2026 13:52:29 +0000

Self practiced Questions:

1) Five students enter the classroom one after another. The first student gets roll number 1, the second gets 2, and so on. Display the assigned roll numbers.

stud = 1
while stud <= 5:
    print(stud, end = ' ')
    stud = stud + 1

Output

1 2 3 4 5

2) A coach asks students to stand only at even-numbered positions in a queue. Display the first five positions.

coach = 2
while coach <= 10:
    print(coach, end = ' ')
    coach = coach + 2

Output

2 4 6 8 10

3) A newly constructed building has a special lift that does not stop on every floor. For safety reasons, it stops only at every third floor. A person enters the lift at the ground floor and presses the "Up" button. Display the first five floors where the lift will stop.

lift = 0
while lift <= 15:
    print(lift, end = ' ')
    lift = lift + 3

Output

0 3 6 9 12 15

4) A rocket launches with a countdown using only even numbers from 10. Display the countdown.

rocket = 10
while rocket >= 1:
    print(rocket, end = ' ')
    rocket = rocket - 2

Output

10 8 6 4 2

Functions in python

Kamaleshwar A — Thu, 06 Aug 2026 13:40:58 +0000

Python functions are reusable blocks of code used to perform a specific task. They help organize programs into smaller sections and execute the same logic whenever needed by calling the function.

Defining a function:

A function can be defined using def keyword. Below is the syntax to define a function:

Here, we define a function using def that prints a welcome message when called.

def fun():
    print("Welcome to learn python")

Calling a Function

After creating a function, call it by using the name of the functions followed by parenthesis containing parameters of that particular function.

def fun():
    print("Welcome to learn python")

fun()

Function Arguments

Arguments are values passed to a function when it is called. They allow functions to receive input data and perform operations using those values.

Syntax

def function_name(arguments):
    # function body
    return value

def function_name(arguments): defines a function with optional arguments.
# function body contains the statements to be executed.
return value returns a result from the function. If no return statement is used, it returns None by default.

def evenOdd(x):
    if (x % 2 == 0):
        return "Even"
    else:
        return "Odd"

print(evenOdd(16))
print(evenOdd(7))

Types of Arguments:

1. Default argument: Default argument use a predefined value when no value is passed during the function call.

def myFun(x, y=50):
    print("x: ", x)
    print("y: ", y)

myFun(10)

2. Keyword Arguments: pass values using parameter names, so argument order does not matter.

def student(fname, lname):
    print(fname, lname)

student(fname='Kamalesh', lname='A')
student(lname='A', fname='Kamalesh')

3. Positional Arguments: values are assigned to parameters based on their order in the function call.

def nameAge(name, age):
    print("Hi, I am", name)
    print("My age is ", age)

print("Case-1:")
nameAge("Kamal", 22)

print("Case-2:")
nameAge(22, "Kamal")

Reference:

https://www.geeksforgeeks.org/python/python-functions/

My experience at FOSS United X Dev to ops meetup

Kamaleshwar A — Mon, 03 Aug 2026 04:23:33 +0000

Recently i attended a FOSS United Chennai X Dev to ops meetup!.
I gather a lots of information and knowledge by attend that event, its fully open source software's and tools. They conduct a 5 sessions that is about a technically very impressive and got aware about that software and its legacy. Many things are new to me, I didn't heard about that software terms and tools.In this meetup I learned a lot by the session.

Even though they conduct a small fun activity in between the event that was also interesting. And also i had a network with all professional, graduate, and students that was inspiring.

The sessions was about the shifting left for real, Building open source AI-Agent for dev-ops professionals, Nix and its ecosystem and Harbor satellite these session are taken in that meetups.

I had a lots of network with some professionals and they people guide me and give a path for build my career, he is Mr. Dinesh Kumaran M bro, he shared me a lots gatherings and experience about industry and also gave me some tips to focus on build a career. I would thank him for humble and kind with me.

The experience was so nice for me to attend like these type of meetups and be aware in open sources.