Forem: Sameer Kumar

Day 3 - Virtual Machine

Sameer Kumar — Tue, 02 Dec 2025 18:30:00 +0000

The Initial Use of Resources

Imagine you have a one-acre plot of land in your village or hometown. You decide to build your dream house on this land, constructing a home for you and your family. You use the entire one acre of land to live comfortably. You have access to water, a garden, a park, and other resources, and you’re happily living in this space.

Realization: Wasting Resources

After some time, you realize that even though you’re enjoying the one-acre property, you’re only using half of the land. The other half remains unused, meaning much of the land and its resources are going to waste. You then start thinking of ways to use the extra land more efficiently.

Efficient Use of Resources

Instead of letting that unused half-acre go to waste, you decide to build another property on it. You keep living in your original home with your family, but now you rent out the second property. This means that without compromising your comfort, you are now using the entire one-acre efficiently and also generating extra income from the rented property.

Sharing Resources Without Interference

Even with another family renting the additional property, there’s no interference. Each household has its own space and resources. The tenant uses one-fourth of the property, while you and your family continue using the remaining three-fourths. Both families are living comfortably, utilizing water resources, parks, and gardens without disturbing each other.

Increased Efficiency and Optimization

Now, instead of two people living on the land, four people are living comfortably, and the resources are being used to their full potential. This is an example of improving efficiency by ensuring that nothing goes to waste.

The DevOps Connection

In a similar way, the purpose of DevOps is to improve efficiency, especially through automation. As a DevOps engineer, your goal is to ensure that resources are being utilized in the best way possible. Whether working on platforms like AWS or Azure, your role is to optimize resource usage—ensuring that virtual machines and other resources are allocated properly, reducing waste, and improving overall system performance.

The Concept of Cloud Servers

Just as example.com might purchase five servers from a company like HP, cloud providers such as Amazon, Microsoft, and Google do the same—but on a much larger scale. These providers buy or build millions of servers and store them in data centers around the world.

Example: Amazon's Data Center in Mumbai

Let’s take an example of Amazon's AWS data center in Mumbai. When a user, such as you or me, makes a request to Amazon for cloud services and selects Mumbai as the region, AWS will provide resources from that location.

Requesting a Virtual Machine (EC2 Instance)

In AWS, you can request a virtual machine—or, as Amazon calls it, an EC2 instance. This is the same as asking for a virtual machine on any cloud platform, regardless of the terminology used. Once you select the Mumbai region, your request is sent to one of the physical servers in the Mumbai data center.

The Role of Hypervisors

These physical servers have hypervisors installed, which are responsible for creating and managing virtual machines (VMs). When you request a virtual machine, the hypervisor creates one on the physical server and allocates the necessary resources.

How Virtual Machines Operate

In the world of cloud computing, whether it's AWS, Google Cloud, or Microsoft Azure, hypervisors play a critical role. They enable cloud providers to efficiently allocate virtual machines from physical servers in data centers. So, when you request a virtual machine from a specific region, like Mumbai, the hypervisor ensures that your VM is created on one of the physical servers in that region.

Scaling Beyond Physical Servers

Imagine if Amazon’s Mumbai data center had 100 physical servers. In a traditional setup, each server could be allocated to just one user or team. This means only 100 users or teams could access the resources of that data center. However, with the introduction of virtual machines (VMs) and hypervisors, Amazon can now serve millions of users with those same 100 physical servers.

How Virtual Machines Enhance Efficiency

By using hypervisors, each physical server can host multiple virtual machines, allowing cloud providers like Amazon to maximize resource usage. Instead of just 100 users having access, millions of users can now utilize the resources provided by those servers, significantly improving efficiency.

A Leap in Technology

If we go back 20 or 30 years, the concept of virtual machines didn’t exist. Back then, each organization had to rely on dedicated physical servers, which limited scalability. The invention of virtual machines revolutionized how servers are used by allowing multiple users to share the same physical hardware.

Virtualization on Personal Devices

You can even experience this on your personal laptop today. For example, by installing Oracle VirtualBox, you can create a virtual machine on your laptop. You could then share this virtual machine with others in your household, allowing multiple people to use the same laptop at the same time. While you use the main system, others can use the virtual machine—this is an example of how virtualization has improved everyday processes.

Day 2 - Improve SDLC with DevOps

Sameer Kumar — Sun, 30 Nov 2025 18:30:00 +0000

Understanding the Software Development Life Cycle (SDLC)

When working in an organization, whether it's a startup, multinational corporation (MNC), or unicorn, there are specific standards and processes that are universally followed. These standards are crucial for ensuring the smooth functioning of the organization, especially in the software or IT industry. One of the most important of these standards is the Software Development Life Cycle (SDLC).

What is the Software Development Life Cycle (SDLC)?

The Software Development Life Cycle is a structured process used by the software industry to design, develop, and test software. It provides a systematic approach to ensure that high-quality software products are delivered to end users. Whether you're working at companies like Amazon, Flipkart, or Tesla, all organizations follow these core steps—design, develop, and test—as part of their SDLC.

While the SDLC might also involve additional phases, these three are at the heart of the process, ensuring that the final product meets customer expectations.

The Key Phases of SDLC

Let's break down the core phases involved in the SDLC:

Design Phase:
In this phase, the software architecture is created based on the requirements. It lays the foundation for the development phase and ensures that the product is built on a solid structure.
Development Phase:
Here, developers build the actual product based on the designs created in the previous phase. Code is written, and all the functional components of the application are implemented.
Testing Phase:
Once the development is complete, the product undergoes rigorous testing to identify and fix any bugs or issues. This phase ensures that the product functions as expected and meets quality standards.

What is the End Goal of SDLC?

The primary goal of the SDLC is to deliver a high-quality product that meets customer expectations.

Why Testing is Crucial: Imagine delivering a product that hasn't been tested. While it may have been well-designed and developed, the lack of testing means that issues and bugs could go unnoticed until it's in the hands of the customer. Without testing, you're risking delivering a product that fails to meet expectations, which can harm the company's reputation and customer satisfaction.

In summary, the SDLC helps ensure that every product:

Is well-designed,
Developed according to specifications, and
Thoroughly tested to ensure high quality.

Why Following the SDLC is Important

Without following a standard process like the SDLC, it would be difficult to produce high-quality software. Each phase—design, development, and testing—plays a critical role in delivering a successful product. Skipping or underestimating any of these phases can result in a subpar product that does not meet customer expectations.

Practical Application: Diving Deeper into SDLC

Now that we've covered the basics of the SDLC, let's move on to see how it applies in a practical context. We'll look at how an example organization might implement these steps to build and deliver high-quality software. Understanding these real-world applications will give you a clearer picture of the importance of each phase and how it all comes together in practice.

When working in the software or IT industry, whether at a startup or a multinational corporation (MNC), there are standard processes followed by every organization. These standards are essential for understanding how to work efficiently within any company. One of the key standards is the Software Development Life Cycle (SDLC). It is a structured process that organizations use to design, develop, and test high-quality software products.

What is the Software Development Life Cycle (SDLC)?

The SDLC is a process used across the software industry to guide the creation of software products. It involves a series of phases that ensure the successful development of software, including:

Designing
Developing
Testing

These phases are standard regardless of the organization—whether you're working at Amazon, Flipkart, Tesla, or a smaller company. The goal is to deliver a high-quality product that meets customer expectations.

The Importance of Testing in SDLC

You might wonder, what happens if we skip testing? If a product is designed and developed but not thoroughly tested, there’s a risk of delivering a faulty or low-quality product to the customer. Testing ensures the product works as expected and meets the required standards. Without testing, there’s no guarantee that the software will function correctly in real-world scenarios.

In summary, the SDLC is a cyclic process that involves these steps at a high level:

Design
Develop
Test

The ultimate goal is to deliver a high-quality product to customers.

Phases of the Software Development Life Cycle

Let's explore the key phases of the SDLC using a hypothetical e-commerce company, "example.com" (similar to Flipkart or Amazon), to understand how the process works in a real-world scenario.

1. Planning Phase

The first step in any software project is the planning phase, where you gather the requirements and ideas for the new feature or product. This phase is crucial as it lays the foundation for the entire project.

For example, let's say the team at "example.com" decides to introduce a new kids' clothing section. Previously, the platform only sold men’s and women’s clothing, but based on market research, the company decides to expand its offerings to include kids’ clothing.

What Happens in the Planning Phase?

The product owner or business analyst gathers customer feedback and research.
The team assesses whether the new feature (kids' clothing) would be beneficial based on customer demand.
If the research supports the new feature, the idea moves forward. If not, the idea may be suspended at this stage.

The planning phase is one of the most critical stages because it ensures that you are building something that customers want.

2. Defining & Requirements Phase

Once the planning is done, the team moves to the requirements phase, where they define the project’s specific needs. This involves documenting the exact details of the new feature.

For example, in the case of the kids' clothing section:

The team documents the age range for the clothing (e.g., 6–12 years, 1–4 years).
They create a Software Requirements Specification (SRS) document, outlining everything the system should accomplish.

3. Designing Phase

The designing phase is where high-level and low-level design plans are created. This phase includes creating both a High-Level Design (HLD) and a Low-Level Design (LLD) for the project.

High-Level Design (HLD)

The HLD outlines the system architecture, scalability, and other overarching details. For example, the team might plan to ensure that the new kids' section is highly available and scalable, especially during peak times like Christmas.

Low-Level Design (LLD)

The LLD focuses on the detailed components of the software, including specific functions, modules, and how different systems interact. The team specifies which databases, programming languages (Java, Python, etc.), and other technical details will be used.

4. Building Phase

This is the development phase, where the actual coding takes place. The engineering team builds the software based on the design specifications.

DevOps Role in the Building Phase

As a DevOps engineer, this is where you can introduce automation tools to streamline the development process. Automating builds and deployments can save time and reduce errors.

5. Testing Phase

After the software is built, it undergoes thorough testing to ensure that it functions correctly. The testing phase checks for bugs, performance issues, and overall functionality.

DevOps Role in Testing

In this phase, DevOps engineers can implement continuous integration/continuous deployment (CI/CD) pipelines, automating testing to ensure faster feedback and bug fixes.

6. Deployment Phase

Once the software passes all tests, it is deployed to the live environment. This is the phase where the software is made available to the users.

DevOps Role in Deployment

DevOps engineers play a critical role here by automating the deployment process, ensuring that new features or products are deployed with minimal downtime.

7. Maintenance & Updates

The SDLC is cyclical. After deployment, if the team decides to introduce new features or updates (like adding more categories to the kids' section), they follow the same process again. This ensures a consistent and high-quality approach to software development.

The Role of DevOps in the SDLC

As a DevOps engineer, your focus will be on automating the following phases:

Building: Automating code builds.
Testing: Setting up continuous integration pipelines to automate tests.
Deployment: Ensuring smooth and efficient deployment processes.

While your primary focus might be on these phases, you should still understand the planning, defining, and design phases, as they directly impact the success of the project. Automation is the key to improving efficiency in the organization.

Conclusion

In conclusion, the Software Development Life Cycle (SDLC) is a process followed by organizations to design, develop, and test high-quality products. Each phase, from planning to deployment, plays a critical role in ensuring the success of the project. As a DevOps engineer, your role is to automate processes in the building, testing, and deployment phases, thereby improving the overall efficiency of the development lifecycle.

Day 1 - Fundamentals Of DevOps

Sameer Kumar — Sun, 30 Nov 2025 18:30:00 +0000

Understanding DevOps: A Single Definition Among Many

There are countless definitions for DevOps depending on where you look. For instance, if you check Amazon or Red Hat, they each have their unique take on it. However, in simple terms, DevOps is a culture that enhances an organization’s ability to deliver applications efficiently. The key focus here is on delivery—how quickly and reliably new features, fixes, or updates reach the end-users.

DevOps in Action: The PUBG Example

To illustrate the importance of quick delivery, let’s consider a popular game like PUBG. Imagine there’s an issue with the game, or the developers want to introduce a new feature. If the development work is completed but it takes 10 days to deliver the new version due to multiple stages like unit testing, staging, and final production, that’s not ideal.

In today’s world, where time is critical, such a delay is unacceptable. For instance, if your Android device has a security vulnerability, Android would release a patch immediately, urging all users to update their devices. This rapid delivery is what DevOps aims to achieve—ensuring that updates, bug fixes, and features are deployed within hours, not days or weeks.

More Than Just Delivery: The Pillars of DevOps

While delivering quickly is crucial, DevOps is not just about speed. Several key components are necessary to ensure effective delivery:

1. Automation

Just like in a factory, automation plays a vital role in DevOps. If you think of a company manufacturing chips, automating the process reduces manual labor, speeding up production. Similarly, in software development, automation ensures that tasks are completed efficiently without manual intervention.

2. Quality

Automation alone isn’t enough. End users expect quality. If chips are being manufactured quickly but are of poor quality, customers will not be happy. In the same way, DevOps ensures that quality is maintained even while speeding up the delivery process.

3. Monitoring

Once automation and quality are in place, the next crucial aspect is monitoring. Monitoring helps track the system's performance and quality in real-time. It ensures that if anything goes wrong—be it with automation or quality—you are alerted immediately, allowing for quick fixes. This is also known as observability, which goes hand-in-hand with monitoring.

4. Testing

Without proper testing, neither quality nor automation can be guaranteed. Continuous testing is an essential part of DevOps. It ensures that all updates are rigorously tested before reaching users, reducing the chances of bugs or issues in production.

The New Definition of DevOps

To summarize, DevOps is the process of continuously delivering applications quickly by ensuring proper automation, maintaining quality, implementing continuous monitoring, and conducting rigorous testing. These pillars help organizations achieve fast and reliable software delivery, ensuring that users get the best possible experience.

The Role of a DevOps Engineer

As a DevOps Engineer, your goal is to streamline the application delivery process. For example, if you're hired by example.com and their current delivery timeline is two weeks, your job would be to reduce that to one week while ensuring automation, quality, monitoring, and testing are all in place. The ultimate aim is to minimize manual processes and accelerate delivery, improving overall efficiency.

Why DevOps Engineer needed?

Long long ago, Before DevOps...

Here is a step-by-step summary based on the provided image:

Multiple Developers (#1):

Multiple developers work on the code and store it at a central location.
System Administrator Creates Testing Server (#2):

A system administrator sets up a server where the application will be tested.
Tester Tests the Application (#3):

The tester performs tests on the application running on the server to ensure functionality.
Application After Testing (#4):

Once testing is complete, the application is ready for further processing.
Build and Release Engineer (BRE) (#5):

The Build and Release Engineer promotes the tested application to the next stage.
Promotion to Staging or Pre-Production (#6):

The application is promoted to the staging or pre-production environment for further testing.
Testing in Staging or Pre-Production (#7):

The same application undergoes testing again in the staging or pre-production environment.
Moving to Production (#8):

Once the application passes all tests, it is moved to the production environment.
End Users (#9):

Finally, the application is delivered to the end users, who can now access it on their devices.

Each step involves collaboration between developers, system administrators, testers, and build and release engineers, ensuring a smooth delivery process from development to production.

The Challenges of Application Delivery Before DevOps

Before DevOps, the process of delivering applications was much more manual and time-consuming than it is today. Here's how it worked and why the need for DevOps emerged.

1. Multiple Roles Involved

To deliver an application from a developer’s laptop to the production server, several roles were required:

System Administrator: Responsible for setting up and managing servers for testing and production.
Build and Release Engineer: Managed the process of building the application and deploying it to the server.
Server Administrator: Ensured the production servers were running smoothly and that the application was deployed correctly.

2. Manual Process and Collaboration

The process was manual and heavily dependent on collaboration between these different teams. For example, a system administrator would set up the server, while the build and release engineer handled the deployment. Each step required communication and coordination, often leading to delays.

3. Time-Consuming Workflow

Due to the manual nature of the process and the need for different teams to work together, the delivery of an application could take a significant amount of time. It wasn’t unusual for this process to take:

10 days,
One month,
Or in the best cases, around five days.

The variability in time depended on the complexity of the application and the efficiency of communication between teams.

4. Why DevOps Emerged

The concept of DevOps was introduced to address these inefficiencies. The main reasons for the shift towards DevOps include:

Manual Effort Slows Down Processes: Manual interventions made the entire delivery process slow and prone to errors.
Collaboration Overhead: Involving multiple teams in every step increased the risk of miscommunication and further delayed the process.
Need for Automation: Automating these steps became essential to reduce time, effort, and human errors in the delivery process.

5. The Solution: DevOps

DevOps emerged as a new concept to improve the speed, reliability, and effectiveness of delivering applications. By integrating development and operations teams and emphasizing automation, DevOps transformed the way applications were built, tested, and deployed. It reduced the time needed to deliver applications and made the process much more streamlined.

In summary, the manual, time-consuming processes before DevOps, which involved multiple teams like system administrators, build and release engineers, and server administrators, led to inefficiencies. DevOps evolved to automate and optimize these workflows, allowing for faster, more reliable application delivery.

🌱 Type-safe navigation in Jetpack Compose - Quick Guide

Sameer Kumar — Wed, 11 Sep 2024 13:27:17 +0000

Type-safe navigation in Jetpack Compose allows for strong typing and safety when passing arguments between composable screens. Here's a detailed explanation of how it works, along with the provided code and comments:

Dependencies

First, you need to add the necessary dependencies for Kotlin serialization and Jetpack Navigation in Libs.toml and build.gradle files.

libs.version.toml



[versions]
kotlinxSerializationJson = "1.7.1"
kotlinxSerialization = "2.0.20"
navigationCompose = "2.8.0"

[libraries]
androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigationCompose" }
kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinxSerializationJson" }

[plugins]
jetbrains-kotlin-serialization = { id ="org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlinxSerialization"}

build.gradle.kts



plugins {
  alias(libs.plugins.jetbrains.kotlin.serialization) apply false
}

Another build.gradle.kts file:



plugins {
  alias(libs.plugins.jetbrains.kotlin.serialization)
  id("kotlin-parcelize") // needed for non-primitive classes
}

dependencies {
  implementation(libs.androidx.navigation.compose)
  implementation(libs.kotlinx.serialization.json)
}

Data Class Definition

We create a simple data class User to hold user-related data like ID, name, age, and gender.



data class User(
    val id: Int,
    val name: String,
    val age: Int,
    val gender: String
)

Defining Navigation Routes with Serialization

The NavRoutes sealed class defines the possible screens in the app. Each screen can have parameters passed, making navigation type-safe.



@Serializable
sealed class NavRoutes {
    // ListScreen with no arguments
    @Serializable
    data object ListScreen: NavRoutes()

    // UserDetailScreen that accepts parameters for user details
    @Serializable
    data class UserDetailScreen(
        val id: Int,
        val name: String,
        val age: Int,
        val gender: String
    ): NavRoutes()
}

ListScreen (First Screen)

In this screen, we display a list of users from popular anime characters. The items are arranged in a LazyColumn, and each user is clickable, navigating to a detailed screen.



@Composable
fun ListScreen(navController: NavController) {
    // Sample user data (anime characters)
    val myUser = listOf(
        User(1, "Naruto", 14, "Male"),
        User(2, "TenTen", 15, "Female"),
        User(3, "Hinata", 14, "Female"),
        User(4, "Shikamaru", 15, "Male"),
        User(5, "Sakura", 15, "Female"),
        User(6, "Kakashi", 23, "Male")
    )

    // Display the user list in a LazyColumn
    LazyColumn(
        modifier = Modifier.padding(15.dp) // Add padding to the list
    ) {
        // Iterate over the list of users and display each as a SingleUser composable
        items(myUser) {
            SingleUser(navController, name = it.name, id = it.id, age = it.age, gender = it.gender)
        }
    }
}

SingleUser

This composable represents an individual user in the list. It’s clickable and navigates to the UserDetailScreen when selected.



@Composable
fun SingleUser(navController: NavController, id: Int, name: String, age: Int, gender: String) {
    Row(
        modifier = Modifier
            .fillMaxSize()
            .padding(5.dp) // Add padding around each user entry
            .clip(RoundedCornerShape(30.dp)) // Rounded corners for a polished look
            .background(Color.LightGray) // Light gray background color
            .clickable {
                // Navigate to UserDetailScreen with the user's details
                navController.navigate(
                    NavRoutes.UserDetailScreen(
                        id = id,
                        age = age,
                        name = name,
                        gender = gender
                    )
                )
            },
        horizontalArrangement = Arrangement.SpaceEvenly, // Space out elements evenly
        verticalAlignment = Alignment.CenterVertically // Align items vertically in the center
    ) {
        // Display user's name, age, and gender with a font size of 15sp
        Text(text = name, fontSize = 15.sp)
        Text(text = age.toString(), fontSize = 15.sp)
        Text(text = gender, fontSize = 15.sp)
    }
}

UserDetailScreen (Second Screen)

This screen displays detailed information about a selected user. The user can also navigate back to the list.



@Composable
fun UserDetailScreen(navController: NavController, name: String, age: Int, gender: String) {
    Column(
        modifier = Modifier.fillMaxSize(), // Take full available space
        horizontalAlignment = Alignment.CenterHorizontally, // Align content horizontally in the center
        verticalArrangement = Arrangement.Center // Align content vertically in the center
    ) {
        // Display user name, age, and gender with some spacing in between
        Text(text = name, fontSize = 20.sp) // Name with larger font size
        Spacer(modifier = Modifier.height(5.dp)) // Spacer between text elements
        Text(text = age.toString(), fontSize = 20.sp)
        Spacer(modifier = Modifier.height(5.dp))
        Text(text = gender, fontSize = 20.sp)
        Spacer(modifier = Modifier.height(5.dp))

        // Back button to return to the previous screen
        Button(onClick = { navController.popBackStack() }) {
            Text(text = "Back")
        }
    }
}

MainActivity Setup

In the NavigationExample activity, we set up navigation using NavHost. It maps the NavRoutes to corresponding composables.



class NavigationExample: ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            // Create a NavController to handle navigation
            val navController = rememberNavController()

            // Define the NavHost which manages the navigation graph
            NavHost(navController = navController, startDestination = NavRoutes.ListScreen) {
                // Composable for ListScreen
                composable<NavRoutes.ListScreen> {
                    ListScreen(navController)
                }
                // Composable for UserDetailScreen with safely passed arguments
                composable<NavRoutes.UserDetailScreen> { navBackStackEntry ->
                    val args = navBackStackEntry.toRoute<NavRoutes.UserDetailScreen>()
                    UserDetailScreen(navController, args.name, args.age, args.gender)
                }
            }
        }
    }
}

Explanation

Type Safety: NavRoutes uses Kotlin's sealed classes and serialization to safely pass arguments between screens, ensuring type safety. When navigating, you can only pass the expected arguments.
Serialization: The @Serializable annotation allows passing complex data types (like objects) through the navigation system in a type-safe way.
Back Navigation: On the UserDetailScreen, you can navigate back using navController.popBackStack().

Output

This setup allows for safe and robust navigation between screens with parameterized data in Jetpack Compose.

Now, it’s time to unleash your new superpowers on the coding world!



<aside>
  <p>
    Thanks for taking the time to read!<br>
    If you found this post helpful,<br>
    I'd appreciate a clap. 😄
  </p>
</aside>