Phrenorrhea: the weblog of psychoslave

Exploring algorithmic: swap and bubble sort

2022-06-28T15:15:49+00:00

Some general context

It’s been a while since my two initial posts, and although I progressed on some other side projects at satisfying pace, I didn’t dedicated the time I wanted to allocate for this project.

Well, in the mean time I also became father a second time, so I had other priorities, and anyway I try to make my attention less scattered on too many things in parallel. So maybe once I have finished one or two of my current projects, I’ll have more time to dedicate to writting blog posts.

One thing I fully finished since my last post was to read Polished Ruby Programming by Jeremy Evans. It gave me a deeper knowledge of Ruby echosystem, and filled me with ideas to create more modular gems. I didn’t have time to apply much of what I lernt in it so far however. I will surely try to integrate some of these insights in Englishest at some point, but I first want to focus on delievering a first major version which provides verbal alias for each ideographic method identifier.

Inspiration of this post

But as I’m determined to keep progress through learning material, I started to read 40 Algorithms Every Programmer Should Know by Imran Ahmad. The book use Python to provide implementation examples. Altough Python is fine, I clearly still prefer Ruby. So this gives me a great opportunity to make practical exercises and implement these algorithm using Ruby.

The initial material recall basics of algorithmic analysis, especially the way you can quantify the worst case scenario of an algorithm to evaluate its performance, and the famous associated big-o notation. It also cover the basic data structure one can use to implement algorithms, focused on Python, such as list, tuple, dictionary and sets, as well as some already more advanced such as DataFrame and Matrix, Vector, Stack, Queue and Tree. The book also provides complexity of various basic operations on these structures such as time to access, insert and remove an element in each case. We won’t cover these details here, although that might be a topic for a later post.

The first actual algorithm presented in the book is the classical Bubble Sort. As the book recall, its worst-case performance is quadratic, also refered as O(N²), which makes it a poor choice for any production software, but perfect for didactic purposes. The implementation of Imran Ahmad is repoduced below with its kind permission.

def BubbleSort(list):
# Exchange the elements to arrange in order
  lastElementIndex = len(list)-1
  for passNo in range(lastElementIndex,0,-1):
    for idx in range(passNo):
      if list[idx]>list[idx+1]:
        list[idx],list[idx+1]=list[idx+1],list[idx]
  return list

Of course, neither in Python nor in Ruby you would need to really implement such a basic algorithm, as they both come natively with a far more efficient implementation of this operation. In the case of Ruby, there are Array#sort and Enumerable#sort, as well as the more flexible #sort_by flavor, all coming with their inplace modifying versions suffixed with a bang !.

Without further ado, here is an alternative self-made implementation in Ruby:

class Array
  def swap!(spot, slot)
    tap{ self[spot], self[slot] = self[slot], self[spot] }
  end

  def bubble_sort!
    size.-(2).downto(1).each do |cap|
      0.upto(cap).each do |spot|
        slot = spot.next
        next unless self[spot] > self[slot]

        swap!(spot, slot)
      end
    end
    self
  end
end

That’s it, but there is actually a lot of details about this implementation, and how it differs from the one proposed by Imran Ahmad.

First, this implementation use the so called Monkey Patching facility that Ruby offers, that is it extends directly the Array class to add methods that will achieve intended goal, and allows later expression like [2, 1, 5].bubble_sort!. Most object oriented programming langages in constrast come with closed classes: you can’t modify them on the fly like this. This open class design of course should be used sparingly in production code, otherwise overweight classes and identifier collisions with hard to track side effects could easily arise. They are well known methods to mitigate these issues without losing the benefit of expressivity, and we shall explore them later on.

The next thing we can focus on is the swap! method. The retained method name is classical, and probably don’t require much more comment. Wiktionary provides the following definition: To exchange or give (something) in an exchange (for something else), which match perfectly want we intend indeed. Most implementation of swap function out there seems to use parameters with dummy identfiers, like a, b¹ or x, y², or at best some numbered couple of a more or less meaningful term like pos1, pos2³ or even some without any cryptic apocope like index1, index2⁴. Those used in this implementation come out of a more personal approach to use identfiers with names which are ideally:

usual English terms, without apocopes
meaningful in context
terse as long as it doesn’t conflict with previous requirement

The last point on terseness is a bit more weighted in my attention when these terms are included within a line which include many terms, like the single one defined in swap!.

Both spot and slot are usual English terms with a locative semantic. The morpohlogical proximity is more fortuitous, altough they might be etymologically related just like splot and splotch.

Regarding the famous unique line of swap! it uses Kernel#tap to return self after due changes, without having to explicitely express it on a second line. Indeed, an equivalent method body would be:

    self[spot], self[slot] = self[slot], self[spot]
    self

Or even more verbosely using return self for the last line. The solution however doesn’t opt for maximizing brevity, and avoid the shorter but more cryptic tap{ _1[spot], _1[slot] = _1[slot], _1[spot] }, which uses the implicit numbered arguments introduced in Ruby 2.7.

Moving on, we finally get to the #bubble_sort! method definition. As the context provide directly access to the aimed main variable, it doesn’t take any parameter. This is in contrast with a more bare functional approach where each parameter is provided explicitely. For exemple in Python, even using an object oriented implementation, one would write something like def bubble_sort(self):.

In contrast Ruby bind self implicitely for you, and even let you call most methods on self while completely omiting this term. That’s how the first line can start directly with a call to size, rather than the more circumlocutory self.size.

This first line is somehow dense, so we are going to chunck it, but note that once you have all the implied acquaintances, all this is really straightforwardly expressed.

Basically the goal of this line is to generate a list of index for the last spot that will be considered in each pass. In the first pass, the last spot is the penultimate element in the array, the last one being the slot.

So, since Ruby array indexes start at 0, if we have an Array with 10 elements, the last spot of the first pass will have index 8, that is size-2, the last slot will have index 9. Of course, the algorithm will first analyse if a swap is required for elements with index 0 and it’s subsequent, and so on until 8 included for this first circuit round. The next tour will go up to 7, then 6, and so on until all laps where roamed.

The first line start with rather unusual way to call the minus operator, that is size.-(2). This allows to chain directly with a call to the Integer#downto method. An other way to do that would be to use #pred twice: size.pred.pred̀ . Using latest development version of Englishest, it would be possible to express it assize.minus(2) or size.mow(2)` which would have my preference, but here I wanted to stay on bare Ruby facilities. All the more it gives the opportunity to recall how in Ruby operators are mostly regular methods which are given some syntactic sugar privileges allowing them to be called in a different manner than through the usual tagememic dot notation which act as a syncategorema, also called syncategoremata. Of course you don’t need to understand any of this abstruse linguistic matter to happily hack with this kind of stuff, but surely it might have a nice effect if throwed at the appropriate audience. Don’t use them at your next familly dinner though. 🤣

The code might be a bit clearer with a named variable assigned, as penultimate_index = size - 2, so that the first loop would look like penultimate_index.downto(1).each….

With that in mind, the first line of this implementation is hopefully crystal clear: size.-(2) compute the index of the last spot, downto(1) generate an Enumerator that start with this integer and counts down to 1. Those elements are taken as cap of new enumerators starting from 0. Thus the inner loop will be given the current spot to consider upfront, and the slot is simply the following integer. The loop can jump to the next iteration if no swap is required on the current pair, otherwise the swap is done. Note that in this implementation, we fully take advantage of Ruby flexible syntax, inherited from Perl, and put the condition after the instruction to execute. This can arguable sometime lead to code whose flow is harder to track, but when the instruction is a flow control command, this result in a code that stick better to how you might reason about the code, rather than how the machine instruction set constraints your thought flow. This consideration partly explain why I chose to put the condition on a separate line rather than using something like swap!(spot, slot) if self[spot] > self[slot]. We could also replace the three lines of the inner loop with a single one like _1>(_=_1+1) && swap!(_1,_) if we would like to be especially cryptic. _

Finally, once all loops where traversed, the method return the array instance for conviniency: this allow to chain method in a fluent way. The same result could be achieved using tap as in swap!, however this would add one more block level depth that was judged undesirable here.

The bangless version

As you might have notice, so far we provided only methods with a bang, that denotes some danger in Ruby, like inplace modification of an instance. But this is not a consistent garanty: Array#push will change the instance object even it doesn’t have a bang suffix. And as Nick McCurdy famously report it: ActiveRecord::Base#save! is a version of ActiveRecord::Base#save that performs validations… and ! is only needed when there is a more dangerous version of a method that already exists, and this does not necessarily mean that the dangerous method edits in place.

So let’s have safe versions for both methods swap! and bubble_sort!!

The easy way to do it, is to simply apply the changes on a copied version. There are some points that worth our attention tough:

this will impact performance as the whole list will have to be copied first;
depending on object types in the list, a shallow copy could be insufficient.

Provided that we are fine with these aspects, the implementation could be as easy as:

# within class Array

def swap(...)
  clone.swap!(...)
end

def bubble_sort
  clone.bubble_sort!
end

For list of direct value like small numbers, that is enough, and for composed values, it would ask to create deep copy whose efficient implementation won’t be covered here.

Modularization

As mentionned above, in practice you would rather avoid to directly integrate your methods within a basic class. At the very least, you would first implement them in a module, and extend the target class with this module like this:

module Endopermutable
  def swap!(spot, slot)
    tap{ self[spot], self[slot] = self[slot], self[spot] }
  end
end
Array.include Endopermutable

With that, Array.instance_method(:swap!) will output a String which contains something like Array(Endopermutable)#swap!, unless an other module override it in the same manner: that makes code tracking far easier.

But there is more. You don’t actually need to directly include a module into a basic class to benefit from its features in Ruby. Of course, you might create a subclass, like in most object oriented language and include the module in this subclass. But there is an other option in Ruby that allows for a thinner granularity, which is mixing in a module directly into an object instance, so that [1,2].extend(Endopermutable).swap!(0,1) will work as expected while leaving the raw Array class unchanged, avoiding any side effect this might generate.

Generalizing the `swap` method

https://www.cplusplus.com/reference/algorithm/swap/ ↩
https://www.delftstack.com/howto/c/swap-function-in-c/ ↩
https://www.geeksforgeeks.org/python-program-to-swap-two-elements-in-a-list/ ↩
https://stackoverflow.com/questions/64189589/how-to-swap-two-numbers-of-index1-and-index2-in-my-array ↩

My motivation to write a blog

2022-02-10T17:06:21+00:00

So as I cheated yesterday writing my first blog post a day after the “official” publication date, and as I wasn’t able to write a second post in the same day, I’ll just skip 2022-02-09 unlogged. Not a big lost for humankind I guess, and this seems a better approach for cognitive load, rather than trying to catch with every gap here and there.

I think that one thing that played a motivation role into starting this blog was simply time that pass, and will to have a more clear narative of my life, be it for myself alone. Incidently, 8 Februabry is my birthday. As I was born in 1984 (yes, like the title of the famous dystopian book of Orwell), that was my 13,880 circadian cycle. I know it because I asked Ruby:

require 'Date'
Date.new(2022, 2, 8) - Date.new(1984, 2, 8)

How neatly it makes easy computationnal tasks easier! I love it! ❤️

As we are with some geekery, did you know that 1984 spells 11111000000 in binary notation? That’s 5 ones and 6 zeros. I don’t know for you, but for me it immediately catches the will to know what are the previsous number in this sery of n ones and n+1 zeros. And is this series already registered in the The On-Line Encyclopedia of Integer Sequences® (OEIS®)?

So the series start like this: 100 (4), 11000 (24), 1110000 (112), 111100000 (480), 11111000000 (1984), 1111110000000 (8064)”. Obviously, I’ll be dead by 8064. Probably no one of this far away year will ever read this. Actually, I wonder if anyone will read it during my lifetime? 😅 Also, by current evidences of the life and death of calendars, by 8064 Common Era, whatever human civilization will still roam around – if any –, it will have probably moved to another one. By the way, you get the previous series in Ruby with, 1.upto(6).map{|n| "1"*n + "0"*(n+1)}.map{|n| "#{n} (#{n.to_i(2)})"}.join(', '). And it is registered as A059153.

13,880 is of course also an interesting number about which a lot of statements can be uttered. But none that catched my attention though. 😆

Back to motivation, an other thing is that a few years ago I red The miracle morning by Hal Elrod. From it I kept the habit to wake up early, but didn’t fully followed the whole method, especially I never started a diary. So far.

Finally there seems to be some interest from recruiters that ask if you do have a blog. Until know I just had nothing to drop in for this kind of demand. But to be honnest, I was more embarrassed with the state of my Github account which didn’t show as much as open contributions as I would like. Indeed, I spent most of my professional career working on inhouse software building and maintenance, which often don’t let you release much things in the wild. This is all somehow ironic as in my spare time I’m a firm defensor of Free Libre Open Works (FLOW), as I like to call them. So as this blog can be hosted on Github, this will make more wild contribution, although that is still not as contributive to the software side of things.

Oh, one more thing regarding motivation. I recently stopped, again, to use Timewarrior to track everything in my life. It was marginally useful to know where I was at some point and to who I paid attention, how much time I had spent on some project, but in the end this wasn’t so useful insight, at least I never got oh great WOW from looking at it. I feel like writing prose like this one will better contribute to my personal fulfillment than seizing tag centric chronometries, which poorly synthesis the luxuriance of thoughts and feelings.

My discovery of Jekyll and the world of writing a blog

2022-02-08T16:46:30+00:00

So this is a first post. It’s actually more a training field for me to play with Jekyll.

I will let the orignal engine documentation bellow, it might serve me well in the near future, and who knows, maybe others?

Anyway I don’t have yet precise topics I want to discuss on my very own blog, and to be honnest this is rather an alien practice to me. I’m more accustomed to publish things on the form of “research project” with unpersonal tone. Like the Sur l’extension des genres grammaticaux en français. Oh, yes, since French is my mother tongue it is also the one I most often write into my prose. I might switch here and there, but since chances are good that I write here to unleash opinions and share experiences on CS/IT stuffs, whose vehicular language is English, I will probably mainly stick with that.

So yesterday, as I’m actually writing that on the 9 February, editing the first blog post Jekyll created for me, while making my daily HN watch, my eyes where catched by the entry Human technology: Text files. In this blog post by Boris Marinov made me discover Jekyll and how easy it was to maintain and publish a blog using my familiar dev tools. So this is it, I can write some Markdown in my beloved Vim/Neovim and git push to Github to get there. To be honnest, it took me a bit more of perseverance, as I was sitting at the time before an almost naked Windows box. So I had first to:

install Ruby – one of my favorite programming language anyway
setup a descent command line, with WSL2, Alacritty, Fish, and so on
fix an issue that prevented to run bundle exec jekyll serve from a git bash prompt with Ruby 3.0.

Anyway, all in all it worked, and here we are, a few commits later, ready to publish something.

Bellow is the original post, prefilled by Jekyll

You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve, which launches a web server and auto-regenerates your site when a file is updated.

Jekyll requires blog post files to be named according to the following format:

YEAR-MONTH-DAY-title.MARKUP

Where YEAR is a four-digit number, MONTH and DAY are both two-digit numbers, and MARKUP is the file extension representing the format used in the file. After that, include the necessary front matter. Take a look at the source for this post to get an idea about how it works.

Jekyll also offers powerful support for code snippets:

def print_hi(name)
  puts "Hi, #{name}"
end
print_hi('Tom')
#=> prints 'Hi, Tom' to STDOUT.

Check out the Jekyll docs for more info on how to get the most out of Jekyll. File all bugs/feature requests at Jekyll’s GitHub repo. If you have questions, you can ask them on Jekyll Talk.