Forem: Viral Patel

Deliberate practice in software development

Viral Patel — Sat, 05 Sep 2020 00:00:00 +0000

What is Deliberate Practice (DP)?

Deliberate practice is common phenomenon in sports, arts and other industries. Athletes have a dedicated time each and every single working day for deliberate practice. It is same with musicians, actors, painters, singers, dancers. Actors dedicate some time perfecting dialogue delivery by deliberately practicing it for hours and hours. Singers tries to perfect their pitch by intentionally focusing only on a particular pitch while practicing. Dancers and sportsman and sportswoman practices a single move over and over and over again until it becomes natural as part of their natural reflection.Deliberate practice is nothing but an intentional practice. A time slot dedicated to focus on only one core unit of your craft and perfecting it until you understand and have knowledge of all possible aspect of the component that you are trying learn and practice.

Anders Ericsson, the psychology professor quoted above, coined the term deliberate practice (DP) to describe this special type of work. If you read Malcom Gladwell’s Outliers , you probably have an answer: the 10,000 hour rule. This concept, which was first introduced in academic circles in the early 1970s, was popularized by Gladwell in his 2008 book.To summarize in Anders Ericsson’s words

[A]ctivities designed, typically by a teacher, for the sole purpose of effectively improving specific aspects of an individual’s performance.

What is not Deliberate Practice?

Reading a book, watching tutorial videos, going through online courses or reading blogs are not part of “Deliberate Practice”. These are the resources for knowledge so as a knowledge worker, you definitely should be doing combination of things mentioned in a previous line to gain new knowledge, a new perspective or to clear your existing false assumptions, but, they do not account towards your 10,000 Hour rule. However, coding exercises, preparing notes by hand, trying to solve the same problem in many different ways, or, trying to solve many different problems from the same concept, all of this can account for deliberately practiced hours since all of these activities engages your brain in many ways and doing these over and over again will help you grasp the acquired knowledge in a long-term memory.

Resources

Read this amazing article by Cal Newport The Grandmaster in the Corner Office: What the Study of Chess Experts Teaches Us about Building a Remarkable Life

Git branch naming conventions

Viral Patel — Fri, 10 Apr 2020 00:00:00 +0000

As you have spent a couple of years in software or web development and if Git has become part of your work routine, this small tip of the day is going to help you optimize your workflow and increase productivity. The benefit of adopting this habit is long term and will add a lot of value.

There are only two hard things in Computer Science: cache invalidation and naming things.— Phil Karlton

As we have all struggled naming things whether it is variables, classes or even at times naming our projects is hard. I bet a lot of developers still struggle to name their git branches as well or do not put enough thought into naming them since they are not something that will come and bite us in the future but trust me even if they do not bite, it still leaves certain marks on our projects.

I have a convention that I follow myself to make it easy to find branches later in the future and identifying intention behind creating this branch just by looking at their name.

Feel free to modify this convention best to your workflow and the way your mental modal works and identifies words.

git checkout -b YOUR_INITIAL/TYPE_OF_WORK/JIRATICKETNUMBER-BRANCH-NAME

I know this might look a bit tedious to create branches with such long names but again the idea is to be able to interpret intention behind created branch just by looking at their name or you can even search with the pattern.

For example, I name my branches as,

vp/feature/124-create-login-page

This can help you a few months/years down the road to find the branches you’ve worked on easier either through Github UI shown in the screenshot,

OR by the command line

git branch --list | grep "vp/feature/"

git branch --list "vp/feature/*"

Summary

To break it down the convention,

YOUR_INITIAL/TYPE_OF_WORK/JIRATICKETNUMBER-BRANCH-NAME

YOUR_INITIAL: It can be anything you want, your first name, your GitHub username

TYPE_OF_WORK: It can be of any category i.e. feature, fix, refactor, task, prototype, throwaway

JIRATICKETNUMBER-BRANCH-NAME: You can have a JIRA ticket number or if you are not using a ticket-based system it can be MMYY timestamp format followed with the branch name.

I’d love to know what do you guys use for naming your branches and how do you optimize your workflow.

PS: Cover Photo by Yancy Min on Unsplash.

Tests are executable documentation

Viral Patel — Sat, 08 Feb 2020 00:00:00 +0000

A well-written test case tells a clear story, communicating the intent of code. Learn how to write expressive tests and why duplication isn't always a bad thing in your test cases. - phrase from ThoughtBot blog about TDD.

Well written Tests are always a source of truth for a living documentation for that perticular project. Other form of documentation such as git wikis, code comments, code commits, pull request descriptions, google doc, Slack comments can easily get out of the sync with the production code.

Well written Tests guides your example documentantion which can be used by the developers using your library. Developers of your library should never have to read your source code, code comments to figure out how to use your library. If you see yourself reading source code or code comments of other libraries you are using, it is an indication to you that the library does not have a well written test suite or example documentation to go through.

You should be revealing your intents through your tests. Developers using your library should never have to worry about how it is implemented. They should be able to use your library by reading your tests and examples only. We need to seperate the intent from the implementation.

Understanding MySQL Index Basics

Viral Patel — Wed, 11 Dec 2019 17:12:52 +0000

An index is an on-disk or in-memory structure associated with a table or view that speeds retrieval of rows from the table or view. An index contains keys built from one or more columns in the table or view. For on-disk indexes, these keys are stored in a structure (B-tree) that enabled the SQL server to find the row or rows associated with the key values quickly and efficiently.

An index stores data logically organized as a table with rows on columns, and physically stored in a row-wise data format called row-store, or stored in a column-wise data format called column-store.

The selection of the right indexes for a database and its workload is a complex balancing act between query speed and update cost. Narrow indexes, or indexes with few columns in the index key, require less disk space and maintenance overhead. Wide indexes, on the other hand, cover more queries. You may have to experiment with several different designs before finding the most efficient index. Indexes can be added, modified and dropped without affecting the database schema or application design. Therefore, you should not hesitate to experiment with different indexes.

row-store has been the traditional way to store relational table data.

Without an index, MySQL must begin with the first row and then read through the entire table to find the relevant rows.

The larger the table, the more these costs. If the table has an index for the columns in question, MySQL can quickly determine the position to seek to in the middle of the data file without having to look at all the data. This is much faster than reading every row sequentially.

Here is a sample command to add an index to the existing table

CREATE INDEX user_name_index ON user (name);

if using b-tree,

CREATE INDEX user_name_index ON user (name) USING BTREE;

This blog was originally published on my personal blog Viral Patel

Understanding React stateless components

Viral Patel — Wed, 11 Dec 2019 17:11:15 +0000

Since React v14, a simpler way was introduced to define stateless functional components. These components use plain Javascript functions. With React 16.6+, you can declare "pure" functional components via React.memo

The simplest way to define a stateless component is to write a Pure Javascript function.

function Welcome(props) {
  return <h1>Hello, {props.name}</h1>
}

Here's why React's stateless components are amazing,

Props are Read-Only

Whether you declare a component as a function or a class, it must never modify its own props. Consider the following function:

function sum(a, b) {
  return a + b
}

Here's an anti-pattern

function withdraw(account, amount) {
  account.total -= amount
}

No Class Needed

Plain functions are generally preferable over ES6 classes and eliminating the class-related cruft like extends and the constructor in the example above a nice win.

No this keyword

The entire component becomes easier to understand without the this keyword. All the annoying and confusing quirks with Javascript's this keyword can be avoided.

Dumping classes eliminates the need for calling bind to pass the this context around. Given how confusing Javascript's this keyword is to many developers, avoiding it is a nice win.

Enforced Best Practices

Stateless functional components are useful for dumb components. Presentational components focus on the UI rather than behavior so it's important to avoid using state in presentational components. Instead, the state should be managed by higher-level "container" components, or via state management libraries like Redux.

Stateless components don't support state or lifecycle methods. This is a good thing. Why? Because it protects from laziness. Stateless functional components programmatically enforce keeping the component pure. You're forced to put state management where it belongs: in higher-level container components.

Easy to Understand

When you see a stateless functional component, you know it's simply a function that takes props and spits out HTML. It's a pure function.

Easy to Test

Since it is a pure function, your assertions are very straightforward: Given these values for props, I expect it to return this markup.

Performance

Finally, stateless functional components offer improved performance as well. Since there are no state or lifecycle methods to worry about.

To consider downsides of using React's stateless components, visit this link

This blog was originally published on my personal blog Viral Patel

Setup aliases and shortcuts for git commands

Viral Patel — Wed, 11 Dec 2019 17:06:55 +0000

Here is how you setup aliases and shortcuts for git commands. Edit .gitconfig file in your $HOME directory.

[alias]
  co = checkout
  ci = commit
  st = status
  br = branch
  hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
  type = cat-file -t
  dump = cat-file -p

Refer to the branch you've checked out when you use git push and/or git pull

[push]
  default = current

Here are some more goodies in your aliases list. Thank me later 😎

[alias]
  # Adds and commits files with a single command
  add-commit = !git add -A && git commit

  # Delete all local branches but master and the current one, only if they are fully merged with master.
  br-delete-useless = "!f(){\git branch | grep -v "master" | grep -v ^* | xargs git branch -d;\}; f"

  # Delete all local branches but master and the current one.
  br-delete-useless-force = "!f(){\git branch | grep -v "master" | grep -v ^* | xargs git branch -D;\}; f"

This blog was originally published on my personal blog Viral Patel

Why use React Hooks? Explained

Viral Patel — Wed, 11 Dec 2019 15:34:13 +0000

Start with why?

If you want to use Hooks in React in your application. Make sure you update your react version to >=16.8 since it was introduced in React v16.8.

Before React Hooks was a feature in React the only way to use state in your component was to write your component as ES6 Class. Now, with React hooks you can use state and other React features without writing a class.

Click here to watch a youtube video from React Conf 2018

Completely opt-in

You can try Hooks in a few components without rewriting any existing code. But you don't have to learn or usee Hooks right now if you don't want to. It is 100% backwards-compatible.

Hooks don't replace your knowledge of React concepts

Hooks only is an alternative way to use React concepts you already know: props, state, context, refs, and lifecycle but without classes. Hooks allow you to reuse stateful logic without changing your component hierarchy

How do lifecycle methods correspond to Hooks?

Function components don't need a constructor. You can initialize the state in the useState call. If a computing the initial state is expensive, you can pass a function to useState.
Instead of using shouldComponentUpdate lifecycle, use React.memo
Hook called useEffect can express all combinations of all the standard lifecycles like componentDidMount, componentDidUpdate and componentWillUnmount
There are no hooks yet for handling exceptions in your component.

Next steps

Hope this article helps you understanding a motivation behind why Hooks were introduced but many details will be probably unclear. Click this link to deep dive into Hooks

This blog was originally published on my personal blog Viral Patel.

Docker Cleanup Commands

Viral Patel — Wed, 11 Dec 2019 15:18:01 +0000

If you see Docker claiming lot of space on your computer and if you want to reclaim all of your space back from Docker, use following Docker commands for cleanup. Make sure you are aware that this will delete images and containers from your machine, make sure you do not run this on production machines unless you know what you are doing 😎.

How to remove docker’s unused data?

docker system prune —force

To delete everything

docker system prune -a --volumes

How to delete all docker containers including its volumes use?

docker rm -vf $(docker ps -a -q)

How to delete all docker images?

docker rmi -f $(docker images -a -q)

These commands helped me to reclaim more than 10GB of data for only few months of work with Docker.

This blog was originally published on my personal blog Viral Patel.

How to dockerize a Rails application

Viral Patel — Wed, 11 Dec 2019 15:15:17 +0000

Introduction

Microservices architecture is a particular way of designing software applications so that it can be deployed independently, test independently, and scaled independently. Read What are microservices? to get more deep understanding about this particular architecture pattern.

One of the first few steps you as a developer or ops person can do to move towards microservices architecture is to start containerizing your applications.

If Rails is part of your stack, this blog will explain you how to dockerize your Rails application. This blog is not a docker tutorial, yet you will be instructed with some best practices with docker. With assumption that docker is installed on your system and you have a working rails application with PostgreSQL database. If you haven’t installed Docker already, download it from official docker website.

Create `Dockerfile` in the root folder of the project

Dockerfile describes all the steps that are required to create an image and would usually be contained within the root directory of the source code repository for your application.

# rails-app/
cd rails-app/
touch Dockerfile

First step of writing any Dockerfile is to choose the base image. We are going to use official ruby docker image but a slim version.

FROM ruby:2.6.3-slim

Applying labels to images and containers allows you to add metadata via key/value pairs that can later be used to search for and identify Docker images and containers. You can see the labels applied to any image using the docker inspect command.

LABEL "maintainer"="viral@fakemail.com"
LABEL "app_type"="backend"
LABEL "service_type"="API"

Maintainer is a deprecated field in the Dockerfile specification.

Docker runs all processes within the container as root but it is recommended to use USER instruction to potentially avoid any security risks. Production containers should almost always be run under the context of a non-privileged user.

USER root

One of the most important instruction ENV allows you to set shell environment variables that can be used by your running application for configuration and during the build process to simplify the Dockerfile.

ENV APP /usr/src/app
ENV RAIL_ENV development

Now, we are going to introduce RUN instruction. We will be using these commands to create the file structure you need, and install required software dependecies. You will also be able to use shell environment variables defined in the previous step. Let’s write few RUN instructions required for our rails application.

RUN mkdir -p $APP
RUN apt-get -y update && apt-get install -y --no-install-recommends \
    libgmp-dev \
      gcc make git \
    postgresql-client \
    dnsutils \
      libpq-dev libglib2.0-dev build-essential patch zlib1g-dev liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

First instruction creates an app directory and second instruction runs few commands and installs require software, a Postgres client into a single step.

Remember that every instruction creates a new Docker image layer, so it often makes sense to combine a few logically grouped commands onto a single line. It is even possible to use the ADD instruction in combination with the RUN instruction to copy a complex script to your image and then execute that script with only two commands in the Dockerfile.

Next instruction, WORKDIR, is use to change the working directory in the image for the remaining build instructions.

WORKDIR $APP

COPY instruction copies file from the host machine to your container image.

COPY Gemfile $APP/Gemfile
COPY Gemfile.lock $APP/Gemfile.lock
RUN gem install bundler -v 1.17.3
RUN bundle install
COPY . $APP

Install required gems from Gemfile. Remember we are in currently root folder of the app because of the WORKDIR instruction use.

This completes installing required dependency. Now we only need to boot up the application and expose the public endpoint so that public internet can access our application. Before we do that, it is important remove any unnecessary dependency to reduce our overall image size which eventually comes in handy when downloading and running applications.

RUN apt-get purge -y --auto-remove \
      gcc make git \
      libpq-dev libglib2.0-dev build-essential patch zlib1g-dev liblzma-dev \
        && rm -rf /var/lib/apt/lists/*

CMD instruction which defines the command that launches the process that you want to run within the container.

CMD [ "bundle", "exec", "puma", "-C", "config/puma.rb", "config.ru" ]

And finally we use EXPOSE instruction to expose application running process.

EXPOSE 3000

Here is your final Dockerfile looks like

FROM ruby:2.6.3-slim

LABEL “maintainer”=“viral@fakemail.com”
LABEL “app_type”=“backend”
LABEL “service_type”=“API”

USER root

ENV APP /usr/src/app
ENV RAIL_ENV development

RUN mkdir -p $APP
RUN apt-get -y update && apt-get install -y —no-install-recommends \
    libgmp-dev \
    gcc make git \
    postgresql-client \
    dnsutils \
    libpq-dev libglib2.0-dev build-essential patch zlib1g-dev liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

WORKDIR $APP

COPY Gemfile $APP/Gemfile
COPY Gemfile.lock $APP/Gemfile.lock
RUN gem install bundler -v 1.17.3
RUN bundle install
COPY . $APP

RUN apt-get purge -y —auto-remove \
      gcc make git \
      libpq-dev libglib2.0-dev build-essential patch zlib1g-dev liblzma-dev \
    && rm -rf /var/lib/apt/lists/*


CMD [ “bundle”, “exec”, “puma”, “-C”, “config/puma.rb”, “config.ru” ]

Build your docker image by running,

docker build -t user/repo_name:tag .

But wait, before you can run this docker image locally, make sure your database yaml file is configured properly.

# database.yaml
default: &default
  adapter: postgresql
  encoding: unicode
  host: db
  username: postgres
  password:
  # For details on connection pooling, see Rails configuration guide
  # https://guides.rubyonrails.org/configuring.html#database-pooling
  pool: <%= ENV.fetch(“RAILS_MAX_THREADS”) { 5 } %>

development:
  <<: *default
  database: rails_docker_blog_development

Now copy this docker-compose file to your root folder of the project. And run docker-compose up -d --build

version: ‘3’
services:
  db:
    image: postgres
    volumes:
      - ./tmp/db:/var/lib/postgresql/data
  web:
    build: .
    command: bash -c “rm -f tmp/pids/server.pid && bundle exec puma -C config/puma.rb config.ru”
    environment:
      - RAILS_ENV=development
    volumes:
      - .:/usr/src/app
    ports:
      - “3000:3000”
    depends_on:
      - db

Finally, you need to create the database. In another terminal, run:

docker-compose run web rake db:create

That’s it. Your app should now be running on port 3000 on your Docker daemon.

On Docker Desktop for Mac and Docker Desktop for Windows, go to http://localhost:3000 on a web browser to see the Rails Welcome.

If you are using Docker Machine , then docker-machine ip MACHINE_VM returns the Docker host IP address, to which you can append the port <Docker-Host-IP>:3000.

Optional Chaining in JavaScript

Viral Patel — Wed, 08 May 2019 00:00:00 +0000

Optional chaining enables capabilities for Javascript developers to perform a nil check on the objects before trying to access any object properties.

As an example:

this.props?.user?.email

Optional Chaining behaves similarly to Ruby’s pretzel(&) operator.

Check out the official babel documentation. Babel - Optional Chaining

Toggle NOT NULL constraint with Rails migration

Viral Patel — Wed, 08 May 2019 00:00:00 +0000

Take advantage of change_column_null to add or remove NOT NULL constraint on a column. The null flag indicates whether the value can be NULL.

To add the constraint (says column cannot be NULL):

change_column_null :users, :name, false

To remove the constraint (allows the column to be NULL):

change_column_null :users, :name, true

The method accepts an optional fourth argument to replace existing +NULL+s with some other value. Use that one when enabling the constraint if needed, since otherwise, those rows would not be valid.

Note: Please note the fourth argument does not set a column’s default.

Forem: Viral Patel

Deliberate practice in software development

What is Deliberate Practice (DP)?

What is not Deliberate Practice?

Resources

Git branch naming conventions

Summary

Tests are executable documentation

Understanding MySQL Index Basics

Here is a sample command to add an index to the existing table

Understanding React stateless components

Props are Read-Only

No Class Needed

No this keyword

Enforced Best Practices

Easy to Understand

Easy to Test

Performance

Setup aliases and shortcuts for git commands

Why use React Hooks? Explained

Start with why?

Completely opt-in

Hooks don't replace your knowledge of React concepts

How do lifecycle methods correspond to Hooks?

Next steps

Docker Cleanup Commands

How to remove docker’s unused data?

How to delete all docker containers including its volumes use?

How to delete all docker images?

How to dockerize a Rails application

Create Dockerfile in the root folder of the project

Optional Chaining in JavaScript

Toggle NOT NULL constraint with Rails migration

Create `Dockerfile` in the root folder of the project