Forem: Girish Koundinya

Payments are Async

Girish Koundinya — Sun, 05 Nov 2023 14:09:00 +0000

~~~ This post was originally published in my blog ~~~

As a founding engineer at inai, a payment orchestration platform that integrates with hundreds of payment methods and gateways worldwide, I've had the opportunity to learn a lot about the complexities of global payments. Before inai, I worked in the customer support SaaS software space, so a lot of the payment gateway terminology and nuances were new to me. Also made me remember the wise words of an Angry Hacker

"The Internet from every angle has always been a house of cards held together with defective duct tape. It’s a miracle that anything works at all. Those who understand a lot of the technology involved generally hate it, but at the same time are astounded that for end users, things seem to usually work rather well.
"

Turtles all the way down: What happens when you swipe your card

When you swipe your credit or debit card, it initiates a complex sequence involving the cardholder, merchant, acquirer (merchant's bank), processor, card network, and issuing bank. The process starts with the card swipe, information flows through these entities for authorization, and if approved, a series of authorization messages are relayed, culminating in the completion of the transaction.

It sounds and looks beautiful. When it works.

Payments are not final

When I was a payments noob, I thought that receiving a 200 response from Stripe meant that a merchant was going to get paid. I learned that's not true, while close to the truth a 200 response from the payment gateway ONLY indicates that the payment gateways has received the request to kick start a complex payment process.

As the UML diagram above shows, there are many steps that can fail after a 200 response from the payment gateway. For example:

The acquirer may decline the transaction.
The issuer may decline the transaction.
The processor may experience a technical outage.
The merchant's bank account may be insufficiently funded.
The customer may file a chargeback.

In any of these cases, the merchant will not receive payment. There are tons of such examples in Patrick McKenzie's blog

This is why it is important for merchants to understand the difference between HTTP status codes and transaction statuses. An HTTP status code of 200 simply means that the payment gateway has received the request and processed it successfully. It does not mean that the transaction has been approved or that the merchant will receive payment.

This is also why it is important for merchants to implement webhook handling. Webhooks allow merchants to receive real-time notifications about the status of their transactions. This way, merchants can be alerted to any problems immediately and take corrective action if necessary.

HTTP status != Transaction Status

An HTTP status code is a three-digit number that indicates the result of an HTTP request. The most common HTTP status codes are:

200 OK: The request was successful.
400 Bad Request: The request was malformed or incomplete.
401 Unauthorized: The client is not authorized to access the resource.
404 Not Found: The resource does not exist.
500 Internal Server Error: An unexpected error occurred on the server.

A transaction status is a different concept. It indicates the state of a payment transaction.

Here is an example where Stripe says 200 OK but the transaction status JSON shows that the transaction has failed:

{
  "id": "ch_1234567890",
  "object": "charge",
  "amount": 1000,
  "currency": "usd",
  "status": "failed",
  "failure_code": "card_declined",
  "failure_message": "The card was declined by the issuing bank."
}

This response indicates that Stripe received and processed the payment request successfully, but the transaction was ultimately declined by the issuing bank. This could happen for a variety of reasons, such as insufficient funds in the customer's account or a suspected fraudulent transaction.

Even though the transaction failed, Stripe will still return a 200 OK HTTP status code. This is because the HTTP status code is only indicative of the success of the API call, not the outcome of the transaction itself.

To get the true status of a transaction, merchants should always inspect the transaction status JSON. If the status is failed, then the merchant should take appropriate action, such as notifying the customer of the declined transaction.

Webhook handling is as important as the API call

Webhook handling is an important part of any payments system. It allows merchants to receive real-time notifications about the status of their transactions. This way, merchants can be alerted to any problems immediately and take corrective action if necessary, so if you are evaluating a payment gateway integration, don't just evaluate the APIs, also make headroom for the callback and how you can eventually identify the status of a payment.

For example, a merchant could use webhooks to:

Be alerted to declined transactions so that they can contact the customer and resolve the issue.
Be alerted to refunds so that they can update their inventory and customer records.
Be alerted to chargebacks so that they can dispute them with the payment processor.

My key takeaways from working with different payment gateways are:

1. Asynchronous payments are the norm.

2. Callbacks are equally important as API calls.

3. Understand different types of transaction codes.

4. Imagine the whole payments network as if it were discworld

After completing tons of payment integrations, I couldn't help imagining if Terry Prachett would compare a payments system to great a'tuin and 4 elephants.

Why imagine when you can ask ChatGPT to describe it in Terry Pratchett style ?

"Think of the payment system as the Discworld itself, a flat world perched on the backs of four colossal elephants, which, in turn, stand atop the shell of a giant turtle. It's a realm where coins spin like the stars and payments flow like magical rivers. But beware, for in this fantastical place, financial transactions are a cosmic ballet, where money appears and vanishes, and commerce is a surreal adventure amidst guilds, wizards, and curious creatures. It's a realm where the improbable is the norm, much like the Discworld itself"

Elo Ratings, Ruby and Cricket

Girish Koundinya — Fri, 26 Feb 2021 03:55:41 +0000

~~~ This post was originally published in my blog ~~~

I’ve started watching a lot of chess streams during the lockdown. The quartet of Anish Giri, Vidit, Sagar Shah and Samay Raina have rekindled my curiosity in Chess and while my low rating at chess.com clearly indicates I haven’t progressed much, I do enjoy a 5 minute chess game when I can.

India toured Australia recently the battle was a joy to behold. Never had I been so hooked on to Test cricket as I was during the series.

If you are question is “What do I do with these two pieces of trivia about how you spent your lockdown?”. I would say that’s a fair question. My new found interests reminded me of a side project I had worked on in 2019.

In 2019, I had recently joined the platform engineering team at Freshworks and the Cricket World Cup had just begun. We played a game within the team, the aim was to see who got most match predictions right.

As developers do, our first step when faced with any challenge is to open a jira ticket open Google Sheets. It had a column for each participants and rows indicating the different matches and venue for each match.

Was this a low (zero) stakes game to hide the fact that we had a gambling problem? Maybe.

Inspired by the data folks at fivethrityeight, https://fivethirtyeight.com/methodology/how-our-nfl-predictions-work/ , I wanted to predict world cup match results based on ELO ratings. ELO ratings are widely used in Chess games. It was invented by Arpad Elo, who was a chess player himself and wanted a better way to rate players than the rating system that was prevalent then.

A player's Elo rating is represented by a number which may change depending on the outcome of rated games played. After every game, the winning player takes points from the losing one. The difference between the ratings of the winner and loser determines the total number of points gained or lost after a game. If the high-rated player wins, then only a few rating points will be taken from the low-rated player. However, if the lower-rated player scores an upset win, many rating points will be transferred. The lower-rated player will also gain a few points from the higher rated player in the event of a draw. This means that this rating system is self-correcting. Players whose ratings are too low or too high should, in the long run, do better or worse correspondingly than the rating system predicts and thus gain or lose rating points until the ratings reflect their true playing strength.

Requirements
Scraping Historical Data
A lot of Elo depends on historical matchups between two teams, so it was critical that I had this information.

Calculating winning %
I wanted to give two teams as input and the program to tell me who has a higher chance of winning based on their elo ratings.

Scraping Fixtures
As a bonus, I wanted to have the ability to look up fixtures and tell me today’s fixtures, so that I can query the winner between the teams.

Design Choices
I broke my goal down into three smaller problems

Interface
I wanted to build a CLI tool, and didn’t want to get my hands dirty with OptionParser class and was looking for an out of the box solution. Thor fit the bill perfectly.

Fetching / Scraping Data
If you are parsing XML in Ruby, the default choice is Nokogiri, so i didn’t spend much time trying other libraries.

Calculating Elo
Ruby’s Elo Gem to the rescue. (That was a Ruby pun)

Note
At this point, there’s an argument to be made that Elo is a rating mechanism and not a means to predict results, which is true. All of this is probably an elaborate ruse to try and make a CLI tool in ruby and do a bit of data scraping and that wouldn’t be far from the truth.

Fin
Code - https://github.com/girish-koundinya/Predicta

Further Reading
Tinder and Elo - https://twitter.com/iamkoshiek/status/1201111952916975617

Elo Ratings in Tinder, War of Warcraft - https://www.theatlantic.com/entertainment/archive/2016/01/how-tinder-matchmaking-is-like-warcraft/424350/

Gomobile - Caveat Emptor

Girish Koundinya — Sun, 31 Jan 2021 05:05:27 +0000

My previous post talks about implementing a simple business logic in Go and integrating it with a mobile application. As an application grows in complexity, there comes a need for a more complex data transfer mechanisms to exist between the app and the library. This post lists a few caveats that one needs to keep in mind while working on Gomobile.

Communication between App and Library

Essentially, the communication with Go has to be two way. Communication from Java and Objective-C is via the public header generated by GoMobile and callbacks from Go are implemented using Go Interfaces. GoMobile translates Go interfaces into Protocols in iOS and Interfaces in Java. We can define a Communication Interface that has two methods onSuccess() and onError(), which will act as our callbacks. We create a class that implements this interface/protocol and pass an instance of this object as a parameter to Go. Go can use this object and callback into the respective platform on completion of the desired action. GoMobile also offers support for the Errors and Exceptions in Objective-C and Java respectively making it very easy to propagate errors from the library.

Datatypes

Gomobile has its shortcomings and the most prominent of all, is its restrictive datatype support. Gomobile only allows the use of the following datatypes.

Datatypes in Gomobile

Signed integer and floating point types.
String and boolean types.
Byte slice types. Note the current implementation does not support data mutation of slices passed in as function arguments.
Any function type all of whose parameters and results have supported types. Functions must return either no results, one result, or two results where the type of the second is the built-in ‘error’ type.
Any interface type, all of whose exported methods have supported function types.
Any struct type, all of whose exported methods have supported function types and all of whose exported fields have supported types.

Particularly, the lack of a slice datatype is very inhibiting and as mobile applications tend to deal with collections on a daily basis. There are a few workarounds for this problem.

Workarounds

There a few workarounds that can be made so that the data type restcitions doesn't inhibit us from using Gomobile

Code generators

One solution is to generate data access methods for a wrapper object around a slice and pass it back and forth between Android/iOS and Go. This solution is presented here - https://github.com/golang/go/issues/13445#issuecomment-173660985

Protocol Buffers

Another solution (which I use currently), is to define protocol buffers as contract objects between Go <> Application. So when Go wants to callback iOS/Android, it converts the complex data type into an array of bytes (which is a supported datatype in Gomobile) and on the application side, it can be converted back into an object. With the help of a few workflow changes, Gomobile can be easily used to pass on complex datatypes to the application.

Support for bitcode in iOS

Gomobile does not have support for bitcode that means that bitcode enabled iOS applications will not be able to integrate with Gomobile. That also means that Gomobile cannot be used with platforms like tvOS and watchOS.

Note - I noticed that this issue is being worked on currently, so hopefully we should have bitcode support soon :)
https://github.com/golang/go/issues/22395

A Three Step Recipe for using Gomobile

Girish Koundinya — Sun, 31 Jan 2021 05:02:05 +0000

This post was originally published in blog.koundinya.xyz

In my earlier post, we saw different ways in which we can use Gomobile. In this post I'll try illustrating how to incorporate Gomobile into a mobile application using the bind command.

Prerequisites

Ensure that you've setup Go and Gomobile in your machine
Install NDK (If you are generating a Android library)

Three Step Recipe

Step 1 - Write a Go Package

Create a go package in $GOPATH/src/github.com/$username/gomobile_contact
Create the following files

In the above linked files I've made a network request, parsed the response and unmarshalled it into a Contact object and returned the first Contact's name. This is an example of a simple business logic component that can be written in Go and ported as a library.

Step 2 - Generate libraries

Use the following commands to generate libraries for iOS / Android applications

    gomobile bind --target=ios #ios
    gomobile bind --target=android #android
```

`


#####  Step 3 - Import library into Application

Gomobile generates a .aar/jar for Android and .Framework for iOS

Import the packages into your application and call the `FetchContactName()` method which returns the first contact's name.

Voilà! You've succesfully generated a library using Go and integrated into your application :)

<br>

MEET HERMES - MY KINDLE BOT

Girish Koundinya — Sun, 09 Aug 2020 06:09:29 +0000

~~~ This post was originally published in my blog ~~~

The Nudge

I receive a lot of links on my mobile phone and more often then not, I forget about these links and end up missing content that I was looking forward to reading. I also wanted to make the Kindle as the my primary reading device.

I was using Pocket to save links and did explore the possibility of using ifttt to send links saved in pocket to my kindle device. It didn't work that well for me :/ there are a few other options https://help.getpocket.com/article/1127-using-pocket-on-kindle-devices, but they didn't seem very mobile friendly.

Save to Kindle is the official chrome extension that does a very decent job of sending articles to your kindle, I couldn't find an equivalent mobile app for it.

I did come across https://p2k.co/ and the free plan seemed to fit the bill.

Oh hell, I think at this point you're probably thinking that i just wanted to build something and was making up reasons for it. You aren't wrong.

Architecture

The goal was to have a simple interface to send articles to my kindle and in my head, this how I was thinking about it.

I didn't want to install / build another app and have the hassle of publishing, installing and pushing updates. I wanted to use an existing app and it would be a choice between using Telegram and Whatsapp (apps where sharing was easy). Telegram (at the time of writing ) had a better bot framework and it I could see that there were libraries in multiple languages that supported Telegram.

While technically not an architectural decision (or is it? https://martinfowler.com/bliki/TwoHardThings.html ), I decided to name the bot Hermes.

In association with his role as a psychopomp and god who is able to easily cross boundaries, Hermes is prominently worshiped as a messenger, often described as the messenger of the gods (since he can convey messages between the divine realms, the underworld, and the world of mortals).[35] As a messenger and divine herald, he wears winged sandals (or, in Roman art influenced by Etruscan depictions of Turms, a winged cap).

Components

Communicating with Kindle

I couldn't find a Kindle API, and the only reliable way to send content to Kindle was by e-mail
Every kindle account gets a Send-to-Kindle e-mail address. Attachments mailed to this email id, automatically get synced to your kindle.
You have to list the email id from which you'll be sending content in the "Personal Document Settings" section.

Choosing a bot framework

I came across https://telegraf.js.org/#/ and the examples and documentation were neat and immediately gave me multiple ideas on how I could structure my app.
While at this point, I hadn't chosen a programming language nor my deployment platform. Telegraf's easy to use API and the fact the deploying a Nodejs app on Heroku is something I've done before, I felt that an express app on Heroku would be the fastest and easiest way to build my bot server.

Setting up a Mailer

Since the only way to send to Kindle was by Mail. Choosing a mailing service became a critical.
My only criteria for choosing a mailer was that it should be free. SendGrid's free plan - "Send 40,000 emails for 30 days, then 100/day forever." was more than adequate for my requirements.

Extracting Article Content

Not all HTML content can be rendered on the Kindle, and I wanted to ensure that only the text content is sent to kindle and didn't want my device glitching.
I came across - https://github.com/ndaidong/article-parser a node package that extracts content from website. It worked beautifully.

Code

https://github.com/koundinya/hermes

Fin

Bot Interface -

On My Kindle -

What happens when ... you run $apt-get install <>

Girish Koundinya — Sat, 24 Aug 2019 10:59:15 +0000

~~~ This post was originally published in my blog ~~~

If you have tried any Linux based system, chances are that you would have run

apt-get install <>

atleast once.

This would have been followed by you going to have coffee (or tea?) and taking a break while your terminal is spewing stuff like -

![Windows-Installation](https://media.giphy.com/media/JmJMzlXOiI0dq/giphy.gif)

I think we need to talk about a few things before we proceed.

I know the gif shows a windows terminal.

It doesn't show apt-get install.

I spent a lot of time procastinating and trying to find the perfect gif. It doesn't exist. But a lot of cat gifs were watched during the process.

You get the idea.

apt-get is a command line interface for managing packages provided by

What is a package

We need step in to a time machine and head back to the age when software was predominantly distributed via mailing lists and FTP. One would have to download the source code, look for a ./configure that would
install the required depedencies and then use the Makefile to compile and install the software.

Makes you want to give npm a nice hug and say "Thank you" doesn't it?

This was a cumbersome process to install and play around with software.
Packages were designed to battle this complexity. Packages are prebuilt binaries that one could install using a tool called package manager. The early versions of these package managers only handled the binaries and the dependencies of a binary were not part of the downloaded artifcat. Later versions of package managers included dependency resolution which made it easy and removed the need to lookup depedencies before downloading software. Package management systems usually go hand in hand with a software repository which is a collection of packages or meta infromation about packages. Package managers usually search repositories to find software and their depedencies.

What is a Debian Package

Debian GNU/Linux is a particular distribution of the Linux operating system, and numerous packages that run on it.

The Debian Project was created by Ian Murdock and I love the fact that the project name is a contraction of the names of Debra and Ian Murdock.

With Linux having multiple flavours, each of these distributions have their own sofware repositories, package managers and package structures.
Most notable of these are -

.deb packages which are used in Ubuntu, Linux Mint and Debian
.rpm used by RedHat, Fedora and SUSE.

.deb package mainly contains the following components

debian-binary - Contains information regarding version of debian package.
control archive - This archive contains meta information about the package.
data archive - Contains the actual software.

So what is apt-get

The .deb packages were initially managed by a tool called dpkg. dpkg was built to download pre-built binaries and it had capabilities to check if depedenices are matched but did not have the ability to resolve dependencies for the user. Later, a new debian project, Advanced Package Tool (APT) was started which would take care of depedency resolution aswell and works with dpkg.

APT includes a collection of tools that deal with package management and also command line programs that use the library. apt-get and apt-cache are the most commonly used command line programs. Popularly, apt and the command line tools are reffered to as a front-end to dpkg. i.e means by which users can communicate with dpkg.

APT uses /etc/apt/sources.list as a list of sources from which packages can be downloaded.
An example of a source list is as follows -

deb http://deb.debian.org/debian buster main
deb-src http://deb.debian.org/debian buster main

deb http://deb.debian.org/debian-security/ buster/updates main
deb-src http://deb.debian.org/debian-security/ buster/updates main

deb http://deb.debian.org/debian buster-updates main
deb-src http://deb.debian.org/debian buster-updates main

You can add or remove sources and after modifiying the source list and apt-get is made aware of new locations to search for packages.

There quite a few front-ends for apt that are avaiable now, some also have a GUI apart from having a command-line interface like Synaptic and aptitude. Historically, apt-get was only designed as a test front-end for libapt-pkg but it was exteremly succesful and popular.

![apptitude](https://debian-handbook.info/browse/stable/images/aptitude.png) ![synaptic](https://debian-handbook.info/browse/stable/images/synaptic.png)

Summary

When you run

    sudo apt-get install <package-name>

apt-get searches for the package in the software repository.
Checks dependencies.
Installs dependencies.
Installs the software package.

A more detailed look into the lookup and dependency resolution process is available here -
https://debian-handbook.info/browse/stable/sect.apt-get.html

References

Gomobile : Under The Hood

Girish Koundinya — Sat, 20 Apr 2019 05:17:45 +0000

This post was originally published in my blog

Photo by Nathan Van Egmond on Unsplash

To understand and fully appreciate what Gomobile does, we’ll need to go through a few concepts (features) related to Java/Objective-C and Go itself and see how Gomobile brings them together. Primarily Java and Objective-C ‘s ability to communicate with c / c ++ and go’s ability to generate c shared libraries.

C and C++ support in Java and Objective-C

Java and Objective-C applications have had the ability to interact with libraries written in c and c ++ for a while.

Java -

Communicates with C libraries using JNI framework. Many of the standard library classes depend on JNI to provide functionality to the developer and the user, e.g. file I/O and sound capabilities. Including performance- and platform-sensitive API implementations in the standard library allows all Java applications to access this functionality in a safe and platform-independent manner.

Objective-C -

Superset of c, and has access to c libraries.

Go and CGo

cgo is a library that allows Go programs to interoperate with C libraries. We are interested with a specific feature that cgo provides which allows us to compile Go files into C shared libraries. Go 1.5 introduced execution modes that permits Go methods to be exposed using a C-style api. To read more about execution modes and what their capabilites are - https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGhFDelrAP0NqSS_00RgZQ/edit?pli=1#heading=h.44n2lm20ate5

Cgo has a few requirements for a Go file to be compiled into a shared library.

The package must be a main package. The compiler will build the package and all of its dependencies into a single shared object binary.
The source must import the pseudo-package “C”.
Use the //export comment to annotate functions you wish to make accessible to other languages.
An empty main function must be declared.

If the following requirements are met then any .go file can be converted into a shared library that contains a .h and a .so file. The .h file contains the exported methods. A in depth example of creating your own .so and .h file is available here - https://medium.com/learning-the-go-programming-language/calling-go-functions-from-other-languages-4c7d8bcc69bf

So what does Gomobile do?

We know that -

Java and Objective-C can talk to C
Using cgo we can make a shared library that can be called by other c files or Java and Objective-C via (1)

gomobile bind brings together both of these concepts to generate a library that applications can use to call Go code.

Example code (Objective-C example) --

If we have a file hello.go ->
package hello func HelloWorld() {}
When we run gomobile bind --target=ios, a Hello.framework is created that contains a hello.Objective-C.h and binary called hello. Hello.Objective-C.h is a header file.
Now we know that a shared library has been generated and we know that our hello.go does not meet the requirements for a go a file to be converted by cgo. This is where Gomobile comes in, it generates a proxy go file that adheres to cgo requirements and then runs the cgo tool to create a public header and a shared library that can be then be called by Java and Objective-C. So gomobile bind creates a temporary file for hello.go and passes it to cgo to generate a .framework or .aar archives.

References -

Introduction to Gomobile

Girish Koundinya — Thu, 18 Apr 2019 17:24:33 +0000

This post was originally published in blog.koundinya.xyz

When someone reads about the Go programming language, they would probably come across Rob Pike’s famous 'Concurrency Is Not Parallelism' talk or they might discover that Docker and Kubernetes and many other cloud infra tools have been written in Go (Go has been dubbed 'The Language of the Cloud'). I want to write about one of Go's lesser known tool in the box - Gomobile. Gomobile is a mobile application development tool written in Go, built with the aim of developing cross-platform applications.

Why would you try Gomobile?

I can hear your collective groan, 'Not another Cross Platform Mobile Development Solution'. And I agree, and infact I would want to lend my voice to it. Sometimes the benefit of having a single codebase pales in comparison to the sub par experience provided by cross platform frameworks.

So why are we talking about Gomobile then?

Gomobile provides two strategies for development

To develop an entire mobile application using -
gomobile build
To develop a library that can be used by mobile applications using -
gomobile bind

Using Gomobile as a generator for SDKs that can be plugged into applications is very similar to how companies are Google and Dropbox are approaching cross-platform development. Google used J2OBJC in Inbox
and Dropbox has Djinni.
gomobile bind is an option if your application has a lot of business logic that you don't want to rewrite in multiple platforms.

Gomobile bind

gomobile bind generates language bindings for Java and Objective-C. A simple pattern for developing mobile applications using bind would be develop the view layer in the native language and then communicate with the generated sdk to obtain model objects.

Mobile App Architecture

There are quite a few mobile application architecture patterns in Android and iOS like MVC, MVP, MVVM, and VIPER. All of these architectural designs can be broadly represented by three layers.

![Mobile App Architecture](https://blog.koundinya.xyz/images/mobile+arch.png)

View Layer

This layer is responsible for user interaction and rendering of data. Activity and ViewController classes in Android and iOS respectively are types of classes that are normally associated with this layer.

Business Logic Layer

This layer contains the core application logic. The interactions from the view are sent to this layer, which is processed and used to make calls to the data layer.

Data Layer

The data layer controls all of the data access operations. This can be anything from accessing a local SQLite database to interacting with the network.

![Mobile App Architecture With Gomobile](https://blog.koundinya.xyz/images/mobile+go+arch.png)

With gomobile bind, the business logic and data layers can be moved to Go and shared between iOS and Android applications. This way business logic needs to be written only once and the data access protocols are similar between operating systems. You also don’t lose out on the user experience which is a common drawback in most cross platform solutions.

References

Here are some references that you might find interesting to get started with Gomobile