Should you join TCS, Wipro or startup as a junior software developer?

Yatin Choudhary — Sat, 08 Jun 2024 16:25:01 +0000

Let me first briefly tell you about myself. I am a junior software engineer in a startup. It is a product-based company which sells software for interior design to people. I was taken as a front-end developer in this.

So...What's new in it? And why have I written an article about joining startups or big companies?

Let me tell you a small story, my friend and I were searching for a job. He got a job as a Frontend Developer (React Js) in TCS, and I got the same in a startup. Fast forward to now, I met him on the weekend, and we discussed our little journey in the tech world. He was shocked when I told him the technologies I have worked on, from frontend, and backend to deploying code on AWS. In just a matter of one to two years, I have had more exposure to technology than him. Though our salaries remain the same ( we both cried on this).

Everything aside, I asked him the reason. And he told me the same as any LinkedIn post would, in big companies like TSC and Wipro which are service-based, ( I don't know about Product Based Companies like Amazon etc), junior software developers either work on fixing small bugs or are on bench when there is no work. So the growth in these companies as a developer is Nil batee san nata. Whereas in startups even the junior developers may have the responsibility of a feature ( it may not be something big). It teaches a lot of things as a fresher from ownership to seeing its impact on actual users.

I still remember I removed sorting on the name (as we had a search feature on it) in one table thinking no one used it. The next day we got a call from a customer who complained about sorting not working on name. Yes, my code was reviewed, and tested (our company didn't have testers, the developer was the owner of the feature so he was the tester himself, inspired by Amazon) but somehow it was missed, and guess who was blamed, no one.

Of course, it was a joke, I was blamed for it.

But I was not scolded for it. I was asked to fix it and within one or two hours, we deployed my fix. (So fast isn't it). Later my manager after my apology told me to never remove any feature on my own.

I don't know what would have happened in big companies, either it would have been detected earlier or I don't know.

This is one of the many mistakes that I have done and learnt from them ( Yes, I made a lot of mistakes).

I not only learned about ownership, but as I was getting a grip of one technology, our team leader started delegating more work, from deploying code on AWS to writing backend for some applications.

It made me learn more and more technologies, and I was growing.

It was not the same for my friend. It's been more than a year, and guess what his knowledge is still somewhat the same ( I am not criticizing him, he had tried learning from doing personal projects, but his speed is slow).

So should you join startups over these companies?

I would say take a step back and look what you want. Though I may have learned a lot, but still working on some Saturdays and Sundays is tiring. And we are not given extra money for overwork.

So would you be able to do it, will determine what you want (If the salary in both companies is the same).

Why You Should Avoid Using 'any' in TypeScript and How to Do It

Yatin Choudhary — Sun, 16 Apr 2023 15:28:10 +0000

In TypeScript, 'any' is a special data type that allows a variable to hold any type of value, similar to the 'Object' type in JavaScript. When a variable is declared as 'any', TypeScript's type checker doesn't perform any type checking on it, making it possible to assign values of any type to the variable. While using 'any' can make the code more flexible and easy to write, it can also lead to runtime errors and make the code less maintainable, as it makes it harder to catch type-related errors during development.

let myVariable: any = "Hello World";
console.log(myVariable); // Output: "Hello World"

myVariable = 123;
console.log(myVariable); // Output: 123

myVariable = true;
console.log(myVariable); // Output: true

Using 'any' in TypeScript can provide some benefits in certain scenarios. For eg.

When prototyping an application, using 'any' can make the code more flexible and easy to write. It allows you to quickly build the application without worrying about the data types and allows you to test your code quickly.
When prototyping an application, using 'any' can make the code more flexible and easy to write. It allows you to quickly build the application without worrying about the data types and allows you to test your code quickly.
If you are working with existing code that doesn't have type annotations, using 'any' can help to gradually introduce type safety in your codebase. By starting with 'any' types, you can progressively add type annotations to your code over time, making it more maintainable.

BUT...

Using 'any' in TypeScript should be avoided as much as possible for several reasons

When using 'any', TypeScript's type checker does not perform any type checking on the variable, making it easier to introduce runtime errors. This can make the code less reliable and harder to maintain, especially in larger projects.
When a variable is declared as 'any', it can be difficult to understand what type of data it should hold. This can make the code less readable and harder to understand for other developers working on the project.
When a project grows in size and complexity, using 'any' can make it harder to maintain and debug the code. This is because it's more difficult to catch type-related errors during development, making it harder to identify and fix issues.
TypeScript is designed to use type inference to determine the types of variables based on their values. When a variable is declared as 'any', TypeScript loses the ability to infer the type, making it harder to detect errors and maintain the code.

So how to do it ,

Some well known answers are :

Use more specific types
Use type inference
Use interfaces or types
Use strictNullChecks

And you can also use :

Record types to avoid using 'any' in TypeScript. Record types allow you to define an object type with a specific set of keys and values. For example, instead of using 'any' to represent an object with unknown keys and values, you can define a Record type that specifies the shape of the object:

type MyObject = Record<string, unknown>;

const myObj: MyObject = {
  foo: "bar",
  num: 123,
  bool: true,
  nestedObj: {
    key: "value",
  },
};

console.log(myObj.foo); // Output: "bar"
console.log(myObj.num); // Output: 123
console.log(myObj.bool); // Output: true
console.log(myObj.nestedObj.key); // Output: "value"

2.'Partial' and 'Required' utility types to create a new type with some properties optional and some required.

For example, let's say you have an object type that includes 'any' to allow for flexibility:

type MyObject = {
  name: string;
  age: number;
  address: any;
}

If you want to make the 'address' property optional, you can use the 'Partial' utility type to create a new type with the 'address' property as optional:

type MyPartialObject = Partial<MyObject> & {
  address?: any;
};

Similarly, if you want to make the 'name' property required, you can use the 'Required' utility type to create a new type with the 'name' property required:

type MyRequiredObject = Required<MyObject> & {
  name: string;
};

3.Pick and Omit
'Pick' and 'Omit' utility types can be used to select or remove properties from an object type, respectively.
The 'Pick' type allows you to select specific properties from an object type and create a new type with only those properties. For example, if you have an object type with multiple properties:

type MyObject = {
  name: string;
  age: number;
  email: string;
}

You can create a new type with only the 'name' and 'age' properties using the 'Pick' type:

type MyPickObject = Pick<MyObject, 'name' | 'age'>;

On the other hand, the 'Omit' type allows you to remove specific properties from an object type and create a new type without those properties.

type MyOmitObject = Omit<MyObject, 'email'>;

Thanks for reading...

DEV Community: Yatin Choudhary

Should you join TCS, Wipro or startup as a junior software developer?

Why You Should Avoid Using 'any' in TypeScript and How to Do It