Kiran Chauhan

સારા ભાષાંતરના ગુણ

February 06, 2024 — ગાંધીજી

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

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

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.

Day 2 - Lisp Learning

February 04, 2024 — lisp

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.

Day 1 - Lisp Learning

February 03, 2024 — 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")

Sails Tutorial — Chapter 2

January 19, 2024 — sails

Application is up and running at http://localhost:1337 but it throws a 404 error. Let’s fix it by adding a root route. To do so, first create a config folder and then routes.js file within config folder.

mkdir config
touch config/routes.js

Open the config/routes.js file and write the following code.

module.exports.routes = {};

It exports the routes object that will have all the routes of the application.

Go ahead define a root route or GET / as follows.

module.exports.routes = {
  'GET /': 'HomeController.index',
};

Meaning that when the root route (/) is requested, server run the index action (or method) from the HomeController. But, we don’t have controller and action.

Go ahead and create a folder with the name api. Within this api folder, create a folder with name controllers. In this folder, we’ll put all the application controllers.

mkdir api
mkdir api/controllers

Finally, within this controllers folder, create a file with the name HelloController.js. The name of the file should be the same as the controller name defined in routes.js file.

touch api/controllers/HomeController.js

Open the api/controllers/HomeController.js file and write the following code.

module.exports = {};

It exports the object that will have all the actions we are interested in calling from this controller.

Sails internally uses Express framework. So, the actions within the controller are essentially the callback function we usually write in Express for a given route with req and res (and next) parameters.

Let’s define an index as a named function that returns a sample JSON response.

module.exports = {
  index: (req, res) => {
    res.json({ message: 'Home page' });
  },
};

That’s it! Reload (or open) the http://localhost:1337 in the browser. You should now see a JSON response with the message { "message": "Home page" } instead of a 404 error page.

Express.js Code Reading

October 24, 2023 — express

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.

PostgreSQL Tutorial Pt. 1

October 22, 2023 — psql

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)

Sails Tutorial — Chapter 1

August 18, 2023 — sails

We are going to build the sample Sails.js or Sails application from the scratch with some unusual steps (for learning). We will end up with a small, functional CRM application.. Without further ado, let’s get started.

Create a folder with name crm.

mkdir crm

Go inside the created crm folder.

cd crm

Create a package.json file with defaults (-y).

npm init -y

Install the Sails framework (sails) as the dependency in this project.

npm i -E sails

Also install the Nodemon (nodemon) to restart the server on changes as development dependency (-D).

npm i  -E -D nodemon

Go ahead and create a new file with name app.js.

touch app.js

Open this created app.js file and write the following code.

const sails = require("sails");

sails.lift();

We first required the sails package and then called the .lift method. That’s it (in terms of code setup to use the Sails)!

Open package.json file and add two scripts — one to run app.js with node and second to run app.js with nodemon (I will add dev first and then start to write the scripts in alphabetic order).

{
  "name": "crm",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "dev": "nodemon app.js",
    "start": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sails": "1.5.7"
  },
  "devDependencies": {
    "nodemon": "3.0.1"
  }
}

Also, change the main file from index.js to app.js.

{
  "name": "crm",
  "version": "1.0.0",
  "description": "",
  "main": "app.js",
  "scripts": {
    "dev": "nodemon app.js",
    "start": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "sails": "1.5.7"
  },
  "devDependencies": {
    "nodemon": "3.0.1"
  }
}

In the terminal, run the dev script.

npm run dev

The application is running at http://localhost:1337. Open this URL in the browser and you should see ‘Not Found’ with 404 status code. This is obvious as we haven’t write any code for the root route. But, the important thing is you have the Sails application up and running with just two lines of code in app.js file. Rest of the things were setup!

Object Based Routing in Express.js

July 11, 2023

On the other day, I was looking over the source code of the Sails.js framework. Sails.js framework has a nice routing configuration based on the routes.js file. In this file, you can have the exported object in the following way.

module.exports = {
  'get /': 'HomeController.index',
  'get /pages/contact': 'PagesController.contact',
  'post /users': 'UsersController.create',
};

When the user visit GET /, the framework maps the HomeController.js file from the controllers folder and executes the index method or an action (as in terms of MVC). The key in the above object is HTTP (GET) verb, followed by a space, and then route(/) and the value (of the object key) is the file name without extension(HomeController) followed by dot(.) and then action name(index). Nice and clean mapping!

Sails.js framework is based on Express. In other words, the above code at the end should be converted into standard app.get(), app.post(), etc. methods. So, I thought about the possibility of adding this object-based routing in a simple Express application. Rest of the article is walk-through on how one can add. I do not yet recommend trying this in a production application.

Create a folder with the name routing-object. Go inside, and then create a package.json file to mark this folder as a package/module.

$ mkdir routing-object
$ cd routing-object
$ npm init -y

Install the Express(express) as the production dependency and Nodemon(nodemon) as the development dependency(-D).

$ npm i express
$ npm i -D nodemon

Nodemon is used in development mode to restart the server when we do the changes. Let's add the dev and start scripts in package.json file to run the application in development and production mode respectively.

{
  "name": "routing-object",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "dev": "nodemon app.js",
    "start": "node app.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "4.18.2"
  },
  "devDependencies": {
    "nodemon": "3.0.0"
  }
}

Finally, create an app.js file and write the following skeleton Express code.

const express = require("express");
const app = express();

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

We can easily run this application in development mode using dev script.

$ npm run dev
[nodemon] starting `node app.js`
Application is up and running on port 3000

With these changes, the base Express application is up and running.

Let's add three routes GET /, GET /pages/contact, and POST /users as mentioned in the object at starting of this article. I'll just return simple messages for all these routes.

const express = require("express");
const app = express();

app.get("/", (req, res) => {
  res.json({ message: "home page" });
});

app.get("/pages/contact", (req, res) => {
  res.json({ message: "contact us" });
});

app.post("/users", (req, res) => {
  res.json({ message: "user created" });
});

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

Test these routes in the browser and/or Insomnia.

With these changes, our application is now supporting the above-mentioned routes.

Now, we're going to do the changes in the application in such a way that it should not affect the output but the structure of the application.

Go ahead and create a routes.js file in the route folder.

$ touch routes.js

Open this file and copy the object mentioned in this article at the beginning.

module.exports = {
  "get /": "HomeController.index",
  "get /pages/contact": "PagesController.contact",
  "post /users": "UsersController.create",
};

The plan is when the user called POST /users, we should look for the file name UserController.js. Even further we'll look for this file in the controllers folder. So, let's create the controllers folder first in the root folder.

$ mkdir controllers

In this folder, based on the above routes object, we need to create three files - HomeController.js, PagesController.js, and UserController.js.

$ touch controllers/HomeController.js
$ touch controllers/PagesController.js
$ touch controllers/UsersController.js

HomeController.js should have the index method.

module.exports = {
  index: () => {

  },
};

When the user visit GET /, this index method ultimately runs. In other words, if we map the following code with the above code,

app.get("/", (req, res) => {
  res.json({ message: "home page" });
});

Then

(req, res) => {
  res.json({ message: "home page" });
}

should be within the index method in HomeController.js file as follow.

module.exports = {
  index: (req, res) => {
    res.json({ message: "home page" });
  }
}

Similarly, PagesController.js should have the contact method.

module.exports = {
  contact: (req, res) => {
    res.json({ message: "contact us" });
  }
}

And finally, the UsersController.js file should have the create method.

module.exports = {
  create: (req, res) => {
    res.json({ message: "user created" });
  },
};

With these changes, the routes are ready and the associated code is implemented. Next, we need to map these two.

In the app.js file, go ahead and remove three routes code as we have that code in other places.

const express = require("express");
const app = express();

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

To call the method from the files or controller's files, we need to first import these files. For this, we can use require-all npm package. This package requires all the files and makes them available for use to directly call. Go ahead stop the server and install this package.

$ npm i require-all

As mentioned in the documentation of this package, we can write the following code.

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

This controllers object now has reference to all the modules or files within controllers folder. To call index method from HomeController we can simply write

controllers.HomeController.index()

Let's use the require-all package in the app.js file and require all the controllers.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

With these changes, we just figure out what to do with the values of the routes object. Next, we need to fetch the routes from routes.js file and attach the respected method to each of the routes by loop through.

Let's simply require the routes.js file to fetch all the routes.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

We're going to use for...in loop to loop through the object.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

The route is the key and it contains two things - HTTP verb and route itself. We need to fetch both the details from route. To fetch the HTTP verb, we can simply use the RegEx as follow.

const verbExpr = /^(get|post|put|delete)\s+/;
const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;

The first line is the RegEx for four HTTP verbs and the second line check for the verbs and return and saved them into the verb variable.

Let's add these lines to our app.js file.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  const verbExpr = /^(get|post|put|delete)\s+/;
  const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

Next, we need to fetch the route itself. Fetching the route is as simple as replacing the verb with an empty string as whatever remains must be the route.

let path = route;
path = path.replace(verbExpr, "");

Instead of directly changing the route iterator, I used the intermediate path variable and saved the route in it.

Let's add these lines to our app.js file.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  const verbExpr = /^(get|post|put|delete)\s+/;
  const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;

  let path = route;
  path = path.replace(verbExpr, "");
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

We now have all the needed code but in de-composed mode.

Even though all the methods within controllers are available in the controllers object, we can not dynamically call them. We need to save the controllers and methods separately to call.

To save the controllers and method from object value, we can simply split by dot(.).

let location = routes[key];
location = location.split('.');
let controllerLocation = location[0];
let methodLocation = location[1];

The above code saves the value of the route object in location and we split it by dot(.). With this, we can have the controller in controllerLocation and the method in methodLocation variables in callable form.

Let's add these lines to our app.js file.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  const verbExpr = /^(get|post|put|delete)\s+/;
  const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;

  let path = route;
  path = path.replace(verbExpr, "");

  let location = routes[key];
  location = location.split('.');
  let controllerLocation = location[0];
  let methodLocation = location[1];
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

The exact callable form is within controllers object. So, let's fetch specific controllers and methods from the controller per route.

let controller = controllers[controllerLocation];
let method = controller[methodLocation];

Let's add these lines to our app.js file.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  const verbExpr = /^(get|post|put|delete)\s+/;
  const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;

  let path = route;
  path = path.replace(verbExpr, "");

  let location = routes[key];
  location = location.split('.');
  let controllerLocation = location[0];
  let methodLocation = location[1];

  let controller = controllers[controllerLocation];
  let method = controller[methodLocation];
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

With these changes, we now have the verb, route, and method to call.

The only code we now need to write is,

app[verb](path, method);

The above code attaches .get() or .post() method to app and the path and method as the argument to it.

Let's add these lines in our app.js file to complete the working Express application.

const express = require("express");
const app = express();

const controllers = require("require-all")({
  dirname: __dirname + "/controllers",
  filter: /(.+Controller)\.js$/
});

const routes = require("./config/routes");

for (let route in routes) {
  const verbExpr = /^(get|post|put|delete)\s+/;
  const verb = key.match(verbExpr || [])[key.match(verbExpr || []).length - 1] || null;

  let path = route;
  path = path.replace(verbExpr, "");

  let location = routes[key];
  location = location.split('.');
  let controllerLocation = location[0];
  let methodLocation = location[1];

  let controller = controllers[controllerLocation];
  let method = controller[methodLocation];

  app[verb](path, method);
}

app.listen(3000, () => {
  console.log("Application is up and running on port 3000");
});

Go ahead and re-run all three routes in the browser and/or Insomnia. You should see the identical output.

The above code is not complete. I intentionally left many scenarios and improvements. For example,

You can add all the HTTP verbs in verbExpr and even do case-insensitive matching.
You can place this code into a separate file.
You can have better names for the variables.
You can even implement your require-all package as this package is quite small as one file only.
You can add error checking as what if someone forgot to add. between controller and method name of added tab between HTTP verb and route instead of single space, etc.

Learning Rails Pt. 3

March 22, 2023 — rails

Continue from previous article, let's add one more route /about/company. You know the steps now to make this route working in Rails application.

First, add a route entry like this.

Rails.application.routes.draw do
  get "/about" => "about#index"
  get "/about/company" => "about#company"
end

Second, we already have the AboutController. So, we just now need to add company method.

class AboutController < ApplicationController
  def index
  end

  def company
  end
end

Finally, we already have about folder. So, we just need to create company.html.erb with following code inside this file.

<h1>About company</h1>

Visiting the /about/company should display this About company header in the browser.

Learning Rails Pt. 2

March 20, 2023 — rails

Open the http://localhost:3000/about in the web browser. Obviously, you get the No route matches [GET] "/about" error. Because, this route doesn't exist.

The routes for the Rails application are defined in config/routes.rb file. Open this routes.rb file in the text editor. You should see the following code.

Rails.application.routes.draw do
  # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html

  # Defines the root path route ("/")
  # root "articles#index"
end

Remove all the comments from this code.

Rails.application.routes.draw do
  
end

Add the /about route line like this.

Rails.application.routes.draw do
  get "/about" => "about#index"
end

This line means, when GET /about is called, run the about's index method. This about is a controller (or class) and index is an action (or method within class).

Reload the /about in the browser. You should now get uninitialized constant AboutController error. Because, we do not have AboutController in about_controller.rb file.

All the controllers for the Rails application are defined within app/controllers folder. In app/controllers, create a file with name about_controller.rb. Open this file in text editor and write the following code.

class AboutController < ApplicationController
end

We defined the AboutController controller that Rails is looking for. This controller is extended with helpful functionalities from ApplicationController controller provided by Rails.

Reload the /about in the browser again. You should now get The action 'index' could not be found for AboutController error. Because, AboutController does not have index action.

Let's define an empty index method in this controller like this.

class AboutController < ApplicationController
  def index
  end
end

Reload the /about in browser for one more time. You should now get No template for interactive request error. Because, we do not have index.html.erb template or view for the method to fulfil the request.

All the views for the Rails application are defined within app/views folder. Create a file with name index.html.erb in folder with name about inside the app/views folder. Here, we need to create about folder first and then index.html.erb file in this created about folder. Open this file in the text editor and write the following code.

<h1>About</h1>

Reload the /about in browser for the last time. You should see the About header in browser now.

In summary, Rails check for the routes in routes.rb file and run the associated action from given controller. Finally, with the help from associated view, request will be fulfilled.

Learning Rails Pt. 1

March 15, 2023 — rails

Go ahead and create a new Rails application using following command.

$ rails new hello-world

This will create a Rails application in hello-world folder.

Go inside the hello-world folder.

$ cd hello-world

Run the created Rails application using following command.

$ rails server

This command boots up the server at http://localhost:3000. Open this in web browser and you should see the Rails default welcome page. If that is the case, you just have created your very first web application using the Rails framework.

GTK4 Tutorial Pt. 4

March 09, 2023 — gtk, vala

Vala is the programming language but the interesting one. After compilation, it produces the C code and then this C code further fed to C compiler to get the final output.

Create a dump.vala file and write the following code. Nothing is new in this code and we already write this same code in previous articles.

public class Hello {
  public string name;

  public Hello(string name) {
    this.name = name;
  }

  public void greet() {
    stdout.printf("hello, %s\n", this.name);
  }
}

int main(string[] args) {
  string name = "world";
  Hello hello = new Hello(name);
  hello.greet();
  
  return 0;
}

Let's run this file using Vala compiler but with -C option.

valac -C dump.vala

This -C flag outputs the C code into the file with same name as the Vala file i.e. dump.c file. Open this dump.c file and you should see the following code.

/* dump.c generated by valac 0.56.3, the Vala compiler
 * generated from dump.vala, do not modify */

#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>


/* ... more core ...*/
/* ... more core ...*/
/* ... more core ...*/


int
main (int argc,
      char ** argv)
{
    return _vala_main (argv, argc);
}

You don't have to worry about this C code and even you don't need to know this C code produced by Vala compiler. I show this step to you to give some background information such as Vala use GLib Object and GLib libraries extensively as you can see from the header files of this C code. Some of the code and syntax you'll going to use in Vala depends on these libraries and C in general. So, don't be surprise!

Apart from this, even though Vala is general purpose programming language, it is mainly used to develop the GUI application for the GNU/Linux system using GTK library as it has tight integration with GTK library and the ecosystem. elementary OS extensively use the Vala language to build most of their applications including the Pantheon, their desktop environment.

Vala gives nice abstraction like higher level languages such as Java and C# to make desktop application using GTK which is written in C language. That being said, let's continue with Vala language and build the hello, world desktop application using GTK library (GTK4).

GTK4 Tutorial Pt. 3

March 05, 2023 — gtk, vala

In this article, we're going to do some structural changes in existing Hello.vala file that we created in previous article. Following is the code we currently have in the Hello.vala file.

public class Hello {
  public void greet(string name) {
    stdout.printf("hello, world\n");
  }

  public static int main(string[] args) {
    string name = "world";
    Hello hello = new Hello();
    hello.greet(name);
    
    return 0;
  }
}

I don't think that main() should be within the Hello class as main() has nothing to do with Hello class and we should follow separation of concern.

public class Hello {
  public void greet(string name) {
    stdout.printf("hello, world\n");
  }
}

public static int main(string[] args) {
  string name = "world";
  Hello hello = new Hello();
  hello.greet(name);
  
  return 0;
}

As main() is not part of the class, we don't have to worried about public and static.

public class Hello {
  public void greet(string name) {
    stdout.printf("hello, world\n");
  }
}

public static int main(string[] args) {
  string name = "world";
  Hello hello = new Hello();
  hello.greet(name);
  
  return 0;
}

Let's run this program and confirm the output. It should not effect the output as we did structural changes for refactor.

valac Hello.vala && ./Hello
hello, world

Yes, it is working!

Even further, I don't think we should have the main() method within Hello.vala file at all. Because, Hello.vala file should suppose to the Hello class and nothing else. main() method is a special method and we should have it in the main.vala file.

Let's create a new file with name main.vala and cut-paste the main() method from Hello.vala file to newly created main.vala file. After doing this modification, we should have the following code in the Hello.vala file.

public class Hello {
  public void greet(string name) {
    stdout.printf("hello, world\n");
  }
}

Following is the code we now should have in the main.vala file.

int main(string[] args) {
  string name = "world";
  Hello hello = new Hello();
  hello.greet(name);
  
  return 0;
}

With these modifications, you or our colleague can easily guess from the file name that Hello.vala should contains the Hello class code and main.vala should contains main() method.

We now have two files instead of one. We need to compile both files at the same time otherwise it'll generate errors. In such a case, the command to run two or more file is follow.

valac Hello.vala main.vala -o Hello && ./Hello
hello, world

Here, we've compiled both Hello.vala and main.vala files using valac compiler. After successful compilation it'll generate an object file (-o) or an executable with name Hello. You can give any name you like, but Hello make more sense here. Finally, we're ran the executable and it print the hello, world as expected output.

Before I complete this article, I would like to cover one more concept in Vala and that is constructor. We'll cover the constructor in more details in future articles. But, in this article, I want to give a glimpse of it.

Continue with the name variable in our hello, world example, instead of passing name variable while calling the greet() method, it make more sense to pass it while creating an object in main.vala in following way.

int main(string[] args) {
  string name = "world";
  Hello hello = new Hello(name);
  hello.greet();
}

Notice, I removed the name from greet() method call and now passed it while creating an object from the Hello class. Based on this, we need to do some changes in Hello class to accepts this modification.

First, let's define the class attribute or class variable with name name in the Hello.vala file.

public class Hello {
  public string name;

  public void greet() {
    stdout.printf("hello, %s\n", name);
  }
}

Next, let's define a method with name Hello() i.g. same name as the class name that accepts the name parameter with type of string. This is our constructor method and it'll accept the arguments passed while creating an object or instance of this class. We can assigned this passed argument to created class variable using this keyword.

public class Hello {
  public string name;

  public Hello(string name) {
    this.name = name;
  }

  public void greet() {
    stdout.printf("hello, %s\n", name);
  }
}

Finally, within greet() method, instead of name, we need to write this.name to access the set value of the name variable.

public class Hello {
  public string name;

  public Hello(string name) {
    this.name = name;
  }

  public void greet() {
    stdout.printf("hello, %s\n", this.name);
  }
}

Our program now is back in shape to print the hello, world in the terminal. But, this type we've used class constructor in Vala. Let's run the programs and confirm.

valac Hello.vala main.vala -o Hello && ./Hello
hello, world

Yeah. It is working!

I don't want to hold you more with this article. Enjoy rest of the day. See you in the next chapter after sometime. The plan is to do some re-structure in next article. I'll not introduce any new concept in the next article except will talk about bit of compilation pipeline in case you're interested.

GTK4 Tutorial Pt. 2

March 03, 2023 — gtk, vala

In this article, we're again going to write the hello, world program. But, this time with object-oriented paradigm. Create a new file with name Hello.vala (H is capital in file name) and open in your favorite text-editor.

Let's define a Hello class with class keyword. CamelCase is used to name the classes in Vala.

class Hello {

}

It is always good practice to use access modifiers with class while defining it such as public, protected, private, etc. I don't have any reason to hide this Hello class.

public class Hello {

}

Class can have many things inside it. But, it is important to have the main() method. Otherwise, our program wouldn't run! Let's add the minimal version of the hello, world program code we know from the previous section.

public class Hello {
  int main(string[] args) {
    stdout.printf("hello, world\n);
    
    return 0;
  }
}

But, this wouldn't work. Why? Because, method within class not run automatically. We need to either run by creating an instance of the class or mark it as static as class method. We'll going to mark this method as static.

public class Hello {
  static int main(string[] args) {
    stdout.printf("hello, world\n);
    
    return 0;
  }
}

As I said for the class, it is also good practice to define methods with access modifiers. In case of the main() method, it must be public otherwise you'll get the error.

public class Hello {
  public static int main(string[] args) {
    stdout.printf("hello, world\n);
    
    return 0;
  }
}

That's it! This is how you can write the hello, world program in Vala using object-oriented way. Let's run and confirm the output!

valac Hello.vala && ./Hello
hello, world

Yeah! The program work as expected.

Let's do the same modifications as we previously did after our hello, world program was written correctly. You're correct! We're going to define the greet() method within Hello class.

public class Hello {
  public void greet() {
    stdout.printf("hello, world\n");
  }

  public static int main(string[] args) {
    stdout.printf("hello, world\n);
    
    return 0;
  }
}

Like I said previously, to call this greet() method, we need to create an instance of class or an object using new operator.

public class Hello {
  public void greet() {
    stdout.printf("hello, world\n");
  }

  public static int main(string[] args) {
    Hello hello = new Hello();
    hello.greet();
    
    return 0;
  }
}

Running this program should print the same hello, world as the output.

valac Hello.vala && ./Hello
hello, world

Next, let's define a name variable with world as the initial value to print the same hello, world text like we did previously.

public class Hello {
  public void greet(string name) {
    stdout.printf("hello, world\n");
  }

  public static int main(string[] args) {
    string name = "world";
    Hello hello = new Hello();
    hello.greet(name);
    
    return 0;
  }
}

Again, running this program should print the same hello, world as the output.

valac Hello.vala && ./Hello
hello, world

With these changes for the hello, world program, let's take a break. We'll meet again in next article and do further modifications in this same hello, world program.

Home

Kiran Chauhan

સારા ભાષાંતરના ગુણ

The Law Of Complexity

Day 2 - Lisp Learning

Day 1 - Lisp Learning

Sails Tutorial — Chapter 2

Express.js Code Reading

PostgreSQL Tutorial Pt. 1

Sails Tutorial — Chapter 1

Object Based Routing in Express.js

Learning Rails Pt. 3

Learning Rails Pt. 2

Learning Rails Pt. 1

GTK4 Tutorial Pt. 4

GTK4 Tutorial Pt. 3

GTK4 Tutorial Pt. 2

વર્ગીકૃત // Labels

કડીઓ // Links

જોયેલ // Views