Forem: tanyaa-arora

Internship Experience: My First Week Unveiled

tanyaa-arora — Sat, 20 Jan 2024 11:46:24 +0000

For most of us, the first internship typically occurs in the third or last year of college, and that holds true in my case as well. I am currently in my last semester of Engineering and have recently joined a startup as a software development intern. In this blog post, I will cover all the things I have learned so far, discuss my assumptions about working in an IT company, outline what beginners need to know, and explore what one can expect from an internship.

Navigating Assumptions: What You Need to Know as a Beginner

I used to believe that I needed to know a lot to land an internship, but to my surprise, that's not the case. Companies don't expect you to know everything; a basic understanding of even one programming language can help secure the position. More important than existing knowledge is your willingness to learn new things. In my office, I was assured that I could always approach any senior for help if I faced any problems. This emphasizes the importance of not hesitating to ask questions, even seemingly silly ones, and going the extra mile to learn something that might not be immediately useful but will benefit you in the future.

Overcoming Workload Myths

Another misconception I had about being an intern was that the company would overload me with work. However, in my initial days, they allowed me time to get acquainted with everything before assigning small tasks. These tasks were either easy for me or involved a small concept I had to learn to complete. This experience taught me that companies won't burden you with excessive work from the beginning; they might start with manageable tasks that facilitate learning. It's crucial to be honest about what you don't know; maintaining transparency and a learning attitude is key.

The Development Cycle: Exploring Environments in Software Development

Moving beyond assumptions and reality, I learned about the various environments used in the development and deployment cycle in my first week. These include the development environment for creating and testing the product, the QA environment for bug checking, and the staging environment—a replica of the production environment where we can preview the product's appearance and functionality for users. The final step is the production environment, where the code goes live for users. This cycle continues, enhancing the product's quality with each new version.

Overcoming Overwhelm: Consistency and Connection Building

Feeling overwhelmed is normal, but consistent effort will help you overcome it. Building connections in the office, engaging in conversations with different people, and participating in various activities can lead to unexpected learning experiences. Remember, working all the time can be draining, so take breaks to refresh your mind.

Essentials for Internship Success: Language, Version Control, and Confidence

Securing an internship requires only a basic understanding of one programming language, a bit of familiarity with version control, and self-confidence. This formula worked out well for me and I hope it does for you too! Expect significant professional and personal growth during your internship, and make it a goal to absorb as much knowledge as possible.

So, for all the people out there who are going to kick off their internship journey anytime soon, I'd like to wish them luck and I hope you have a great learning experience!!

Making a stopwatch in React. The process, the challenges, and the takeaways

tanyaa-arora — Sun, 07 Jan 2024 16:33:43 +0000

For most of you, making a stopwatch using React might be an elementary problem. It was yesterday when I tried making one for the first time. In this blog, I will share with you all the challenges I faced as a beginner and how I overcame them while making the stopwatch.

The process

The first thing I did was think about all the features I wanted my stopwatch to have and jot them down. They were as follows:-

Create a display to show the time passed
Give buttons (and keyboard controls) to start/stop the watch
Give a lap button and display the lap time below the watch

The next step was to create a workflow to have a clear vision of how to proceed ahead. For that, I went through several blogs and articles on how to create a stopwatch using React. That gave me an idea of how to go ahead with my project. So, I wrote down the steps to it, which were:

Create a component Stopwatch that displays time in hh: mm: ss: ms format with the control buttons
Create a state timer that increases by 1 every 10 milliseconds using useState hook
Create a state that checks if the stopwatch is active or not
create a useRef hook interval that stores the id of the interval started by setInterval()
Create a useEffect that triggers every time the active state changes
Define functions to start/pause, restart the stopwatch
Attach them to start/pause and restart buttons using event handlers
Create a lap button to display the laps passed

- Create a state for storing lap values in an array

- Create a function to capture lap value and store it in the lap array

- Attach the function with the onClick event of the lap button

- Display the array using the .map() function

- Re-initialize the array on restart

Calculate the time passed as follows:

const milliseconds = (timer%100).toString().padStart(2,"0"); //padStart(target,"str") function is used to add padding(str) to the start of a string until it reaches the target length.

const seconds = Math.floor((timer 100)%60).toString().padStart(2,"0")

const minutes = Math.floor((timer / 6000)%60).toString().padStart(2,"0")

const hours= Math.floor((timer/360000)%24).toString().padStart(2,"0")
Display the time passed.

The challenges and the takeaways

There were some new things that I learned along the way. One of them was the discovery ofsetInterval(callback,interval) function. I came to understand that this function executes the callback function after every interval and to stop it from executing I should use clearInterval(intervalID) function. I learned that setInterval() function is used for making stopwatches.
I used this function inside the useEffect hook that would get triggered every time I changed the state of my timer. This led me to understand the working of useEffect hook in-depth and its life-cycle phases (mounting phases, unmounting phase, updating phase).
One major challenge for me was to stop the timer by clicking the pause button and for that, I needed to have the interval ID of the interval that was currently executing. That led me to find out about useRef hook which once set, persists the same value and does not change over re-renders. That helped me to store the interval ID and pause it using the clearInterval(intervalID) function when needed.

What is aliasing in Ubuntu?

tanyaa-arora — Wed, 03 Jan 2024 15:22:09 +0000

Problem

So, I have recently started using Ubuntu and I often face the problem of typing the same commands again and again. We know that 80% of the commands that we use everyday are only 4 or 5 of them. It sometimes becomes frustrating as well as time-consuming. Well, this is not how I want to make use of my precious time. What should I do then?

Solution

Well, I came across the concept of aliasing today which made me realise that this is the exact solution to my problem. You must be wondering that what does aliasing mean? Let me try to tell what I understand by it. Aliasing simply means giving a nickname to something.

Suppose, a friend of yours has a name "Ramakrishna". You'd rather call him R.K. instead of addressing him by his name everyday. So, R.K. is his nickname. Similarly, we can give nicknames to our daily use commands. Thus, this is called aliasing.

In order to make aliases, you can use the following steps:

Firstly, go to your terminal and open the .bashrc file on gedit so that you can edit your file.

gedit ~/.bashrc
Once, the gedit text editor is opened, create the alias and save the file.

alias <nickname> ='The command you want to give a nickname to'
alias ll='ls -l' //Command to show all the files in your system
Kill the current terminal and reopen it. Then execute ll

Voila!! Now you can view all the files in detail. This is one such example of aliasing.

One specific use case of aliasing is when there's a file that's nested deeply within multiple directories. In such scenario, writing the whole path to access it would be a waste of time.

It can also be used when we are regularly pulling and pushing our code to remote repositories such as on GitHub. Suppose, we can give an alias to git add as:

alias ga='git add .'

Limitations

We know that every thing has its own benefits and limitations. This goes for aliasing as well.
It is very important for us to know when is it of use and when it's not.

Let's take an example where you have created some aliases on your own system and you are so dependent on them, that if given another system, you wouldn't be able to execute the actual commands. So depending entirely on anything is wrong.

Also, aliasing should be used only when you need to repeatedly use some command. Creating an alias for a command that only needs to be used once does not make any sense. Suppose, you can execute a direct command in one minute, whereas creating an alias and executing it takes more time that to when that command only needs to be run once.

Thus, I would like to conclude by saying that aliasing can be greatly useful to us provided we keep in mind its use cases.