DEV Community: Bruno Baère

Configuring NeoVim plugins

Bruno Baère — Thu, 04 Aug 2022 05:37:40 +0000

NeoVim is a fork of vim that evolved into its own thing, but maybe you already knew that.

In this very short post, I'm going to help you configure your NeoVim installation on Windows to use NERDTree and vim-airline.

Starting from ready-made `init.vim` file

Download Lefticus's vim-config files (including the autoload directory) to your nvim configuration directory.

On Windows 10 it will be located at C:\Users\<USER>\AppData\Local\nvim, where <USER> is your user handle. Maybe you'll need to create the nvim folder.

Lefticus's config files already include vim-airline. Let's add NERDTree. Locate in the init.vim file the section where plugins are added. Add the line Plug 'preservim/nerdtree' to this section. You may end with something like this.

Installing the plugins

Launching neovim after adding the files may show some errors. These errors will be corrected after downloading the plugins.

Enter command mode (press :) and run the command PlugInstall. Ex: :PlugInstall. Another tab will open with the downloading and installation progress.

If at any moment you need to update the plugins, run :PlugUpdate. And if any plugin is broken (for example, when I changed the path to NERDTree), you may be prompted to run :PlugClean.

Configuring Airline to use a Nerd Font with Powerlines

Firstly, if you don't have a Nerd Font, you can install Cascadia Code.

Better yet, if you're using the vim-devicons plugin, use the patched version at Nerd Fonts that include the icons. The rest of the post follows as equal.

The next step is to add a line to your init.vim file configuring GUI Font to a font with powerlines. See the example below, where I configure neovim to use Cascadia Mono PL with size 12:

set guifont=Cascadia\ Mono\ PL:h12

Mapping an shortcut for toggling NERDTree

Add the following line to your init.vim file.

map <C-o> :NERDTreeToggle<CR>

This will set Ctrl+o to run the command :NERDTreeToggle.

Adjusting tabs to spaces

These lines will adjust tabs to 4 charactes wide. (Extracted from StackOverflow).

set tabstop=4
set softtabstop=0 noexpandtab
set shiftwidth=4

Being a heretic and using the mouse

If you really want to use the mouse with neovim, add set mouse=a to your init.vim. a stands for "all modes".

Beware! You will attract strange looks from fellow workers using a mouse with neovim.

The final look

References

C++ Weekly with Jason Turner - From where I took the initial vim files. Jason is a well known figure in the C++ community, and his channel is a great place to learn.
How to make a pretty prompt in Windows Terminal with Powerline, Nerd Fonts, Cascadia Code, WSL, and oh-my-posh - Scott guides you through configuring Windows Terminal to show git status on your prompt. Still useful, and where I first heard about Nerd Fonts.

The experience of writing a ray tracer in Go

Bruno Baère — Fri, 08 Jul 2022 05:11:42 +0000

Motivation

There was a lazy day on an extended weekend when I was watching The Cherno's Code Reviews series and came to meet (again) the Ray Tracing in a Weekend book series. As the code was already in C++, I thought it wouldn't be much of a challenge to write it again in the same language. It would rather be best to identify and improve bottlenecks, or to use Modern C++ techniques.

Alas, I had already written a ray tracer in C back in college as a classroom assignment and had worked on some improvements in a Computer Graphics class in my post-grad.

But as I'm learning Go (and loving it) and I was searching for projects that would be nice to have a taste of what Go has to offer, it occurred to me that writing the ray tracer¹ in Go would be fun and easy.

And it was.

Go makes it a breeze

Go already has image manipulation, profiling, and flag-parsing off the shelf. So, instead of following the book's suggestion of writing the result to a text file, I could output it directly to a png file.

Go's syntax² makes you write clean and easy-to-understand code. This project made me work with interfaces, whereas in C++ I'd probably resort to templates or inheritance.

The only external library I had to resort to was a Go implementation of glm.

What's next?

Once I finished the first book, I knew some improvements could be made to run faster and better. For example, as ray tracing is extremely parallel, I could use goroutines to use more cores.

Also, there are other two books in the series: "The next week", and "The rest of your life".

The path of others

Surely, I wasn't the only one who thought about doing this project. If you're interested in how other developers handled implementing the ray tracer in Go, I'd recommend taking a look at these:

What do we take from it?

Adapting "Ray Tracing in a Weekend - Part 1"'s code to Go was an entertaining experience. I certainly would recommend using it to get a hold of the basics of a new language you're learning. I'm just waiting for the opportunity to tackle the second and third books in the series, and going back to the start with The Ray Tracer Challenge.

killerasus / GoRTIW

Implementation of the book series Ray Tracing in One Weekend in Go

Go Raytracing in One Weekend

This is an implementation of Ray Tracing in One Weekend - The Book Series using Go and go-glm.

As I am learning Go, I decided to translate the book's C++ implementation to Go. The objective is to compare both implementations, trying firstly to accomplish each chapter's objectives, and secondly trying to optimize the result.

The current status of the code is shown below:

Chapter	Result
Book 1 Complete

As stated in the book, Ray Tracing in One Weekend does not aim to create a complete ray tracer (more of a path tracer). The following books add more functionalities to the ray tracer, making it feature complete by the end of the series.

View on GitHub

1: Actually more of a path tracer than a ray tracer.
2: Sometimes I get myself thinking that Go is C and Python's child.

Using Hoppscotch to test REST APIs

Bruno Baère — Tue, 05 Jul 2022 22:32:44 +0000

Recently I've been involved in backend development writing an REST API to expose some data to other apps from our client's ecosystem.

After messing with curl, I felt the need to have some friendlier way to test the API, besides writing some shell scripts or Python code, so non-technical people could also test with ease. Hoppscotch came to the rescue.

Hoppscotch

Hoppscotch is a free open source API development suite which runs in your browser. A commercial equivalent is Postman. Hoppscotch provides a workspace environment, where you can organize your work in request collections and environment variables.

This post shows the basic usage of Hoppscotch services for testing requests to an API. For more details on how to setup testing and scripts, refer to the official documentation at https://docs.hoppscotch.io/.

Sample code for the server

For this article, I'm using the following GitHub repository for the server code (Go with Gin). It provides an API to retrieve and create drivers for an ~~not nearly secure or even close to~~ hitchhiking-like app (you know which one).

killerasus / GoRest

Implementing the REST API examples from APIs REST by Alexandre Saudate

Go REST API

This program simulates a driver-sharing app like many famous apps through a REST API using Go and Gin.

An adaptation of the examples from the book APIs REST by Alexandre Saudate.

View on GitHub

The server (as of the time of writing this post) provides the following API:

Method	Endpoint	Action
`GET`	`/driver`	Recover drivers list
`GET`	`/driver/:id`	Recover driver information
`POST`	`/driver`	Create a driver

We'll start by creating a collection to hold our requests.

Creating a collection

Collections are a way to organize your work. So, for your workspace, you could create a collection for all driver-related requests, other collection for hitchhiker requests, and another for the rides requests.

Let's start by clicking on the Collections icon and then clicking on + New.

Give your collection a name (if following the example API, I would recommend GoRestDrivers).

Next, we'll create our first request. On the three dots icon on the right hand side of your collection, you can see other operations, such as exporting and renaming your collection.

Creating a request

After creating a collection, we can use the New button to create a new request. Let's do that.

Let's name our request Create Driver. The main area is now representing this request. Let's customize the request. According to the documentation, to create a driver we must send a request usiung the method POST to the /driver endpoint. The body of our request is a json object.

There's a combo for choosing the method. On the left, click on GET and change it to POST. The URL should be http://localhost:8080/driver, as I am running my server on the localhost using port 8080.

To set the body of our request, click the Body tab. Set content-type to application/json, and on the raw request body, we can insert the data to create our driver.

Running the request and troubleshooting

To test our request, we must first run the server. Then, we'll need to click on the button Send.

If this is your first time running, you may receive an error that the API endpoint couldn't be reached. This could mean the server isn't running, you need a proxy or you haven't installed the Hoppscotch browser extension. A message similar (because I already have installed the browser extension, but haven't started the server yet) to the following should appear.

After installing the browser extension and making sure the server is running on the correct port, click Send again. You should see the result.

Try modifying the body json to create new drivers. A following exercise should be creating the other request, like the GET request to get the list of drivers to verify everything is working as it should.

Creating environment variables

Until now, our requests used a hardcoded port (8080) to access our server. But if we are to modify the port, we would have to change every request created.

We can use environment variables to avoid this issue. Let's change our GET /driver request to use a variable named port instead of a hardcoded port. The URL will be written as follow:

Variables are referenced by <<variable>> and can be used everywhere. For example, you can define a token variable and use it as the authorization token value. When a variable isn't defined yet, it will have a red shading. After defining the variable, it will assume a blue shading.

Click the Environment icon, and the Global environment.

A popup will open to Edit Environment. Click the + icon to create a new variable, name it port and assign the port value.

The port variable shading in the request will be changed, signifying it is defined.

Anytime you need to change the value of the port, you just need to change the variable value in the Environment.

Conclusion

This was a quick introduction to Hoppscotch. I hope this has driven your curiosity to experiment with Hoppscotch. It has made testing our APIs easier.

For more information, check the current documentation on https://docs.hoppscotch.io/.

Measuring program execution time in PowerShell

Bruno Baère — Sat, 05 Mar 2022 00:32:33 +0000

As I was nearing completion of implementing Ray Tracing in One Weekend in Go, I felt the need to measure the time it would take to render a scene¹.

My day-to-day work is in CentOS, so I was tempted to try time gortiw in Windows Terminal, as it already had some improvements over cmd, like ssh and an alias for ls. I was disappointed. There was no easily accessible time-like command nor it was an alias.

After searching a little, I got to a solution: using PowerShell's Measure-Command. Then I just needed to create a function time in my PowerShell profile and it was done.

Steps

Edit your Documents\PowerShell\Microsoft.PowerShell_profile.ps1

Add the line

function time { $Command = "$args"; Measure-Command { Invoke-Expression $Command 2>&1 | out-default} }

Open a new instance or tab of PowerShell to use the new time function.
Ex: time gortiw.exe

Satisfied with the results, the next step will be using a profiler to check where to improve.

Notes

1. Yes, I could have used a timer in Go inside the ray tracer itself, but having a timer like `time` is still useful.