One more bit please!


 Hello All!

Well it has been some time since I began working in Ruby and creating little gems of code for my page in the the repository. When I looked at my stats this morning I realised that I had reached a milestone of sorts. The total downloads counter showed a value of 65,881 downloads!

Now, it is a well known fact that a sixteen bit, unsigned integer can count up to 65,536. This means that my download total no longer fits into that data type. While this is not nearly as impressive as the video Gangnam Style blowing through the YouTube signed 32 bit integer view count limit of 2,147,483,647, it is my accomplishment! 😉

One more bit please! That’s right, I’d like a seventeen bit integer, Thank You Very Much!

Best regards;

Peter Camilleri (aka Squidly Jones)

Gem Download Study: The first 12 weeks.

As most of the readers of this blog know, I release a lot of Ruby language gems. They are announced on this web site regularly. Now it is possible for me to check how often these gems are downloaded. You can see that data here.

Now fairly early on, the view was expressed that most (if not all) of downloads I was seeing were the result of “bots” that grab everything they can find and gather the results for their industrial overlords, most likely in China. For some time I’ve wondered if that was true. To be honest, I hope it isn’t, but the nagging doubt never left me.

So I came up with a plan. I would track the downloads of my gems on a weekly basis for 12 weeks and see if I could see some trends that might indicate the nature of the download traffic. Well, it’s been 12 weeks and here are my initial results:

Gem_Downloads_12Now I know it’s a bit of an eye chart, but just click on it to get a better view of the data. Maybe even open it in another tab for easier reference.

The first thing that becomes visible is that the slopes of the lines, and thus the rate of downloads, is not the same for all of the gems. Some of the gems are clearly more popular than others.

Even more telling, is that for one gem, “vls”, a change was made recently, that described the use of this gem with the popular “rails” web framework/library/system. Once this appeal to this very active group was made, the rate clearly began an sharp upward trajectory.

Now this is only 12 weeks worth of data, so one should not read too much into these results, but they seem to indicate that at least some of these downloads can be traced to real people. Time will tell. I plan on my next study release at the 24 week point.

Yours Truly

Peter Camilleri (aka Squidly Jones)

Announcing the Mystikó Encryption gem

Let me start by saying that there is some very important advice to any programmers who might be tempted to create the own encryption security systems. That advice is well summarized by the word: DON’T!

Most home-brewed encryption schemes, including many used in vital embedded systems, are laughably weak. Straying from proven, working standards is a recipe for disaster and loss. So I say again: DON’T!

Having said that, why am I now going to discuss the Mystikó encryption gem? Very simply, this gem is only intended for educational and amusement purposes. Under no circumstances should it be construed to be a serious encryption tool or fit for protecting actual property, privacy or security.

So why do it? Why not? It was a fun challenge and a good follow on for my earlier work with pseudo-random number generators. It was also an interesting way to learn a little bit more about this fascinating topic while having fun with Ruby programming.

The gem itself is at: The Mystiko gem. The source code may be found at: Source Code. The source code also comes with a special added treat! In the Challenge folder of the source code you will find the file “challenge.bin” This file contains a paragraph of famous text encrypted by the Mystiko gem.

At this time, I am still working on raising some funds/prizes for the first person to crack this code, after which the plain text and the key will also be published so that others may verify the winning entry!

So, what shall happen? Will a jury rigged encryption program stand the test of time? or will it be cracked soon as predicted by common wisdom? Time will tell!

Yours Truly

Peter Camilleri (aka Squidly Jones)

Announcing the vls utility.

One of the joys of modern programming is the ability to utilize external code libraries to speed up development, saving time, and reducing wasted effort. The Ruby language is especially blessed in this regard with its system of code gems. Instead of the narrow minded NIH (not invented here) mindset, the world has become our tool chest.

There is, however, a downside to this modular nirvana. Versioning! To be precise: Am I using the correct version of each (and every) little code gem? This problem goes back all the way to the old Visual Basic days. Back then it was called DLL Hell, as developers struggled to maintain a myriad of cryptic, often poorly documented binary files.

Now Ruby does have the bundler utility that allows gem versions to be specified, but what if you simply want to know: When I use this application, what modules/classes are being used?

The vls utility answers that question. To use this simply enter:

$ vls <names>

where names are a list of gems/files to be required before the modules are listed. Here, see an example of this in action:

$ vls fOOrth
vls (VersionLS): 0.1.0

Bignum, 0.0.5
Complex, 0.0.5
Date::Infinity, 0.0.5
FalseClass, 0.0.5
Fixnum, 0.0.5
Float, 0.0.5
FormatEngine, 0.7.2
FullClone, 0.0.5
Gem, 2.2.2
InArray, 0.1.5
Integer, 0.0.5
MiniReadline, 0.4.8
NilClass, 0.0.5
Numeric, 0.0.5
Rational, 0.0.5
Regexp, 0.0.5
RubySscanf, 0.2.1
SafeClone, 0.0.3
Symbol, 0.0.5
TrueClass, 0.0.5
XfOOrth, 0.6.1

The vls gem may be found at: and the source code lives at:

Yours Truly

Peter Camilleri (aka Squidly Jones)

The Durham Makerspace

I’ve written about meetup groups in the blog space before and I continue to enjoy them as a social and educational outlet. Yesterday, I attended my first East-End Tech Meetup. I must say that having a group closer to home is a lot nicer than a 3 hour round trip into downtown Toronto. The real excitement, for me however, was the topic. Here it is from the meetup description:

A remarkable young member of our community is planning to launch a GTA-class Makerspace right here in Oshawa. He wants to present his ideas to our community, elicit feedback, generate more ideas & strategies, as well as gather the much needed support from our citizens here in the Durham Region. This is no small undertaking and it will take the effort of many to back his execution.

This would be a substantial asset to Oshawa and its people so spread the word. Tell your friends & neighbors. Every bit of support is needed to make (pun) this a reality.

Now, I’ve visited maker labs before. They were all far away, very expensive, and difficult to join, especially for an older person such as myself. Let’s just say that I did not feel welcome.

This group is different. I suppose it is at least partly the thrill of getting in on the ground floor, but there was an energy present that I had not seen or felt before. There was also an open exchange of ideas and many diverse contributions were being sought after. My impressions were very positive.

The effort is still in its infancy, but they have a facebook page. Take a look and hopefully find a resource to express your creativity through engineering and making.

Yours Truly

Peter Camilleri (aka Squidly Jones)


fOOrth_logoIt is with great pleasure that I am finally able to announce the release the initial beta of the fOOrth programming language system version 0.5.0. This language, written entirely in pure Ruby is released both as a Ruby gem and in Source Code on github.

So, what exactly is the fOOrth programming language system anyway? The source code repository has this to say about the project:

The fOOrth language is an experimental variant of FORTH that attempts to incorporate object oriented and functional programming concepts. It also tries to extrapolate an alternate reality where FORTH was not frozen in the past, but continued to grow and develop with the times. Above all this project is the result of nearly 30 years of thought on the design of threaded compilers and languages with simplified grammars and syntax.

Also included in the docs folder are a User’s Guide and Reference in both open office and PDF formats.

A lot of work and effort has gone into this personal labour of love. For example, I have discovered that writing good documentation is a lot harder than it looks. It is certainly harder than just writing code. I have also found however that having to explain what is going on in plain, simple, and easy-to-understand terms has resulted in many improvements to the code that would not have happened otherwise. In effect, it served as a sober, detailed review of the code being generated.

This is still only a beta, and there is still a great deal more work to do. I hope you find it useful or at least interesting. If you like what you see, give the code a star to show your support. Suggestions, comments, complaints and ideas are always most welcomed.

Yours Truly

Peter Camilleri (aka Squidly Jones)

The redesigned minitest_visible gem (v0.1.0)

Just because code works, doesn’t mean it’s the correct code. A case in point is my own minitest_visible gem. This little bit of Ruby code adds simple progress tracking to the testing process. In any programming, and especially in a  dynamic language like Ruby, testing is vital. So is having faith in those tests.

Now the standard minitest testing system is awesome! It is full of helpful methods for confirming the correctness of code. It is however a little terse regarding progress. That is where minitest_visible comes in. When used, it lets you know the version of minitest being used and prints out the name of each test file as it is processed.

A fairly simple task. Yet, when I came up with the first version of this code, it was clunky and ugly, but it worked. I suppose I had other matters pressing at the time, but I let things stand at “good enough”

Recently, I began to think that there must be a way to make the code better, cleaner, and easier to use. It seems that I have indeed learned some stuff in the last year because I am now writing about a new version that is far simpler and streamlined.

OK, let’s be clear: The old way of doing things is still supported, but prints out a message about the needed changes. Test still pass though so disruption and panic should be minimal.

The new minitest_visible can be found and the source code is at

Yours Truly

Peter Camilleri (aka Squidly Jones)

A Double Bill!

Having just announced format_engine version 0.4.0, things seem to be speeding along as I now announce format_engine version 0.5.1 and ruby_sscanf version 0.1.1.

These two gems are rather tightly coupled. The ruby_sscanf gem uses the capabilities of the format_engine to create a Ruby translation of the POSIX ‘C’ sscanf routine. This allows a formatted string to be processed into the data elements contained within. The new version of the format_engine is required to add some features required by the ruby_sscanf gem.

I thought a great deal about the idea of merging the ruby_sscanf gem into the format_engine, but in the end, concluded that they did different things despite the high degree of coupling. Further, ruby_sscanf modifies (or monkey patches) the base String class, and that was something that might not always be desired. So two separate gems.

These may be found at:

format_engine gem, format_engine source code

ruby_sscanf gem, ruby_sscanf source code 

I hope all Ruby programmers find these programming tools to be useful.

Yours Truly

Peter Camilleri (aka Squidly Jones)

Format Engine Version 0.4.0

I am pleased to announce the new version of the format_engine gem. This blog has been highly remiss in keeping up with the releases of new code. So, we are skipping ahead from version 0.0.2 to 0.4.0. After a hiatus of six months, the new version has improvements, mostly to the parser side of the engine.

  1. Parsed spaces may match zero or more input spaces so that it is no longer necessary to predict the exact number of spaces between data elements.
  2. The parser now supports strings with regular expression sub-sets like %[abc] which matches the input in the set “a”, “b”, and “c”. Also supported is exclusion sub-sets like %[^abc] which matches the input not in the set “a”, “b”, and “c”.
  3. Improved documentation in the file.

The gem may be found at Ruby Gems and the source code at GitHub.

Yours Truly

Peter Camilleri (aka Squidly Jones)