The solution was not elegant enough. I then started experimenting with different setups. On the Mac Mini I hooked up an external web cam and made the audio input come from the web cam – on a usb-extention cord to the baby’s room. I then tried 3 things. First I did a Quicktime Stream server and used the QuickTime Broadcaster application on the Mac Mini to create a stream. This approach – though it would scale well didn’t really match up well on the iPhone or the iPad as a client – without writing a html-page and embedding the stream in that page. Scrapped that plan. Then I went for FaceTime. Using FaceTime I had video and sound directly between either an iPad or the iPhones. Excellent. One drawback was that the video-part of it made the iPhone very hot – and it drained battery very fast. An added problem was the same as on the BabyMonitor-app – it needs wifi to work – any drop in connectivity means that you need to place a new call and answer that call in the other end. Scrap that.

The last and final solution – so far – is to run Skype on the Mac Mini – create a special account that auto answers people you have in your contact list. You then use the Skype-app on the iPhone to call in to the baby-monitor-account. This was you instantly get audio when dialing in – you can even go video – but that is not needed. The system works quite well – it’s even available on the 3G network – so the wifi-connectivity-issues aren’t important. Having an unlimited data-plan – I have no scruples doing it entirely over 3G on the iPhone-side – and the quality of the audio is not bad at all.

So if you already own a machine – any kind – be it linux, pc, mac or whatever – and already own an external webcam – already own the usb-extention cable and a smartphone or tablet capable of running skype – this solution is free. Skype doesn’t cost a dime – and the only thing you need to worry about is paying for the data – unless you go unlimited. You can even do an iPad->iPhone, iPad->iPad, iPhone->iPhone, Android->iPhone,Galaxy->iPad. The sky is the limit in terms of platforms – but a real cheap old linux-box would suffice.

Method

To do this benchmark I made simple Hello World programs in the different languages (some compiled, some interpreted). I then wrote a simple wrapper in Perl that ran the programs in a for-loop, simulating running the program 1000 times. This method may be a testament to how well my ubuntu fires different executables and frameworks and not to the code, but it is still interesting to see how a real world application of a program language is to do a menial task like printing a string many times. To eliminate the graphics-card I piped the output of the programs to a file in one instance and did nothing with it in another instance (just back-ticking the output to a perl-variable and then doing nothing to it). Before claiming that the methodology is unfair I would like to point out that this is the way I run programs on linux/unix and that for my particular use this is  a valid benchmark.

Doing another benchmark where I basically let the hello world program contain a 1000000 long for-loop written in the program itself and then running this program 10 times I got different results:

GCC:    timethis 10:  1 wallclock secs ( 0.00 usr  0.00 sys +  0.69 cusr  0.39 csys =  1.08 CPU) @  9.26/s (n=10)
LLVM:    timethis 10:  1 wallclock secs ( 0.00 usr  0.00 sys +  0.68 cusr  0.42 csys =  1.10 CPU) @  9.09/s (n=10)
Perl:    timethis 10:  2 wallclock secs ( 0.00 usr  0.00 sys +  1.73 cusr  0.44 csys =  2.17 CPU) @  4.61/s (n=10)
Python:    timethis 10:  8 wallclock secs ( 0.00 usr  0.00 sys +  6.41 cusr  0.68 csys =  7.09 CPU) @  1.41/s (n=10)
Php:    timethis 10: 40 wallclock secs ( 0.00 usr  0.00 sys +  7.20 cusr 28.15 csys = 35.35 CPU) @  0.28/s (n=10)
Java:    timethis 10: 111 wallclock secs ( 0.00 usr  0.01 sys + 36.21 cusr 61.36 csys = 97.58 CPU) @  0.10/s (n=10)
Bash:    timethis 10: 321 wallclock secs ( 0.00 usr  0.01 sys + 248.54 cusr 49.48 csys = 298.03 CPU) @  0.03/s (n=10)

This speaks to the sluggishness of the different interpreters and virtual machines and/or the size of the executable. But it also underlines the importance of choosing which programming language you use wisely depending on the case you want to solve. Sure this is a moot point in most cases, but imaging taking development time into account. Writing something in PHP can be OK to solve a problem quickly, but seeing that writing the same code in Perl can be as easy or even easier and seeing the performance boost that script would have makes you wonder why PHP is even out there.

The most surprising result is the Bash. Running a simple bash-script 1000 times from the console is pretty snappy in terms of other scripting languages, but having bash loop a million times and running that is slower than even Java. That is a real surprise. The relative slowness of Python is also interesting, given that Python’s popularity is growing where Perl looses supporters. But equally as surprising is the speed at which Perl does this simple operation. Writing stuff in Perl is relatively straight forward (compared to C) but that does not seem to be a problem when doing menial tasks like this.

I did ls /usr/bin/*toascii and found a program to convert from pbm to ascii (pbmtoascii) from the netpbm package. That was swell. So I did another ls /usr/bin/*topbm to find a way of doing a .pbm image. I got a list of programs but alas no bmptopbm.

So after contemplating usage of the many online ascii art generators I decided to do the least cost effective thing and write a program to determine possible conversion paths from one format to another using the netpbm and other packages out there.

I tried writing a recursive function that looked for converters until all of them would be found, but due to the nature of the netpbm-package some image-formats are only convertible to one other format and some are convertible to multiple formats. That meant that I have a lot pitfalls in terms of writing a good recursive function to find all of them. Multiple loops to get stuck in. So I gave the job to my CPU and decided to not spend my time scratching my head for a recursive routine. In stead I would map out all the converters in a couple of layers in both directions and use Dijkstra or some other graph-traversing algorithm to find the way to go.

#!/usr/bin/perl
use Graph;
my $g = Graph->new;
$input = $ARGV[0];
$output = $ARGV[1];
$g->add_vertex($input);
$g->add_vertex($output);
my @toOutput = &findTo($output);
foreach my $format ( @toOutput) {
$g->add_vertex($format);
$g->add_path($format,$output);
my @levelTwo = &findTo($format);
foreach my $forma (@levelTwo) {
$g->add_vertex($forma);
$g->add_path($forma,$format);

and so on and so forth. And thus be able to do:

print “Graph: $g \n”;
@path = $g->SP_Dijkstra($input,$output); if (!@path) { print “No path\n”; }
else { print “Dijkstra-Path: @path \n”; }

And that would yield, when running for instance find bmp ascii:

Dijkstra-Path: bmp ppm pgm pbm ascii

And thus I found a way of converting a .bmp to a .ppm and convert the .ppm to a .pgm to be converted to a .pbm and lastly from .pbm to .ascii. Adding a couple of lines to map the graph point that is the mighty ImageMagick convert tool I can then convert from jpeg to ascii doing the extra step from jpeg to bmp.

So if anybody wonders … for instance how to convert a .st4-file to .tiff here’s the solution:
st4 to pgm, pgm to pbm, pbm to gem, gem to pnm, pnm to tiff…

Or maybe you are wondering how to convert a PostScript file to ascii in a completely useless way? :
ps to pnm, pnm to jpeg, jpeg to bmp, bmp to ppm, ppm to pgm, pgm to pbm, pbm to ascii

import java.net.*;import java.io.*;import java.util.*;

public class whatEver {

static void singleSocketOpen (String hostname, int socket) {

try { Socket s = new Socket(hostname, socket); s.close();

System.out.println(“Port “+socket+”, “+ portInfo(socket) +” on “+hostname + ” is open.”); }

catch (UnknownHostException e) {System.out.println(“no such host”);}

catch (IOException ioe) {System.out.println(“port closed.”);}

} }

The first day I did the obligatory “Hello World”-stuff and made an app with a couple of buttons that updated text on the view. Pretty straight forward if you just follow a tutorial. The XCode-environment, fancy as it is, can be a little daunting, so I decided to do the classic learning by doing and see how far I got.

Day two was spent with Interface builder and XCode to draft a rough sketch of my app and then link the stuff together with XCode, building the interfaces and synthesizing them in my code to play with them. After one hour of playing I found that I already had half my app there, so I spent the rest of the day looking up the different APIs that I needed to make my app. This went surprisingly fast. I was anticipating, with my complete lack of Objective-C experience, a couple of days work of trial and error to just piece together a running thing. To my great surprise, not only did I get it running on day two (my app) but I had managed to make it run with zero memory leaks or warnings from the compiler. At the end of day two I felt so confident that I applied for the iPhone developer program to get my app on my device.

Day three started at two in the morning, just hours after I had put in my request to join the developer program. After an hour or so of emails and web-forms I had my app running natively on my device. After gearing down with a beer I went to sleep, eagerly anticipating the next day of coding. When I got up I realized that I actually had managed to create a native iPhone app in two days and deploy it on my device by day three. All the stuff I had heard about the program just seemed like pure nonsense in light of how breezy it all went for me. 

Now I am at the end of day three. The day has been spent creating new graphics for the app and tuning some of the off-device code that the device will communicate with on the outside to accomplish the mission. If anyone asks me I will gladly recommend the program for anyone who loves the iPhone and has a couple of hours to create something they want.  

Just my two cents but I seriously believe you have to have the Microsoft-company pretty far up your ass to complain about the iPhone developer program, the decisions they make and the speed at which you are expedited. Think about it. There are tens of thousands of iPhone developers and tens of thousands of apps and still they manage to have some degree of control over what you can sell at their store. Without enforcing some kind of control over the content that they sell they would basically encourage people to scam folks for dough by falsely marketing their apps. I for one welcome our fruit-based overlords.

#!/usr/bin/perl -w

use IO::Socket;

unless ($ARGV[0]) { die “Use: command IP.AD.RE.SS STRING”; }

$ip = $ARGV[0]; $text = $ARGV[1];

my $sock = new IO::Socket::INET (

PeerAddr => $ip,

PeerPort => ’9100′,

Proto => ‘tcp’,

);

die “No socket!” unless $sock;

print $sock “\e%-12345X\@PJL RDYMSG DISPLAY = \”$text\”\n”;

print $sock “\e%-12345X\n”;

close ($sock);

Have fun! Remember to fill in the required variables!

#!/bin/sh

wget –user=USERNAME –password=PASSWORD https://webmail.YOURDOMAIN.WHERE/exchange/EMAIL.ADDRESS/Inbox/?Cmd=contents -O inbox –quiet

MAILCOUNT= `cat inbox | grep -i -o “icon-msg-unread.gif”|wc -l`

echo -n “You have “;

if [ $MAILCOUNT != 0 ]; then

echo “$MAILCOUNT new message(s)”

else

echo “no new messages”

fi

rm inbox

sunData.pl:

#!/usr/bin/perl -w

use XML::Simple;# qw(:strict);

use Data::Dumper;

use LWP::Simple;

$location = “lat=59.57;lon=10.42″;

for (my $month = 1;$month<13;$month++) {

for (my $date = 1;$date<31;$date++) {

$mon = sprintf(“%02d”,$month);

$dat = sprintf(“%02d”,$date);

$url = “http://api.yr.no/weatherapi/sunrise/0.9/?$location;date=2009-$mon-$dat”;

$content = get(“$url”);

if ($content ne “”) {

my $parser = XML::Simple->new(); 

$sunData = $parser->XMLin(“$content”);

push (@sunRisings, $sunData->{time}->{location}->{sun}->{rise});

push (@sunSettings, $sunData->{time}->{location}->{sun}->{set});

}

} 

}

for (my $i = 0; $i <= $#sunRisings; $i++){

my $riseTime = substr $sunRisings[$i], 11, 8;

my $setTime = substr $sunSettings[$i], 11, 8;

my $riseHour = substr $riseTime, 0,2;

my $setHour = substr $setTime,0,2;

my $hoursOfLight = int ((($setHour – $riseHour)/24)*100);

push (@lightArray, $hoursOfLight);

}

$urlThang = join (‘,’ , @lightArray);

$chartLink = “http://chart.apis.google.com/chart?
cht=lc&chd=t:$urlThang&chs=800×300&chco=4D89F9&
chxt=x,y&chxr=0,30,356&chm=o,0066FF,0,-30.0,6&chg=30,5,1,0″;

chomp($chartLink);

`open “$chartLink”`;