DEV Community: Tonny Kayage

Why software development is more like an open-world RPG video game

Tonny Kayage — Thu, 15 Sep 2022 06:00:00 +0000

I have recently completed The Ghost of Tsushima expansion (Iki Island) and I couldn't help but draw parallels between my work and the countless hours spent trying to get better at the game.

               Jin Sakai vs The Eagle

Gamers will understand the immense pleasure one gets after beating a "boss" after the 1929th time. The open-world nature of some RPGs allows for building skills that better prepare you for the battles that are to come in the main story. Also known as side quests. Side quests are a great way for the player to get even more familiar with the video game.
How does this translate to Software development? Software development is another skill that requires you to put in time in order to get better at it. It relies on your ability to upskill, seek and try new technologies. There are many ways to achieve this but one method that has worked for me particularly well is trying to build outside projects with the particular technology I'm trying to learn.
In tackling this side p̶r̶o̶j̶e̶c̶t̶ quest you get to learn new techniques that could aid you well in your daily main j̶o̶b̶ mission. In my short career as a Software developer, it has been the work that I do in the side quests that has helped me land better roles and projects rather than my actual day job.
In conclusion, don't be afraid to work on that side quest because you never know how that could help you in your journey as a developer. The only difference is that programming creates new bosses for you to battle against every day and it's important to choose your battles wisely… why? that's an article for another day.

For similar articles like this please checkout our Engineering Blog available on:

Clean Code: Introduction to clean code

Tonny Kayage — Fri, 05 Aug 2022 12:44:27 +0000

At ClickPesa we strive to write scalable, performant and maintainable code. We try to maintain great standards inorder to enhance the quality of our products.

I have recently picked up the "clean family” books written by Robert C Martin. The books are Clean Code, Clean Architecture and Clean Coder. I will share my thoughts and insights i gain from these books as i go through them while also trying to incorporate the lessons i deem workable. I have added links to where you can also get them in the conclusion section of this article depending on your favorite mode of consumption (Audiobook or Kindle).

What is Clean Code

These are principles, patterns, and practices of writing readable and maintainable code. Clean code can be easily picked up by any team member to further add features. This helps create uniformity in the team in terms of Coding style and patterns.

Importance of Clean Code

Uniformity of code among the team contributing to the same codebase. As mentioned earlier stick to patterns already existing in the codebase. Unlike building components that are dissimilar. This aids in onboarding new team members into the team.
Swappable technologies can be easily integrated/removed from the codebase without affecting the business logic. Let's say we have a system that utilizes a certain Queuing technology in our application but a recommendation from a consultant wants the team to utilize emerging exciting technology. This new exciting technology can be easily introduced without touching any logic that utilizes it if clean code was used.
Software development is a continuous process and requirements are ever-changing. It is a measurable task with an associated cost to each feature developed. The cost for each modification of the codebase should always be constant over time. Poorly written/organised codebases are characterized by more escalating costs of change with relation to time. The graph below explains such phenomena:

As the graph explains developers that maintain clean code throughout their development cycles usually maintain speed and efficiency in software delivery.

Closure

As a professional developer, your job is to maintain high code quality and structure. Business teams usually pressure developers into delivering services but you should always maintain your stance of maintaining great standards. At the end of the day, the same business personnel pressuring you to produce more deliverables without standards will come and ask you to modify the same codebase with them expecting it to be a trivial task simply because you have already implemented some parts of the feature. To them, you are simply adding to what exists.

In the next chapter we will dive deep into more concepts explained the book and how we have tried to use them in our projects at ClickPesa.

Additional resources that i also found useful including the books from amazon.

For the next chapter of this series or similar articles like this please checkout our Engineering Blog available on:

Queueing with BullJS

Tonny Kayage — Tue, 12 Jul 2022 09:11:26 +0000

Introduction

A queue is a data structure that places elements in a sequence, similar to a stack. The difference is the methodology of accessing the data. It operates using the LIFO concept, meaning the last item to be added to the stack will be the first one to get accessed whereas the queue operates using FIFO meaning the first item inserted will be the first one out of the queue.

Please find the illustrations below:

Queue

Stack

There is a multitude of ways Queues are used in developing the most common being Sequential execution of tasks/jobs. It allows for developers to add jobs on one end and after processing leaving on the queue on another end. It usually operates on FIFO (First In First Out) methodology, which means the first job to arrive in the queue will get executed early before moving on to the next job arriving in the queue. After execution, the job is removed from the queue on the other end.

What queues are good for:

It allows breaking down large amounts of jobs into smaller more manageable jobs.
It Gives you the ability to add multiple processors for a particular job. Meaning we can attach multiple consumers that can pick up jobs from the queue and execute them
More complex workflows can easily be visualized and implemented with multiple queues ensuring consistency and atomicity.

BullJS

BullJS is one of the many node packages that can be used to implement queues in your application. Like any other Queueing library, it utilises the FIFO methodology.

npm install bull

Bull is extremely fast in execution and much of it owes to the fact that it uses Redis as the underlying technology that backs it up. This means data generated or inserted on the queue is stored in memory for faster reads and writes. Redis also supports pub/sub mechanism that aids in receiving callbacks for failed, completed or failed jobs.

Example implementation for Queues using BullJS

There are two parts to this implementation. A Producer, one that will produce the jobs to be added to the queue and a Consumer whose task is to execute the tasks added by the producer.

A Consumer should inform the Producer once the job has completed execution.

First define the redis configuration

const defaultRedisConfig = {
  redis: {
    host: redisHost,
    port: redisPort,
    db: redisDatabaseNumber,
  },
};

Consumer logic

// Redis server Configuration 
const <queue-name> = new Bull("<queue-name>", defaultRedisConfig);

setQueues([
  new BullAdapter(<queue-name>),
  ...
]);

// Consumer processing logic
<queue-name>.process(async (job) => {
   // Processing logic
});

Producer logic

const Bull = require('bull', { redis: defaultRedisConfig });
const <queue-name> = new Bull('tigo-queue');
<queue-name>.add(<Job Data>);

For similar blogs to this please checkout the ClickPesa Engineering Blog on:

Medium
Dev.to
Hashnode

Automating code review on commit

Tonny Kayage — Sat, 09 Jul 2022 11:49:20 +0000

HOW TO AUTOMATE CODE REVIEWS ON COMMITS

Imagine the hustle of spending hours on code review every day. Code review automation may save countless wasted efforts.

This Article may walk you through steps on how to add automated code reviews that may be executed during every code commit.

Codacy is one of the tools that may be used to achieve this.

Codacy is an automated code review tool that helps developers ship better software, faster. With Codacy, you get static analysis, cyclomatic complexity, duplication, and code unit test coverage changes in every commit and pull request.

Steps to integrate your project with Codacy

1. Sign up

You may use your Git provider such as GitHub, GitLab, or Bitbucket to sign up to Codacy. This links your Codacy user with your Git provider user, making it easier to add repositories to Codacy and invite your teammates.

2. Grant access

Codacy will request access to your Git provider and will require you to provide a few details regarding your organization. (this helps them on use case evaluation).

3. Choose organization

Now you will be required to join the organizations that contain your repositories

Note:

codacy name the organizations similar to your git repository user name.

Example If your repository is “github.com/Fruitsandvegies”. Then the name of your organization will be “Fruitsandvegies”.

4. Adding repository

By selecting the organization on step 3, codency will list all related repositories available. Select the “add” option to add the repository for review. Codancy will immediately set up everything so as to be ready to analyze on the next commit.

Note:

You can add the repository to Codancy only if you have permission to that repository.

5. Review result of the analysis

Select “Go to repository” once the analysis has completed reviewing the results.

Detailed analysis result

The initial analysis from Codancy will be based on the default configuration. Codacy provides tweaks to allow you to set up a custom configuration such as files to ignore, code pattern, and adjust quality settings.

Utilising Doppler for managing environment variable configuration

Tonny Kayage — Tue, 31 May 2022 06:34:35 +0000

What are environment variables and why are they important?

Environment variables are key-value pairs that are used during the execution/runtime of a program. This may be a connection string to the database, or ports used for listening to incoming traffic.

Every developer has at least 2 environments. A development environment where most of the work is done and a production environment where users interact with your product. There is a clear separation of resources in those environments.

For example, You have a database set up locally for testing functionality and a database in production containing user-generated data that we don't want to temper during our tests. In this instance, we maintain two connection variables that we can switch according to the environment we are currently working on.

These variables are usually maintained in separate files from the source code by design to allow you to make changes to the variables without affecting your source code.

What is the conventional way of managing environment variables?

One of the common ways to manage environment variables adopted by developers is the usage of a separate file that contains multiple key-value pairs that represent the variables utilized in the application. This file is usually never added to any version control system. It is often added manually to the directory/site of deployment. It is also added as a hidden file in the file system (eg Linux) by prefixing the file with “.”.

Most projects that utilise version control systems often contain a sample of the environment variables file that is usually postfixed by the -example.format name to inform new developers of the environment variables required to execute the project or existing developers of new variables added by fellow contributors.

It is usually written in JSON, YAML or TEXT file formats.

Drawbacks of the conventional way

At ClickPesa, we maintain multiple environments that are used in our development and release cycle. Each environment variable contains its own set of “key-value” pairs that dictate the behaviour of the application(s).

Our release cycle contains automated tests that are performed on the automated build and deployment process. We needed a way to call upon these secret key-value pairs during the testing process just as how it should work in any given environment when a user interacts with our application.

Does that mean we need to duplicate the same file and provide it as input to the build-test-deploy process?
How do we deal with changes to the file in a development cycle?

The two above questions can be resolved with an introduction of a centralized area where we can store our environment variables and call them from anywhere. Whether that is a Bitbucket pipeline, Github Action, Virtual Private Server, Lambda function etc.

What is Doppler

Doppler is a SaaS platform that streamlines environment variables management with an intuitive dashboard, powerful CLI, and integrations for syncing secrets across development environments, cloud providers, hosting platforms, CI/CD tools, Docker, Kubernetes, and Terraform.

Doppler solves our need to centralize and version our environment variables across our applications with interoperable tools.

We use it to configure environment variables for specific locations in the file system where our applications are hosted inside a VPC. This means we can maintain different versions of the same application according to the context of the environment.

These variables can be updated by using scripts defined in our build-test-deployment process.

Conclusion

For more information please use the following link for a practical guide on how you can use doppler in your current working environment.

Listening to payments (real-time) on your Stellar wallet

Tonny Kayage — Thu, 05 May 2022 09:30:44 +0000

Listening to payments (real-time) on your Stellar wallet

Stellar is an open source, decentralized protocol for digital currency to fiat money low-cost transfers which allows cross-border payments between any pair of currencies.

A Stellar wallet is a digital wallet used to hold lumens & other assets as a digital currency. It consits of a public key and a secret key which in combination can work as an address to recieve and send funds from.

Why do we want to get notified of the latest payments incoming to our wallet

Lets say you have a service whereby you are utilizing stellar as one of your payment options. Inorder to confirm the status of a transfer you need to continously check the whether you have recieved your funds via Horizon.

We need to find a way to get notified of incoming payments.

Solution 1

Periodically retrieve an account's payments using an API request. By using the following GET request a user is able to retrieve payments related to the account_id/public_key.

Using a curl request:

curl "https://horizon.stellar.org/accounts/<account_id>/payments?limit="

The above curl request gets the latest payments on specified account_id.

An example response is:

{
  "_links": {
    "self": {
      "href": "https://horizon.stellar.org/accounts/GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE/payments?cursor=\u0026limit=10\u0026order=desc"
    },
    "next": {
      "href": "https://horizon.stellar.org/accounts/GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE/payments?cursor=110694007436259329\u0026limit=10\u0026order=desc"
    },
    "prev": {
      "href": "https://horizon.stellar.org/accounts/GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE/payments?cursor=119400713599217665\u0026limit=10\u0026order=asc"
    }
  },
  "_embedded": {
    "records": [
      {
        "_links": {
          "self": {
            "href": "https://horizon.stellar.org/operations/119400713599217665"
          },
          "transaction": {
            "href": "https://horizon.stellar.org/transactions/b9d7c534b5fa168570a5bffe0f2089de150d00bf8cbd19ec93e897c565958f3f"
          },
          "effects": {
            "href": "https://horizon.stellar.org/operations/119400713599217665/effects"
          },
          "succeeds": {
            "href": "https://horizon.stellar.org/effects?order=desc\u0026cursor=119400713599217665"
          },
          "precedes": {
            "href": "https://horizon.stellar.org/effects?order=asc\u0026cursor=119400713599217665"
          }
        },
        "id": "119400713599217665",
        "paging_token": "119400713599217665",
        "transaction_successful": true,
        "source_account": "GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE",
        "type": "payment",
        "type_i": 1,
        "created_at": "2020-01-17T20:32:38Z",
        "transaction_hash": "b9d7c534b5fa168570a5bffe0f2089de150d00bf8cbd19ec93e897c565958f3f",
        "asset_type": "credit_alphanum4",
        "asset_code": "USD",
        "asset_issuer": "GDUKMGUGDZQK6YHYA5Z6AY2G4XDSZPSZ3SW5UN3ARVMO6QSRDWP5YLEX",
        "from": "GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE",
        "to": "GASWJWFRYE55KC7MGANZMMRBK5NPXT3HMPDQ6SEXZN6ZPWYXVVYBFRTE",
        "amount": "84.9410878"
      },
      {
        "_links": {
          "self": {
            "href": "https://horizon.stellar.org/operations/117356420835532801"
          },
          "transaction": {
            "href": "https://horizon.stellar.org/transactions/c25dd84798076ee8ea126c78407d61c7e8f3efdf8739274f56b07a7029500b00"
          },
          "effects": {
            "href": "https://horizon.stellar.org/operations/117356420835532801/effects"
          },
          "succeeds": {
            "href": "https://horizon.stellar.org/effects?order=desc\u0026cursor=117356420835532801"
          },
          "precedes": {
            "href": "https://horizon.stellar.org/effects?order=asc\u0026cursor=117356420835532801"
          }
        },
        "id": "117356420835532801",
        "paging_token": "117356420835532801",
        "transaction_successful": true,
        "source_account": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "type": "payment",
        "type_i": 1,
        "created_at": "2019-12-18T08:23:35Z",
        "transaction_hash": "c25dd84798076ee8ea126c78407d61c7e8f3efdf8739274f56b07a7029500b00",
        "asset_type": "native",
        "from": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "to": "GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE",
        "amount": "355.3887598"
      },
      {
        "_links": {
          "self": {
            "href": "https://horizon.stellar.org/operations/115354197276323841"
          },
          "transaction": {
            "href": "https://horizon.stellar.org/transactions/c09d4cee993d60d73c80f036666966738a26b8f3b25d7275b93fd995505b5e5b"
          },
          "effects": {
            "href": "https://horizon.stellar.org/operations/115354197276323841/effects"
          },
          "succeeds": {
            "href": "https://horizon.stellar.org/effects?order=desc\u0026cursor=115354197276323841"
          },
          "precedes": {
            "href": "https://horizon.stellar.org/effects?order=asc\u0026cursor=115354197276323841"
          }
        },
        "id": "115354197276323841",
        "paging_token": "115354197276323841",
        "transaction_successful": true,
        "source_account": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "type": "payment",
        "type_i": 1,
        "created_at": "2019-11-18T19:59:40Z",
        "transaction_hash": "c09d4cee993d60d73c80f036666966738a26b8f3b25d7275b93fd995505b5e5b",
        "asset_type": "native",
        "from": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "to": "GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE",
        "amount": "688.4065454"
      }
    ]
  }
}

Disadvantages of this approach are:

The load on servers will increase exponentially as the number of users and transactions increase in the system. This means for each user in your system there must be a job to fetch the latest transactions after every defined duration of time.
You also run a risk of overloading the stellar netowrk with multiple requests.

Solution 2

As the heading of the article suggests the second solution involves listening to transactions as they happen. To make this happen we utilize the Stellar SDK which provides an event-stream that can be subscribed to inorder to recieve latest payment information regarding the users account.

The following is how this solution can be imoplemented:

First we install the required stellar-sdk dependency into our project by using the follwoing command:

yarn add stellar-sdk

Secondly we import the stellar-sdk using the require keyword. Thereafter we initialize the server sdk using the horizon url before using it.

var StellarSdk = require("stellar-sdk");
var server = new StellarSdk.Server("https://horizon.stellar.org");

server
  .payments()
  .cursor('now')
  .stream({
      onmessage: (payment)=>{},
      onerror: (error)=>{}
  })

Example result(s) coming from the event stream are as follows:

{
        "_links": {
          "self": {
            "href": "https://horizon.stellar.org/operations/115354197276323841"
          },
          "transaction": {
            "href": "https://horizon.stellar.org/transactions/c09d4cee993d60d73c80f036666966738a26b8f3b25d7275b93fd995505b5e5b"
          },
          "effects": {
            "href": "https://horizon.stellar.org/operations/115354197276323841/effects"
          },
          "succeeds": {
            "href": "https://horizon.stellar.org/effects?order=desc\u0026cursor=115354197276323841"
          },
          "precedes": {
            "href": "https://horizon.stellar.org/effects?order=asc\u0026cursor=115354197276323841"
          }
        },
        "id": "115354197276323841",
        "paging_token": "115354197276323841",
        "transaction_successful": true,
        "source_account": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "type": "payment",
        "type_i": 1,
        "created_at": "2019-11-18T19:59:40Z",
        "transaction_hash": "c09d4cee993d60d73c80f036666966738a26b8f3b25d7275b93fd995505b5e5b",
        "asset_type": "native",
        "from": "GDV4KECLSZLKRVH4ZTWVAS4I3W2LPAPV66ADFFUZKGIVOTK6GMKGJT53",
        "to": "GCNL55IJTH2HX26HLNIGYD2JIQLTBAQL3SVPNZA6PXK7NAVHU423WOTE",
        "amount": "688.4065454"
}

Advantages of this approach:

Scalable & Robust. It does not require additional resources if / when your transaction activity grows over time.
Get status of payments as they happen in real-time using the memo supplied in conjuction with the business process implemented.

Additional resources

Stellar Documentation