Forem: Vikas Jyani

The Secret Life of Your Files: Why Computers Store Data Like a Filing Cabinet

Vikas Jyani — Fri, 12 Sep 2025 08:42:34 +0000

Have you ever stopped to think about why your computer organizes all your precious photos, documents, and programs into neat little folders? It seems so obvious now, right? We click on "Documents," then "Work," then "Project X," and there's our file. But this intuitive system wasn't always a given. In the early days of computing, finding your data was more like a treasure hunt with no map.

So, who were the unsung heroes who decided our digital lives shouldn't be a chaotic mess? And why did they settle on this "filing cabinet" approach that now underpins almost every device we touch? Let's dive into the brilliant thought process that shaped how we interact with information.

The Wild West of Early Data Storage

Imagine a world where every single piece of data on your computer — every line of code, every paragraph of text — existed as just a raw chunk of bits, identified only by its physical location on a magnetic tape or a spinning disk. No names, no folders, just an address. If you wanted to find your spreadsheet, you'd better remember it was precisely at "Track 7, Sector 23." Sounds like a nightmare, right?

This was the reality for early computer programmers. Data management was a chaotic, machine-dependent mess. It quickly became clear that if computers were ever going to be useful to more than a handful of super-specialized engineers, something had to change.

The "Aha!" Moment: Abstraction and Order

The brilliant minds behind early operating systems, particularly those working on pioneering projects like Multics and later the legendary Unix (think Ken Thompson and Dennis Ritchie), had a profound realization: they needed an abstraction layer.

Think of it like this: when you call someone, you don't need to know the intricate workings of the global telephone network – the copper wires, fiber optics, satellites, and routing protocols. You just dial a number. Similarly, developers understood that users shouldn't have to worry about the physical mechanics of a hard drive. They just needed a name for their "document" and a simple way to get it back.

This quest for an intuitive and efficient way to manage data led to several key goals:

Hiding the Guts (Abstraction): The computer should handle the gritty details of where data physically lives. Users just need to give it a name like "vacation_photos.jpg."

Making Data Stick Around (Persistence): Once you save something, it needs to stay saved, even after you turn off the computer. Revolutionary, right?

Sharing Nicely (Multi-user Support & Security): As computers became more powerful and served multiple people at once, how do you stop one person from accidentally (or deliberately) deleting someone else's work? You need rules, permissions, and ownership.

Why the "Filing Cabinet" Won: It's All About Intuition
Out of this thought process emerged the hierarchical (tree-like) file system we all recognize today. But why this specific design?

It Mimics the Real World: This was arguably the most crucial factor. People already knew how to organize physical documents in filing cabinets with labeled folders. This real-world analogy made the digital transition incredibly intuitive. It's why we still call them "folders" and "files"! 🗂️

Scalability for Days: A hierarchical system can grow almost infinitely. Need to add more files? Just create another folder (or a "sub-directory" in tech speak) and put them in there. The basic structure never breaks down, no matter how much data you throw at it.

No More Name Games: Imagine if every single file on your entire computer had to have a completely unique name. "My Report for Project Alpha 2023 Final Revision v3." becomes a nightmare quickly. Folders solve this! You can have a report.docx in your Work/Project A folder and another report.docx in your Work/Project B folder without any conflict. The path (/Work/Project A/report.docx) makes it unique.

Efficient Searching: While you might think a flat list is easy to search, imagine trying to find one specific book in a library where all the books are just piled in a single, massive room. Now imagine a library with sections, aisles, and shelves. That's the power of hierarchy – it makes locating data incredibly efficient.

The Legacy: An Invisible Foundation

The next time you effortlessly click through folders to open a document or save a photo, take a moment to appreciate the ingenious foresight of those early developers. They didn't just build a way to store data; they built an invisible, logical foundation that made computers accessible, manageable, and ultimately, indispensable to our modern lives. It's a testament to good design: when it works perfectly, you barely even notice it's there.

CI: A Practical Guide to Continuous Integration

Vikas Jyani — Tue, 09 Sep 2025 06:12:53 +0000

Hey there, fellow developers! 👋

Ever wondered how large teams manage to integrate their code changes frequently without breaking everything? Or how they ensure that every new feature doesn't introduce a cascade of bugs? The answer, more often than not, lies in a powerful practice called Continuous Integration (CI).

Continuous Integration is not just a buzzword; it's a fundamental part of modern software development that streamlines your workflow, catches errors early, and drastically improves code quality. If you're looking to level up your development process, understanding CI is a must.

Let's dive in and demystify CI!

What is Continuous Integration (CI)? 🔄

At its core, Continuous Integration is a development practice where developers frequently merge their code changes into a central repository. Instead of building features in isolation for weeks and then attempting a painful, error-prone merge, CI encourages small, frequent merges.

The CI process typically involves:
Code Commit: A developer pushes their changes to a version control system (like Git).

Automated Build: A CI server detects the new commit and automatically pulls the code. It then compiles the code.

Automated Tests: After a successful build, a suite of automated tests (unit tests, integration tests) is run against the new code.

Feedback: The team is immediately notified of the build and test results. If anything fails, developers get fast feedback, allowing them to fix issues quickly before they escalate.

Why is CI So Important? The Benefits! ✨

Integrating frequently and running automated checks offers a treasure trove of benefits:

Early Bug Detection: Catching bugs early means they are typically smaller, easier, and cheaper to fix. Imagine finding an error within minutes of writing the code, rather than weeks later when it's intertwined with a dozen other features!

Reduced Integration Problems: Frequent merges minimize "merge hell." When you integrate small changes often, conflicts are easier to resolve.

Improved Code Quality: Automated tests ensure that new code doesn't break existing functionality (regression). This fosters confidence in the codebase.

Faster Release Cycles: With a stable, well-tested codebase, you can release new features and updates more rapidly and reliably.

Increased Developer Confidence: Knowing that your code is automatically tested after every commit allows developers to be more confident in their changes and take more ownership.

Key Components of a CI System 🛠️

To implement CI effectively, you'll typically need a few key pieces of the puzzle:

Version Control System (VCS): Essential for tracking changes and managing merges. Git (e.g., GitHub, GitLab, Bitbucket) is the industry standard.

CI Server/Tool: This is the engine that orchestrates the entire CI process. Popular tools include:

Jenkins

GitHub Actions

GitLab CI/CD

Travis CI

CircleCI

Build Tools: Depending on your language/framework (e.g., Maven/Gradle for Java, npm/yarn for JavaScript, pip for Python).

Testing Frameworks: For writing your automated unit, integration, and other tests.

A Typical CI Workflow in Action 🚀

Let's visualize a common CI workflow, as often demonstrated in practice:

Developer Commits Code: After making changes to a feature branch, the developer commits their code and pushes it to the remote repository.

CI Server Triggered: The VCS (e.g., GitHub) notifies the CI server (e.g., Jenkins) about the new push.

Checkout Code: The CI server pulls the latest code from the repository.

Dependency Installation: If it's a new environment or dependencies have changed, the CI server installs necessary libraries (e.g., npm install, pip install).

Build Application: The application is compiled or bundled. For example, a React app might run npm run build.

Run Tests: Automated unit tests and integration tests are executed. This is a critical step to validate functionality and prevent regressions.

Generate Reports: Test results, code coverage, and other build artifacts are generated.

Notification: The CI server sends notifications (e.g., via email, Slack, or directly in the VCS UI) to the team about the build status.

Success: Great! The code passed all checks and is ready for potential deployment or further integration.

Failure: Oh no! The build or tests failed. The developer who introduced the change is expected to fix it immediately. This "fix it now" mentality is crucial to CI.

This rapid feedback loop ensures that issues are addressed swiftly, keeping the main codebase stable and deployable.

Implementing CI: Practical Steps & Best Practices
When setting up or working with CI, keep these points in mind:

Automate Everything Possible: From building to testing, aim for full automation.

Keep Builds Fast: Long build times discourage frequent integration. Optimize your build process.

Use Comprehensive Test Suites: Good tests are the backbone of effective CI.

Instant Feedback: Ensure the team gets immediate notifications on build failures.

Fix Broken Builds Immediately: This is a golden rule of CI. A broken build halts progress for everyone.

Version Control Your CI Configuration: Treat your jenkinsfile, .gitlab-ci.yml, or github-actions.yml like any other part of your codebase, committing it to your VCS.

Conclusion: Embrace the Power of CI! 💪

Continuous Integration is more than just a set of tools; it's a cultural shift towards more disciplined, efficient, and collaborative development. By integrating frequently and leveraging automation, teams can deliver higher quality software faster and with greater confidence.

So, if you haven't fully embraced CI in your projects, now's the time. Start small, automate your builds and basic tests, and gradually expand. You'll soon wonder how you ever developed without it!

Happy integrating! 🌟

Understanding Docker: The Essential Guide for Developers

Vikas Jyani — Mon, 01 Sep 2025 16:38:36 +0000

Hey everyone! 👋

If you're in the world of software development, you've almost certainly heard of Docker. It's a game-changer, but like any powerful tool, it can seem a bit daunting at first glance. Think of it as a superpower for packaging your applications and their environments into neat, portable little units. No more "it works on my machine!" excuses!

In this guide, we're going to break down the core concepts and essential commands of Docker that every developer should know. We'll cover everything from building your first image to managing containers, making your development workflow smoother and more consistent.

Let's dive in!

What is Docker? 📦

At its heart, Docker is a platform for developing, shipping, and running applications using containerization.

Containers: Imagine a lightweight, standalone, executable package of software that includes everything needed to run it: code, runtime, system tools, system libraries, and settings. That's a Docker container! It's like a mini-virtual machine, but much more efficient.

Images: A Docker image is a read-only template with instructions for creating a Docker container. Think of it as a blueprint for your application's environment.

Dockerfile: This is a simple text file that contains all the commands a user could call on the command line to assemble an image. It's how you define your application's environment step-by-step.

Getting Started with Docker: Your First Steps 🚀

Let's get hands-on and start working with some basic Docker commands.

docker info: This command gives you a summary of your Docker installation, including the number of containers, images, and other system-level details. It's a good way to check if Docker is running correctly.

docker run: This is one of the most fundamental commands. It creates and starts a new container from an image.

docker run hello-world: This will pull the hello-world image (if not already local) and run a container that simply prints "Hello from Docker!"

d*ocker run -it ubuntu bash*: This command runs an interactive Bash shell inside an Ubuntu container. i means interactive, t allocates a pseudo-TTY.

docker run -d nginx: The -d flag runs the container in "detached" mode, meaning it runs in the background.

docker run -p 8080:80 nginx: The -p flag maps ports. Here, it maps port 8080 on your host machine to port 80 inside the nginx container, allowing you to access the Nginx web server from your browser.

docker run --name my-web-server nginx: The --name flag lets you assign a custom, human-readable name to your container.

docker ps: This command lists all currently running containers.

docker ps -a: The -a flag shows all containers, including those that have exited.

docker stop [container_id/name]: Stops a running container gracefully.

docker start [container_id/name]: Starts a stopped container.

docker restart [container_id/name]: Restarts a container.

docker rm [container_id/name]: Removes a stopped container. You can't remove a running container unless you use the -f (force) flag, but it's generally better to stop it first.

Working with Docker Images 🖼️

Images are the building blocks of your containers. Here's how to manage them.

docker images: Lists all the Docker images currently stored on your local machine.

docker pull [image_name]: Downloads an image from Docker Hub (the default registry) to your local machine. E.g., docker pull alpine.

docker rmi [image_id/name]: Removes a local image. You might need to remove containers based on that image first, or use -f to force deletion.

docker build -t [image_name]:[tag] .: This command builds a Docker image from a Dockerfile in the current directory (.). The -t flag tags your image with a name and an optional version.

Inside a Container: Executing Commands 🏃‍♂️

Sometimes you need to peek inside a running container or execute a command within its environment.

docker exec -it [container_id/name] bash: This executes a command in a running container. The example opens an interactive Bash shell inside your specified container, allowing you to poke around as if you SSH'd in.

Cleaning Up 🧹

Containers and images can accumulate quickly, so it's good practice to clean up regularly.

docker system prune: This is a powerful command that cleans up your Docker environment. It removes all stopped containers, all dangling images (images not associated with any container), and all unused networks.

docker system prune -a: The -a flag also removes all unused images (not just dangling ones) and build cache. Use with caution!

Docker Compose: Orchestrating Multiple Containers 👯‍♀️

For applications with multiple services (like a web app, a database, and a caching layer), docker-compose simplifies management.

docker-compose.yml: This YAML file defines your multi-container application's services, networks, and volumes.

docker-compose up: Reads your docker-compose.yml file, builds (if necessary), and starts all the services defined within it.

docker-compose up -d: Starts services in detached mode.

docker-compose down: Stops and removes the containers, networks, and volumes defined in your docker-compose.yml file.

Why Docker? The Benefits for Developers ✨

Consistency: Your application runs the same way everywhere – development, testing, staging, and production.

Isolation: Applications and their dependencies are isolated from each other and the host system.

Portability: Containers can be easily moved between different machines and environments.

Efficiency: Containers are lightweight and start up quickly, making development and deployment faster.

Scalability: Easier to scale applications by spinning up more containers.

And there you have it! This is just the tip of the iceberg when it comes to Docker, but mastering these essential commands will give you a solid foundation. Docker is an incredibly powerful tool that streamlines development workflows, simplifies deployment, and solves a ton of "it works on my machine" problems.

So, fire up your terminal, download Docker Desktop, and start experimenting. You'll be containerizing your applications like a pro in no time!

Happy Dockering! 🐳

Master Your Command Line: A Developer's Guide to Essential Commands

Vikas Jyani — Mon, 01 Sep 2025 10:08:15 +0000

Hey everyone! 👋

If you're a developer, you know that the command line can be your best friend. It's powerful, it's fast, and it can make you feel like a wizard when you know what you're doing. But if you're just starting out, that blinking cursor can be a little intimidating.

Fear not! In this guide, we're going to break down the essential commands that every developer should have in their toolkit. We'll cover everything from navigating your file system to managing processes, so you can spend less time fumbling around and more time building amazing things.

Let's dive in!

Navigating Your File System 📂

First things first, let's get you moving around your computer like a pro. These commands are the absolute basics for getting from point A to point B.

pwd (Print Working Directory): Ever get lost in your own computer? It happens to the best of us. Just type pwd to see exactly where you are in the file system.

ls (List): This is your go-to for seeing what's inside a directory. Just type ls to get a list of all the files and folders in your current location.

ls -l: Want more details? The -l flag gives you a "long list" with permissions, owner, size, and when the file was last modified.

ls -a: Need to see everything, including hidden files? The -a flag is your friend. You can even combine them like ls -al to get all the details on all the files.

cd (Change Directory): This is how you move around. Type cd followed by the name of a directory to go into it.

cd ..: Need to go back up a level? cd .. will take you to the parent directory.

cd ~: Want to go straight to your home directory? cd ~ is a handy shortcut.

Working with Files and Directories 📝

Now that you can navigate, let's start creating and managing files and directories.

touch: This is a quick way to create a new, empty file. If the file already exists, touch will just update its timestamp.

mkdir (Make Directory): Need a new folder? mkdir followed by the folder name will create it for you.

cp (Copy): To copy a file, use cp followed by the source file and the destination. To copy a whole directory and everything in it, use the -r (recursive) flag.

mv (Move): You can use mv to move a file to a different directory, or to rename a file. For example, mv old-name.txt new-name.txt will rename the file.

rm (Remove): Be careful with this one! rm will delete a file. To delete a directory and everything inside it, you'll need the -r flag.

rm -rf /: NEVER EVER RUN THIS COMMAND! This will try to delete everything on your computer. You've been warned!

Viewing and Editing Files 👀

Okay, you've got files, now how do you look at them?

cat: This command will display the entire contents of a file right in your terminal.

head and tail: For big files, you might not want to see everything at once. head will show you the first 10 lines, and tail will show you the last 10. You can use the -n flag to specify a different number of lines (e.g., head -n 5 my-file.txt).

less and more: These are great for viewing large files. They'll open the file in a "pager," so you can scroll through it line by line or page by page. less is a bit more modern and has more features.

nvim (Neovim): When you need to actually edit a file, a text editor like Neovim is a great choice. You can open a file with nvim my-file.txt, press i to go into "insert mode" to type, Esc to go back to "normal mode," :w to save, and :q to quit.

Searching and Finding 🔎

Lost a file? Or need to find a specific line of code? These commands have your back.

find: This command is a powerful way to search for files. You can find files by name, type, size, and more. For example, find . -name "*.js" will find all the JavaScript files in the current directory and its subdirectories.

grep: This is one of the most useful commands out there. It searches for a pattern of text within files. For example, grep "function" my-script.js will show you all the lines in that file that contain the word "function".

grep -r: The -r flag will search recursively, so you can search through all the files in a directory.

grep -n: Use -n to show the line numbers of the matches.

grep -i: The -i flag makes your search case-insensitive.

grep -v: This inverts the match, showing you all the lines that don't contain your search term.

System and Process Management ⚙️

Time to take a look under the hood and see what's going on with your system.

whoami: A simple one, but useful. This tells you the username of the account you're currently logged into.

sudo (Super User Do): Some commands need to be run with administrative privileges. sudo lets you do that. It will usually ask for your password.

history: Want to see the commands you've run recently? history will give you a list.

clear: If your terminal is getting cluttered, clear will wipe it clean and give you a fresh start.

chown and chmod: These are for managing file permissions. chown changes the owner of a file, and chmod changes the permissions (who can read, write, and execute the file).

ps aux: This command will show you a list of all the processes currently running on your system.

kill: If a program is misbehaving and you need to shut it down, kill followed by the process ID (which you can get from ps aux) will do the trick.

top: This gives you a real-time view of your system's processes, so you can see what's using up your CPU and memory.

man (Manual): Don't know how to use a command? man followed by the command name will show you the manual page with all the details.

Package Management and Networking 📦

apt and brew: These are package managers for Linux and macOS, respectively. They make it super easy to install, update, and remove software. For example, sudo apt install neovim or brew install neovim will install the Neovim text editor.

curl: This is a command-line tool for making network requests. You can use it to download files, test APIs, and more.

And a Few More...

echo: This command simply prints text to the terminal. It's often used in shell scripts.

wc (Word Count): This command can count the number of lines, words, and characters in a file.

lsd: This is a modern, more colorful version of the ls command. It's a great example of how the command line is always evolving!

And that's a wrap! We've covered a lot of ground, but don't feel like you need to memorize everything at once. The best way to learn is by doing. So open up your terminal, start playing around with these commands, and see what you can do.

Happy coding! 🚀

How an Arts graduate got a job as a software developer in less than 3 months.

Vikas Jyani — Thu, 24 Feb 2022 16:09:54 +0000

Yes, you read it right. I'm currently working as an Associate developer in some service based IT company, and it barely took me 3 months to achieve it.

Where it all began.

While in college, pursuing Bachelor of Visual Arts, I learned about front-end development and how we can build top-notch web apps and websites using it. I was so fascinated about it that I wanted to be a software developer myself, no matter what my current qualifications were. So, during the lockdown in 2020, I did a Python certification from Coursera to get the hang of it and enjoyed that part as well and decided to switch to career after I complete my college.

The Mistakes I made

So fast-forward to October 2021, I just completed my graduation with a degree in BVA and was ready to make the transition of my career from Arts to Computer Science and did some research on the internet about where to start. Found some resources regarding the front-end developer path and started watching some tutorials. The sad part was, I started wasting more time on research rather than doing actual learning. I would start watching one tutorial and after some time, I find some other tutorial I would jump to that tutorial. And I knew that I wasn't alone, and it's the story of many folks around the world because I read in some survey that 85% of the people who signs up for a tutorial never completes it. So what change did reading that article bring into my life? None. I was stuck into that tutorial hell for a very long time and was just watching video after video and wasn't really applying what I was learning in these tutorials.

The day my life changed.

It was just a regular day, and I was watching some random YouTube tutorial on HTML, and the name of the guy in the video was Tanay Pratap, he was working as senior developer at Microsoft at that time. At the start of the video, he taught us a very important thing, Learn-by-doing. He would teach us something, then built something out of what he just taught us. I liked his approach to teaching, and it felt like I was actually retaining a lot more information this way. I started following this method and then started looking for a tutorial which was more focused on learn-by-doing.

I found out about Scrimba.

Unlike many other online learning platforms, it actually focuses more on learn-by-doing, and that’s exactly what I was looking for in a course at that time.
So I enrolled in a free JavaScript course taught by one of the founders of Scrimba, Per Herald. I really had a lot of fun learning from that course, I got to learn a lot from that free course. Upon completing the course, I decided to enroll for the frontend developer path offered from Scrimba, and it didn’t even cost that much, so I took the yearly membership. Although the entire frontend path was like a fun roller-coaster ride, I found the React course offered by Bob Ziroll most useful, or I would say most impactful during my job search.

The job hunt

Halfway(covering around 70%) through the frontend career path from Scrimba, I decided to build my resume and started applying for jobs on LinkedIn. I used to send around 50 applications per day and got about 4 interviews in the time span of 15 days. I made it on my 4th interview and was really happy about getting my first job as a developer, and that too within the first 3 months of learning frontend development. Turns out, they were going to make me sign a bond for 2 years. And it was definitely a red flag for me, so I immediately refused to join that company.
Now, I again started applying for jobs and within a week, I got another 3 interviews. One of them was impressed with my skills and dedication to learn software development and asked me to come and work for the company for 3 days, and then they were going to decide if I was a good fit to the company or not. They just wanted to know how long it takes for me to learn and apply new things. So they provided me with a Google firebase tutorial video and asked me to learn it, then they provided me a task requiring knowledge of react and firebase. I did my best, but unfortunately I could only complete the task at 80% and was really disappointed with my performance. But the next day I got a call from them, and they informed me that I was shortlisted. I couldn’t believe it because I knew I didn’t perform that well, but the person who gave me the task told me that the task was indeed challenging, and they were expecting a lot less from what I have performed. Following his call, I got a call from the HR department of the company informing me all the onboarding process details.
So that’s how I was able to secure 2 jobs in less than 3 months into software development. And what I believe is that if me, being an Arts graduate, can do it, then anyone can do it.

Key Takeaways

Believe in yourself. Everybody can learn to code, don’t get discouraged if people say otherwise. I was told by a lot of people that you are just wasting your time, I would just smile at them and just didn’t care. I continued to pursue my dream of becoming a software developer.
You don’t need a degree in Computer Science to become a software developer. Most companies nowadays are just looking for raw talent, degrees don’t matter much. Here I am working as developer with background in Arts.
Write code while watching the tutorials. If you don’t write the code yourself, you aren’t going to progress much. Understand the value of Learn-by-doing, it’s one of the best approaches towards learning to code efficiently.
Learning JavaScript can sometimes be tricky for beginners, so if you don’t understand something, don’t get discouraged and just move on to the next topic for the time being instead of lingering around trying to think too hard to understand it. Give your subconscious mind some time to process the information. You can come back to the problem after 2-3 hours or the next day, and you might have a different approach to the problem this time. You will start noticing the patterns after a bit of practice.
Write code every day, it’s very essential that we write code every day to build the required muscle memory.
Build something from scratch, challenge yourself. One good project that you have built all by yourself is going to weigh much more than 10 mediocre projects that you have just copied and pasted from the internet.

Other sources you might like:

React - The Complete Guide (incl Hooks, React Router, Redux). Get it Here
Some great YouTube tutors.

Web dev simplified by Kyle Cook. Link Here
JavaScript Mastery. Link Here
The coding train. Link Here
Pedro tech. Link Here

“Give yourself sincere 6 months, and it can change your life.” - Tanay Pratap

Please forgive me for the grammar mistakes. And if I have stretched it a bit longer than it should have been. It's my first blog ever and your feedbacks are going to help me correct the mistakes in future blogs.
Thank you for taking time to read this.