DEV Community: Naveen

Silence the makefile recipes

Naveen — Sat, 28 Mar 2026 15:21:41 +0000

Makefile is made up of recipes. Running a recipe in make, prints the recipe and also the output of every command in the recipe. Recipe can be implemented by re-directing the output to /dev/null device. But this approach has a problem. Sometimes, I wanted to read the output of the command and not be re-directed to /dev/null, especially during troubleshooting. In this situation, there is no other way but to change implementation of recipe to remove the redirection.

Makefile has a switch -s to silence the printing of the recipe during execution. I wanted to use this switch to decide for redirection.

ifneq ($(findstring s,$(filter-out --%,$(MAKEFLAGS))),)
  .REDIRECT = >/dev/null 2>&1
else
  .REDIRECT =
endif

test:
    which scala $(.REDIRECT) || printf "scala is not present."

Now, make test prints the recipe and output of the which command. But make test -s completely silences the recipe execution.

Makefile provides a way to silence the echoing of recipes but the implementation of recipe, as in this case, uses conditional redirection to silence the output of commands in the recipe.

This approach, now, becomes less noisy until recipe requires to be debugged.

Curl on FTP

Naveen — Wed, 03 Apr 2024 12:32:37 +0000

cURL for FTP

cUrl is a terminal based client for data exchange over URL syntax.

I knew this definition about curl and I was usually using curl against http endpoints with a several combination of options. There was a time at work where I had to troubleshoot an issue in production and logs were shared over an ftp server path. Little did I know that this little tool would just work with ftp endpoints as well. So, here are some of the combinations I used curl to work on ftp endpoints. These are just starting points to give quick start and there are many more scenarios as well.

Directory listing

Straight forward. Just remember that the directory to be listed would be the home directory of the authenticated user. Output would be list of all files & directories in the home directory of the authenticated user. While trying out listing, try using --list-only to only return the name of remote objects.

curl "ftp://<ftp-host>:21" --user <ftp-user-id>:<ftp-user-password>

Upload a local file to remote

Option --upload-file or -T, in short, is used to upload files.

curl --upload-file ./<local-filename> "ftp://<ftp-host>:21/<remote-filename>" --user <ftp-user-id>:<ftp-user-password>

Download a remote file to local

Option --output or -o (lowercase) is used to collect the content from the remote stream.

curl "ftp://<ftp-host>:21/<remote-name>" -o ./<local-filename>  --user <ftp-user-id>:<ftp-user-password>

Additional point to remember is to consider -O (uppercase) when the file has to be downloaded with the same name as in remote.

Deleting a remote file

Recollect that use of -X option used to set the method name like GET, PUT, POST, DELETE against http endpoints. It is because http server had commands named like DELETE. In similar lines, FTP server has a command DELE <file-to-delete> to purge the given file.

curl "ftp://<ftp-server>:21" -X "DELE remote-file"  --user <ftp-user-id>:<ftp-user-password> -v

Suggestions

Use the option -v for debugging. There is a lot to understand out of the request and response once this debugging switch is enabled.
FTP server I used was not over ssl. In case, the remote FTP server is over ssl, use the switch --ftp-ssl.

That's it !

But yes, there are a lot more scenarios like traversing directory tree, purging a directory, handling binary content. But then the idea is that curl works well on ftp protocols. That makes it easy to script. Then there is no need of a dedicated application for working on FTP requests/responses.

Self signed certificate

Naveen — Wed, 03 Apr 2024 12:30:28 +0000

What is a certificate?

Certificate represents an identity of any entity. An entity could be a person, host, application. In real world, I relate passport to a certificate. A passport is valid only when a passport issuing authority approves a passport request. This is a valid passport because passport issuing authority is trusted. With a trusted authority issuing a passport, this passport becomes an identity of the requesting entity, a certificate. Of course, authority requires a fees to be paid to validate the passport request before issuing one.

What is a self signed certificate?

In cryptography and computer security, self-signed certificates are public key certificates that their users issue on their own behalf, as opposed to a certificate authority (CA) issuing them.

[ do not try this at home :-) ] Issuing your passport by your own self is a typical example I relate self signed certificate with. No authority is going to accept a self issued passport. Consider yourself spared if you even tried and not face legal issues. Issuing your own passport has no valid use case in real world. But a self signed certificate has a few use cases like it can be used in application development phase, no signing authority (CA) is involved - so no wait time on the authority to certificate approved and no cost involved.

Never use a self signed certificate in a production system.

How to create self signed certificate?

There are tools available to create self signed certificate - keytool and openssl are popular ones. In this blog, I will use keytool which is provided with jdk. openssl can also be used but the steps would be different. I will assume that I have a web application hosted in my local machine. This application should be serving HTTP requests over ssl - HTTPS. Let's create a self signed certificate by running the following command.

keytool -storetype pkcs12 -keystore sks.p12 -storepass manage \
-alias server_key_rsa -keyalg rsa \
-genkeypair \
-dname "CN=is, OU=rnd, O=sag, L=ba, ST=ka, C=in" \
-ext ku=digitalsignature,keyencipherment,dataencipherment,keycertsign \
-ext bc=ca:true \
-ext san=dns:localhost

Explanation of the options used.

Option	Description
-storetype pkcs12	Defines type of the keystore. Either pkcs12 or jks.
- keystore sks.p12	Defines name of keystore file. Ex: sks.p12. Keystore file could be any name. A new file is created if one mentioned is not present.
-storepass manage	Defines the password for the store.
-keyalg rsa	Defines the algorithm to create the keypair.
-alias server_key_rsa	Defines an alias for the keypair in a keystore. A keystore can have many key pairs, each of them uniquely identified by an alias. Ex: server_key_rsa.
-genkeypair	Command to create keypair.
-dname "CN=is, OU=rnd, O=gas, L=ba, ST=ka, C=in"	Defines distinguished name for the entity.
-ext ku=digitalsignature,dataencipherment,keycertsign	For a self signed certificate, key usage (ku) should have keycertsign and digitalsignature as the primary generated by the entity will be used to sign its own public certificate.
-ext bc=ca:true	Defines certificate entity as ca.
-ext san=dns:localhost	Defines server name as localhost. It is also possible to localhost in CN and clients could accept but it is more clear to define the dns as localhost to be explicit while the name of application can be used in CN.

Now, we have a keystore (sks.p12) with a keypair identified by alias 'server_key_rsa'. This keystore should be configured in java server application to server HTTP over ssl. I wont be getting into how to configure keystore in java application to server HTTPS.

Extracting self signed cert

Let's assume application is serving HTTPS on port 5443. I use curl and httpie. On firing curl https://localhost:5443, there is an ssl error.

Curl connected to https port. Server sent the certificate, a self signed one which curl does not trust simply because there is no issuing authority involved.

Fixing the client to accommodate self signed certificate

I know that the server is using a self signed certificate and this is not a production system. So, I want the client to work with it. That leaves two options.

Ignore ssl verification

curl	httpie

curl https://localhost:5443 --insecure

|

http https://localhost:5443 --verify no

Get the server certificate which was prepared with -ext bc=ca:true to be used as a mocked ca cert.

Refresh the keystore command we used to create the keypair. The alias we use is server_key and we need a server certificate. Use the below command to extract the server certificate.

keytool -export -rfc -keystore sks.p12 -alias server_key_rsa --storepass manage -file server_key_rsa_ca.pem

Most of the command options, by now, are already defined are familiar. Option -rfc defines the format of the certificate to be rfc format. Now, server certificate is exported to a file server_key_rsa_ca.pem. Feel free to try out keytool -printcert -file server_key_rsa_ca.pem to view the content of certificate.

curl	httpie

curl https://localhost:5443 --cacert server_key_rsa_ca.pem

|

http https://localhost:5443 --verify server_key_rsa_ca.pem

Now, the self signed certificate sent by the server is validated against the server certificate and request passes through.

This is how I got self signed certificate created, configured and used it in the client to test.

I put this blog up as I went through a lot of articles to get the self signed working with server and client by accepting the certificate. While this is a reference to the future me, I hope this article helped you as well.

Now, leave your experience with self signed certificate for me to learn !!

Type Class

Naveen — Wed, 03 Apr 2024 12:26:15 +0000

Type class is an abstract, parameterized type used to extend the behavior of a closed type without sub-typing it.

Overview

Suppose, we want to represent an instance of a particular type in its string format. The built-in toString is not always useful and is a typical example to understand type class. There are 2 steps to creating a type class

Implement a type class
Implement type class instances of concrete types.

Once the instance is created, there are different approaches to using the instance with slight variations.

Implement a type class

Let's define a type class to define the method to return a string of the type instance.

trait Show[T] {
  def show(t: T): String
}

A type class is a trait. It is parameterized on a type and defines a behavior. The behavior in Show is the method show(t: T). This becomes the template to apply to those types that require.

Implement concrete type class

Let us assume, Domain type must be Showable. We implement Show[Domain] and create a type class instance.

case class Department(name: String)
class ShowDepartment extends Show[Department] {
  override def show(d: Department) = d.name
}
implicit val showDepartmentInstance = new ShowDepartment

Type class instance showDomain need not be implicit to be a type class instance! This is covered in the usage of the instance. That's it. We have implemented a concrete type class and created a type class instance.

Usage

Different use cases and convenience required in usage lead to multiple approaches that the type class and its implementation evolve with additional methods. There are two types of using the implementation of concrete type class. They are classified as instance type and syntax type.

Instance type

We have an instance of type class created and it could be explicitly used by direct reference. This makes the call site tightly coupled to the type which is probably never a requirement.

def show(a: Domain): String = showDepartmentInstance.show(a)

Let's make the call site polymorphic on the type.

def show[A](a: A)(implicit ii: Show[A]): String  = ii.show(a)

Now the call site is polymorphic on type. The type class instance to be used depends on the type. Hence, the instance is marked implicit. This means a type of Show[A] must be present in the implicit scope. This is the reason the type class instance showDomain is marked implicit for the call site to work with Department.

Sugared usage

Call site still uses an implicit reference to type class instance and can it be eliminated? Being so, the call site becomes concise. The conciseness is in the idea that there is no reference to type class instance in the snippet. Call site is completely expressed as the name of type class and the behavior required.

def show[A: Show](a: A): String = ???

The semantic show[A: Show] is referred to as the context-bound type. So, it is read as the call site method show is polymorphic on A provided the Show is bound to A.

In a context-bound call site of a type class instance, there is no direct reference to a type class instance. So, we use implicitly[_].

def show[A: Show](a: A): String = implicitly[Show[A]].show

The design of the type class has forced the call site to implicitly resolve the type class instance whether it is sugared or the de-sugared form. This can be improved by a companion for the type class which summons the implicit instance of the type class.

// companion for the type class `Show`
object Show {
  def apply[T](implicit instance: Show[T]) = instance
}
// call site
def show[A: Show](a: A) = Show[A].show(a)

Companion object only summons an implicit instance. It does not create one. The complete implementation looks this way

// type class
trait Show[A] {
  def show(a: A): String
}
object Show {
  // summons an implicit instance
  def apply[A](a: A)(implicit i: Show[A]) = i
}

case class Department(name: String)
object Department {
  // creation of implicit instance
  implicit val showDepartmentInstance = new Show[Department] {
    override def show(d: Department) = d.name
  }
}

// call site #1 with implicit parameters defined
def show_v1[A](a: A)(implicit ii: Show[A]) = ii.show(a)
// call site #2 with context bound implicit instance
def show_v2[A: Show](a: A) = Show[A].show(a)

// test
val d = Department("Engineering")
show_v1(d) // String: Engineering
show_v2(d) // String: Engineering

The problem statement could further be extended but the solution pattern is already simplified. In the current domain model, let's suppose there is a Student belonging Department.

case class Student(name: String, department: Department)
object Student {
  // create implicit instance
  implicit val showStudentInstance = new Show[Student] {
    override def show(s: Student) = 
      s"${s.name}, ${Show[Department].show(s.department)}"
  }
}

// test
val s = Student("Martin", Domain("Engineering"))
show_v1(s) // String: "Martin, Engineering"
show_v2(s) // String: "Martin, Engineering"

Student has an instance of Department. So, the show() of the Student requires the show() of the Department. Since there is one in the implicit scope already, it only needs to be summoned. Hence, Show[Department].

However, we notice a redundancy in the way type class instances are getting created. The core difference lies only in the function by which a given instance of Department or Student would be transformed to String. The rest of it is all boilerplate.

  // from Department
  implicit val showDepartment = new Show[Department] {
    override def show(d: Department) = d.name
  }
  // from Student
  implicit val showStudentInstance = new Show[Student] {
    override def show(s: Student) = 
      s"${s.name}, ${Show[Department].show(s.department)}"
  }

This can be solved by enhancing the companion object of Show with a helper method to create instances given a required function. It is just a helper function to create instances but the instances get created when this helper function is called.

trait Show[A] {
  def show(a: A): String
}
object Show {
  // summons the instance
  def apply[A](implicit inst: Show[A]) = inst

  // helper: to create type class instance.
  def instance[A](f: A => String) = new Show[A] {
    override def show(a: A): String = f(a)
  }
}
case class Department(name: String)
object Department {
  // instance creation
  implicit val showDepartmentInstance = Show.instance[Department](d => d.name)
}
case class Student(name: String, department: Department)
object Department {
  implicit val showStudentInstance = Show.instance[Student](s => s"${s.name]} from ${Show[Department].show(s.department)}")
}

All the boilerplate code to create an instance is now replaced by a function.

It appears to be a lengthy topic about type class with instance type of usage but the definition of type class and its concrete implementation define the type class behavior. The rest of it is the evolution of the companion object Show from not existing in the bare-bone implementation of type class to a flavor with helpers to create and summon the type class instance.

Syntax type

With the syntax type, we can improve the type class usage with the possibility of calling the show() on the given object as if it were defined on the object itself. This is called the extension method. This is achieved by having an implicit class wrapping over the instance of type T.

implicit class ShowOps[A](a: A) {
  def show(implicit instance: Show[A]): String = instance.show(a)
}

case class Department(name: String)
val enggDep = Department("Engineering")
enggDep.show // String: "Engineering"

There is no show() on Department yet, with the syntactic usage of a type class, the method appears to be on the Deparment. The method show() could have been given any other name as well. It is an arbitrary method name but show() makes sense in this case. This is re-written as (new ShowOps[Department](enggDep)).show(showDomainInstance) by the compiler. In this implementation of ShowOps, it is only the method show constraint by the type. An alternate implementation is to enforce the constraint at the class level.

implicit class ShowOps[A: Show](a: A) {
  def show(): String = Show[A].show(a) 
}
case class Department(name: String)
val enggDep = Department("Engineering")
enggDep.show

I prefer enforcing the constraint at the lowest unit of work which, in this case, is the methodshow leaving the class generic.

Where to place Ops implementation?

Class ShowOps is generic and can be placed in the companion of Show.

trait Show[A]{
  def show(a: A): String
}
object Show {
  // instantiator
  def instance[A](f: A => String) = new Show[A] {
    def show(a: A): String = f(a)
  }
  // summoner
  def apply[A](implicit instance: Show[A]): Show[A] = instance

  object ops {
    implicit class ShowOps[A](a: A) {
      def show(implicit instance: Show[A]) = instance.show(a)
    }
  }
}

import Show._
import Show.ops._
case Department(name: String)
val d = Department("Finance")
d.show // String: Finance

Type class is an interesting concept and I have been reading about it from different sources. So, I decided to pen down my learning from different sources like scala-lang.org, scalac.io, with examples that I could relate to better.

Function in bash

Naveen — Sat, 08 Oct 2022 07:45:43 +0000

Function

Function is a familiar topic from mathematics to many programming languages. Function has a defined operation or computation, example: f(x)=x ^ 2.

Function, generally, takes one or more input, operates on the input and returns output. As in the example, given x, the function returns x ^ 2.

Function in bash

Bash scripts can have functions too - tricky part is to return the result of a computation. There are a few options to return the result of the computation in function back to the caller of the function.

Using return keyword

return, in bash, is used to status of execution. Status of execution is represented as integers ranging from 0 - 2 ^ 7 with 0 indicating and the rest indicating failure. The caller of such a function should use $? to read the returned value. This approach is restrictive that the result of computation may not always be returned with loss. Range 0-255 is too small range of integer probably my niece from kindergarten could use !

#!/bin/bash
function add() {
  return $(expr 200 + 200)
}

# main
add
echo $?

Try this one out ! Expect 400 but result is going to be different (144). Clearly return is not meant return result of computation. It is meant to return the state of computation. 0 return code means and any other integer just means something went wrong in the computation.

Using global variable

Using global variable is a naive approach that leads mutation of state. Relying on the global variable based approach would nearly make the script stateful.

Using echo keyword

Using echo is open ended. Any arbitrary type can be returned, example Int, String. Caller of such a function should use evaluation to consume the output of computation. Unlike return statement, there is no limitation in the range, datatype and there is no mutation state.

#!/bin/bash
function add() {
   echo $(expr 200 + 200)
}

# main
sum=$(add 200 + 200)
echo $sum

Using the echo approach is closer to how the commands are used within the script.

#!/bin/bash
today=$(date)

Command date is a builtin tool and the example shows the usage. Now, I can relate to using echo more. I can build shell with all such library functions and import them into any necessary shell scripts.

Gotcha with echo

As the purpose of echo is only to return values, echo should not be used to perform console logging. However, logging to file is still fine with echo "My log message" > logfile

There is no one specific recommended approach. It depends on the scenario and the principles followed by the team. When the principles of referential transparency, purity has to be strictly followed, the preferred approach is to use echo approach.

Tail recursion

Naveen — Sat, 08 Oct 2022 07:29:19 +0000

Before I get into tail recursion, I will take a step back to refresh how I reached the topic of Tail Recursion.

Coming from the foundation of object oriented paradigms, I wanted to understand the principles of functional programming. Of the many principles, one took my attention that I read multiple times to confirm what I just read.

Looping is evil

Functional programming paradigm is about all about expressions. Looping as imperative action and not an expression. If “looping is evil” then how to “loop”? How to iterate over data-structure?

Enter RECURSION

Recursion. Seriously ! StackOverFlowError ! That’s what struck my head immediately. But then I guessed there could be something special in it and I was thrilled to be ‘technically’ surprised 😉.

Recursion – process of a function calling itself

Application of recursion – the infamous example – factorial, fibonacci series are typical applications. Let us look at an implementation of factorial.

// ref: 1 - recursive implementation
def factorial(n: Int): Int = {
  if (n == 1) 1
  else n * factorial(n -1 )
}

A happy little implementation but only until ‘n’ tends to be a large number – just as large as 5000 is sufficient to brought out the evil – StackOverflowError. StackOverflowError occurred because the implementation used stack – an implicit one, called as ‘call stack’ and it was attempted to fill beyond its limit. Stacks are fixed size and they can run out of space. But what is filling the implicit stack? Take a look at the code. When is the expression evaluated? Only when the termination condition n == 1 is met. Until then the expression is preserved in the stack.

# ref: 2
For f (3) = 
stack[0] -> 3 * f(2)
stack[1] -> 3 * 2 * f(1)
stack[2] -> 3 * 2 * 1

When ‘n’ tends to be a large number, the stack is bound to be filled. Now that the problem is understood, how to use recursion without running into StackOverflowError?

The iterative approach to calculate the recursion does not fail even for a large number that failed with recursion. Below snippet is an imperative implementation of factorial.

// ref: 3 - imperative implementation
def factIt(n: Int) = {
  var f = 1
  var index = 1
  for (index <- 1 to n) {
    f = f * index
  }
  f
}

Why did the recursive function run into an error?

In the recursive implementation ref:1, the implicit call stack was preserved because the last expression had to be evaluated out of the return of the recursive call – referring to n * fact (n-1). The stack element has to be preserved to evaluate the product of fact(n-1) and n. This led to preservation of the stack, there by overflowing the capacity of the stack itself for large values of ‘n’.

From recursion to tail recursion

A type of recursion -- Other types are direction and indirect recursion
Recursive function calls itself as the last step in the body.

Tail recursion solves the problem of running into StackOverflowError by not having the expression to be evaluated after the recursive call. Instead, the expression is passed as ‘another’ parameter. Let us go through the tail recursive approach of factorial function.

// ref: 4 - tail recursion
def fact(n: Int) = {
  def helper(n: Int, a: Int): Int = {
    if (n == 1) a
    else helper(n-1, a * n)
  }
  helper(n, 1)
}
println(" factorial of 5000" + fact(5000))

Appears more lines of implementation – but effective enough to handle the large input value with recursion. The key piece of code is else helper(n-1, a * n).

function ‘helper’ invokes itself and that is the final step.
function ‘helper’ evaluates expressions (n-1, a * n) before invoking itself.
Expression a * n is the state that gets carried over. It is called accumulation.

Now with the refactored recursive function, is the stack actually used? Or is the stack still used? Answer: the implicit call stack is still used in tail recursive implementation but the problem of StackOverflowError no longer occurs for large values of ‘n’.

Reason => tail call optimization by compilers

Modern day compilers are optimized for tail calls. When the compiler identifies a function to be tail recursive, it internally optimizes the tail recursive functions to use an iterative approach internally – at least for Scala compiler.

Now, do we replace every recursion by tail recursion? Not necessarily. But being aware of such a technique given that the compiler can perform tail call optimizations is important.

I am glad that this article kept you interested this far.