Building Restful APIs with Axum

2026-04-16T00:00:00+00:00

WIP! </div> </div>

This article is still a work in progress </div> </div>

An API (Application Programming interface) is a contract that defines a way to access the services of an application. There are many forms of APIs. The focus of the article is on web APIs provided over the internet.

REST Representational State Transfer - This is a client-server architecture where there are two communicating parties. The client is responsible for the representation of the data while the server is responsible for producing and processing the data.

Each request in REST carries all information necessary for it to be processed ( It is stateless). The APIs work on resources. The resource could be a blog post, a photo etc. The most common way to represent the properties of the resources is JSON</code>.

A RESTful API is an HTTP-based web service adhering to the principles of REST.

Basics of the HTTP Protocol</a></h3> Every HTTP request is sent to a unique URI/ URL (uniform resource identifier) such as https://mwendwakavete.co.ke/post</code>.The URL has three mandatory parts: The Scheme - It identifies the communication protocol, https in this case.</li> The Domain - This is a DNS domain name that identifies the target system. mwendwakavete.co.ke</code></li> The Path - This identifies the exact resource want to interact with.</li> </ol> A sample request: GET /post HTTP/1.0 Host: mwendwakavete.co.ke Accept: application/json </code></pre> GET is an HTTP verb which expresses our intention with the request. We want to GET something from the server. /post The path of the resource we want to interact with. HTTP/1.0 - The http protocol to use. The other lines contain http headers. The headers are key-value pairs that add more metadata to the request. The Host header identifies the domain we want to communicate with. The Accept header indicates the content MIME type we want the server to use for the response. This declares that we are expecting to receive json</code> data and not any other type of data. After making that request to the server, we expect to receive a response. Our request could succeed or fail due to various errors. A sample response: HTTP/1.0 200 OK Content-Type: application/json { "post": [ { "id": 1, "title": "Post 1", "content": "Long String" }, { "id": 2, "title": "Post 2", "content": "Another Post" } ] }</code></pre> In this case our request was successful with a 200 Status Code. The code indicates whether the request was successful or we ran into an error. The line is followed by HTTP response headers with key-value pairs similar to the HTTP request headers. In this case the server responded back with some json data, as requested. HTTP Verbs</a></h3> The most common HTTP verbs are GET</code>, POST</code>, PUT</code>, PATCH</code>and DELETE</code>. GET - Get information from the system.</li> POST - Create something new in the system.</li> PUT - Update or overwrite something.</li> PATCH - Similar to PUT</code>: It updates something, but it only changes some attributes of the entity -unlike PUT</code>.</li> DELETE - Delete something from the server.</li> </ol> Example: Implementation of a basic CRUD operation on blog posts.</a></h4> Lets assume we have a blog in which we have a table with some blog posts. To add new posts, we have to use the POST</code> HTTP verb to indicate to the server that we want to create a new blog post in the system. POST /posts HTTP/1.0 Content-Type: application/json { "title": "Post 1", "content": "Once upon a time" }</code></pre> Creating the post can either be successful or fail. The server has to send back a response to the client indicating success or failure. To update a post, we need to send a PUT</code> request. (Note that the ID of the subject post appears in the URL). PUT /posts/1 HTTP/1.0 Content-Type: application/json { "title": "Post 1 updated", "content": "Far far into the distant future" }</code></pre> To get a list of available posts, send a GET</code> request to the general posts</code> url. GET /posts HTTP/1.0 Accept: application/json </code></pre> To get information about a specific post, add the ID of the post to the URL. GET /posts/1 HTTP/1.0 Accept: application/json </code></pre> To delete a post, send a DELETE</code> request: DELETE /posts/1 HTTP/1.0 </code></pre>HTTP Response Status Codes</a></h2> HTTP response messages come with a status code and a short message which gives the clients information about the result of the requested operation. HTTP response status codes classification: range 100..199 - Informational messages</li> 200..299 - Success</li> 300..399 - Redirection</li> 400..499 - Client side errors</li> 500..599 - Server side errors</li> </ul> Common Response Codes</a></h3> Successful: 200 Ok</code>: All went well</li> 201 Created</code>: The POSTed entity has been created successfully</li> 204 No Content</code>: request processed successfully but there is no content to return</li> </ul> Redirects: 301 Moved Permanently</code>: The URL of the requested resource changed permanently.</li> 302 Found</code>: The URL of the requested resource moved temporarily</li> 304 Not Modified</code>: Indicates the client can continue to use the cached version of a previous response</li> </ul> Client-side errors: 400 Bad request</code>: The server cannot parse the request</li> 401 Unauthorized</code>: The endpoint requires authentication, and the client is not authenticated.</li> 403 Forbidden</code>: The client has no sufficient permissions to access the resource</li> 404 Not Found</code>: No resource found at the given URL</li> 405 Method Not Allowed</code>: The given HTTP verb (e.g DELETE) is not supported on the resource</li> </ul> Server-side errors: 500 Internal Server Error</code>: Generic server-side error status when no other status is applicable.</li> 501 Not Implemented</code>: The given HTTP verb is not supported by the server.</li> 502 Bad Gateway</code>: An interimproxy or gateway failed to forward the request to the original server.</li> 504 Gateway Timeout</code>: The origin server failed to reply in a timely manner</li> </ul> Axum Hello World</a></h2> Now that we have a basic understanding of Restful Web APIs, let's create a simple one with axum. We are going to create a simple Restful webservice, returning a "hello world" message, formatted as JSON. Note! </div> </div> This section assumes that you are a Rust programmer and doesn't hold your hand on Rust concepts. Therefore I assume that you already have rust and cargo installed. If all these sound new to you, I recommend you check out The Book</a> first. </div> </div> I am going to use a workspace for this simple hello world program. First, create a directory to hold the workspace. mkdir hello_world cd hello_world </code></pre> Next, create a Cargo.toml</code> file and add the resolver as 2 under workspace. [workspace] resolver = "2" </code></pre> Create a new package with Cargo cargo new hello_main </code></pre> We are going to need the axum crate and the tokio crate as our async runtime. The only features from the tokio crate required by default are macros and rt-multi-thread. cargo add axum cargo add tokio --features macros,rt-multi-thread </code></pre> In our package's src</code> directory, there is already a main function that prints "Hello, world" to the standard output. First, we need to convert our main function function to an asyncronous function and then declare that we are using tokio as our async runtime by adding the attribute macro #[tokio::main]</code> . #[tokio::main] async fn main() { println!("Hello, world"); } </code></pre>Axum handlers</a></h3> One of the main components of an axum application is an handler. According to the official docs: A “handler” is an async function that accepts zero or more “extractors” as arguments and returns something that can be converted into a response. </blockquote> Handlers are a core part of axum since this is where all the application logic lives. You route between handlers to create an application. As already mentioned, handlers should return something that implements the IntoResponse trait. This trait is implemented by default on many data types. You can read more about it form the official docs about the IntoResponse Trait</a>. Sometimes you might have to implement the trait yourself such as when returning custom erros, which we'll see later. Let's create a simple handler that returns a string slice, "Hello World". In this case we have specified that we are returning a string slice with a static lifetime. async fn hello() -> &'static str { "Hello, world" } </code></pre> We could also have generalized and said that we are returning anything that implements IntoResponse, and still return a string slice. async fn hello() -> impl IntoResponse { "Hello, world" } </code></pre>Routes and application setup</a></h3> Setup the routing for our web service in the main function and start a simple server. The Router</code> is used to setup which paths go to which service. We want the route /</code> to go have a get service with the logic provided by the hello</code> handler. use axum::Router; use axum::routing::get; #[tokio::main] async fn main() { let app = Router::new() .route("/", get(hello)); let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(); axum::serve(listener, app).await.unwrap(); }</code></pre> The route</code> method binds the hello</code> function to the GET</code> HTTP verb on the "/" path. When a client sents the request to GET</code> / we respond with the hello message. The listener listens on port 3000. The 0.0.0.0 in the address means that we will not bind our service to a specific IP address but respond to requests on all network interfaces. The axum::serve</code> starts the web service and takes the routing configuration from the app</code> variable. To test the basic web app, run the application with cargo run --bin hello_main</code>. Simply running cargo run</code> will also work since we only have one member. I am going to use curl</code> to test the application. curl -v http://127.0.0.1:3000 </code></pre> As previously mentioned, most Restful APIs work with JSON data. We are therefore going to need a way to respond with JSON data. To serve JSON instead of plain text, we are going to add serde</code> and serde_json</code> as dependencies. cargo add serde_json cargo add serde --features=derive </code></pre> Instead of returning plain text, lets create a struct to return as a response. This could be a blog post, a book etc. I am quite the creative and I'll call this struct Response</code>. use serde::Serialize; #[derive(Serialize)] struct Response { // A &'static str lives for the entire lifetime of the program. It is part of the binary! message: &'static str, }</code></pre> The Serialize</code> derive macro provides the serialization capabilities for our struct. Json handler</a></h3> Create a new handler method to respond with json. use axum::http::StatusCode; use axum::Json; async fn hello_json() ->(StatusCode, Json<Response>) { let response = Response { message: "Hello, world!", }; (StatusCode::OK, Json(response)) } </code></pre> The method returns a tuple with an HTTP status code and something that will be formatted as JSON. Add a route for the hello_json</code> function. let app = Router::new() .route("/", get(hello)) .route("/hello", get(hello_json)); </code></pre> Opening the url 127.0.0.1:300/hello</code> on the browser should display the return message in JSON format. Curl command. curl -v http://127.0.0.1:300/hello</code></pre> The Content-Type</code> header should now be application/json</code> instead of plain/text</code> Hello World full code</a></h3> 1use axum::{Router, routing::get, Json}; 2use axum::http::StatusCode; 3use serde::Serialize; 4 5// Setup tokio runtime 6#[tokio::main] 7async fn main() { 8 // Create routes. Send a get request to /. The reponse comes from the functio hello. 9 let app = Router::new() 10 .route("/", get(hello)) 11 .route("/hello", get(hello_json)); 12 13 async fn hello() -> &'static str { 14 "Hello World" 15 } 16 17 async fn hello_json() ->(StatusCode, Json<Response>) { 18 let response = Response { 19 message: "Hello, world!", 20 21 }; 22 23 (StatusCode::OK, Json(response)) 24 } 25 26 27 let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap(); 28 println!("listening on {}", listener.local_addr().unwrap()); 29 30 axum::serve(listener, app).await.unwrap(); 31} 32 33#[derive(Serialize)] 34struct Response { 35 // A &'static str lives for the entire lifetime of the program. It is part of the binary! 36 message: &'static str, 37} 38</code></pre>Error Handling</a></h2> Error handling is a key part of any application.So fare, we've only been using the unwrap</code> method that just panics incase of an error.Instead of using unwrap</code> which panics on encountering any error there are other more graceful options. For example, expect()</code> can be used to provide some context to the error. Rust functions can return a Result</code> type, which is an enum with two variants Ok</code> and Err</code>. The Err</code> variant can hold anything, including non-errors. There is also no standard error type, only an Error</code> trait. This means that one must create their own type. The anyhow crate can be used which introduces its own Error</code> that can hold arbitrary errors, add context to errors and create errors on the fly from strings. Error handling in main</a></h2> A Result</code> return type can be added to the main function and then return an error from it. This will print "Error: " followed by the error's debug representation, then exit with exit code 1. Anyhow's Error</code> type pretty prints the errors it carries so it can be returned from main. #[tokio::main] async fn main() -> anyhow::Result<()> { let app = Router::new().route("/", get(hello)); let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?; axum::serve(listener, app).await?; Ok(()) } </code></pre> Context can be added by using the anyhow::Context</code> method. let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.context("failed to bind TCP Listener")?; axum::serve(listener,app).await.context("axum::serve failed")?; </code></pre>Error handling in handlers</a></h3> Most errors encountered will be inside error request handlers, and will have to be returned to the caller along with an appropriate HTTP status code. Lets call a function that can fail. async fn hello_json() -> (StatusCode, Json<Response>) { let response = Response { message: henerate_message().expect("failed to generate message."), }; (StatusCode::OK, Json(response)) } fn generate message() -> anyhow::Result<&' static str> { if rand::random() { anyhow::bail!("No message for you"); } Ok("Hello World") } </code></pre> anyhow::bail!</code> returns an error on the fly. Let's add the CatchPanic</code> middleware from the tower-http crate. Add tower-http crate and enable catch-panic feature. cargo add -F catch-panic tower-http</code></pre> Then add the middleware. let app = Router::new(),route("/", get(hello)).layer(tower_http::catch_panic::CatchPanicLayer::new()); </code></pre> With this, we'll get a 500 Internal Server error in case of a panic. Let's fix the handler so that it handles the error. Axum allows handlers to return a Result but the Error variant must implement IntoResponse so that the error can be converted into a response. Use a newtype to wrap the anyhow error. struct AppError(anyhow::Error); impl From<anyhow::Error> for AppError { fn from(value: anyhow::Error) -> Self { Self(value) } }</code></pre> Implement IntoResponse where the actual response format of the error is determined. impl IntoResponse for AppError { fn into_response(self) -> axum::response::Response { (StatusCode::INTERNAL_SERVER_ERROR, self.0.to_string()).into_response() } }</code></pre> Return AppError from the handler. async fn hello() -> Result<(StatusCode, Json<Response>), AppError> { let response = Response { message: generate_message().context("Failed to generate message")?, }; Ok((StatusCode::OK, Json(response))) }</code></pre>

Helix Editor: The post modern modal text editor

2026-04-13T00:00:00+00:00

WIP! </div> </div>

Since this is my first post, I decided to include it before it's completed for testing purposes. However, I believe the article already contains enough information to get anyone started with the Helix editor. </div> </div>

If you've written any kind of code, you've probably used an Integrated Development Environment (IDE), a Code Editor, a modal text editor or a normal text editor.

The article is mainly focused on a modal text editor, Helix. However, to get there we have to understand IDEs, Code editors and then finally dive deep into helix editor.

Integrated Development Environment</a></h2>
According to Wikipedia;

An integrated development environment (IDE) is software that provides a relatively comprehensive set of features for software development. At a minimum, an IDE typically supports source-code editing, source control, build automation, and debugging. </blockquote>
However, the same can be achieved in code editors and also the modal text editors discussed later on. The difference is that for an IDE, everything comes as one package. You install one program and get all the good stuff with minimal additional setup. Let's take Pycharm for example, a popular Python IDE from Jetbrains, by default you get so many features such as git integration, debugging, an interpreter and support for library integrations such as Django. I think it even has Jupyter Notebook support.
There's an IDE for all mainstream languages out there. Check out Awesome-IDEs</a>
Code Editors</a></h2>
The most common text editor, by far is VS Code. Code editors are designed specifically for code editing and provide features for achieving that. They come with syntax highlighting by default and shortcuts for easily manipulating code.
What differentiates IDEs and Code editors is that, code editors are not really specialized on one programming language. You can setup your code editor to work with Python, Rust or C. For that reason, to achieve functionality such as code actions, you have to manually install plugins. These plugins provide Language Server Protocols. The plugins are not however just focused on Language support, there are plugins for so many things, including themes.
Code editors are mostly a little more lightweight than IDEs. It is still possible to bloat your code editor to the point that it's heavier than the IDEs themselves.
Text Editors</a></h2>
Code editors are convenient since they offer the perfect balance of control and simplicity.
Some text editors are very simple and are only useful for making slight changes to files. `GNU Nano</code> is one classic example. It does provide syntax highlighting and a few shortcuts to perform quick actions.`
`There are other text editors that provide a way to extend their functionality.Vim</code>, Neovim</code>,Emacs</code> and Helix</code> are all examples of these kind of text editors.Emacs</code> is too extensible to even be called a text editor, while Helix</code> currently doesn't support plugins like Vim and Neovim (There are however plans to include one).`
Modal Text Editors</a></h2> A modal text editor has multiple modes of operation and the key's function change depending on which mode it is in. Helix is highly inspired by other modal text editors - Kakoune</code> and Neovim.Kakoune</code> was also inspired by Vim and as you might have already deciphered, Neovim is the "Neo" Vim :). The key thing to note here is that there is a deep-seated relationship between these editors. However, you do not need to be familiar with the aforementioned editors to learn Helix. ( A familiarity with any of them will obviously make it easier to learn the other due to their overlapping functionality). One of the most popular modal text editors is Vim/ Neovim. With vim you can add plugins and configure it using Vimscript</code>. Even though vim is still actively maintained, most people have migrated to Neovim.The difference is that Neovim introduced Lua as the preferred language for writing plugins. Neovim is quite bare bones to begin with. To achieve most of the tasks you have to set-up a file explorer, language server, themes, fuzzy search and so much more. This means that for any new functionality you need, you will have to edit a lua</code> file. If you love tinkering, and building your own editor from scratch, then Neovim might be for you. There are also some Neovim distros such as LazyVim</code> and NvChad</code>. I have tried both of them and they are pretty solid and give you almost a complete setup for most of the basic stuff you will need. They have by default a package manager (lazy.nvim</code>), allowing you to quickly install other plugins and extend your Neovim configuration as needed. The baseline here is, to get a good working environment in Neovim, you will have to do some tinkering. That's where helix comes in. Unlike Neovim, helix has most of the necessary features built-in. It has a fuzzy search, LSP support and themes all built-in. No setup required, and your editor just works. Now, don't get me wrong, you still might have to touch the config files to change a few things such as themes and the behaviour of LSPs but not quite as frequent as you have to in Neovim. Helix uses TOML</code> for configuration which is quite simple. Helix Features</a></h2> Helix has so many features which will be discovered as you continue learning more about it. Some of the key features include: Built-in Language Server Support </li> Multiple Selections </li> Smart Incremental syntax-highlighting </li> </ul> Installing Helix</a></h2> Explaining all possible ways to install helix is impractical. See the official installation instructions</a> from the official helix website.For example, to install it on arch linux: sudo pacman -S helix </code></pre> Note! </div> </div> After installing helix, I believe that the tutor is enough to get anyone up and running with helix. </div> </div> To access the tutor, run the following command hx --tutor </code></pre> If you are on archlinux, you may have to use the full name: helix --tutor </code></pre> If you want to use the command hx</code>, either create an alias or just create a symlink to the helix binary on a file named hx</code>. sudo ln -s /usr/bin/helix /usr/local/bin/hx # /usr/local/bin/ should be in $PATH </code></pre> I am going to include the basics needed to get up and running with helix in this article. We may end up covering everything in the tutor and more. Note! </div> </div> If you are already familiar with vim, you can skip most of these introductory sections. There are however some subtle differences. I cannot document all of them here, since this is not a guide about migrating from Neovim or Vim</a>. One key difference I can note is that in vim, the command comes before the selection such as dw</code> to delete a word, while in Helix you would use wd</code>. This gives some form of visual feedback on the text your are about to perform changes on. If you are already familiar with modal text editing, you may want to skip to Configuring helix</a> </div> </div> Helix Basics</a></h2> This section covers the basics of modal text editing including movements and commands. Modes</a></h3> Helix has three main modes: Normal mode: This the default mode and it is used for navigation and editing commands. </li> Insert mode: This mode is used for typing text into the document. One way to enter insert mode from normal mode is pressing i</code> </li> Select/ Extend mode: Used for making selections and performing operations on them. Accessed by typing v</code> while in normal mode. </li> </ul> Basic Cursor Movement</a></h3> The keys h, j, k and l are used for basic movement. The arrow keys can also work but it is recommended to use these keys as there are some useful combinations with these keys. Also, it helps in keeping your fingers in the home row. h - Left</li> j - Down</li> k - Up</li> l - Right</li> </ul> Exiting Helix</a></h3> I can't quit Helix — VS code user </blockquote> Not being able to quit Vim has been quite the long running joke. The post-modern version: "I can't quit helix!". Anyway, to quit helix, you need to be in Normal mode or in Select Mode( Press Esc</code> to enter normal mode). Then press :</code> to enter command mode</code> then q</code> short for quit</code> to quit. If you had unsaved changes the command :q</code> will fail, use :q!</code> to force quit. Deletion</a></h3> To delete text use the d</code> key. Pressing the d</code> key in normal mode without any selection deletes the character under the cursor. It can also be used in combination with selections to delete chunks of text (To be demonstrated later). For now, just remember that d</code> deletes text. Insert Mode</a></h3> There are several ways to enter insert mode. The most common is i</code> , used to enter insert mode before the selection. a</code> - Insert after the selection (append) </li> I</code> - Insert at the start of a line </li> A</code> - Insert at the end of the line </li> </ul> Opening Lines</a></h4> o</code> - add a newline and insert below the cursor.</li> O</code> - add a newline and insert above the cursor</li> </ul> Saving a File</a></h3> To save/ write to a file use :w' or </code>:write. You can also use </code>:wqor</code>:write-quit` to write and quit. Note! </div> </div> It should already be obvious that typing :</code> while in normal mode takes you to command mode. I might not include :</code> for subsequent commands. </div> </div> You can also save to a specific file by using :w /path/to/file</code> The path can be either relative to the directory in which helix is opened in or an absolute path. Motions and Selections</a></h3> Motions are used to move around and to make selections. For example, w</code> can be used to move forward a word. This also automatically selects the word and actions can be performed on the word. Hitting w</code> again will move forward to the next word, selecting it. The motions can be combined with commands such as d</code> to delete a word. For example, using dw</code> will delete the word. When in select mode, w</code> can also be used to select a word. The difference is that hitting w</code> again while in select mode will add the next word to the selection. Common Motions</a></h4> w</code> - Move forward to before the beginning of the next word.</li> e</code> - Move forward to the end of the current word.</li> b</code> - Move backward to the beginning of the current word.</li> </ul> WORDS and words</a></h4> The w</code>, e</code>, b</code> motions have counterparts W</code>, E</code> and B</code>. The uppercase counterparts traverse WORDS instead of words. WORDS are separated by whitespace only, while words can be separated by other characters. For example: info@mwendwakavete.co.ke contains 7 words (info, @, mwendwakavete, . , co, . and ke but only one WORD (info@mwendwakavete.co.ke). Counts with Motions.</a></h4> All the motions can be combined with numbers to perform that motion the specified number of times. [number] [motion]</code> performs motion number times. Example: To move 5 WORDS forward, 5W</code> (5 + Shift + w). The Change Command</a></h3> c</code> is used to change the current selection. It deletes the current selection and enters insert mode. It's a short form of di</code>. Select/Extend Mode</a></h3> To enter select mode, type v</code>. To exit select mode, type v</code> again or Esc</code>. In select mode, every movement extends the current selection instead of replacing it. In Normal mode, hitting w</code> selects the current word and hitting w</code> will move to the next word and select it. In select mode, the same motion will select 2 words. Performing commands on selected text returns you to normal mode. Selecting Lines</a></h3> To select the current line, type x</code> while in Normal or Select mode. To select the next line type x</code> again and so on. You can also combine with numbers to select a specified number of lines. For example, 5x</code> selects 5 lines down starting with the current one. x</code> does not select empty lines. X</code> also selects the current line in a similar manner to x</code>, except that it doesn't extend to subsequent lines. Collapsing Selections</a></h3> If you would like to deselect without moving the cursor, use ;</code> Undoing</a></h3> u</code> - undo</li> U</code> - redo</li> </ul> Copying and Pasting Text</a></h3> To copy/ yank the current selection, use y</code> and then use p</code> to paste the yanked text after the cursor. To past it before the cursor, use P</code>. It is important to note that helix doesn't share the system clipboard by default. To yank to the system clipboard, use Space+y</code> and to paste from the system clipboard, use Space+p</code>. Make sure you have a clipboard manager installed. This will most likely be already installed on your system if you are not working with minimal installations of archlinux, void-linux or some other distro. Since I am on wayland, I had to install wl-clipboard</code>. Note: Anytime you delete or change text, helix will copy the deleted or changed text. sudo pacman -S wl-clipboard </code></pre>Searching in a File</a></h3> To search forward in a file, type /</code>, then type n</code> to go to the next search match and N</code> to go to the previous. To search backward, use Shift+/</code> Now that we can do some basic stuff with helix, it is time to see how we can configure various aspects of the editor such as setting a theme. Configuring Helix</a></h2> Helix is configured via a config.toml file. The location on Unix based systems is ~/.config/helix/config.toml</code>. On windows, the directory looks something like %AppData%\helix\config.toml</code>. You can also just open the config right from helix without traversing directories manually by running the command :config-open</code> within helix normal mode. Look at this minimal config file: theme = "github_dark" [editor] line-number = "relative" soft-wrap.enable = true mouse = false [editor.cursor-shape] insert = "block" normal = "bar" select = "underline" </code></pre> You can easily figure out what each of those settings change. As mentioned before, helix uses TOML (Tom's Obvious Minimal Language) for configuration which is quite easy to grasp. This simple config sets guthub_dark</code> as the preferred theme for the editor, sets up relative line numbers and enables soft wrap. It also sets up cursor shape in the different modes. Helix allows you to customize many parts of the editor, includig the statusline, the file picker among others. Check out the editor section configuration options</a> from the official docs for a complete guide. Make sure to play around with the different settings and observe the changes. Themes</a></h3> Helix comes with over 100 themes by default. You can check them out by typing the command :theme</code> a list of the themes will popup, somewhere on the bottom left. You can then tab over the themes to try them out temporarily. If you like a theme, you can then add it to your config by adding theme = "yourtheme"</code> at the top level of your config. You can also create your own themes</a>. This can also be done by inheriting from the existing themes and tweaking specific parts to achieve your desired theme. For example, I used this feature to force helix to inherit the background opacity of my terminal (I love glazing at my wallpaper when working from the terminal 🙂). To achieve that, create a folder named themes on the same level as the config.toml</code> file. On unix based systems, this would be ~/.config/helix/themes</code> and on Windows, this would be %AppData%\helix\themes</code>. You can then create a theme in the folder, in my case I create a theme named transparent.toml</code>, and add the following. # My theme inherits the inbuilt bogster theme inherits = "bogster" # Set various sections' bg to none # For example "ui.menu" configures the code and command completion menus "ui.background" = { bg = "none" } "ui.window" = { bg = "none" } "ui.statusline" = { bg = "none" } "ui.help" = { bg = "none" } "ui.menu" = { bg = "none" } "ui.popup" = { bg = "none" } </code></pre>Language Server Protocol Support</a></h3> Helix has language server support provided out of the box. Just install your LSP and helix will pick it up. For example for C language support, I installed clangd</code>, and helix automatically provides code actions such as code completions and definitions. You can configure the language options in a languages.toml</code> file located in the same location as the config.toml</code> file, which overrides the default configuration provided by helix. You can also have configuration files local to a project by creating a .helix</code> directory in the project root and then create a languages.toml</code> there.For example, to enable both ruff</code> and pyright</code> support for the Python programming language, add the following in languages.toml</code> [[language]] name = "python" language-servers = [ "pyright", "ruff" ] </code></pre> To install the Language servers, in archlinux I used: sudo pacman -Syu pyright ruff clang </code></pre> Please note that these might be different based on your Operating system. Make sure to find out how to install the LSPs for your system. Just install the LSP and it will work out of the box. The configuration is only needed to control the behaviour of the LSPs. To check if the LSP is detected, you can run hx --health language</code>. For example, check status for Python, hx --health python</code>. With our current setup, the output would be something akin to: Configured language servers: ✓ pyright: /usr/bin/pyright-langserver ✓ ruff: /usr/bin/ruff Configured debug adapter: None Configured formatter: None Tree-sitter parser: ✓ Highlight queries: ✓ Textobject queries: ✓ Indent queries: ✓ </code></pre> Check out Language Configuration</a> for more information. More Helix Features</a></h2> Multiple Cursors</a></h3> If you would like to make the same change on multiple lines, you can use C</code> to duplicate the cursor to the next suitable line. To remove the cursors except the last one, type ,</code>. To duplicate the cursors upwards instead of downwards, use Alt+C</code> The Select Command</a></h3> The select command is quite useful when you want to perform some kind of search on a specified chunk of text.Think of it as performing some kind of "grep" on the text. For example, let's say you would like to change all occurrences of a variable in a line. Select the line, x</code> and then type s</code> for select mode. A prompt will appear on the status line prompting you to enter the search term. Entering the term will select all occurrences of the term and actions performed will affect all the selections. The selections don't have to be exact matches! You can also use regular expressions in place of the search term and all the text matching the specified expression will be selected. Find and Till Motions</a></h3> Find Motion(f<ch></code>): Select up to and including a character. Till Motion(t<ch></code>): Select up to but not including a character. To do the same but backward use F</code> and T</code> for find and till. The Replace Command</a></h3> Use r<ch></code> to replace all selected characters with . For example if you've selected five spaces and type r-</code>, the five spaces will be replaced by -</code>. Typing R</code> replaces the selction with previously yanked text. Joining and Identing Lines</a></h3> To join lines together type J</code>. To indent a line, type ></code>, and <</code> to unindent it. This also works on selections and with multiple cursors.

`Joining and Identing Lines</a></h3> To join lines together type J</code>. To indent a line, type ></code>, and <</code> to unindent it. This also works on selections and with multiple cursors.</p>`

Mwendwa Kavete

Building Restful APIs with Axum

Helix Editor: The post modern modal text editor

Mwendwa Kavete

Building Restful APIs with Axum

Common Response Codes</a></h3> Successful:</p> 200 Ok</code>: All went well</li> 201 Created</code>: The POSTed entity has been created successfully</li>

Axum Hello World</a></h2> Now that we have a basic understanding of Restful Web APIs, let's create a simple one with axum. We are going to create a simple Restful webservice, returning a "hello world" message, formatted as JSON.</p> Note!</p> </div> </div>

Axum handlers</a></h3> One of the main components of an axum application is an handler. According to the official docs:</p> A “handler” is an async function that accepts zero or more “extractors” as arguments and returns something that can be converted into a response.</p> </blockquote>

Helix Editor: The post modern modal text editor