DEV Community: Ahmada Khalid

Balancing Speed and Thoroughness: Best Practices for Reviewing and Approving Pull Requests

Ahmada Khalid — Fri, 20 Jan 2023 11:27:49 +0000

As a software developer, one of the most important aspects of your job is to review and approve pull requests (PRs) submitted by your team members.

This process is critical for ensuring that the codebase remains clean, maintainable, and free of bugs.

However, it can also be a source of frustration, especially when you are pressed for time and asked to quickly approve a PR without fully reviewing it.

One of the biggest challenges when reviewing PRs is balancing the need for speed with the need for thoroughness.

On one hand, you want to be able to quickly approve PRs so that your team members can move forward with their work.

On the other hand, you don't want to approve something that is going to cause problems down the road.

One way to strike a balance between speed and thoroughness is to establish a clear set of guidelines and expectations for PRs.

For example, you might require that PRs include a detailed description of the changes made, as well as any relevant test cases or documentation.

This will make it easier for you to quickly review the PR and identify any potential issues.

Another key aspect of reviewing PRs is to be proactive in identifying and addressing potential issues.

For example, you might use automated tools to check for common coding errors or to check for compliance with your team's coding standards.

By catching these issues early on, you can help to prevent them from becoming bigger problems down the road.

Additionally, it's very important to be transparent and communicate well with your team members. If you find a problem with a PR, don't be afraid to bring it up and discuss it with the person who submitted it.

The sooner you can identify and address an issue, the less likely it is to cause problems later on.

Reviewing and approving PRs is an important part of the software development process.

It can be challenging to balance the need for speed with the need for thoroughness, but by establishing clear guidelines, being proactive in identifying and addressing potential issues, and communicating well with your team members, you can help to ensure that the codebase remains clean, maintainable, and free of bugs.

Remember, it is better to take some time to review and approve a PR correctly rather than approving a poor quality one that can cause problems in the future.

Code cleanliness zero to Hero!

Ahmada Khalid — Fri, 20 Jan 2023 10:36:50 +0000

Code cleanliness is an important aspect of software development, as it helps to improve the maintainability, readability, and overall quality of your code. Here are some advanced tips on how to keep your code clean:

Use a consistent code style:

Consistency is key when it comes to code cleanliness. By using a consistent code style, you can make your code more readable and easier to understand. This can be achieved by using a code formatter, or by following a specific style guide.

Follow the DRY principle:

The DRY principle (Don't Repeat Yourself) is a fundamental principle of software development. It states that you should avoid repeating the same code in multiple places. Instead, you should extract common functionality into reusable functions or modules.

Use meaningful and descriptive variable and function names:

Using meaningful and descriptive names for variables and functions can greatly improve the readability of your code. Avoid using single letter variable names or using names that are not relevant to the purpose of the variable or function.

Use comments and documentation:

Comments and documentation can be very helpful in making your code more readable. They can provide context and explain the purpose and functionality of specific parts of your code.

Refactor your code:

Refactoring is the process of rewriting and reorganizing your code in order to make it more readable, maintainable, and efficient. This can include things like renaming variables, breaking down functions into smaller, more focused functions, and reorganizing your code into logical modules.

Use version control:

Using version control software like git can help you to keep track of changes to your code over time. It allows you to easily revert to previous versions of your code, and collaborate with other developers on a project.

Test your code:

Writing automated tests for your code can help to ensure that it is working correctly and that any changes you make in the future do not break existing functionality.

By following these advanced tips, you can improve the cleanliness of your code and make it more readable, maintainable, and efficient.

Remember that code cleanliness is an ongoing process, and that it is important to continue to review and improve your code over time.

Happy coding to you Hero!

Mastering Advanced Types in TypeScript.

Ahmada Khalid — Wed, 18 Jan 2023 23:28:45 +0000

TypeScript, a superset of JavaScript, provides several advanced types that can be used to improve the safety and readability of your code. Some examples include:

Intersection Types: These are used to combine multiple types into a single type. For example, if you have a variable that should be both a number and a string, you can use an intersection type:

let x: number & string;

Union Types: These are used to specify that a variable can be of one of several types. For example, if a variable can be either a number or a string:

let x: number | string;

Tuple Types: These are used to specify the types of the elements of an array. For example, if you want to create an array of a specific length with specific types of elements, you can use a tuple type:

let x: [string, number];

4.Type Aliases: These are used to give a type a specific name. For example, you can create a type alias for an intersection or union type:

type MyType = number | string;

5.Enum Type: Enumerated type is a way of defining a set of named values. For example, you can create an enumeration of the days of the week:

enum Days {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

6.Generics: These are used to create a type that is independent of other types. For example, if you want to create a function that can accept any type of argument and return any type of value, you can use generics:

function identity<T>(arg: T): T {
    return arg;
}

In TypeScript, the Omit type is used to create a new type by picking a set of properties from an existing type and then removing a set of properties from that type. For example, if you have an interface like this:

interface Person {
    name: string;
    age: number;
    address: string;
}

You can use Omit to create a new type that excludes the "address" property:

type PersonWithoutAddress = Omit<Person, "address">;

Now, PersonWithoutAddress is a new type that has all the properties of Person except "address".

Another useful type utility is Pick, this creates a new type by picking a set of properties from an existing type.

type PersonName = Pick<Person, "name">;

There are other utility types such as Exclude, Extract, Record and InstanceType that can help you manipulate and create new types.

interface Person {
    name: string;
    age: number;
    address: string;
    phone: number;
}

You can use Exclude to create a new type that excludes the properties "name" and "age":

type PersonWithoutNameAge = Exclude<keyof Person, "name" | "age">;
```



Now, PersonWithoutNameAge is a new type that includes all properties of Person except "name" and "age".

`Extract`: This type is used to extract a set of properties from an existing type. For example, if you have an interface like this:



```typescript
interface Person {
    name: string;
    age: number;
    address: string;
    phone: number;
}
```



You can use Extract to create a new type that includes the properties "name" and "age":



```typescript
type PersonNameAge = Extract<keyof Person, "name" | "age">;
```



Now, PersonNameAge is a new type that includes only the properties "name" and "age" of Person.

Record: This type is used to create a new type that maps keys of a certain type to values of another type. For example, you can use it to create a dictionary-like object:



```typescript
type PhoneBook = Record<string, number>;
let phoneBook: PhoneBook = {"John": 123456, "Jane": 789012};
```



InstanceType: This type is used to obtain the type of an instance of a class. For example, if you have a class like this:



```typescript
class Person {
    name: string;
    age: number;
}
```



You can use InstanceType to obtain the type of an instance of the class:



```typescript
let person: InstanceType<typeof Person> = new Person();
```



You may ask What is difference between omit and exclude?

The `Omit` and `Exclude` utility types in TypeScript are similar in that they both allow you to create a new type by removing properties from an existing type. However, there is a subtle difference between them.

`Omit` is used to create a new type by picking a set of properties from an existing type, and then removing a set of properties from that type. For example, if you have an interface like this:



```typescript
interface Person {
    name: string;
    age: number;
    address: string;
}
```



You can use Omit to create a new type that excludes the "address" property:



```typescript
type PersonWithoutAddress = Omit<Person, "address">;
```



Exclude is used to exclude a set of properties from an existing type. For example, if you have an interface like this:



```typescript
interface Person {
    name: string;
    age: number;
    address: string;
    phone: number;
}
```



You can use Exclude to create a new type that excludes the properties "name" and "age":



```typescript
type PersonWithoutNameAge = Exclude<keyof Person, "name" | "age">;
```



So in summary, `Omit` allows you to create a new type with a specific set of properties removed, while Exclude allows you to create a new type with a specific set of properties removed from a set of properties.

It's like `Omit` is a more specific version of Exclude, it allows you to create a new type by picking some properties from an existing type and remove other properties from it.


**In** conclusion, TypeScript is a powerful superset of JavaScript that provides several advanced types that can be used to improve the safety and readability of your code. These advanced types include Intersection Types, Union Types, Tuple Types, Type Aliases, Enum Types, and Generics. They allow you to create new types from existing ones, and to specify more precise types for your variables and functions.

Furthermore, TypeScript also provides other utility types such as `Omit`, `Exclude`, `Extract`, `Record` and `InstanceType` that can help you manipulate and create new types. These types can be very useful when working with complex types, providing a way to manipulate and create new types from existing ones.

In this article, we have covered the basics of these advanced types, and we have provided examples of how they can be used in practice. With this knowledge, you will be able to write more robust and maintainable code in TypeScript, making your development process more efficient.