Kiran Chauhan

I'm migrating this blog to chauhankiran.pages.dev. This chauhankiran.blogspot.com blog is created in a first-generation blog theme that I highly customized. I want to customize more. But, I'm not getting any help on it. Also, I'm unable to find the documentation on first-generation themes. Current theme is too complicated for me! I remember copying one widget of 12-15 lines of code and expanding it into a couple of hundred lines of code is complicated for me.

Although, chauhankiran.pages.dev looks the same as this one, it is created in Jekyll and the theme is customized to retain the curren look-and-feel. The repo. is hosted on GitHub and deployed on CloudFlare pages.

I'm slowly migrating these articles. I do not plan to delete this current blogspot. But, the new content will be posted there!

I suggest PostgreSQL when someone asks for the recommendation on what database one should use. I use PostgreSQL when I am learning or building something in a new web framework or library. I use PostgreSQL when I want to experiment with databases. PostgreSQL is the default choice for me in most of the cases.

Every few months, I change the operating system from one GNU/Linux distro to another mostly staying with the land of Debian (e.g. apt). Most of the time, I just need to run the following command to install PostgreSQL.

apt install postgresql

This command install and activates the PostgreSQL server locally on my computer. I use the psql command tool to work with this database server.

Following are the commands I use to work with PostgreSQL.

sudo -i -u postgres
psql

Although technically it is not correct, I read the first command as sudo imagine user as postgres to provide access. After entering the password, the user changes from the current logged-in user to postgres and then I can directly work with PostgreSQL using the second psql command.

We can combine the above two commands into a single one as follows.

sudo -iu postgres psql

Again, technically it is not correct, but I read it as sudo imagine users as postgres and then launch psql directly.

The first thing I normally do after connecting with PostgreSQL is to change the password. This is trivial as running the following command.

password \postgres

We are changing the password for the postgres user. After running this command, PostgreSQL asks you to enter and re-enter a new password for the postgres user. And then you are ready to go!

If somehow, you are facing difficulties installing PostgreSQL on your computer, installing via Docker is yet another option. At some convenient place, save the docker-compose.yml file with following content.

version: '3'

services:
  db:
    image: postgres
    restart: always
    ports:
      - '5432:5432'
    environment:
      POSTGRES_PASSWORD: pq2q4a

You can choose any other password you like instead of pq2q4a!

Once done, run the following command in the terminal where you have this docker-compose.yml file.

docker-compose up -d

This will run the docker-compose.yml file and up the PostgreSQL service in detached mode. Meaning that it'll run the PostgreSQL service in the background once the docker is running. When you start the computer, if Docker is not running, you just need to run the docker and it'll auto run the PostgreSQL service for you.

Labels: postgres

આમ જોવા જઈએ તો "લેખક" આવે પણ અહીં "કરનાર" લખ્યું છે. પણ, એ વધુ બંધ બેસે છે કે, પ્રવાસ કરનાર કરસનદાસ મુલજી.

એક મિત્ર એ કીધું એ પણ ખરું કે પહેલાના લોકો પ્રેક્ટિકલ હતા.

Labels: કરસનદાસ મૂળજી

 Create a folder with name of the project e.g. project-name.

$ mkdir project-name

Go inside the created project-name folder.

$ cd project-name

Create a module or mod file using following command.

$ go mod init project-name

This command will create go.mod file. This file is the manifest file of the project that contains info of your project such as project name, Go version, dependencies of the project and so on. Following is the content as of now we’ve in this go.mod file.

module go-example 

go 1.21.5

We don’t have any dependency related information in this file yet. Because, our project yet not consuming any third-party package.

Create a file with name main.go and write following code in it.

package main

import "net/http"

import "github.com/gin-gonic/gin"

func main() {

  r := gin.Default()

  r.GET("/", func (c *gin.Context) {

    c.JSON(http.StatusOK, gin.H{

      "message": "hello, world",

    })

  })

  r.Run()

}

Labels: go

સારા ભાષાંતરમાં નીચેના ગુણ હોવા જોઈએ:

• એ જાણે સ્વભાષામાં જ વિચારાયું અને લખાયું છે તેવું સહજ અને સરળ હોવુ જોઈએ. જે ભાષામાંથી ઉતારાયું હોયતે ભાષાના રૂઢીપ્રયોગો અને શબ્દોના વિશેષ અર્થો ન જાણનાર એને સમજી ન શકે એવું તે ન હોવું જોઈએ.
• ભાષાંતરકારે જાણે મૂળ પુસ્તકને પી જઈને તથા પચાવીને એને ફરીથી સ્વભાષામાં ઉપજાવ્યું હોય તેવી કૃતિ લાગવી જોઇએ.
• આથી સ્વતંત્ર પુસ્તક કરતા ભાષાંતર કરવાનું કામ હંમેશા સહેલુ નથી હોતું. મૂળ લેખક સાથે જે પૂરેપૂરો સમભાવી અને એકરસ થઈ શકે નહીં અને તેના મનોગતને પકડી લે નહીં, તેણે તેનું ભાષાંતર ન કરવું જોઈએ.
• ભાષાંતર કરવામાં જુદી જુદી જાતનો વિવેક રાખવો જોઈએ. કેટલાંક પુસ્તકોનું અક્ષરશઃ ભાષાંતર કરવું આવશ્યક ગણાય, કેટલાંકનો માત્ર સાર આપી દેવો બસ ગણાય તો કેટલાંક પુસ્તકોનાં ભાષાંતર સ્વ સમાજને સમજાય એ રીતે વેશાંતર કરીને જ આપવાં જોઈએ. કેટલાંક પુસ્તકો તે ભાષાના ઉત્કૃષ્ટ હોવા છતાં પોતાનો સમાજ અતિશય જુદા પ્રકારનો હોવાથી તેના ભાષાંતરની સ્વભાષામાં જરૂર જ ન હોય; અને કેટલાંક પુસ્તકોના અક્ષરશઃ ભાષાંતર ઉપરાંત સારરૂપ ભાષાંતરની પણ જરૂર ગણાય.

Labels: અનુવાદ, મોહનદાસ કરમચંદ ગાંધી

Complexity never eliminate,
it just move from one place to another.

When you're not writing middleware to log requests, someone else wrote or is writing middleware for you. If you think that you can easily write a single page application in a given framework or library then understand that it depends on 1000+ modules to make it easy and the complexity is divided between these 1000+ modules but not eliminated.
 

Labels: random

Going forward with learning, defvar is used to define variables. Continue with last program written in hello.lisp. Here is how I've defined the hello, world program again with variable.

(defvar greetings "hello, world")

(format t greetings)

I read many places that variables are defined with star(*) around it to mark as global variable and * is valid character to define a variable.

(defvar *greetings* "hello, world")

(format t *greetings*)

Not just * but hyphen(-) can be used to define multi-words variables and this is recommended instead of camelCase or snake_case.

(defvar hello-world "hello, world")

(format t hello-world)

Frankly speaking I haven't seen a program like above anywhere else (defining a variable and then using it in next line without context). May be in functional programming, most of the variables are bound to the scope and only defined where needed.

But, defvar is used to define the variable in Common Lisp.

Labels: lisp

In my free time (which I have very less), I'm learning Lisp programming language. After doing some search, I decided to go with Common Lisp and installed sbcl.

Unless you're using Emacs, do not write multiple lines of code in REPL (in Terminal). Most of the terminals don't support paren auto-closing and highlight. Due to this, you might frustrate.

I'm using GNU/Linux machine. Following command help me to install the sbcl on my computer.

sudo apt install sbcl

After installation, check for the version and you can confirm the installation.

sbcl --version

Write only sbcl and it'll open the true REPL for you. In order quit or exit the REPL you need to write (quit).

You can directly write 10 or "hello, world" (use double quotes) as these are the literal values.

* 10
10
* "hello, world"
"hello, world"

If you try to write 10 as (10) or "hello, world" as ("hello, world") you'll get errors. Because, in simple terms, after open paren, Lisp expect to have something that can execute. For example, (+ 3 4) works as + will execute on 3 and 4 values.

Here is the hello, world in Common Lisp.

* (format t "hello, world")

Here, format print on terminal (actually it is standard output) "hello, world" string. You can write code within file that can have .lisp extension. Then you can run it as,

sbcl --script hello.lisp

or Open sbcl REPL and load the file.

sbcl
* (load "hello.lisp")
 

Labels: lisp

Following are the list of the points that I find interesting while reading Express code (I'm still reading the source code).

• Express 4.x support Node v0.10. Due to this, code is not written in ES6.
• 'use strict' increase the performance.
• When you write app.set('view engine', 'something'), Express will check something module in node_modules and load it. EJS use this trick and due to this, you just have write this line only. Even you don't have to import ejs (or something in example).
• All the repos under Express org on GitHub has either index.js if the package is consist of only one file or the package code is within lib folder.

In progress. I'll add more points as I learn more.

Labels: express

Run the following command in the terminal.

$ sudo -i -u postgres

This command is used to open a shell session as the user "postgres" with an environment set up as if "postgres" had logged in directly. This is often useful when you need to perform administrative tasks or run commands specific to the PostgreSQL database system, which typically runs with a dedicated user account for security reasons.

Now, write psql command in terminal to open the command-line interface to PostgreSQL.

$ psql

We now have the PostgreSQL open in our terminal.

To fetch the all database, following command is used.

$ \l
                                    List of databases
          Name           |  Owner   | Encoding | Collate | Ctype |   Access privileges   
-------------------------+----------+----------+---------+-------+-----------------------
 abc_development         | postgres | UTF8     | en_IN   | en_IN | 
 exp_development         | postgres | UTF8     | en_IN   | en_IN | 
 postgres                | postgres | UTF8     | en_IN   | en_IN | 
 template0               | postgres | UTF8     | en_IN   | en_IN | =c/postgres          +
                         |          |          |         |       | postgres=CTc/postgres
 template1               | postgres | UTF8     | en_IN   | en_IN | =c/postgres          +
                         |          |          |         |       | postgres=CTc/postgres
(7 rows)

To connect with specific database, use \c followed by the database name.

$ \c abc_development
You are now connected to database "abc_development" as user "postgres".

We're now connected with the abc_development database.

To list all the tables within given database, following command is used.

$ \dt
Did not find any relations.

We get the message "Did not find any relations." meaning that no table exists as of now in this database.

We can create the table using following command (do not run this command yet).

create table products (
  id int primary key,
  name varchar(256) not null 
);

We're trying to add id as primary key and name as the another string column. But, this query has one problem - id is not auto increment for us by default. To have it that feature, we need to defined it as serial than int like this (now you can run this command).

create table products (
  id serial primary key,
  name varchar(256) not null 
);

With this the products table is created.

Let's write a simple insert query to confirm the usage of the table.

insert into products (name) values ('Neem plant');

Finally, let's confirm that the product is added successfully in table by writing the select query.

select * from products;
 id |     name     
----+--------------
  1 | Neem plant
(1 row)

Labels: psql