DEV Community: Aadit Kamat

Hey guys, I wrote up a blog post based on my struggles working with dates on React Native. Do have a read and feel free to share your thoughts with me

Aadit Kamat — Sun, 27 Apr 2025 22:39:25 +0000

Aadit Kamat

Apr 27 '25

Working with Dates across different platforms

#javascript #reactnative #datefns #dayjs

Comments

4 min read

Working with Dates across different platforms

Aadit Kamat — Sun, 27 Apr 2025 22:36:09 +0000

How I started my journey into React Native

I had my first experience with React Native as a Quality Assurance Engineer at Shopee. To give you folks some context, Shopee is the leading e-commerce firm in Southeast Asia and Taiwan. You can compare it to Temu here in the US, and the user interface of both platforms is deceptively similar.

Since I was in the Test Automation department, I didn't have to touch the React Native code itself. However, I had to familiarize myself with React Native, because the devs were migrating the app from the pre existing Kotlin codebase to React Native, to ensure a consistent codebase across the iOS and Android applications without having to work with two separate technology stacks (Swift and Kotlin/Java).

As any engineer who has worked on a major enterprise system would know, migration from another platform or technology to another is a painful and long process. It can take anywhere from a couple of months to years, depending on how complex the codebase is, how much resources your team can allocate and how business critical the code is. While developers often make breaking changes in the process, the engineers on the testing side have to play catchup.

I had joined the team as this migration was still about half way through, and one of the first things I had to figure out where the IDs associated with the elements being tested were Android or React Native IDs. This helped determine where the tests had genuinely caught some bugs in the application or had yet to be updated to reflect code changes due to the React Native migration.

After leaving Shopee, I had not worked on any mobile app project for a while. Earlier this month however, I was roped in to lead the development of a mobile app called Recyclepedia that Florida Community Innovation, a non profit organization in the civic tech space aiming to empower the citizens of Florida with trusted resources and critical social service, is building in partnership with another non profit, Dream in Green, for the residents of the Miami Dade County.

In the last couple of days, I have been working on a feature rich home page, which includes a calendar showcasing recycling and sustainability events organized by community partners in Miami.

Why am I writing this post?

Now that I have gone into a lot of detail about my background, let me cut to the chase. The reason I am writing this post: I found myself hitting roadblocks a couple of times while handling dates and I'm hoping that any devs facing similar issues would find the journalling of my experience helpful.

As I was implementing a feature for users to select the range of dates for any event they could submit to be included in the calendar, I found myself struggling to get the right dates highlighted.

The hiccups I ran into

At first, I suspected this was due to an implementation error, a rookie "off-by-one" bug. As I dove in deeper, however, I found that I was storing the dates correctly.

As it turns out, the utility functions within the date-fns library, addDays and subDays, don’t always give the expected output.

You run into a similar problem when you try to format a date value.

import {format} from "date-fns";

format(new Date("2025-04-26"), "yyyy-MM-dd")) 
# Expected: "2025-04-26", Output: "2025-04-25"

Furthermore, native Date objects are processed slightly differently on the V8 JavaScript engine, used by browsers like Chrome and by Node.js, as compared to mobile platforms like Android or iOS using React Native. As the ECMA262 specification is not compatible with the ISO8601 spec for some situations, we have to be very careful when parsing dates using the Date() constructor.

How do we resolve these issues?

That's why it is recommended to work with Unix timestamps instead of string representations which are parsed differently for different engines.
The main issue with this though, is that Unix timestamps are not easily understood by humans.

To be consistent with date parsing, it’s better to use a utility library to format and manipulate Date objects consistently across your codebase rather than rely on the native Date object.

My own take

Even after using date-fns’s utility functions, I still found working with those dates across different React Native components to be more tedious than I expected. I mean, what’s with all these different tokens for formatting date strings?

That’s why I decided to give dayjs a shot. So far it seems like a cleaner solution, where you can wrap date strings and date-like objects within a dayjs object before you manipulate them using object methods, but I’ll have greater clarity once everything has been implemented.

Final thoughts

Whatever it is, make sure that you stick to a library that manipulates dates in a consistent way - whether it's moment, date-fns or dayjs. Don’t mix-and-match different Date methods and representations. This will save you a lot of pain as you go working with dates across different platforms.

Linear Algebra basics

Aadit Kamat — Mon, 07 Nov 2022 13:34:36 +0000

I have been reviewing Linear Algebra concepts to get a better grasp of Machine Learning through a MOOC called "Mathematics for Machine Learning: Linear Algebra" offered by the Imperial College of London on Coursera. This blog post aims to summarize some of the basic concepts in Linear Algebra.

Vectors

What are vectors?

Geometric representation of a vector (source: Math Insight)

Vectors lie at the heart of linear algebra. Geometrically, they are directed line segments represented by two quantities: direction and magnitude. You can represent the magnitude of a vector by the length of the line segment and its direction by the direction in which the arrow points.

How are vectors represented?

Vectors are often represented by a letter symbol with an arrow on top such as $v⃗\vec{v}$ or in bold as v. The latter representation is much easier to use while typesetting mathematical equations.

The magnitude of a vector, sometimes also referred to as the norm of the vector, is represented as $∣v⃗∣|\vec{v}|$ or v (no bolding).

Direction of a vector (source: Story of Mathematics)

How is the direction of a vector represented? This is done in terms of the angle it forms with a set of standard bases, or axes as you would know them. In 2 dimensions, these would be the x and y axes. In 3 dimensions, these would be x, y and z axes. You can extend this idea to any number of higher dimensions.

What are standard bases?

Standard Bases(source: Wikipedia)

They are vectors of unit length (magnitude 1) that are orthogonal (perpendicular) to each other. In 2 dimensions, the x and y axes form a plane and in 3 dimensions, the x, y and z axes form a cuboid.

The reason why these are called standard bases is because they are the ones often used to describe vectors. Denoting the x axis as $i^\hat{i}$ , y axis as $j^\hat{j}$ and z axis as $k^\hat{k}$ , we can describe any vector $v⃗\vec{v}$ as $v⃗=ai^+bj^+ck^\vec{v} = a\hat{i} + b\hat{j} + c\hat{k}$ where a, b and c are real numbers.

However, we could use other sets of bases to describe a vector space. These could be of unit length and orthogonal to each other, just like the standard bases, but the main idea is that you can have any vectors form bases as long as they are linearly independent.

What is linear dependence?

If you can describe one of the vectors in the set as a linear combination of the other vectors, then these vectors are linearly dependent.

Consider the case of 2 or 3 vectors in a regular 3 dimensional space. If you can describe one vector as a linear combination of the other vectors ( $a⃗=nb⃗\vec{a} = n\vec{b}$ ) then it points in the same or the opposite direction but with its magnitude increased (scaled) by a factor of n. This means that it still lies along the same line as the other vector.

On the other hand, if you can describe one vector can be as a linear combination of two other vectors ( $a⃗=mb⃗+nc⃗\vec{a} = m\vec{b} + n\vec{c}$ ), then it means that it lies in the plane formed by those vectors because that is what the vector addition signifies.

How can you mathematically represent vectors?

You can operate with vectors in mathematics as lists of numbers, formed by writing down the values of the components along the different axes, wrapped in round or square brackets.

For example,
$5)\begin{pmatrix} 3 \ 4 \ 5 \end{pmatrix}$
is a 3-dimensional vector that has 3 units of length in the direction of the x axis, 4 in the direction of the y axis and 5 in the direction of the z axis.

To make things more standardized for discussion, instead of axes, most linear algebra texts use the term standard bases, but know that these essentially refer to the same concept.
You can represent these as $0)\begin{pmatrix} 1 \ 0 \end{pmatrix}$ and $1)\begin{pmatrix} 0 \ 1 \end{pmatrix}$ in the 2 dimensional case and $0)\begin{pmatrix} 1 \ 0 \ 0 \end{pmatrix}$ , $0)\begin{pmatrix} 0 \ 1 \ 0 \end{pmatrix}$ and $1)\begin{pmatrix} 0 \ 0 \ 1 \end{pmatrix}$ in the 3 dimensional case.

Hence, you can represent any vector $v^=ai^+bj^+ck^\hat{v} = a\hat{i} + b\hat{j} + c\hat{k}$ as $c)\begin{pmatrix} a \ b \ c \end{pmatrix}$ which is actually $\begin{pmatrix} 1 \ 0 \ 0 \end{pmatrix} + b \begin{pmatrix} 0 \ 1 \ 0 \end{pmatrix} + c \begin{pmatrix} 0 \ 0 \ 1 \end{pmatrix}$

Is there an alternate way to represent vectors?

You can also represent them is in terms of r, the magnitude of the vector, and the angles it forms with some of the bases. In the 2 dimensional case, for example, you can do so with variables r and $θ\theta$ , while for the 3 dimensional case, you can use r, $θ\theta$ and $α\alpha$ .

Using the bracket notation, you can write these as $θ)\begin{pmatrix}r \ \theta \end{pmatrix}$ and $α)\begin{pmatrix}r \ \theta \ \alpha \end{pmatrix}$ respectively.

Polar Coordinates(source: Wikipedia)

The coordinates of the point that lie at the end of the vector are known as polar coordinates. By varying the angle, you can describe objects like circles and spheres in the 2 dimensional and 3 dimensional cases.

How can vectors be used in the real world?

When you store numerical data in tables in terms of rows and columns, you can think of each of these rows/columns as a vector. For example, in a table consisting of the heights and weights of different people, each person's height and weight is a row vector whereas the list of heights or the list of weights is a column vector.

What are some operations you can do on vectors?

You can add two vectors following the parallelogram law or the triangle law. In order to add two vectors, you need to place the tail of the second vector on the head of the first. You can easily extend this to the general case of adding n vectors to get a polygon.

You can scale a vector by a factor of n. This essential means that you increase its magnitude by a factor of n. If n is positive, then the vector is stretched in the same direction. If n is zero, then the vector is reduced to a point. Otherwise, the vector is stretched in the opposite direction.

Dot Product(source: Math Insight)

You can take the dot product of two vectors, $a⃗.b⃗\vec{a}.\vec{b}$ , which is a scalar that is:

The projection of vector a in the direction of b multiplied by the magnitude of b or
The projection of b in the direction of a multiplied by the magnitude of a.

Mathematically, it works out to be $a⃗.b⃗=∣a⃗∣∣b⃗∣cos(θ)\vec{a}.\vec{b} = |\vec{a}||\vec{b}| cos(\theta)$

Vector Projections(source: xaktly.com)

The projection can be thought of as the shadow of one vector onto the other when light rays fall on it perpendicularly.
The special cases are when: 1. two vectors are orthogonal, (the dot product is zero as $θ=90°;cos(θ)=0\theta=90\degree{}; cos(\theta) = 0$ ), 2. two vectors lie in the same direction (the dot product is ab as $θ=0°;cos(θ)=1\theta=0\degree{};cos(\theta) = 1$ ) and 3. two vectors lie in opposite direction (the dot product is -ab as $θ=180°;cos(θ)=−1\theta=180\degree{}; cos(\theta) = -1$ ).

Right hand rule cross product (source: Wikipedia) Corkscrew Rule (source: Connecticut State University)

Another operation on vectors results in a vector instead of a scalar (number). This is called the cross product. The way to think about it is in terms of the right hand rules or corkscrew rules, the third vector results from the rotation of one vector to another and is orthogonal to both the vectors. The magnitude of the cross product is the area formed by the vectors, usually computed using the determinant of the matrix formed by these vectors, which we will talk about in a later article.

Matrices

What is a matrix?

Matrix Dimensions (source: Study.com)

In high school, matrices are generally introduced as a collection of vectors, either row or column vectors. These are essentially similar to tables in that way.

Augmented Matrix for a System of Linear Equations (source: Khan Academy)

They come up when you are trying to solve a system of linear equations, to represent the coefficients that appear within the equations.

But that's only part of the picture. Again, there is a very neat way to think about matrices geometrically just as you can think about vectors geometrically. That involves visualizing them in terms of linear transformations.

What are linear transformations?

Linear transformations represent transformations (changes) of vectors and vector spaces. Remember when we said that we don't just have to use the standard bases to describe a vector space. That's where linear transformations come in handy. You can transform one set of bases to another through such transformations. These are linear in nature, because you get shapes formed by straight line segments, which do not have curves in them. The vector spaces can be thought as grids consisting of cells formed by parallel intersecting line segments that are evenly spaced out.

What are some common types of linear transformations?

Types of Linear Transformations (source: Mathigon)

The common types of linear transformations are:

Rotation: You rotate both the bases about the origin, which means that you keep the relative angles and the sizes of the vectors fixed.
Scaling: You stretch the bases in the same directions, changing their sizes but keeping the relative angles fixed.
Shearing: You kept one of the bases fixed and then rotate the other by an angle.
Reflection: You rotate both the bases about a line, rather than about a point such as the origin.

There are some special types of linear transformations such as the identity transformation, which does nothing, and the zero transformation. You can understand them better in terms of matrix multiplication.

How can you visualize matrix-vector multiplication?

Transformation of bases(source: Math Insight)

You can thinking of multiplying a matrix to a vector as applying a linear transformation to that vector. As we said, a vector is usually described in terms of standard bases, but when we multiply it by a matrix, the new vector we get is the same vector described in terms of the bases represented by column vectors in the matrix.

The identity transformation that we spoke out earlier is represented by the identity matrix:

Now it makes sense why you get the same vector when you multiply a vector by the identity matrix: you are not transforming the set of bases and hence the vector space. When you apply the zero transformation, represented by the zero matrix, you essentially collapse everything to a point.

In the 2 dimensional case, you can write down the matrices corresponding to the common types of linear transformations as follows:

Rotation:
Scaling:
Shearing:
Reflection:

You can play around with these transformations and visualize them, using this wonderful tool called the transformation matrix playground.

How can you now think about a system of linear equations?

You can think of a system of linear equations in this way: can you find a vector in the standard coordinate system (the vector space described by the standard bases) that results in the solution vector once you apply a linear transformation represented by the matrix?

This is how we go from numbers to vector spaces - algebra to geometry. Since you aren't dealing with variables raised to any power, you are only concerned with lines and their segments. This is why the field is called linear algebra in the first place.

How can you visualize matrix-matrix multiplication?

What happens when you want to apply successive linear transformations? If you guessed that the equivalent was multiplying more than one matrix, then you are right. For example, when you want to rotate a vector (and its associated vector space) and then shear, you will multiply the matrix representing the rotation transformation and then the matrix representing the shearing transformation.

Matrix multiplication is not commutative, since the order of the transformations matters. For example, rotating and then shearing is not the same as shearing and then rotating.

$\neq BA$

Matrix multiplication is associative, however, since you can group the transformations in different ways, so long as they are applied in the same order.

$A (BC) = (A B) C$

Some basic Machine Learning concepts

Aadit Kamat — Sun, 02 Oct 2022 13:24:25 +0000

Background

Machine learning is a discipline that uses mathematical tools like linear algebra, statistics and calculus under the hood to mainly explore problems related to prediction: predict the price of an index fund, predict the weather tomorrow and so on.

The field has grown in popularity and sees application in a diverse number of fields today largely due to two factors: growing computational power and larger, high-quality data sets (big data) that allow us to make better predictions.

Machine Learning tries to solve two categories of problems: estimation and generalization.

Estimation refers to the problem of trying to guess the value of a variable when you are faced with noisy data, which is usually the case when you are dealing with real-world data. This is a problem that appears commonly in statistics.

Generalization, on the other hand, is based upon the principle of induction: you can formulate hypothesis (prediction) about future data based on past data.

Supervised and Unsupervised Learning

Most Machine Learning algorithms fall under two categories: Supervised Learning and Unsupervised Learning.

As the name suggests, Supervised Learning algorithms require input (supervision) from the humans before they can be executed. Humans provide this input in the form of labelled examples in the training data set.

Some types of supervised learning algorithms:

Classification: The output of the algorithm for each data point is the category to which the data point should belong. The classification can be binary when two categories are involved or multi-class when multiple categories are involved. Examples: Tagging someone based on previously labelled photos, recommending new songs based on feedback for songs in the history
Regression: The output of the algorithm for each data point lies within a range of values in a continuous domain. Examples: Predicting height and weight, predicting weather of a place on a certain day

Unsupervised Learning algorithms, on the other hand, try to identify underlying patterns in the data instead of relying on human input to detect these patterns. Some types of unsupervised learning algorithms are as follows:

Clustering: identify clusters of data points that are closely related by virtue of being closely located in a n-dimensional landscape such as a scatterplot
Density estimation: Given a set of data points, identify the probability of the random variable representing the Independent and Identically Distributed (IID) population from which these data points are drawn
Dimensionality reduction: While visualizing points in higher dimensions, it usually helps to boil the distribution down to lower dimensions (fewer variables involved in the prediction) and that is where dimensionality reduction techniques come in handy.

Evaluation

We need some way to tell whether our predictions are in the right direction or not. When we have access to the actual values of the mathematical function representing the data that we are trying to learn, we make use of loss or error functions to see how far our estimates are from the actual values. A good prediction is one that tries to minimize the loss function.

Before we do this, however, we usually split our input data for a learning algorithm into three sets: training data, test data and validation data. The training data is used by the machine learning algorithm to form a prediction which is then tested out on the test data set. The validation data sets come in handy to ensure that the model is not overfitting the training data. This happens when the model has many parameters and learns the training data set exactly (memorizes it) which leads to a zero error on the test data set.

The types of loss functions that you typically encounter are:

Absolute function ( $y_{actual} - y_{guess}|$ )
Square function ( $y_{actual} - y_{guess})^2$ )
Linear function( $y_{actual} - y_{guess})$ )

Model selection

The model for a given data set is very specific to that dataset: the parameters for that model have specific values. It is usually picked from a class of models. For example, linear functions form a model class, while the linear function used as a classifier for the data set is a model selected from that class.

Learning algorithm

It is easy to confuse Machine Learning algorithms with Machine Learning models because the terms are often used in conjunction. They are related concepts, but they are vastly different from each other.

Learning algorithms are usually designed such that you start with a naive model in a learning algorithm. The learning algorithm then looks to optimize the model by varying the hyperparameters (also known as "hyperparameter tuning"): parameters specific to the algorithms that are not accessible to the models. This kind of optimisation enables models to be able to describe the data better, for example, by trying to minimize the loss function.

How to deactivate your Slack account on a Workspace

Aadit Kamat — Sun, 25 Sep 2022 14:37:39 +0000

I was trying to deactivate my old Slack accounts on different workspaces and I was kind of confused about how I should go about doing that. Since I was not able to figure it about going through the Slack docs, I thought that I would write a mini blog post with steps to go about deactivating your account.

Steps:

Click on the icon at the top right corner and select Profile
Click on the button with three vertical dots and choose Account Settings from the dropdown menu
Click on the Deactivate your account button after scrolling down the page, all the way to the bottom.

Testing with Jest and React Testing Library

Aadit Kamat — Sun, 18 Sep 2022 08:20:18 +0000

Jest is a library developed by Meta for testing JavaScript applications. React Testing Library, on the other hand, is a library developed by Kent C Dodds and other open source contributors, which wraps around the React library and provides a black box solution specifically for unit testing React applications.

At Visa, I was writing unit tests for a Next.js project using components designed with Chakra UI. That's where React Testing Library came in handy. Unlike other solutions like Enzyme, I did not have to worry about the application snapshot but could instead focus on each UI element, its expected behaviour and the data it would render upon user interactions.

Jest

In Jest, you usually split your tests into groups using the describe block. You can write a descriptive message as the title of the block to indicate what kind of tests you are including in this block. Similarly, each individual test case is written using the it or test wrapper, with a message to describe the individual test case.

The nice thing about Jest - which can also be a pain point when you actually get down to writing the tests - is that they execute in parallel rather than sequentially. You can force sequential execution by using the --runInBand parameter and this comes in handy sometimes while debugging issues related to timing. However, test suites are generally executed in parallel so that they run faster.

jest example.test.js --runInBand

With Jest, you write tests using the expect clauses, where you specify the matcher that you are expecting and compare it to the received output, to verify that the expected behaviour is satisfied.

You can specify the chunks of code you wish to execute before and after each test case using the beforeEach and afterEach clauses respectively. If you want to include some code before all the test cases are executed or after all the test cases are executed, you can use the beforeAll and afterAll clauses. These functions are very useful for consolidating all the common data setup as well as doing some cleanup.

Mocking is a useful feature in Jest that allows you to test the expected behaviour when an API call is made without actually calling the respective APIs. This is necessary for testing because calling the actual APIs can be costly, since these calls are subject to constraints like network bandwidth. These can also be used for simulating calls to third party dependencies, which are not supposed to be tested because they have been developed by others.

React Testing Library

These are the abstractions (functions) from the React Testing Library that I have used most for writing unit tests:

screen: The screen API allows you to access the HTML DOM, and print out either the entire DOM or a portion of it using the debug method. You can also retrieve element(s) by using the findBy*, queryBy* and getBy* functions. findBy* is an asynchronous function that allows you to fetch an HTML Element or an array of HTML Elements. queryBy*, on the other hand, allows you to fetch either as well as return null if they are not found. getBy* throws an error if the element(s) in question is not found. findAllBy*, queryAllBy* and getAllBy* are variants of the respective methods that let users retrieve an array of matching elements instead of a single element.
waitFor: waitFor allows you to execute a block of code and wait for it to finish before you move on to the other blocks of code in the test case.
render: render is used to render a React Component or Fragment as you would in a React application. This is basically a re-export of the original render function from the React library.
fireEvent: fireEvent allows you to handle trigger events on the different elements like input or select. An alternative is the userEvent library for simulating the user interactions.

Example of a unit test case

Let's say we build a login form using Chakra UI. We want to do very basic validations on the form data and check the logic flow once the submit button is called.

You only need to specify the respective test ids for the components while designing the front end. You can then match the values filled in with the expected values after carrying out the interactions. Here, the mock for the console object comes in handy to determine whether the statement is printed upon successful login or not.

Pain points:

While writing unit tests seems straightforward in theory, it requires a good amount of trial and error in practice.

These are some of the issues that I faced along the way:

1. Time out issues

If the tests involve a large set of UI interactions like filling in multiple fields in a form or handling multiple input events, they are likely to time out before the whole test case executes, or even in the waitFor block. A work around is using fakeTimers in jest and then runAllTimers once the component is rendered so that the test timer waits for the completion of the execution. Another way, is to use setTimeout and specify the timeout you are expecting.

The main problem is detecting the line(s) of test code responsible for the delay in test execution. For this, you have to usually resort to some trial and error with reordering the test cases in the suite or even the way you break the test cases into suites. You might also have to log the execution of the source code at several points to see whether the data obtained from a mock is the same one that the test was expecting at that point in time. The problem is compounded due to the asynchronous nature of execution of React code in hooks.

2. Test cases pass individually but fail when run in a suite

Honestly, this is a very frustrating problem to solve. The first easy step to troubleshoot this issue is to have all the shared data setup for the test cases in the beforeEach and afterEach clauses. However, it could also be that some of the tests have taken longer to execute than others and therefore, only part of the source code gets tested in a failing case. Resolving this issue involves significant trial and error similar to the timeout issue.

3. Element not found

Sometimes the element(s) you are looking for simply cannot be found. You would have to print out the whole DOM using debug and inspect why this is not found. It's an easy fix if the matcher specified in the expect clause is wrong, but it becomes quite troublesome if the element is not displayed because the state of the application has not been updated. This might require you to inspect the application flow more thoroughly. It's good if the test has helped you catch the bugs in code execution, since that is the main purpose behind software testing. However, it is also possible that your code is executing correctly but there is some other issue that results in this error, like a timeout issue.

How to start blogging

Aadit Kamat — Sat, 25 Jun 2022 13:35:54 +0000

Writing is a demanding activity. There is no right or wrong way to approach this task. In the end, it boils down to is being able to find your own grooves and patterns, but I thought of writing a post with some tips to help you get started.

Tip 1: Find a template

Nicholas Cole template

When you are writing a lot, it becomes difficult to start writing from a blank page each time. Having a template in place can help you structure your thoughts as you start writing your first draft. Nicholas Cole’s YouTube video for Prepping the Page includes a template that you may find useful in getting started.

Tip 2: Use a Pomodoro

Pomofocus

Pomodoros are great productivity tools that help you to keep track of the time spent on your tasks. Think of writing itself as a task that demands your undivided attention and don't rely solely on your willpower to reach the end.

You can start with one pomodoro and do a brain dump, either on a piece of paper or in an online document. The advantage of dumping the information in an online document is that you can easily transfer over bits and pieces for your first draft.

Tip 3: Outline before your draft

Outline of this blog post

I have written a couple of posts in prose form and edited them later on, but I find that this works better for a writing piece that relies less on structure, like a diary entry.

For any other kind of writing where you are trying to convey information to your audience, it’s better to create an outline, where you can get your points out first. A list-like format helps you keep track of all the information you want to include in your post.

Tip 4: Headings draw attention

When you have headings for your posts, readers can figure out what each section of the post is trying to convey and focus on the key points.

To see the difference that formatting can make, contrast a well-formatted post as opposed to those that reads like a long wall of text. You’ll find it much easier to comprehend information from the well formatted post.

The same logic applies to conveying information to other readers.

Tip 5: Draft first, edit later

Don’t worry about editing your outline or even the first draft. This includes fixing spelling and grammatical errors as well as changing sentence structure.

You should focus on drafting the post based on your outline first and leave the editing to the second phase of your writing. This separation of concern reduces the unnecessary time spent during the writing process.

Tip 6: Pictures speak a thousand words

Include pictures in your blog post that are relevant to what you are trying to say. This is a common technique used in Medium and Dev.to articles. The key though is to find a balance between using pictures to elucidate and removing additional distractions for your reader.

Tip 7: Practice writing more

The nice thing about blogging is that it does not have any prerequisites apart from reading and writing ability. One way to become a better writer is by reading more. However, at the end of the day, you need to hone your writing skill by practising it more often.

Additional References:

Ship 30 for 30: They have a lot of practical and actionable advice to get started. Apart enrolling in their cohort, you can also subscribe to their 10-day email course as well as their Mastery Monday, Roundup Wednesday and Fast-Track Friday email newsletters.
Neel: He started blogging more regularly as a part of month long challenge. Maybe this will inspire to start such a challenge yourself.
Nikolas Goeke: He has been writing for a long time. He provides insights on writing and other things he finds useful. He also runs a course called Write Like a Pro for getting others started with writing.

Is college essential for success?

Aadit Kamat — Sun, 08 Aug 2021 07:47:53 +0000

The learning experience in college experience is very different from the learning experience in schools. You have more flexibility to choose the courses related to your major as long as you meet the degree requirements.

Learning "hard" and "soft" skills

College is a fantastic place to not only learn hard skills related to your discipline, but also develop soft skills like communication, time management, team work and critical thinking ability that are critical for success not only within college but also later on in life.

Pursuing research

Colleges offer many avenues for students to discover their interests and follow career paths that align with those interests. One of the primary activities that colleges are renowned for is research. That is why, one of the major factors that decide the ranking of a college is research output. If your goal is to pursue a career in the academia, then college is the best path to achieve that goal. As a college student, you are able to get access to the resources you need for your research such as journals, research papers and books much more easily. It is also much easier to attain a research assistant position while you are in college than if you were to look for such positions in the industry.

Becoming an entrepreneur

You can also pursue entrepreneurship when you are in college. One of the ways to do so is to take up a minor in entrepreneurship. If that does not fit your schedule, you may want to take some elective entrepreneurship classes instead. The best way to get into entrepreneurship, however, is to work on your own project and secure funding to turn your idea into a startup. Thanks to incubators and startup accelerators supported by many of the universities, students can also get access to a network of professionals who have been involved in their own startup journeys. They can give the right kind of advice or the motivation for the students to become entrepreneurs.

Is college for everyone?

At the same time, there is some merit to the idea that college is not an absolute prerequisite for career success. There are fields where there are ample opportunities to self learn and you can in fact thrive better if you are an auto-didactic learner. For example, to pursue a career in programming, you don't really need to get a degree in Computing and IT related fields. However, getting a degree becomes necessary to virtue signal to employers that you have the required skills to do well in the job.

Even then, going to the college is still not a waste of your time and resources. You never know when the knowledge you gain through your courses proves to be useful in your career. This is the view shared by Naval, the co founder of AngelList who is also recognized as a thought leader, in a podcast episode that I've personally come to agree with: if you don't have a good idea about what you wish to do later in life, then college is your best bet. However, if you have more surety, you may want to look into alternate options that align better with your personal goals.

Advice to my younger self in college

Aadit Kamat — Sat, 17 Jul 2021 02:36:03 +0000

There comes a time after a student graduates where he reflects back upon his journey through the undergraduate days, usually right after his graduation. These are the four things that I wish I had known as an undergraduate student back in college.

1. Focus on personal development

First, I wish I hadn't gotten into the rat race to achieve stellar grades or bag prestigious internships at the top companies, just out of peer pressure. As the definition of success varies from individual to individual, it does not make too much sense to focus exclusively on these goals. I'd instead advise students to spend the extra time they get from attending classes to carry out personal development activities, especially those that they'd likely not get the time to work on once they start a full-time job.

2. Think long term

It is important to develop hobbies outside of work that you can derive a sense of purpose from or find enjoyment in, so that you can keep yourself buoyed up when the going gets tough in your full-time job.

3. Connect with your professors

Third, form meaningful relationships with your professors by connecting with them after classes. This will help you in the long run, as the professor is likely to refer you to opportunities that will benefit you from a career perspective or within the college to develop skills.

4. Take all advice with a pinch of salt

Last, but not the least, all advice given to others is from that individual's perspective. People will always have some regrets when they reflect back upon their college days. So take this advice with a pinch of salt and enjoy the college journey while you can!

My journey to becoming a developer

Aadit Kamat — Sun, 04 Jul 2021 07:48:10 +0000

I first started coding in 11th Standard when I took up a course on Computer Science, at the age of 16. I had learnt about HTML, CSS and a bit of JavaScript back when I was in 9th and 10th, but I hadn’t used it to create a website beyond the project that was assigned in the classroom, so that knowledge was rusty. Reflecting back on the experience in high school, I realise that I was more keen on learning other STEM subjects like Physics and Maths, so I didn’t spend much time learning about CS concepts beyond the classroom or researching about software in general. I’d also like to think that I had to spend a lot of time catching up with concepts taught at high school as it was a big jump from 10th to 11th.

After giving my board exams in 12th, I was required to enlist in SCDF on May 2015 as part of my National Service (NS) obligations. I had secured 96% in my board exams, which was good enough to secure an admission at the National University of Singapore (NUS). I had initially applied for a Bachelor of Engineering degree program in Electrical Engineering as I wanted to continue learning physics at a higher level and apply concepts I had learnt in Electrodynamics and Mechanics classes back at high school to solve real Engineering problems. Admittedly, my greatest source of inspiration was my dad, who had studied the same subject in college for his Bachelor’s and Master’s. However I had a change of mind after my discussion with my dad when I had passed out of recruit phase and was well settled into my new role as an Admin assistant at the National Service Training Institute (NSTI). Given my stellar results in the Computer Science subject and the rising demand for Computing professionals, my dad encouraged me to think of pursuing Computer Science at the NUS School of Computing. The admission criteria for getting into the School of Computing was more stringent as compared to the one to get into the Faculty of Engineering, but he said that it was worth a shot if I was truly interested. As I reconsidered my decision to apply to the Electrical Engineering course, I realised that I wasn’t sure if I really wanted to go into Engineering of my own accord or because my other peers were applying for Engineering courses as well. I didn’t know how Computer Science would turn out, but I decided to try something new and take the gamble of switching the course. To my fortune, I was accepted into the Computer Science course.

One of my regrets during my time in NS is that I did not try learning Computer Science concepts or practicing programming on my own over the weekends or after work. I assumed that I would learn more in depth in college anyways, so I didn’t need to spend the time doing that before college. I’d like to clarify here that one can learn programming in college and still succeed in the Computer Science course. However, I would have had a better time during the CS1010X (Programming Methodology) course that I had taken as I was completing my NS, had I spent more time refreshing the concepts I had learnt back in high school.

Even though CS1010X was an introductory course, it was much more rigorous as compared to my high school course. The Professor who administered the course swore by the “sink or swim” methodology used to teach such courses there. Of course, we were not left completely stranded and the Teaching Assistants as well as Prof himself were quite helpful when we ran into any issues. However, Prof made it amply clear that they weren’t running an “Apple Genius Bar” service to guide us through each small technical issue and we were expected to research solutions to our problems as far as we could. This would turn out to be quite useful later on, during the course and after I had completed it, as every developer has to go through the journey of interpreting stack traces as they debug their programs, often on platforms like Stack Overflow. It takes a lot of time to get proficient at the art of debugging and it also depends on your experience with the particular programming language and project in question, but it helps you learn and ramp up quickly. This is something that I think most beginners might miss out in the beginning if they continue to follow along with tutorials or watch them passively without working on programming exercises and projects that employ these skills.

I haven’t yet mastered coding and I do spend a lot of time trying to figure out why I am running into a particular issue even now after I have completed my undergraduate Computer Science course, but I think that all of this is a part of a learning process that never truly ends. I started writing this post as I was reading through Ali Spittel’s tips to beginners, as a way of reminding myself about how I started and what I can learn from my own journey that I can now apply to my work as a QA Engineer.