Archive

Archive for the ‘Uncategorized’ Category

MarkIt, an app to mark where you parked your car or to remember a special place.

January 22nd, 2015 aaron No comments

MarkIt http://www.markitapp.net is a tool to help you track where you parked your car or a great way to remember special places you’ve seen while traveling or just exploring neighborhoods in everyday life.   Use it to remember a bar, restaurant, museum, theater, park or whatever else you can think of.

Setting a marker is incredibly simple. Once you get your current location, just set your marker over the point on the map you want to mark and press the “Tap to Markit!” button.

In addition to simply saving an address we let you take up to 3 photos to store with your marker and we let you record notes about your marker. Sharing is easy. To share your marker along with images and notes just click the share icon in the action bar when viewing your marker. It will present you with a list of applications which will allow you to share your photos. A slide up panel with all your markers is available in the lower portion of the initial screen.

Finally navigation to your marker is available by clicking on the address when viewing your marker.

You can download it here MarkIt

Cyanogen Mod 6 and mytouch 3g speed problems solved

July 30th, 2011 aaron No comments

So I have my old mytouch 3g with cyanogenmod 6 as my gsm phone when I’m on vacation. The slowness is unbearable. It turns out the key to getting excellent performance is the following.

  • Under cyanogenmod settings go to performance settings
    • turn on JIT (Just in time compiler for the Dalvik VM)
    • uncheck enable surface dithering
    • Check Lock home in memory
  • Finally replace the default ADW Launcher with LauncherPro

This last step, replacing the home launcher with Launcher Pro is what really did it for me. Hope someone finds this useful.

Categories: Android, Cell Phones, Uncategorized Tags:

NYC Health Ratings for Android

July 13th, 2011 aaron No comments
NYC Health Ratings for Android

I just released version 1 of nyc health ratings for android. You can search for restaurants by name and location and get detailed inspection results just as you can on nychealthratings.com.  Having this information available to you on a mobile device is so much more useful isn’t it.  One really nice feature is that searches default to your current network location, which works for the majority of searches.  If you are searching for a restaurant that isn’t in the immediate vicinity just input the zip code, address, or neighborhood name.  In addition to the android market it is also available on amazons market.

Now that I’ve finished version 1 for Android, I’m going to start building an iphone version.

Method::Signatures blazing fast and makes me sane

March 6th, 2011 aaron 4 comments

My biggest gripe about Perl has always been the lack of functional prototypes and method signatures.  The concept of method signatures is not a revolution it’s been around forever, almost every programming language I can think of off the top of my head has it in some form.  Having to unpack @_ time and time again is just such a waste of keystrokes.  Not only that there are multiple ways to do something so basic.  (Shift, copy the list to lexical vars, direct access in $_[i] etc).  It’s surely been the source of a number of bugs and something every Perl programmer needs to be conscious of.

My main argument for method signatures is it reduces bugs and it documents your code without having to write documentation.  Its declarative, it does what it says and says what it does.  Plain and simple no guessing.  As most Perl programmers are aware Devel::Declare is a module that has added the ability to extend Perl 5 the language without source filters.  There are several really cool modules that have been developed on top of Devel::Declare.  MooseX::Declare and MooseX::Method::Signatures and Method::Signatures in particular.  The first MooseX::Method::Signatures, comes bundled as part of MooseX::Declare.   MooseX::Declare adds  declarative class and method keywords on top of Moose.  MooseX::Method::Signatures has it’s own type system and does optional run time type checking on arguments much like you would do with Params::Validate except with a declarative syntax.  It’s down right beautiful and makes you warm and fuzzy inside to use it, the down side is there is a huge performance penalty to use MooseX::Method::Signatures at run time.  Depending on what you are doing it might not matter much.

The module Method::Signatures gives you 95% of the sugar and 100 x performance over MooseX::Method::Signatures.  Type checking at run time is something that I usually don’t need (This is still Perl, I swear).  Positional and named parameters are both supported along with defaults and constraints.  On my latest project I’ve been using Moose along with Method::Signatures and I couldn’t be any happier.  Take a look at the performance benchmarks I’ve included comparing these two modules along with regular ‘sub’ methods.

MooseX::Declare bench code

use MooseX::Declare;
 
class Foo {
  has x => (
    is  => 'rw',
    isa => 'Str',
  );
 
  has y => (
    is => 'ro',
    isa => 'Str',
  );
 
  # I use the three vars below to ensure that the subs
  # are not constant-folded away.  Although I'm not sure perl will do that.
  our $meth_counter                 = 0;
  our $meth_without_args_counter    = 0;
  our $meth_typed_counter           = 0;
  our $regular_sub_counter          = 0;
 
  method method_with_type( Int $x ) {
    $meth_typed_counter++;
    $self->x . $x
  };
 
  method method_without_type($x) {
    $meth_counter++;
    $self->x . $x
  };
 
  method method_without_args() {
    $meth_without_args_counter++;
    $self->x;
  };
 
  sub regular_sub {
    my ( $self, $x ) = @_;
    $regular_sub_counter++;
    $self->x . $x;
  }
 
};
 
package main;
use Benchmark qw(:all);
 
my $foo = Foo->new( { x => "3", y => "45" } );
 
cmpthese(
  300000,
  {
    method_with_type    => sub { $foo->method_with_type(5) },
    method_without_type => sub { $foo->method_without_type(5) },
    method_without_args => sub { $foo->method_without_args() },
    regular_sub         => sub { $foo->regular_sub(5) },
  }
);

MooseX::Declare Results

aaron@ ~/method_signature_bench $ perl MooseXTest.pl
                        Rate method_without_type method_with_type method_without_args regular_sub
method_without_type   5320/s                  --              -9%                -12%        -99%
method_with_type      5865/s                 10%               --                 -2%        -99%
method_without_args   6014/s                 13%               3%                  --        -99%
regular_sub         612245/s              11408%           10339%              10080%          --

Method::Signatures

package Foo;
 
use Method::Signatures;
use Moose;
 
has x => (
 is  => 'rw',
 isa => 'Str',
);
 
has y => (
 is => 'ro',
 isa => 'Str',
);
 
our $meth_counter                       = 0;
our $meth_without_args_counter          = 0;
our $meth_typed_counter                 = 0;
our $regular_sub_counter                = 0;
our $regular_sub_without_args_counter   = 0;
 
method method_without_type($x) {
 $meth_counter++;
 $self->x . $x
}
 
method method_without_args() {
 $meth_without_args_counter++;
 $self->x . '5';
}
 
sub regular_sub {
 my ( $self, $x ) = @_;
 $regular_sub_counter++;
 $self->x . $x;
}
 
sub regular_sub_without_args {
 my ( $self ) = @_;
 $regular_sub_without_args_counter++;
 $self->x . '5';
}
 
package main;
 
use Benchmark qw(:all);
 
my $foo = Foo->new( { x => "3", y => "45" } );
 
cmpthese(
 300000,
 {
 method_without_type         => sub { $foo->method_without_type(5) },
 method_without_args         => sub { $foo->method_without_args() },
 regular_sub_without_args    => sub { $foo->regular_sub_without_args() },
 regular_sub                 => sub { $foo->regular_sub(5) },
 }
);
 
1;

Method::Signatures Results

aaron@ ~/method_signature_bench $ perl MethodSignature.pl
 Rate regular_sub method_without_type regular_sub_without_args method_without_args
regular_sub              579710/s          --                 -7%                     -17%                -25%
method_without_type      625000/s          8%                  --                     -11%                -19%
regular_sub_without_args 701754/s         21%                 12%                       --                 -9%
method_without_args      769231/s         33%                 23%                      10%                  --

Analysis

These tests are not exhaustive nor do they need to be.  Its clear that even with no arguments subs and Method::Signatures are on order of 100 times faster than MooseX::Method::Signatures.  What really surprised me here is that Method::Signatures looks to be faster than subs.  It would be an interesting test to benchmark the number and types of arguments.

Bottom line is I will use Method::Signatures and Moose in any new projects I write in Perl.  I’ve been successfully running production code with Method::Signatures since September with no problems.  Hoping to get some feed back on how Method::Signatures could possibly be faster than subs.

Note

Ipod touch makes a great voip phone

October 10th, 2009 aaron 4 comments

Have spotty cell phone service at home?  Skype for iphone/ipod touch can turn your ipod touch into a full fledged voip/skype out phone.  Skype in and out with a full pledged number is only around 6 dollars a month.  Throw your landline away.  Sorry if this sounds like an ad!

Categories: Uncategorized Tags: