Maurício Gardini - Blog

Sorting Algorithms Studies: Selection Sort

2019-11-02T00:00:00-03:00

After some hiatus, let’s continue with the Sorting Algorithms Studies series. Let’s talk about Selection Sort.

This algorithm showcases a very natural way to order things, one that you probably already used yourself: repeatedly finding the lowest value, and putting it at the start of the list.

Explanation

This algorithm works by, starting at the first element of the list, repeatedly comparing the current value with the next value, searching for the lowest value - or the highest, if the order is decrescent -, until the end of the elements of the current iteration. When the inner loop ends, the value that was identified as being the lowest - or the highest, if the order is decrescent -, is placed at the start of the list. Having provided the clarifications, from now on this article will focus on the crescent order implementation. After the end of the last inner loop, the algorithm starts a new inner loop, excluding the value that was just swapped, and repeats the same procedure above.

Structure

It is comprised by two nested loops:

The outer one loops amongst the numbers that comprise the range between 0 and the size of the array, minus 1. Example: if the array has size 5, the outer loop will loop from 0 to 4. Let’s call the number of the outer loop x.
The inner loop is the one that actually makes the comparisons and swaps. It loops amongst the numbers that comprise the range between 0 plus the number of the outer loop (x) and the length of the array, minus 1. Example: if the array has size 5, the inner loop will loop from 0 to 4 on the first outer loop, 1 to 4 in the second outer loop, and so on. Let’s call the number of the inner loop y.
For each y in the inner loop, it compares the element on the index y with the element on the index y + 1, searching for the element with the lowest value, placing its index in an auxiliary value. Let’s call it swap_index.
At the end of the inner loop, it swaps the element on the index x with the element in the index swap_index.

Also, there is an Selection Sort implementation with a minor optimization. Instead of just looking for the lowest value at each loop, it also looks for the highest value, making two swaps per loop. And, as each loop progresses, the range of elements to be compared by the next loop diminishes by two.

Code

This is the implementation of Selection Sort in Python. It may look slighter more complex than the usual Selection Sort implementation, but that’s because I’ll to provide codes that work both for the crescent and decrescent sorting.

And this is the implementation of optimized Selection Sort in Python. Again, this codes works both for the crescent and decrescent sorting.

Finally, here’s the interactive algorithm visualization, with step-by-step execution.

Complexity

Worst-case performance: O(n²)

Best-case performance: O(n²)

Average performance: O(n²)

Space complexity ¹: O(n)

Auxiliary space ²: O(1) for the normal implementation; O(2) for the optimized implementation. ³

Benchmark

As the posts from the Sorting Algorithms Studies are posted, I’ll benchmark the algorithms against each other. For now, there’s only Bubble Sort, Insertion Sort and Selection Sort to be shown.

Sorting 1000 different arrays with 1000 randomly sorted elements
Algorithm	Average Time Spent (seconds)
Selection Sort Optimized - Crescent	0.0752946375
Selection Sort Optimized - Decrescent	0.0753254230
Insertion Sort Optimized - Decrescent	0.0754734700
Selection Sort - Decrescent	0.0768013875
Selection Sort - Crescent	0.0769227114
Insertion Sort Optimized - Crescent	0.0774509237
Insertion Sort - Decrescent	0.1340322953
Insertion Sort - Crescent	0.1360035590
Bubble Sort - Decrescent	0.1568078588
Bubble Sort - Crescent	0.1597317403
Bubble Sort Optimized - Decrescent	0.1602741867
Bubble Sort Optimized - Crescent	0.1618632810

Sorting 1000 different arrays with 1000 elements in ascending order
Algorithm	Average Time Spent (seconds)
Bubble Sort Optimized - Crescent	0.0002221006
Insertion Sort - Crescent	0.0003292135
Insertion Sort Optimized - Crescent	0.0003776510
Selection Sort Optimized - Decrescent	0.0864848356
Selection Sort - Crescent	0.0876183987
Selection Sort - Decrescent	0.0900442983
Selection Sort Optimized - Crescent	0.0924761386
Bubble Sort - Crescent	0.0998125052
Insertion Sort Optimized - Decrescent	0.1702091216
Bubble Sort - Decrescent	0.2626039418
Bubble Sort Optimized - Decrescent	0.2685824222
Insertion Sort - Decrescent	0.3066988004

Sorting 1000 different arrays with 1000 elements in descending order
Algorithm	Average Time Spent (seconds)
Bubble Sort Optimized - Decrescent	0.0001869991
Insertion Sort - Decrescent	0.0002643334
Insertion Sort Optimized - Decrescent	0.0004072941
Selection Sort - Decrescent	0.0790777007
Selection Sort Optimized - Crescent	0.0794137814
Selection Sort - Crescent	0.0829683988
Selection Sort Optimized - Decrescent	0.0836715313
Bubble Sort - Decrescent	0.0884681934
Insertion Sort Optimized - Crescent	0.1560818879
Bubble Sort - Crescent	0.2418319963
Bubble Sort Optimized - Crescent	0.2456611876
Insertion Sort - Crescent	0.2854158659

Wrapping Up

Selection Sort is another of those simple algorithm that we use more often than we realize. As the Bubble and Insertion Sort, it doesn’t performs well, but it may be enough for some scenarios, like when you have really small lists.

Stay tuned for the next chapters of this series!

Sorting Algorithms Studies: Insertion Sort

2019-10-01T00:00:00-03:00

Continuing the Sorting Algorithms Studies series, let’s talk about Insertion Sort. Basically, this algorithm takes inspiration from the way that you would normally sort a hand of shuffled cards.

Explanation

This algorithm works by, starting at the second element of the list, repeatedly comparing the current value with the previous value, and swapping them if the previous value is higher than the current value; or, if the sorting is being done in decrescent order, if the previous value is lower than the current value. Having provided the clarifications, from now on this article will focus on the crescent order implementation.

Besides doing that with the previous element, if there was a swap, before going ahead and making the comparisons amongst the next elements, it goes retroactively, verifying if the swapped element is in the right place. If it isn’t, continues swapping it with the previous elements until it is. After that, the algorithm resumes the comparisons with the next elements.

Structure

It is comprised by two nested loops:

The outer one loops amongst the numbers that comprise the range between 1 and the size of the array, minus 1. Example: if the array has size 5, the outer loop will loop from 1 to 4. Let’s call the number of the outer loop x.
The inner loop is the one that actually makes the comparisons and swaps. It loops amongst the numbers that comprise the range between x and 0, not including zero itself. Let’s call the number of the inner loop y. But, although the loop is comprised by these values, an inner loop iteration will only be executed if the element in the y index is lower than the element in the y - 1 index. Example: if the array has size 5, the inner loop will loop from 2 to 0 on the first outer loop, 3 to 0 in the second outer loop, and so on, always checking the condition stated above.
For each y in the inner loop, as the condition above was already checked as a requirement for the loop iteration to be valid, all that is left is to swap the element in the index y with the one in the index y - 1.

Also, there is an Insertion Sort implementation with a minor optimization. Instead of continuously swapping elements, for each outer loop, it stores the value of the element in the x index in an auxiliary variable. Then, it keeps assigning the value in the index y to the y + 1 index as long as y is bigger or equal to zero and the value in the index y is greater than the value in the auxiliary variable. Finally, when the inner loop is finished, the auxiliary variable value is assigned to the y + 1 index.

Code

This is the implementation of Insertion Sort in Python. It may look slighter more complex than the usual Insertion Sort implementation, but that’s because I’ll to provide codes that work both for the crescent and decrescent sorting.

And this is the implementation of optimized Insertion Sort in Python. Again, this codes works both for the crescent and decrescent sorting.

Finally, here’s the interactive algorithm visualization, with step-by-step execution.

Complexity

Worst-case performance: O(n²)

Best-case performance: O(n)

Average performance: O(n²)

Space complexity ¹: O(n)

Auxiliary space ²: O(2) for the normal implementation; O(2) for the optimized implementation. ³

Benchmark

As the posts from the Sorting Algorithms Studies are posted, I’ll benchmark the algorithms against each other. For now, there’s only Bubble Sort and Insertion Sort to be shown.

Sorting 1000 different arrays with 1000 randomly sorted elements
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Insertion Sort Optimized	0.0753	0.0736
Insertion Sort	0.1372	0.1312
Bubble Sort	0.1582	0.1544
Bubble Sort Optimized	0.1596	0.1566

Sorting 1000 different arrays with 1000 elements in ascending order
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Bubble Sort Optimized	0.0001	0.2260
Insertion Sort	0.0002	0.2700
Insertion Sort Optimized	0.0003	0.1450
Bubble Sort	0.0839	0.2211

Sorting 1000 different arrays with 1000 elements in descending order
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Bubble Sort Optimized	0.2533	0.0002
Insertion Sort	0.2929	0.0002
Insertion Sort Optimized	0.1607	0.0003
Bubble Sort	0.2491	0.0919

Wrapping Up

Insertion Sort is a simple algorithm, one that we use daily more than we realize. As the Bubble Sort, it doesn’t performs well, but it may be enough for some scenarios, like when you have really small lists.

Stay tuned for the next chapters of this series!

White Noise

2019-08-26T00:00:00-03:00

When it’s time to sleep, random noises bother me a lot. And, although I’m a very noise aware person, some of my neighbors aren’t.

There are the neighbors’ parties that go beyond the allowed times, and talking to them about this isn’t very fruitful.

There are also neighbors which have their TVs in a volume that is too loud, and my current apartment doesn’t have any soundproofing.

Finally, there are the random night noises: traffic, sirens, revving cars and motorcycles, barking dogs… Well, you got it.

As most of these things are not in my control (and I gave up on talking with my neighbors, because this was being more stressful than fruitful), I had to try some ways of fighting this. And, for quite some time, I’ve been trying something that it’s really effective (at least for now): White Noise.

What is this?

Technically, white noise is an audio signal that has the same intensity at different frequencies. Its name is an analogy from white light, which contains all the frequencies combined together. An example of white noise is the static that comes when you try to tune a radio, but it is nonexistent.

White noise image.

Other than that, white noise is also used colloquially to describe constant background noises. The most common examples are rain, sea and fireplace, but there’s also people that find washing machine and air conditioning noises appealing as white noises.

Basically, as it contains all frequencies, the white noise masks other noises. And, added to the fact that white noise is a constant sound, there is no unpredictability, which raises less awareness, diminishing the risk of disturbing.

When I started thinking about this, I can see that I had previous experience with this kind of thing, and it had kind of a nostalgic factor: back when I still lived with my parents, their house had asbestos roof (yeah, I know that asbestos isn’t a good thing nowadays, but these were older times), and when it rained, it resulted in a constant noise that blocked pretty much any other sounds that existed. This even made it hard to watch TV in times when there was heavy rain. Little that I know that I already was being benefited by some kind of white noise.

How I use it

What I do is that, when I lie in my bed, I put my earphones, turn on my white noise app, rest my head in my pillow and close my eyes.

My perception is of a linear noise that fills my hearing and inhibits me from hearing pretty much anything else, allowing me to relax faster.

As for the app, the one that I’m currently using is MyNoise. It has many kind of noises, and there are some of them than need to be bought. You can also customize each of the noises, removing or lowering certain frequencies that may be bothering your experience.

MyNoise app.

I currently only use the White Noise & Co. noise. Based on my previous experiences and memories, it would make more sense that I used the Rain Noise, but I don’t think that the rain noise that’s on the app looks like the real rain noise that I’m used to. For me, it reminds me of a stream, a river. In fact, that’s one of the reasons for me to use the White Noise & Co. noise: because, for me, it kinda sounds like a heavy rain.

MyNoise also has a website, which can be an alternative if you don’t want to download an app. I used it so much that I had to donate to it. It’s a cause that it’s worth supporting!

MyNoise site.

It’s worth noting that there are tons of white noise apps and websites. I just mentioned MyNoise’s app and site because this is what I actually use.

Other Uses

I sometimes find it hard to concentrate to read a book, even more if it is in a foreign language. And, for that, white noise also comes to rescue. At first, it may seem annoying, but once you get into the flow, it helps a lot.

Also, when I’m studying at home, it can be a noisy place sometimes. When you really need to be focused on something, any distraction bothers a lot. And white noise can help a little too. Of course, I can’t play it on a really high volume, because I need to be aware of my surroundings (phone, doorbell), but it helps.

Have a try, maybe?

If you are enduring some of the problems mentioned here, maybe have a try on white noise. It may sound weird at first, but if it “makes the click” for you, you’ll see how beneficial it can be.

Sorting Algorithms Studies: Bubble Sort

2019-08-20T00:00:00-03:00

Lately, I decided to revise on some subjects that I studied a long time ago. One of these subjects is sorting algorithms. And, by studying it, I thought that creating a material explaining these algorithms could be helpful. Yeah, it’s one more person talking about this, but different people have different visions, and looking through other perspectives is always a good thing.

The first article on this subject will be about the first sorting algorithm that people learn, usually: Bubble Sort.

Explanation

This algorithm works by repeatedly comparing the current value with the next value, and swapping them if the next value is lower than the current value; or, if the sorting is being done in decrescent order, if the next value is higher than the current value. Having provided the clarifications, from now on this article will focus on the crescent order implementation.

Some say that the name comes from the fact that, as it happens with the bubbles, that rise to the top in the water, so it happens too to list elements with greater values, which are recurrently pushed to the end (top) of the list.

Structure

It is comprised by two nested loops:

The outer one loops amongst the numbers that comprise the range between 0 and the size of the array, minus 2. Example: if the array has size 5, the outer loop will loop from 0 to 3. Let’s call the number of the outer loop x.
The inner loop is the one that actually makes the comparisons and swaps. It loops amongst the numbers that comprise the range between 0 and the length of the array, minus 2, minus the number of the outer loop (x). Example: if the array has size 5, the inner loop will loop from 0 to 3 on the first outer loop, 0 to 2 in the second outer loop, and so on. Let’s call the number of the inner loop y.
For each y in the inner loop, it compares the element on the index y with the element on the index y + 1. If the first is greater than the second, the elements are swapped.

Also, there is an optimized Bubble Sort implementation. Basically, for each outer loop, a swapped flag is set to False. If there is any swap in an inner loop, swapped is set to True. At the end of the last inner loop, if swapped is False, it means that the array is sorted and no more outer loops are needed, so the outer loop can be ended prematurely and the array can be returned.

Code

This is the implementation of Bubble Sort in Python. It may look slighter more complex than the usual Bubble Sort implementation, but that’s because I’ll to provide codes that work both for the crescent and decrescent sorting.

And this is the implementation of optimized Bubble Sort in Python. Again, this codes works both for the crescent and decrescent sorting.

Finally, here’s the interactive algorithm visualization, with step-by-step execution.

Complexity

Worst-case performance: O(n²)

Best-case performance: O(n²) for the normal implementation; O(n) for the optimized implementation

Average performance: O(n²)

Space complexity ¹: O(n)

Auxiliary space ²: O(1) for the normal implementation; O(2) for the optimized implementation. ³

Benchmark

As the posts from the Sorting Algorithms Studies are posted, I’ll benchmark the algorithms against each other. For now, there’s only Bubble Sort to be shown.

Sorting 1000 different arrays with 1000 randomly sorted elements
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Bubble Sort	0.1692	0.1692
Bubble Sort Optimized	0.1704	0.1702

Sorting 1000 different arrays with 1000 elements in ascending order
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Bubble Sort Optimized	0.0002	0.2563
Bubble Sort	0.0985	0.2519

Sorting 1000 different arrays with 1000 elements in descending order
Algorithm	Average Time Spent (seconds)
Algorithm	Crescent	Decrescent
Bubble Sort Optimized	0.2435	0.0001
Bubble Sort	0.2373	0.0890

Wrapping Up

Bubble Sort is a simple algorithm, easy to understand and implement. It doesn’t performs well, but it may be enough for some scenarios, like when you have really small lists of when there’s not much time to make a better implementation (like in a hackaton).

Stay tuned for the next chapters of this series!

Digital Bullet Journal

2019-06-28T00:00:00-03:00

I’ve been reading about ways to organize my thoughts, trying to be more productive and more conscious about the tasks that I tackle. And, after having a try at Kanban, GTD and others — and not adapting well to them —, I decided to try Bullet Journal, also know as BuJo.

Bullet Journal

The definition of Bullet Journal, by the creator himself, is “the analog method for the digital age that will help you track the past, order the present, and design your future”.

Bullet Journal site.

The problem about this definition is the word “analog” which, in other words, means to me:

Not available at all times;
Can’t be backed up in an easy way;
Has an irregular input method (My writing is not the prettiest thing in the world…).

The idea of Bullet Journal being an analog media is intentional, however, and has its pros:

Doesn’t depend on an internet connection or even any kind of power;
When you are writing analogically, people say that you are being more thoughtful and conscious about what you’re writing.

Despite that, I choose to try to adopt it because:

It’s highly customizable: nothing is predetermined, nothing is mandatory;
You can use it to pretty much anything:
- Organize your daily tasks and to-dos;
- Log activities and facts;
- Taking notes of ideas and thoughts;
- Compile lists;
- Track down habits;
- …and pretty much anything else.

Trying it, the digital way

But, as I said earlier, the “analogic” part of it bothered me. And that’s when I thought: can’t I make it digital?

My requirements for it were:

Inputting on it should be simple, not getting in the way of the information;
Despite the fact that most Bullet Journal users love to decorate their journals, I’m a fan of clean and concise design, so my tool should have a little bit of customization, but not much would be needed;
Should be available everywhere I have an internet connection (pretty much everywhere where I am daily);
Should be easily exportable.

I searched for people which were trying to do the same and, for my surprise, I found them. The three most common ways that people use to create an online BuJo are:

Evernote: I never been a fan of it, but looks like this is the most common way of going digital;
iPad softwares, like GoodNotes, Noteshelf and Notability: probably it’s one of the best and most appealing ways to create a digital Bullet Journal, and it would me my choice if I could. But, despite the fact that I can’t afford an iPad at the moment, taking an iPad (or any valuable stuff) with me in my day to day routine would be kinda risky, as I don’t live at the safest of places at the moment;
Bullet Journal apps: they usually follow an specific interpretation of BuJo, which makes them not that customizable.

Thinking about the tools that I had around, I tried starting a Bullet Journal on a Google Docs document. It had a summary, and each of its pages were equivalent to an analogic page. I tried using it for about 3 months, but as it grew in size I found it harder and harder to manage. Even adding anchors to specific chapters didn’t make it easier to use.

After giving some thought about it — and not willing to give up on the idea of a Bullet Journal yet —, I tried moving it to a Google Sheets file. And yes, it sounds weird and counterintuitive at first, but let me talk more about it.

Journaling in Google Sheets

My experience using Google Docs wasn’t for nothing: at least, with that I discovered what worked for me and what didn’t, Bullet Journal-wise. I came up with three premises:

Write once, display in many places;
Each information must have a purpose;
Automate a new week/month creation the maximum as possible.

Using Google Sheets, each Bullet Journal would be a sheet page. The pages navigation on Google Sheets is simple, due to the pages menu button and for the possibility to hide past and unused pages, which is good to reduce the cluttering. There’s even the possibility of a little bit of customization, as you can add a color to a page tab.

And, with that in mind, I came up to the conclusion that my Bullet Journal has, basically, 4 types of pages:

Year Calendar
Month View
Week View
List

Year Calendar

Year Calendar.

A Calendar of the whole year. Despite the fact that this type of page made it to be featured at my second Bullet Journal iteration, I’m thinking about removing this page, as I don’t use it that often. Also, it doesn’t provide any information that isn’t already in another view.

Month View

Month View.

The view of a single month. It’s where the appointments are written. Also, I integrated the habit tracker on this view, for the sake of succinctness. In my private Bullet Journal, I identify each habit using a two letter identifier, much like a periodic table element, so “Meditating” would become “Me”. At last, there is some conditional formatting on the appointment fields, as the days that have passed will be grayed out, so you know where to look in the moment that you open the page.

This page is named in the pattern <Year> | <Three letter month identifier>, e.g. 2019 | AUG.

When it’s needed to setup a new month, the process is quite simple. On the bottom of this page, below the fold, there are some metadata that are responsible for making this configuration easier. Having said that, the following steps must be followed:

Duplicate a month page;
Remove the appointments and clear the habit tracking data;
Fill the metadatas: Month’s First Day and Month’s Last Day.

With that, the information regarding the title and the days of the week will be automatically calculated. It may be needed to remove (or add) a day in the month, if it’s a 30 day one, but that’s about it.

Week View

Week View.

The view of a single week, starting in a Sunday. It’s composed of 9 sections: a mini calendar, a blank space for each day of the week and an extra space for random notes. As in the month view, there is some conditional formatting on the daily information fields, as the days that have passed will be grayed out, so you know where to look in the moment that you open the page.

This page is named in the pattern <Year> | <Three letter month identifier> | <First day of the week in a two-digit format>-<Last day of the week in a two-digit format>, e.g. 2019 | AUG | 04-10.

As in the month view, the process of creating a new week page is quite simple. On the bottom of this page, below the fold, there are some metadata that are responsible for making this configuration easier. Having said that, the following steps must be followed:

Duplicate a week page;
Remove the information of each day;
Fill the calendar with the appropriate data (will be less laborious if you keep the Year Calendar on your Bullet Journal, then you can just copy from it);
Fill the metadata: Week’s First Day.

With that, the information regarding the title and the days that compose the week will be automatically calculated.

List

List View.

A list of, pretty much, anything I need to log: post ideas, things to study, etc.

Normally, its composed of a single column list, but the number of columns may grow as needed. For example, for things to study, you may feel the need to include a “Reference” column.

To create a new list, just copy from an existing one and remove the content.

For now, it’s working

It’s been around 4 months that I’ve been using Bullet Journal and, for now, it’s doing its job. I’m being more accountable on where I spend my time and more focused on how to spend my free time.

I’ll probably try to use it for at least two more months, to see if it really it’s worth the effort, but I’m sure that the fact that the approach I’m following is a digital one is contributing lots to its success.

If you want to try using my template, feel free to make a copy of it. And, if you have any suggestions or comments, please do contact me!

New Site, New Content

2019-06-03T00:00:00-03:00

6 years. That’s approximately how long since I’ve written a post in my personal site. Lots of things happened since then, but about 2 years ago I decided that it was time to start writing again. Yeah, you read that right: 2 years ago. And this post will describe why it took so long and what happened since then.

A small recap

My old personal site was, actually, a Tumblr. It had many limitations but, for the purpose of sharing my thoughts, it was enough. And, together with a custom domain, it did the trick for some time.

Screenshot of my old site.

I posted for some time on this site, but… Well, “life” happened since then: an 8-6 job, college at night… Everybody does that, I know. It shouldn’t be an excuse for this. But, at the time, it was enough of a hassle for me to stop writing.

Despite not writing, I kept on reading a lot. And, with that, I frequently found content that I felt the need to share. For this purpose, I used Facebook. But, in the middle of 2014, I was feeling more annoyed than pleased on being a Facebook user, so I deactivated my profile on it (I kept it this way until 2016, when I reactivated it and since then I use it as a “read-only” media).

With the deactivation of my Facebook, the main place that I had to share the interesting content that I found during my daily online reading didn’t exist anymore. So I started using Twitter as a tool to share these links. But, as I am not an active social media user, my Twitter profile ended up being a collection of links. Again, it wasn’t that appropriate as well, but it was what I had at my reach at the moment.

In the end of 2015, I finally finished my Graduation on Computer Science. It was a milestone in my life, both for the knowledge and friends that I got from that, but also from the extra time that I would have from now on.

In the meantime, I got increasingly interested in beer, as a drinker and as a self-learner on the subject. So, in 2016, I became an affiliate of CervaSerra, a local homebrewers association. With that, I became exposed to a whole lot of new information, and it made me interested in studying and producing content about it as well.

During 2017, I decided that it was time to create a more appropriate media to share my thoughts. And then my effort to make my new site started.

New site

From the start, I had decided that my new site would be static. With that, I hoped to have:

More control over what I’ll share and how I want to display my content;
Small/smaller hassle on the deploy process;
Low/lower back-end dependency.

Going back to my older times, when I was exposed to Ruby during the development of the now defunct Lector, I remembered of Middleman, a Ruby-powered static site generator. And, then, I started creating my new personal site with it.

But, for reasons that I don’t remember that well at the moment, I felt that Middleman wasn’t what I was looking for. Looking for alternatives, I found Hugo, a Go-powered static site generator. And, again, I started working on my new site using that.

I fiddled around with Hugo for a lot more time than with Middleman, but after that I felt that Hugo was closer, but not what I was looking for either. And, looking for more alternatives, I found my weapon of choice: Pelican, a Python-powered static site generator.

Pelican probably isn’t better or worst than Middleman or Hugo, I know. But, probably because it’s made in Python, which is my day-to-day language, and also is a language that is closer to my heart, I felt more secure on using it.

The development process

Having high standards about the things that I create, I knew that, even though I had chosen the tool that I would use to create the site, it wouldn’t be a simple and short job.

Initially, I thought about choosing one of the themes that pelican themes provides. “Yeah, I’ll do that, so i can focus on the content”. Yeah, right.

I wanted something minimalist, focused on the reading. I found some themes that had this thought as its main purpose, but they weren’t exactly what I needed. “Oh, really? What a surprise!”, you may say. I know, I was just delaying the inevitable: I was going to create my theme.

And so I did it. I wanted it to be minimalist, focused on reading and as CSS-only as possible - and it was what I think that I achieved -, although I needed a little bit of (vanilla) Javascript here and there (Not that much, though).

Having a focus on reading, I thought that appropriate font sizing was really important. So, I tried to implement the concept of Modular Scale. Or, as the Modular Scale site says, “a multi-stranded modular scale”, as it uses more than one ratio. I don’t have a broad knowledge on typography, so I don’t know if I got it right, but the result of trying to apply it was satisfactory for my lay eyes.

Modular Scale site.

I also wanted to implement search. Normally, it requires a back-end, or to use a third-party alternative, like Google. There is a pelican plugin, tipue search, that implements that, but it relies on jQuery, and I didn’t want to add that dependency. Searching for an alternative, I found Joe Vennix’s implementation of a search engine that relies on the RSS feed to make its searches. Looked good enough for me, but it also had jQuery dependency. As it was smaller and simpler than the Pelican Plugin, I decided to convert his implementation to a Vanilla Javascript one, and so I did. I’ll make a post about it in the future.

My First Open Source Contribution

When you work with an open source project, you have the opportunity to be helpful, either by helping the others to achieve their goals by answering doubts, for example; or by making a code contribution.

Despite all my time with programming, I had never submitted a pull request to a project in Github. Again, I blame myself for not doing that yet, and more specifically I blame my self-confidence.

But, during the creation of this site, I was instigated to make a contribution to the Pelican project to solve the lack of a feature that I thought that was interesting. And that’s exactly what I did!

Of course, contributing to a project has its rules, and I didn’t know them, so I can’t say that the process was completely seamless. But there’s some learning in everything, and once I surpassed these difficulties, I managed to make my commit to pass the tests and now I have a pull request that is ready to be merged.

Having said that, making this pull request (and managing to make it eligible to be merged) gave me courage to contribute more and, if I feel that I can help in some project, I’ll probably feel more capable now.

Old Habits Die Hard

During the creation of this site, obviously I had to produce a lot of code. And, for that task, every developer has its favorite text editor.

I started the project using Atom, the text editor created by GitHub. I was using this editor for some months when I started the project, so I got used to it. But, as the title of the chapter says, “old habits die hard”, and some features were missing for me. But, nevertheless, I continued using this editor.

But, then, I started having problems with some default plug-ins, which were producing behaviors that were undesirable for me. So, I disabled one plug-in, then I had to disable another, and another… And, soon enough, there wasn’t many differences between using Atom the way that I was using and using Notepad or something similar. Maybe the color coding and the file tree would be missing, but there wasn’t much more than that.

So, I decided to go back to my trusty friend: Vim. It was my editor of choice for about 4 years and, after a year of Atom, here I was back at Vim again.

My current Vim setup.

As nobody that I know use Vim with its default configuration as a day-to-day editor, I fiddled around with .vimrc and plugins for quite some time. So, expect some texts about this editor as well. There are many knowledge nuggets to be shared.

There’s room for all!

As I stated above, there is an urge to write, but it isn’t limited to programming, tech stuff and life blog, subjects that used to appear on my old site and still will appear here under the Blog section.

I’ll also use this space to post beer-related stuff:

The full recipes of the Brewed Beers so far, as writing down all the variables that were involved on the brewing process is a great way of discovering what you did right and wrong;
My Beer Maps, where I map all the beer-related places of the cities that I already visited;
Other ideas that may come to my mind;

Also, as I said before, I stumble upon interesting links that I want to share. Then, there’ll be a place to post this content. My areas of interest are the broadest possible, so there isn’t a particular theme that will surpass amongst the others. For these unpredictability, I’ll file these posts under what I call Curated Randomness.

At last, as there is some book reading as well, when appropriate I’ll share my two cents about the Books that I read.

…and that’s pretty much it.

I really hope you can find something of your interest here.

I worked really hard to create this site and will do my best to keep creating and sharing quality content. After all, there’s a lot to be discovered and learned out there!

Lector - A news reader for people who want one simple thing: read

2013-06-24T00:00:00-03:00

Yeah, it’s been awhile since my last post here. In my mind, trying to deliver a constant stream of information would be easier. But, with all the things that have been happening in my life, it gets harder and harder to stop everything and write. Nevertheless, this hiatus happened for a good reason: it happened so I could have more time for the realization of a dream of mine.

I’ve been reading feeds for quite some time, and in a quite intense way too: it was not unusual for me that Google Reader showed me a (feared by many) 1000+ on its counter. And I always liked that things worked this way. I like the feeling of navigating through a giant sea of information, searching for unknown lands full of fresh and relevant information.

Google Reader always have been my reader of choice. I really tried using other ones, but they ended up being bulky, counterintuitive, ugly. However, even being my top of mind when it comes to RSS readers, Google Reader wasn’t perfect. But, although its defects kinda bothered me, they were minor, so the discomfort wasn’t strong enough to propel me to create something. Yeah, I was stuck in the comfort zone.

But, then, Google announced they would be killing Reader. At first, there was shock, followed by bewilderment… And, at last, a spark. A spark that lit the fire that would end up igniting the flame of proactivity, of the creativity, of idealism: it’s time to build the RSS reader I always wanted.

By joining forces with a friend that had the same wishes and wills, we made our RSS reader possible. We built a product that makes us proud of it. We created Lector.

Lector: for those who read

Lector: for those who read.

Lector is a RSS reader targeted for those who want a no frills reading experience. To achieve this, we designed an as clean as possible layout, avoiding the use of anything that could cause the sensation of restrainment in any way; also, we tried to remove any structure or marking that could distract you from what really matters: the content. We also have a very interesting set of hotkeys, ready to be used by those who can’t move the hands away from the keyboard, providing a fast and seamless navigation.

But, of course, we aren’t stopping there. An application with a pleasant interface and nice performance is just the start. We have many ideas yet to be implemented, and we are eager to implement them. Why? Because we are RSS reader’s users, just like you. We want an application that can provide us a wide range of features as badly as you. Nonetheless, time is our only enemy, because we are sure that we can achieve the goals that we are aiming for. There may be some daring ones, but we are up for the challenge.

Besides all the things that we already want to implement, we are really eager to know what you, Lector user, would like to see implemented. We are probably missing something that is really important to much people. So, after you try it out, leave us a feedback on how it can be improved, or about what feature is missing.

Oh, and, at last: it will be a paid service. But, please, don’t see this as a bad thing: by requiring you a little amount of money to use the service, we can, then, assure you that we won’t monetize your private information; or else, that the servers will manage to take the load that is required.

So, yeah, that’s pretty much it. And it is with great joy that I can finally invite you all: please, do try Lector. Maybe your Google Reader replacement is here.

Edit: unfortunately, due to time constraints and external factors, we decided to shut down the project.

Using IFTTT to fix the missing pipes on your internet experience

2013-02-27T00:00:00-03:00

I’m an avid user of Google Reader, at least for my standards: I’m signed up to a bunch of feeds, look over hundreds of items, read dozens of articles. It really is a great tool (Actually, any RSS feed reader would do, but Google Reader is the best one for me) and the daily use of it pretty much suffices my need of fresh information and news.

But with Google Reader’s information abundance came another problem: tab management. It wasn’t unusual for me that, when I read my feeds, in a matter of minutes I’d end up having 10, 20 tabs open. Not a great thing for memory management, neither for user experience (Try opening 20 tabs in a 13” screen and see if you can distinguish what is in each tab).

And this used to be the result of a RSS reading session. Or worse.

I looked for alternatives to try to make things work better:

Using other browsers: I tried Safari and Chrome, but the good and old Firefox is still my favorite (and current) browser. Hell, I even tried compiling Waterfox - a high performance browser based on Mozilla Firefox - for Mac OS, but I failed on that task;
Installing extensions to improve the tab management: Tab Mix Plus helped quite a lot here, allowing me to stack rows of tabs instead of a unique row and for improving foreground link opening;
Configurations on the browser’s config to improve memory management and other things.

Some of the solutions quoted above helped more than the others, but none of them was a definitive keeper. But then a thought came to my mind: maybe the problem isn’t the browser. Maybe the problem is… me. Me and my tab management failure. And that’s when I started to think differently and then IFTTT came to my mind.

IFTTT - Put the internet to work for you

IFTTT (Stands for “IF This Then That”) is a service that enables you to connect channels. Sounds weird, but this idea solves many of the problems that a more demanding internet user may find throughout his day-to-day browsing.

This service works using the formula (Or, as they call, “recipe”) “if this then that”, being “this” the trigger that will provoke the “that”, the action by itself. Also, there are the ingredients, which are the pieces of data used/transmitted by the action.

Still hard to understand? Let me narrow it down to an example:

Just a simple example.

Pretty self explanatory now, huh? Then, every time I upload a new photo to Facebook, a copy of it will be uploaded to Dropbox (More specifically to the path “Facebook/Personal”). Simple, isn’t it?

Among the available channels to fiddle with, I can cite Delicious, Evernote, Flickr, Foursquare, Gmail, Google Calendar, Last.fm, Tumblr, Twitter… The list is long and continually grows.

My new RSS reading’s modus operandi

Now, to explain how IFTTT helped with my personal problem, I’ll have to introduce you to three other services:

Pocket, a read it later service: It gets your links and store them for you to read later, pretty simple. It also has a Firefox extension, which I use;
Pinboard, a bookmarking site: It stores the links that you may find useful for future use;
Readability, a service for decluttering webpages on behalf of a better reading experience (I know that Pocket has this feature, but I like to keep each thing on its place).

Having that said, let me dive into how I read my feeds: when browsing through my feeds on Google Reader, if I find something that I want to read, instead of opening it in a new tab, I just click on the nifty Pocket icon that is present on each Reader’s item (Thanks to the Firefox extension).

Adding items to Pocket with its Firefox extension is really easy.

This action automatically adds the item to Pocket and, then, I can keep on browsing through the remaining feeds ‘till there’s none left. And no, I usually don’t read any article directly on Google Reader, unless it is a short one or if I want to read it really badly.

Pocket: visually pleasant and very practical.

With all the items I want to read in Pocket, I dive into the reading process by itself. From here, the items can be included into three recipes:

The recipes I’m using at the moment.

Explaining: if I want to bookmark it, I just mark it as favorite and it is automatically added to Pinboard as a private bookmark; if I want to share it with my friends, I just tag it with a custom tag and it is automatically added to Pinboard as a public bookmark with the custom tag; if the article is too big to read at the moment or it treats about a subject that I don’t want to read just now, I just tag it with the tag “read-it-later” and it is automatically added to Readability; and, if it doesn’t apply to any of the previous cases, I just read it and delete it.

By using this modus operandi, I solved the tab management problem by its root and, at the same time, organized the links that I stumble upon in a more intelligent way.

But, of course, you can do plenty more…

IFTTT is now an essential service for me. I’d happily pay for it if I had to, ‘cause the array of things that can be done with it are almost endless.

Maybe my use case isn’t the best one to showcase all the power that IFTTT provides to the user, but you can check by yourself all that this service has to offer: just go to the browse section of their site and check out all the interesting ideas of things to be done. Maybe you’ll find there the solution to a problem that you have, but you hadn’t noticed yet. Here are some examples of other interesting applications of IFTTT:

Save starred items from Google Reader to Pocket (I could use this one as an alternative to Pocket’s extension);
Send a SMS about the weather every morning;
Save a video marked as Watch Later on Youtube to Pocket;
And many, many others.

Hopefully, IFTTT will be useful for many of you ‘cause, as I said, it allows many, many possibilities. Then, if you discovered an interesting recipe or if you already use IFTTT and would like to share something you use quite often, be my guest!

Slate: a Mac OS X window manager for power users

2013-02-17T00:00:00-03:00

Well, as I already stated, even though I’m quite a newbie when it comes to Linux, it doesn’t mean that I’m not curious about some products developed for it. And one that I’ve been curious since the moment that I first read about was XMONAD.

XMONAD is a keyboard-based automated window manager developed in Haskell. It basically places the windows that you open in a tiled environment, exempting you (Entirely or mostly, depends on how picky and demanding you are) from the task of resizing and organizing them. Also, you keep its configurations in a config file, just like bashrc or vimrc, which is always good. Well, when you see it in action, you’ll agree on how awesome this thing is.

So. Fast.

Nevertheless, I’m a Mac OS user, and using XMONAD on it is not as seamless and practical as it is on Linux. So, of course I had to find something equivalent. Enter Slate.

Slate: my new window manager

Slate is a Mac OS X window manager made for those who are tired of fiddling around with the mouse when it comes to resizing, focusing and arranging programs. With Slate, all comes down to the keyboard: just customize the dotfile with the hotkeys of your liking and you are good to go. If you are a software developer, you know how important it is to maximize the time you spend on the keyboard (Even more if you use vim or emacs), and that’s one of the main reasons for me to adopt it.

Basically, Slate allows you to perform the following actions through keyboard hotkeys:

Move and/or resize windows;
Directionally focus windows;
Activate preset layouts;
Create, delete, and activate snapshots of the current state of windows

An example on how my windows are arranged usually.

Configuring Slate’s dotfile: the basics

As I stated before, Slate is configured through a dotfile called .slate that is placed in the home directory. And, to make it even more clear how Slate is configured, I’ll strip down my .slate as we dive into each concept (or, if you want to check it out by yourself, just check it at Github).

Slate’s readme says that you can configure it using the following directives:

config-: For global configurations;
alias-: To create alias variables;
layout-: To configure layouts. Even though I don’t use layouts yet, I’ll put an example on how to configure it;
default-: To default certain layouts or snapshots to certain screen configurations;
bind-: For key bindings. It’s the one I use most. I’ll narrow down to the location bindings along with an example of each of the main cases I use;
source- To load configurations from another file.

How my location hotkeys could be pictured.

And there’s more…

There are even more things that Slate allows you to do. For example, I only mentioned about snapshots, that allows you to save your current window layout and restore it whenever you want. There’s also the possibility of Slate being more “GUI-friendly”, as there are configurations for showing icon overlays to help focus changing or grids for visual aid when resizing windows.

So, if you’re on a Mac and feel adventurous, have a try. I used to use Moom to place and resize my windows, but Slate does the job much more seamlessly, and it’s a keeper for me.

Hello World!

2013-02-13T00:00:00-02:00

Well, I’m Maurício Gardini, and this is my website.

In my inaugural post, I was planning to talk about myself. But the draft of this post was becoming kinda… huge. So, I’ll leave my “bio things” at the About section and narrow this post to things related to what I’ll write about in this blog.

It’s kind of a big thing to me to finally turn this idea into reality, ‘cause this website was something that I wanted to accomplish for quite a long time.

I live by a motto: “Stay curious”. And, while this is a good thing generally speaking, it can be kinda troublesome because I have many interests, but little free time allied with a huge time management problem. And that’s why this site’s launch got delayed… And delayed… And delayed.

Anyway: in this site, I’ll talk mainly about the things that I experience, use and discover. Yeah, it’s going to be more like a technical site than a blog, but I’m not intending to be very formal either.

So, yeah. Stay tuned for the upcoming updates. =)