Gist of the Day: Using Mojo, Mongo, and SL4A to send SMS Messages (1 of 2)

I got a little bored with what I had been posting (I suspect you did, too), so I’m doing something neat. I’m going to write a full (though limited) program for you. Here are the user stories (if you don’t know what user stories are, see here before continuing):

Facebook, the Qt5 Web Application

This is a really cool idea, it’s a site-specific browser, similar to Fluid on OS X. This has alerts and such that come up as well, and it’ll sit in your KDE task bar. I’m digging it so far. I suspect that it’ll play nice in other DEs as well.


The app is available as a .deb as well as a source package, and many different OS’ and configurations are available. I’m using the Ubuntu package since I’m in Kubuntu land. This app does appear to be receiving updates, the most recent one according to was on September 3rd, 2013.
Here are the features I see:

  • Supports SSL Facebook (very important for me since I have an ISP which engages in DPI)
  • Works with two-factor authentication with Facebook
  • Simply uses the web UI of Facebook (I see this as a plus, not a minus, that way I’m not stuck waiting for someone to implement changes that Facebook threw into an API update)
  • Very lovely Facebook blue window border, fits in very nicely

Here are some areas that I would like to see improved:

  • I’d like to be able to resize the window
  • I’d like it not to crash when something tries to use Flash (too much stuff on Flash crashes)
  • It’d be neat to not have to log in again every time I opened the app.

I think that with only some minor changes, this app could be one that I keep running in the background all the time. I’d love to see something like it for Twitter as well.
Here’s the app: Facebook

Gist of the Day: Find All Paths for an Undirected Graph

I’ve been doing a lot of stuff lately with data structures and algorithms. This is one that seemed remarkably complicated to me – and still kinda does – when I started. It’s not as trivial as a binary tree mainly because there are far fewer rules. There’s a whole lot of stuff you can do with graphs, and this is by no means an advanced or complicated usage of them. This is as simple a task you can do with a graph.
The task at hand is to find all possible paths between two vertices. Continue reading “Gist of the Day: Find All Paths for an Undirected Graph”

Gist of the Day: Re-Inventing Hashes… In Perl.

Before you begin the well-deserved flaming, please understand that I do not intend on submitting this to CPAN. This is purely an academic exercise to demonstrate the algorithm (poorly), and to help me practice some stuff. I understand that this isn’t terribly efficient, and I am quite confident that one could do this much faster (and probably has many times over). I wrote this for fun, and for boredom, and I’m posting it because I thought it was cool and because I promised you I’d post stuff.
This algorithm is pretty simple. The premise is that you take a key value of some sort, you hash it using any algorithm, and then you take the mod of that hash value by the capacity of your hash table, and that gives you an index! It’s pretty simple, and even in the implementation I have here I believe it’s not a terrible look-up time.
The basic idea is this: $array_index = hashval($key) % $array_capacity
Continue reading “Gist of the Day: Re-Inventing Hashes… In Perl.”

Gist of the Day: Process Control with fork(), exec(), and kill()

I feel really bad for leaving you all high and dry yesterday… really bad… okay, you’re right, I don’t really feel all that bad.
I have a doosey for you all today though, no doubt about it! One of the most common trends in computers these days is multi-processing. Multiple cores means one program can do more work by spawning extra threads or child processes. I’ve already done a bit of stuff with threading, so here’s a bunch of stuff with forking (tee-hee). Continue reading “Gist of the Day: Process Control with fork(), exec(), and kill()”

Gist of the Day: Analyzing Performance with

In my post on Inline::C a few days ago I mentioned The Rules of Optimization Club, and then I ranted a little bit about how if you cannot measure a performance problem then you don’t have a performance problem. That’s not to say that you’re incorrect in asserting that you have a performance problem, it is only to say that you cannot identify any particular part of the problem as a performance problem until you have measured it.
There a great number of ways to measure performance problems, profiling probably being the most useful in situations involving large applications where you want to test performance under real-life situations. For profiling, I would recommend you look at Devel::NYTProf. This profiler is exceptionally feature-rich and has a boatload of useful functionality. All that said, here I’m only going to talk about bench-marking small pieces of code. Continue reading “Gist of the Day: Analyzing Performance with”

Gist of the Day: Some convenience macros for use with Perl C internals

I feel awful. Like, really awful. The baby is sick, my partner is sick, I am sick. You still want something neat though, so I’m going to show you something very simple that I’ve used for a while.
As I’m sure you noticed in yesterday’s Inline::C demo, Perl guts and C API are pretty noisy with a lot of boiler-plate. For this reason, when I first started playing with Perl guts and API, I created a header file just to make things a little simpler. Nothing here is terribly complicated, and they’re all just simple convenience macros, but sometimes that type of macro saves you oodles of time. Continue reading “Gist of the Day: Some convenience macros for use with Perl C internals”

Gist of the Day: Automated Testing With CUnit

It’s no secret that I love automated testing. I have done automated testing in Perl, C, Java, JavaScript, C++, Python, Objective-C, and PHP. I have yet to find an automated testing framework I didn’t like. C is a unique case since it requires a little more cleverness to perform some of the normal control techniques that you can do with other frameworks.
Continue reading “Gist of the Day: Automated Testing With CUnit”

Gist of the Day: Roles in Moose!

Have you ever struggled with how to structure your class hierarchy, given a common type of functionality which applies to some classes but not others? Say for instance you have a class named Animal. With this Animal class you can derive all of your animal classes. Take for instance a chicken, for which you subclass Animal to a class you call Chicken.
One of the features you’d like to implement is that an animal makes a noise. Chickens, for instance, cluck. Some animals, however, don’t make a noise. Take a seahorse for instance, it doesn’t make noise. It is every bit an animal, but it doesn’t make noise. There are many other mute animals across many different families of animals, so it doesn’t really seem to fit in to your hierarchy. For this purpose, you can use a Role in Moose. A role allows you to dynamically add functionality to an existing Moose class (as many of them as you like) without having to mangle your nice, clean class hierarchy. Think of it as a grab-bag of functionality for your class which can also be used by other classes regardless of their parentage.

Continue reading “Gist of the Day: Roles in Moose!”