Before we get into this, if you're new here or don't know me - I'm Harshit, and I'm a Software Engineer primarily working on Backend Systems. In my steep upward career of 3+ years, I've worked at two unicorns - BigBasket (bigbasket.com), India's Largest Online Grocery Supermarket and Postman (postman.com), an API Development Platform which was my latest sprint.

This is a new series that I've started - Demystifying APIs, and it aims to promote API Literacy in the tech community. Feel free to ask me any questions around APIs in the comments below or by tweeting to me (twitter.com/harshitbudhraja) - I'll be happy to answer each one of those.

Also, don't forget to subscribe to my newsletter, so that you don't miss any of the further posts in this series.

In the last post, we introduced APIs and discussed the basics of what they are and how they work. In case you missed it, do check it out here: https://harshitbudhraja.com/what-is-an-api

In this post, we'll dive deeper into the most commonly used types of APIs - REST and SOAP APIs. Let's begin with a closer look at these two types, shall we?

What are REST APIs?

REST stands for Representational State Transfer, and it is a type of web service that uses HTTP protocols to transfer data. REST APIs are stateless, which means that they do not maintain any information about the client. Instead, each request contains all the necessary information to complete the request.

REST APIs use standard HTTP methods such as GET, POST, PUT, DELETE, and PATCH to perform operations on resources. These resources can be anything that can be identified by a unique identifier, such as a user, a product, or an order.

One of the advantages of REST APIs is that they are easy to understand and implement, which makes them very popular among developers. They also allow for caching, which can improve performance.

What are SOAP APIs?

SOAP stands for Simple Object Access Protocol, and it is a type of web service that uses XML as the data format and a standardized messaging protocol for communication. SOAP APIs are stateful, which means that they maintain information about the client.

SOAP APIs use a specific messaging format called a SOAP envelope, which contains a header and a body. The header contains information about the message, such as the message ID and the destination. The body contains the actual message.

SOAP APIs are often used in enterprise environments where security and reliability are of utmost importance. They provide a standardized way of communicating between systems, which makes them ideal for integrating different systems.

Structural differences in REST and SOAP

Let's try to understand with examples, the differences in the structure of the request and response messages. Before that, you should know that REST APIs typically use JSON or XML for data exchange, while SOAP APIs use XML exclusively. Additionally, SOAP APIs require the use of a WSDL (Web Services Description Language) file to define the API methods and message formats, while REST APIs do not have a standardized definition format.

We'll be talking about different API Definition Types in the upcoming posts in this series, so make sure you stay tuned and subscribe to the newsletter to receive email digests whenever I publish.

Okay, so we were talking about structures, right?

REST Structure

Request:

GET /hello HTTP/1.1
Host: example.com
Accept: application/json

The request includes a GET method to access the /hello endpoint on the example.com domain. It also includes an Accept header indicating that the client is expecting a JSON response.

Response:

HTTP/1.1 200 OK
Content-Type: application/json

{ "message": "Hello, World!" }

The response includes a 200 OK status code indicating that the request was successful. It also includes a Content-Type header indicating that the response is in JSON format. The response body includes a JSON object with a message property set to "Hello, World!".

SOAP Structure

Request:

POST /hello HTTP/1.1
Host: example.com
Content-Type: text/xml;charset=UTF-8
Content-Length: nnn

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <HelloWorldRequest xmlns="http://example.com">
      <name>World</name>
    </HelloWorldRequest>
  </soap:Body>
</soap:Envelope>

The request includes a POST method to access the /hello endpoint on the example.com domain. It also includes a Content-Type header indicating that the request is in XML format. The request body includes a SOAP envelope containing a HelloWorldRequest element with a name child element set to "World".

Response:

HTTP/1.1 200 OK
Content-Type: text/xml;charset=UTF-8
Content-Length: nnn

<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <HelloWorldResponse xmlns="http://example.com">
      <message>Hello, World!</message>
    </HelloWorldResponse>
  </soap:Body>
</soap:Envelope>

The response includes a 200 OK status code indicating that the request was successful. It also includes a Content-Type header indicating that the response is in XML format. The response body includes a SOAP envelope containing a HelloWorldResponse element with a message child element set to "Hello, World!".

When to use REST and when to use SOAP?

The decision to use either REST or SOAP depends on several factors such as the type of application being developed, the complexity of the API, the performance requirements, and the desired level of security.

RESTful APIs are ideal for building lightweight web services that are simple, scalable, and easy to develop. They are particularly suitable for public-facing APIs that need to support a variety of clients, including web browsers, mobile apps, and IoT devices. REST APIs use HTTP and offer a standardized set of methods and status codes, which makes them easy to use and understand. They also offer good performance and caching capabilities, which can help improve the scalability of the application.

SOAP APIs are a better choice for building complex, enterprise-level applications that require more advanced security and transaction management features. They use XML-based messaging to exchange data between client and server, which makes them more secure and reliable. SOAP APIs also offer support for advanced messaging features such as message queuing, reliable messaging, and transaction processing, which can be important for mission-critical applications.

Examples of Public REST and SOAP APIs

SOAP APIs used to be common in the last decade, but most providers have slowly moved towards REST for the reasons mentioned above. An example of a publicly used SOAP API is the Europe PMC (https://europepmc.org/SoapWebServices).

REST APIs are more commonly used in modern software, so the examples are numerous. But for instance, Github has one (https://docs.github.com/en/rest?apiVersion=2022-11-28), Apple has one to help authenticate using Apple's Servers (https://developer.apple.com/documentation/sign_in_with_apple/sign_in_with_apple_rest_api).

These are just to mention a few. In fact, you can find yourself surrounded by APIs, you just have to look.

Now, because we're covering REST and SOAP, why don't we write simple Hello World APIs in both of them?

Code Time: Hello World in SOAP and REST

Using NodeJs and REST

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`REST API Example listening at http://localhost:${port}`);
});

In this example, we create a simple REST API that responds to a GET request to the root URL ("/") with the message "Hello World!". The express package is used to handle the HTTP requests and responses.

Using NodeJs and SOAP

const express = require('express');
const app = express();
const bodyParser = require('body-parser');
const soap = require('soap');

const wsdlUrl = 'http://www.dneonline.com/calculator.asmx?wsdl';
const port = 3000;

app.use(bodyParser.raw({ type: function () { return true; }, limit: '5mb' }));

app.post('/hello', (req, res) => {
  const xml = req.body.toString();
  soap.createClient(wsdlUrl, (err, client) => {
    client.HelloWorld({}, (err, result) => {
      res.setHeader('Content-Type', 'text/xml');
      res.send(result.HelloWorldResult);
    });
  });
});

app.listen(port, () => {
  console.log(`SOAP API Example listening at http://localhost:${port}`);
});

In this example, we create a simple SOAP API that responds to a POST request to the "/hello" endpoint with the message "Hello World!". The body-parser package is used to parse the XML request body. The soap package is used to create a SOAP client and call the HelloWorld operation on the SOAP API.

Conclusion

In conclusion, REST and SOAP APIs are the two most common types of APIs. REST APIs are easy to understand and implement, while SOAP APIs are more secure and reliable. Which type of API you choose to use will depend on your specific needs and requirements.

In case you have any more questions or concerns about REST or SOAP APIs, or there is something you'd want me to talk about in the upcoming posts, please tweet to me (twitter.com/harshitbudhraja) or leave a comment on this post.

In the upcoming posts, we will be diving deeper into REST APIs and the principles governing them. We will also discuss different types of API definitions, including OpenAPI, AsyncAPI, GraphQL and more. Stay tuned!

So, as I was experimenting with Tor in the last few days, I decided to check out tools to help generate these new ED25519 signatures. Out of many out there, mkp224o worked well for me.

Now usually, setting up the dependencies for such C99-based tools is usually trickier in most Windows or MacOS systems than in Linux systems. But, thanks to this docker image which I found on the DockerHub, things were smooth for me.

Let's see how to generate one, then?

It's fairly straightforward with Docker - just run a container from the image, exec inside it and use the tool 🚀

To run a container and exec inside it:

docker run -it nwtgck/mkp224o

Once you're in, mkp224o will be available to you as an executable. You can check out the usage and options by running mkp224o -h to see a help text like this:

Need a quick-start command to begin with, eh?

Well, got you covered there. Let's quickly see which options are the easiest, to begin with:

1. -B - Use this for batching the key generation process.

2. -S 1 - Use this for printing stats after every second as the generator is running.

3. -d dirname - Use this to output all the generated .onions to a dirname directory

4. -n 1 - To stop the process after 1 key is matching the filters is found

With all the above options, here's how the syntax to generate 2 keys starting with temp and store them into a onions directory looks like:

mkp224o -B -S 1 -d onions -n 2 temp

And voila, we now have them in the specified directory:

You can find the public key, secret key and a hostname file for each .onion that you've generated.

Happy Tor-ing! 🧅😁

Before we get into this, if you're new here or don't know me - I'm Harshit, and I'm a Software Engineer currently working at Postman (https://postman.com), an API Development Platform.

This is a new series that I've started - Demystifying APIs, and it aims to promote API Literacy in the tech community. Feel free to ask me any questions around APIs in the comments below or by tweeting to me (https://twitter.com/harshitbudhraja) - I'll be happy to answer each one of those.

Also, don't forget to subscribe to my newsletter, so that you don't miss any of the further posts in this series.

Well, nothing fancy here. Let me start by telling you that most (actually, ALL) modern software use APIs in one way or the other.

Okay, but what exactly is an API? 🤔

API stands for Application Programming Interface. Don't stress too much over it (just remember it for your interviews though 😛).

Breaking it down for you:

1. Application - This could be anything from a mobile app, web app, or desktop app to apps that run on your smartwatch to even browser extensions.

2. Programming - To make them (i.e. the apps) work according to your requirements.

3. Interface - Any tool/library/software/hardware that helps you complete your task (in this case, helps you program your apps).

Ah, that was a bouncer for me 🤯

Haha, no big deal. Let's understand it using a simple example:

Your smartphone shows you weather updates, right? Do you think companies like Oppo, Vivo, Xiaomi, Micromax or Samsung own satellites that relay this information to them for them to deliver it to you on that home screen? Well, they don't.

Then, where do they get these weather updates from?

The answer to this question is simple - from organizations that have satellites and specialize in meteorology.

But how?

Here's a little diagram to understand how this communication takes place:

Satellites owned by meteorological organizations relay the weather data to them, who in turn relay this to the requesting companies - like Samsung, and they further make this data available to their users on their smartphones.

But, where do APIs come into the picture?

Simply putting, everywhere you see blue arrows in the above diagram :p

Wow, I think I get it. But what do they look like? 😍

Beautiful 🥰

Just kidding (well, not really).

Okay, so there are many different types of APIs: SOAP APIs, RPC APIs, REST APIs, Websocket APIs etc. of which REST APIs are the most commonly used ones. You'll find them almost everywhere. They generally use a universally recognized data interchange format/language like JSON (Javascript Object Notation) or XML (Extensible Markup Language) which are typically both machine-readable and human-readable to exchange data.

For example, if you'd like to see a real-world weather API, you can check this out: https://open-meteo.com/en/docs. Whenever anyone requests weather data from them, they return a response that looks something like this:

{
  "latitude": 52.52,
  "longitude": 13.419,
  "elevation": 44.812,
  "generationtime_ms": 2.2119,
  "utc_offset_seconds": 0,
  "timezone": "Europe/Berlin",
  "timezone_abbreviation": "CEST",
  "hourly": {
    "time": ["2022-07-01T00:00", "2022-07-01T01:00", "2022-07-01T02:00", ...],
    "temperature_2m": [13, 12.7, 12.7, 12.5, 12.5, 12.8, 13, 12.9, 13.3, ...]
  },
  "hourly_units": {
    "temperature_2m": "°C"
  },
  "current_weather": {
    "time": "2022-07-01T09:00",
    "temperature": 13.3,
    "weathercode": 3,
    "windspeed": 10.3,
    "winddirection": 262
  }
}

This, by the way, is the JSON format.

Final Notes (for now) 📝

Don't worry if you don't understand a word in that 😅 We'll take this slow and step-by-step. And by the end of this series, you would have a fair understanding of everything you need to know about APIs.

With that, I hope you have an idea of what APIs are 🤞🏻 In the upcoming posts in this series, we'd be talking more about APIs and their types in detail.

Cheers!

So, I recently got access to the feature everyone is talking about these days - Notion's AI Assistant. And I decided to give it a try.

Here was my input to the AI: "A blog post about the top 10 skills needed for a Product Management role". Check out what it wrote - I was astonished by the quality of the content it generated. Tell me what you think about this in the comments.

Disclaimer: The content of this post is generated, in its entirety, by Notion AI and is untouched.

Product Managers have the unique role of driving a product from concept to launch and beyond. It requires a broad range of skills to successfully manage a product lifecycle. Here are the top 10 skills needed for a Product Management role:

1. Vision: Product Managers need to have a clear vision for the product and be able to articulate it effectively to the team.

2. Product Strategy: Product Managers need to have a deep understanding of the competitive landscape, customer needs, and how to create a product that meets those needs.

3. Technical Knowledge: Product Managers need to be familiar with the technical aspects of the product they are managing. They need to understand the architecture, design, and development processes.

4. Communication: Product Managers need to be able to communicate effectively with both internal and external stakeholders.

5. Collaboration: Product Managers need to be effective collaborators who can work with a variety of teams, including Engineering, Design, Marketing, and Support.

6. Problem-solving: Product Managers need to be able to identify and solve problems quickly, efficiently, and effectively.

7. Analytical Skills: Product Managers need to have strong analytical skills to be able to interpret data and make informed decisions.

8. Leadership: Product Managers need to have the ability to lead teams and motivate them to reach their goals.

9. Creativity: Product Managers need to be able to come up with creative solutions to complex problems.

10. Time Management: Product Managers need to be able to manage their time effectively, set deadlines, and meet them.

These are just some of the skills that are needed for a successful Product Manager role. With these skills, you can be sure to build great products and drive successful product launches.

I always saved a message on Slack when I wanted to check it out later. Little did I know, Slack has a feature to let you add reminders against messages (and even snooze them!).

How?

To add a reminder against a message:

1. Click the "More actions" button on the message to open up the actions menu.
2. Find an action "Remind me about this".
3. From the list of intervals, select your desired interval or choose a custom date and time.
4. Once you do that, a reminder will be created for you and you would get a DM from Slackbot at the set date and time. You can choose to delete it, mark it as completed or just snooze it for a later time.

1. storing them in an Excel Workbook;

2. securing the file with a master password (and Touch ID);

3. with dozens of different sheets categorising my credentials;

4. keeping the file in sync with my smartphone through iCloud;

It was a lot of work doing all of that, honestly.

1Password was pretty good at what it did, but with the pricing structure that they offered for personal and family use, I wasn't sure if it was even worth the $36 or $60 I'd be spending "just to store my passwords".

I recently learnt that 1Password started offering free Family Plans to users who use 1Password at work (with a Business plan), and fortunately my organisation is on one of these plans.

Well, so what next?

To experience the full potential of 1Password, I'm migrating all my passwords (stored at various distributed locations - excel workbook, chrome, safari etc.) to my vaults.

The one thing which excites me about 1Password (for now) is how seamless the experience is - it has native Mac app, Windows app, Android app, iOS app, a chrome extension and even a Command Line Utility (😳).

Looking forward to have a better experience now!

Background

A lot of you might have received an email from our friendly neighbourhood Spiderman; just kidding; Sandeep Panda (Co-founder, Hashnode) with a catchy subject starting with [ACTION REQUIRED] and wondered what is it about. Let's demystify this together!

What's the story?

What we understand from the email is that Hashnode's Engineering Team, apparently, had been working on an upgrade that would make all the blogs hosted on their platform load way faster. Well, this was much needed and had been expressed by a large portion of the community in the past, so big kudos to the Engineering Team for finally rolling this out!

Now this email should've been sent to users who are using Custom Domains on Hashnode because that's where the migration is required. The blogs which are hosted on a subdomain under hashnode.com should've been taken care of by Hashnode internally. So, if you're not using a custom domain and you've still received an email, you know whose neck to hold for spamming your inbox 😉

Let's make our blogs faster

Hashnode requires users who're using A records in their domain's DNS configuration to point to them make a minor change to make their blogs use the new platform. This change needs to be done by all users eventually, as Hashnode will stop supporting its legacy platform after August 20, 2021.

Let's dive head-first:

1. Disable your custom CSS: One of the breaking changes highlighted in the email was support for non-standard CSS classes. If you're not sure about this, it's recommended to disable your custom CSS feature as a precautionary measure. You can do so by heading over to your Blog Dashboard > Appearance and scrolling down towards the end to find the option under Advanced Settings.

2. Grab the IP Address for the new server: Head over to your Blog Dashboard > Domain and you should see a warning like shown below. This is an indicator that you are required to migrate to the new platform manually. On scrolling down, you should see the new IP Address that Hashnode requires you to update into your DNS configurations.

   For the purpose of this tutorial, let's assume the IP Address to be XX.XX.XX.XX as shown below.

3. Find your DNS Console: So, if you're using a custom domain, you must have purchased the domain from a domain registrar like Godaddy, Namecheap, Google Domains etc. These domain registrars also provide you with a console to manage your DNS. You should head over to your registrar's website and find the console.

4. Do you see an A record?: Once you have found the way to your console, you should see all your DNS records listed there. The one we're concerned about is the A record which currently points to an IP Address which is the one to Hashnode's legacy platform. This is the one we need to edit.

5. Update this record's IP Address: This is the most important step where you need to update the IP Address pointer of this A record to point to the new IP Address we noted in Step (2) i.e. XX.XX.XX.XX.

And we're done 🚀 Your blog should now be migrated to Hashnode's new platform.

How long does it take?

It may take up to 24 hours for DNS changes to propagate fully. But it's usually pretty quick. You can check the progress by using a service like this.

What about my SSL certificate?

As usual, Hashnode will continue provisioning and managing an SSL certificate for your domain using Let's Encrypt.

Using Cloudflare?

If you are using something like Cloudflare, remember to bypass it for this route by clicking on the "Orange Cloud". Make sure that it appears grayed out and the "Proxy Status" is "DNS Only".

Catalin Pit Ayushi Rawat Victoria Lo You have been the folks who have, unknowingly, motivated me to start a blog on Hashnode. Would love to hear your feedback!

What is tor-nginx-proxy?

tor-nginx-proxy is a docker image which helps you to do exactly that ☝🏻

How does this actually work?

What you see is a tiny docker image based on alpine which encapsulates tor and nginx in a single container, and enables you to proxy traffic from your .onion url to your website on the clearnet. Too many jargons, eh?

In NSS ("not-so-sophisticated") terms, this can be understood as a simple proxy_pass happening from your website on the dark web which is being served through tor to your website on the internet, but inside the docker container.

Can I see any website live on Tor which is using this? discontinued

Of course! IPOAlerts.in, a service which was built by me over a weekend last month, is now available over Tor 🎊 And it's using nothing more than tor-nginx-proxy behind-the-scenes. Here's a glance of my docker container which is serving it on Tor.

Check it out on: http://ipoaltnp5be3mvotgap2ohu62py5nyu25cg2uognl7u5kysqxsrezoad.onion/ using the Tor Browser.

You can also check out the twitter feed to see who else is talking about #tor_nginx_proxy.

Why call it "tiny"?

Because, it's less than ~15MB in size 😆

How can I use it?

To get started, I recommend checking out the README(s) on either of the following:

1. Github Repository: https://github.com/harshit-budhraja/tor-nginx-proxy
2. DockerHub Repository: https://hub.docker.com/repository/docker/harshitbudhraja/tor-nginx-proxy/

You can possibly use it in any way you'd like to (given that it adheres to the terms of the License).

Show some support 🙇🏻‍♂️

This is my first attempt to really give something back to the open-source community. If you liked this and are currently using (or planning to use) it, please do show some support by starring and forking the repository and / or by following me on Github and Twitter to be updated with more such work by me.

These little actions won't cost you a penny, but they'll boost my motivation and confidence in ways I can't even express 😅

Also because I don't have any tracker to see who's using this at all (in-fact, I'm not a supporter of trackers), please don't forget to talk about how you're using tor-nginx-proxy for your use-case with the hashtag: #tor_nginx_proxy.

Can I contribute to maintaining it?

Of course, I'd be glad to have you contribute to this in any way possible. Please feel free to open an issue or reach out to me on Twitter to discuss more about it.

Have any issues?

Please open a new issue on the github issue tracker so that me or anyone from the community can have a look at it and suggest.

Support The Tor Project

For the Tor project sustainability, I strongly encourage you to help setup Tor bridges/exit nodes(script) and donate money to the Tor project (Not this nginx-proxy project) as and when you have the ability / capacity :))

• Your app uses a protocol other than HTTP/HTTPS
• You are working towards balancing the load across multiple containers
• You want to test new features as canary deployments
• and so on...

Here's a quick .conf snippet to proxy pass a request coming on port 80 to port 8081 where your custom app is running:

server {
    listen 80;
    access_log /path/to/log/access.log;
    error_log /path/to/log/error.log;

    location / {
        proxy_pass http://localhost:8081;
        proxy_set_header Host $host:$server_port;
        proxy_set_header X-Forwarded-For $remote_addr;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection upgrade;
        proxy_set_header Accept-Encoding gzip;
    }
}

Of course, you can replace the ports with your own values.

With the fraternity getting fairly scrutinised in the last few years, it would not be wrong to say that the modern tech is indeed driven by open source software. The plethora is so firm and crisp that we typically use certain open source softwares and tools without even realising that they’re open source. From Python to Node.js to React to Golang to Java to Apache Kafka to Redis to dozens of other recognised languages / frameworks that we all use, we are all constantly taking from the open source community.

And it’s not long before we, at BigBasket Tech, realised that it’d be really good to give something back to the community. And that’s when we made our first-ever mark into giving back to the open source community by sourcing a tiny bit of our code open for the community – a react package called ra-treemenu.

A little background, eh? Sure.

We use an open-source react-based framework called React Admin for our catalog, search engine and review admin portals. While in the early days when we did not have a lot of quick access menu items to be shown on the sidebar, things worked well for us. But gradually with about 20+ items on the quick access sidebar menu already, the layout started overflowing and it was turning out to be inefficient for our administrators to navigate through the portal. Also, this was certainly a bottleneck at the back of our minds for new menu items and features to be added to this admin portal.

There’s always a way to do it better – one just needs to find it.
– Thomas A. Edison

With that thought in mind, what we needed was a better way to group them and create a multi-level hierarchy and that would solve our problem without over-engineering things.

So, did we check for existing open-source packages which we could integrate to make this work?

Of course, the first idea was to search for a react package (which would be compatible with React Admin) which could do this for us with some tweaks. But unfortunately, we couldn’t find any which worked well. Clearly, the next choice for us was to build one from scratch – extending over the React Admin framework.

Soon after building the package, with the statistics that we had about React Admin’s user-base around the world, we thought it would be a good value addition to the community if we decided to open source it.

And the rest is history! ☺️

What now?

Since August ’20, when we made the package open source (https://github.com/BigBasket/ra-treemenu) and published the first version of it on NPM (https://www.npmjs.com/package/@bb-tech/ra-treemenu), we have had over 2400+ downloads with an average of about 10-12 downloads per day. We’ve released 4 versions till date which had decent contributions from the community as well. Here’s what it looks like:

Detailed stats: https://npm-stat.com/charts.html?package=%40bb-tech%2Fra-treemenu&from=2020-08-01&to=2021-03-17

Now that we have put our foot into open-source and the traction we’ve got in the last few months is keeping us all motivated, it would not be a surprise to see us open sourcing more of such small and big pieces of our work, right?

Do stay tuned to our Github Org (https://github.com/BigBasket).

Cheers!

This article is republished from BigBasket's Tech Blog.

As much as we think we know MySQL, it never fails to surprise us with unusual and weird, yet well-documented, scenarios.

I was perplexed when I learnt about one such thing about MySQL today where it strip-typecasts (as I like to say it) strings to integers. For example, let’s first have a well-defined table schema and insert some dummy data into it.

Assuming the schema like the one shown below -

+---------+----------+--------+-------+-----------+----------------+
| Field   | Type     | Null   | Key   | Default   | Extra          |
|---------+----------+--------+-------+-----------+----------------|
| id      | int(11)  | NO     | PRI   | <null>    | auto_increment |
| name    | text     | YES    |       | <null>    |                |
| city    | text     | YES    |       | <null>    |                |
| state   | text     | YES    |       | <null>    |                |
| country | char(36) | YES    |       | India     |                |
+---------+----------+--------+-------+-----------+----------------+

We insert dummy data in the table after which it looks something like -

+-------+---------+-----------+-------------+-----------+
| id    | name    | city      | state       | country   |
|-------+---------+-----------+-------------+-----------|
| 12345 | Harshit | Bengaluru | Karnataka   | India     |
| 34213 | Rahul   | New Delhi | New Delhi   | India     |
| 34256 | Rohan   | Dehradun  | Uttarakhand | India     |
| 45897 | Satwik  | Mumbai    | Maharashtra | India     |
| 98364 | Aayush  | Pune      | Maharashtra | India     |
+-------+---------+-----------+-------------+-----------+

Now, what according to you will a query like **SELECT * from table_name where id = 12345;** return? Well yes, you’re right. It will return -

+-------+---------+-----------+-----------+-----------+
| id    | name    | city      | state     | country   |
|-------+---------+-----------+-----------+-----------|
| 12345 | Harshit | Bengaluru | Karnataka | India     |
+-------+---------+-----------+-----------+-----------+

Let’s tweak that query a bit to something like **SELECT * from table_name where id = '45897siujwehrirc';** and can you now predict the output? And no, as much as you think that MySQL will throw an error or return an empty set, in fact it doesn’t. Here’s the output that you’d get -

+-------+--------+--------+-------------+-----------+
| id    | name   | city   | state       | country   |
|-------+--------+--------+-------------+-----------|
| 45897 | Satwik | Mumbai | Maharashtra | India     |
+-------+--------+--------+-------------+-----------+

So the question is why this? And the answer is quite a cliche one though -

This is how MySQL works!

What MySQL does is get all the numbers from the start of the string '**45897siujwehrirc**’ and strip off any characters following it before typecasting it to integer and querying the table. So, the resultant query which actually gets fired to the table is -

SELECT * from table_name where id = 45897;

whose expected result matches our result.

Coming to the part where I tell you that MySQL has documented this clearly. MySQL :: MySQL 5.7 Reference Manual :: 12.2 Type Conversion in Expression Evaluation When an operator is used with operands of different types, type conversion occurs to make the operands compatible. Some…dev.mysql.com

Weirdly counterintuitive way of casting '45897siujwehrirc' to 45897. Ain't it?

Let me make my point with the help of a small example.

Let’s say we have an architecture like -

Example architecture

Assuming that each replica of the codebase can do only one job at a time and it takes ‘t’ time for one replica to complete one task, only after which can it take up the next one, consider -

*Case I — Where Job #A — {Job #1, Job #2, Job #3} i.e. Job #A is a collective job which strictly needs to be completed sequentially. When the replicas take up jobs, the situation is something like -*

Replica #1 <= Job #A : Running time = 3t

Replica #2 <= Job #4 : Running time = t

Replica #3 <= Job #5 : Running time = t

In this case, the total time the system will take to complete all the five jobs would be 3t.

*Case II — Where all the five jobs are independent. When the replicas take up jobs now, one of the permutations of the possible situations is something like -*

Replica #1 <= Job #1, Job #4 : Running time = 2t

Replica #2 <= Job #2, Job #5 : Running time = 2t

Replica #3 <= Job #3 : Running time = t

In this case, the total time the system will take to complete all the five jobs would be 2t.

What if you had this situation in a real life scenario — Your user uploads some “sets of images” to your app and now while displaying those images, you actually want your UI to display thumbnails of those images and when the user clicks the thumbnail, show him the actual image. Pretty common and relatable example, right? Now, you write an asynchronous service that is called as soon as a set of images uploaded by a user is available and generates the thumbnails for them. Or you write an asynchronous service that is called as soon as an image is uploaded and generates a thumbnail for it. The service is deployed on a three-node kubernetes cluster. For a user, the images are a set, no doubt. But from engineering perspective, it is upto you as an engineer whether you want your service to treat them as a set (Case I of the above example) or you want your service to treat them as individual images (Case II of the above example).

Clearly, from the above example, we can see that one small implementation decision can impact the overall infrastructure cost.And further, with managed services like Google Cloud, AWS, DigitalOcean etc. offering pay-as-you-go plans which are the most popular plans among customers, optimal use of your resources might just save you a lot of money.

Just something to ponder over!

Cheers 🍻

Originally published at https://premagious.xyz on September 13, 2019.