DEV Community: Haki

QUERY METHOD HAS NOW COME TO HONO

Haki — Mon, 20 Jul 2026 13:13:38 +0000

Hono Just Added Support for the New HTTP QUERY Method — and I Got to Contribute ❤️

A few weeks ago, the new HTTP method QUERY was standardized, making it necessary for frameworks and tooling to begin adopting it.

One thing I love about Hono is how quickly it evolves. Even before official support existed, Hono already made it possible to work with custom HTTP methods. Thanks to the amazing Hono community, I had the opportunity to contribute to adding first-class support for the new QUERY method.

That was a fun contribution to be a part of!

What is the QUERY method?

We’re all familiar with GET and POST, and while you can technically use either for almost anything, HTTP semantics exist for a reason.

GET

GET is used to retrieve data from a server without changing its state. It should not create, update, or delete resources.

One limitation of GET is that it doesn’t have a request body. Any data sent with the request typically has to be included in the URL as query parameters.

For example:

GET /users?name=John&age=25

This means request data becomes part of the URL, which can be inconvenient for larger or more complex queries.

POST

POST is commonly used to send data that may change the server’s state, such as creating or updating resources.

Unlike GET, it supports a request body:

{
"name": "John",
"age": 25
}

However, using POST purely for data retrieval isn’t always semantically correct since it’s generally associated with state-changing operations.

Enter QUERY

The new QUERY method fills this gap.

It allows clients to retrieve data without modifying server state, just like GET, while also allowing a request body. This means complex filters or search payloads can be sent as JSON instead of being encoded into the URL.

In other words:

GET → Read data, no request body
POST → Usually changes server state, supports request body
QUERY → Read data, supports request body

This provides a cleaner and more expressive way to perform complex queries while preserving HTTP semantics.

Hono Supports It

Hono is among the first frameworks to officially support the new QUERY method, continuing its reputation for staying modern and developer-friendly.

I’m also happy that I got to contribute to making that happen.

If you haven’t tried Hono yet, I’d definitely recommend checking it out. It’s fast, lightweight, and a joy to build APIs with.

Happy coding! ❤️

How noise cancellation technology works (without the annoying math)

Haki — Fri, 08 May 2026 19:46:55 +0000

Ever wondered how you’re wearing a modern headphone or EarPod, and suddenly the noise/sounds around you reduce drastically ?Its not magic, it’s a cool technology called noise cancellation and I’ll explain how it works;

So there are two ways this can be achieved;

Passive noise cancellation
Active Noise cancellation (ANC) Passive noise cancellation is simply the use of materials to partially block sound waves, as simple as that. However this method is not very effective, there is a more effective means;
- Active Noise cancellation (ANC) works in a more advanced way, applies methodologies on physics, let me explain properly; Sound is a wave, and that wave has a few properties, such as frequency and direction. ANC exploits this property by first of all analyzing the incoming sound in real time, then process it, and produce an inverse of that sound, in lame terms: If sound go forward, noise cancellation reproduces that same sound but backwards, this causes something called destructive interference. Then noise is partially cancelled. IMPORTANT : The end product of the destructive interference is not 2 different sounds at thesame time, it is one sound produced from the collision of the two opposite sounds.

As easy as that :)

Prompt engineering vs RAG vs Finetuning

Haki — Sun, 03 May 2026 12:00:58 +0000

Before I get started, this is my first blog on this platform, I hope it goes well.

MAIN FOCUS
It’s become a very easy thing to mistake prompt engineering for finetuning, especially the scenario of “when should I use which”, this blog posts explains everything.

Difference between Prompt Engineering and finetuning

Straight to the point!

Prompt engineering essentially changes/tailors the output of the model, FROM the input itself
An example might be
“Give me a dummy list of students and their cgpa in JSON format, the advantage of this is that the result you’re getting is something you expect, not just random or unstructured.
key focus : in prompt engineering, you change the input, NOT the model itself.

While on the other hand…

Finetuning is much broader, in this case, you retrain the model on your own data, directly modifying the model behavior, this can be done in different environments although expensive, eg: google collab (free), hugging face (models and data), or even server/ locally (very expensive). Finetuning is more expensive because it requires very large compute to be performed, depending on the data and model.

When should you use which ?
Use prompt engineering in most cases when you need structured output.
Use finetuning only in extreme cases that you need to modify the model itself

In between these two concepts there’s something called rag (RETRIEVAL AUGMENTED GENERATION)
in this paradigm, you provide search context for the model to respond with, this involves embedding, vectorization and so on.
Mental model: user -> model -> search -> model -> user
This is good for large context based operations

I hope this helps :)