Keith's Web Blog RSS Feed en-us http://www.keithwatanabe.net/index.php Keith Watanabe's Website mod_perl DSO installation http://www.keithwatanabe.net/blogs/2004/2/12/75dd605e1405c3f214cb360377cfb599.html Thu, 12 Feb 2004 13:21:44 -0700 http://www.keithwatanabe.net/blogs/2004/2/12/75dd605e1405c3f214cb360377cfb599.html HTML::Mason & Apache::Request http://www.keithwatanabe.net/blogs/2004/8/30/437913452914dce6568f8ac5e2d061e9.html Mon, 30 Aug 2004 22:59:05 -0600 http://www.keithwatanabe.net/blogs/2004/8/30/437913452914dce6568f8ac5e2d061e9.html Storable's Many Uses http://www.keithwatanabe.net/blogs/2005/5/23/79c0f830142e169b5054e43c2cc7a433.html Mon, 23 May 2005 21:04:57 -0600 http://www.keithwatanabe.net/blogs/2005/5/23/79c0f830142e169b5054e43c2cc7a433.html interesting bit of perl http://www.keithwatanabe.net/blogs/2005/8/18/4ebf4991fed8fcb05834e352c8e1510d.html
my @first = qw( Reina Norika Kaori Ryoko Shiho Aya Hitomi );
my @last = ( 'Miyauchi', 'Fujiwara', 'Kawai', 'Yonekura', undef, 'Matsuura', 'Kuroki' );
@names{ @first } = @last;
print "$_ is $names{$_}\n" foreach sort keys %names;

my @hotties = ( 'Naoko Kido', 'Michiyo Seki', 'Hisaki Nakamura', 'Shoko Kanemura', 'Keiko Iino' );
@h{ @hotties } = (1) x @hotties; print "$_ is $h{$_}\n" foreach sort keys %h;]]> Thu, 18 Aug 2005 11:12:22 -0600 http://www.keithwatanabe.net/blogs/2005/8/18/4ebf4991fed8fcb05834e352c8e1510d.html 'our' is a good thing http://www.keithwatanabe.net/blogs/2005/9/20/f6371b366818965cdaab55b26cb82ce8.html Tue, 20 Sep 2005 13:36:28 -0600 http://www.keithwatanabe.net/blogs/2005/9/20/f6371b366818965cdaab55b26cb82ce8.html Test::Unit.pm unit testing framework http://www.keithwatanabe.net/blogs/2005/9/27/150c7ad9397b30c607f5470c2e598748.html Tue, 27 Sep 2005 16:32:07 -0600 http://www.keithwatanabe.net/blogs/2005/9/27/150c7ad9397b30c607f5470c2e598748.html Java Is NOT An Agile Language http://www.keithwatanabe.net/blogs/2007/8/7/9fd8a694e22bb98e7c67f3707bcf2279.html
My answer: Java doesn't help this.

Perhaps, it's my level of expertise in the language, but after dealing with this project, I've come to realize just how HEAVY Java can be. I haven't had a chance to work in detail with the latest version, so I can't say that some of the newer features have made it better (I'm sure it has, but there are still deficiencies in the language). It could be my lack of experience with Eclipse. Maybe I'm not utilizing the right plugins and doing far too much "hand coding" in terms of boilerplate code.

No, the problem is that the language is too bulky and takes itself too seriously.

Read that statement again. Especially the last part.

Let me provide an example.

Let's say you have a primitive type that's supposedly a char and is saved into the database as a number (0 or 1). so in reality you need an int. But let's say another object requires it either as an int or be turned back into a string. So if you try to parse it, you might get an exception rather than letting the language auto-convert it. So you're doing many things here: 1) checking if the value is null; 2) checking if the type can be converted; 3) potentially converting it over to another type; 4) converting it again. And you may have to wrap all these operations in a big try/catch block. If you're working with a database that may contain null values, and you're forced to use primitive types, you're royally screwed. I mean, all you're trying to do is guarantee a value type, but you still need hundreds of checks.

This is just awful. And it's just for one value.

What if you have 40-50 values? How much of this do you have to deal with? What if you have to deal with several operations that require you to do this 40-50 times? What if there's no easy way to loop through the parameters in your object without having to take out the equally bulky Reflection API?

In perl, since objects are glorified (or blessed more specifically) forms of hashes, arrays, scalars or globs, you could, especially if you use a hash, provide a method that can loop through, utilize the Fields pragma, and easily get the same benefit.

In PHP, you can utilize variable interpolation by doing something like this for a dynamic method call:

$obj->$method()

You're pretty much out of luck with Java (at least in doing some easily the same way). You can't naturally take advantage of in-built features to really help you through these situations.

Worse yet, you might be forced to code declaratively in XML because it's nearly impossible to do something easily and dynamically in Java. Take Spring and Hibernate as examples of this.

Out-of-the-box, Java is just a monster of a language. You are forced to employ various plugins, IDEs, frameworks, etc. to really get any significant and immediate benefit. And that can take a while to do as well.

Notice the words used there: "a while." That implies time and implies not moving fast, which in turn implies lack of agility.

More of my friends are turning towards languages like Ruby and being empowered from getting more work done through frameworks like Ruby on Rails. I think people who continue to use Java are quite arrogant in believing too much in Sun's marketing. Java only is good in the hands of those that use it. But for me it's too difficult to get any real benefit that I can see.

The truth is, at the end of the day, you just want to be productive. The language is truly irrelevant as long as you and your peers utilizing it understand in detail how to get the best out of it. I for one see Java as being verbose, cumbersome, and unnecessarily detailed. The flaws that kept a lot of C/C++ programmers away I think never were truly addressed. C/C++ programmers have some advantage over Java people since they have more power and speed naturally.

Overall, if you need to execute something quickly, consider NOT using Java to do the job, unless your people are extremely adept at it. Mine aren't, nor am I so I think I will continue to stay away from it where possible.
]]> Tue, 07 Aug 2007 09:40:50 -0600 http://www.keithwatanabe.net/blogs/2007/8/7/9fd8a694e22bb98e7c67f3707bcf2279.html Programming (Language) as/is a Philosophy http://www.keithwatanabe.net/blogs/2007/8/8/dd813dee5dbb08b567377b63eb18ab72.html
Whenever you're tempted to do any of these things, you need to sit back and think about what will do the most good for you and your neighbor over the long haul. If you're going to pour your creative energies into a lump of code, why not make the world a better place while you're at it?

This can really apply to any language. The fact that this statement occurred in the Perl book made me realize the connection of programming, programming languages and their attribute as a philosophical mode of thinking.

Think about the flamewars between Java and scripting languages such as Perl. The core arguments that Perl people have against Java is the verbosity while Java programmers call Perl programmers obscure and lacking thoroughness. Shouldn't the real result be about results you bring to a business?

All of these statements above are loaded philosophical questions. The best programmers, in my view, are those that have an issue or stake involved in such questions. Should each little optimization be so critical for a business? Why not just lie to the company and say optimization is impossible that issue?

Again, it's all philosophical. But the intention behind that philosophy is equally critical. The person who refuses to optimize places importance on immediate results at the sacrifice of performance so that his end of the bargain is complete. The person who prefers verbosity emphasizes thoroughness and process. The person who favors obscurity prefers succinctness.

I think those who practice programming philosophy rather than simply programming are those who are looking or have their own set of best practices. This is one area which isn't well defined. Certainly, there are tons of books, online articles and whatnot prescribing sets of best practices, but like any philosophy, there are numerous variations that really fit with a person's core value system.]]> Wed, 08 Aug 2007 18:11:57 -0600 http://www.keithwatanabe.net/blogs/2007/8/8/dd813dee5dbb08b567377b63eb18ab72.html Very Productive At Work http://www.keithwatanabe.net/blogs/2008/2/14/69f343033cd927b333aba268df2adb28.html
Another aspect I got to work with recently is the Reflection API in PHP. I do some quirky things where I have my authorization piece defined as a combination of the controller name and the action name (where the action part is handled via convention in the Zend Framework). From a search prompt, you can enter the name of an application and it will examine for the controller directories of the application. Then using Reflection, I am able to query the controller for public methods. From there, I reconstruct the authorization permission name and am able to display it. It's quite cool actually because I don't have to manually run all these insert SQL commands to put the permissions into the database.

Also, in the future, I'm hoping to write some web services for Bugzilla, PhpMyAdmin and MediaWiki to create permissions and user accounts from my system. User management is a royal pain in the butt when you have disparate applications containing their own proprietary form of entitlements. I hope to unify these aspects through my administration application and make granting access easier to these applications.

Then my boss and I did a little interesting experiment where we compared the performance of different slurp methods with Perl. We tried using one of the slurp modules as well as this little Perl idiom:

open (<$fh>, "somefile.txt") || die $!;
my $txt = do { local $; <$fh>; };
close <$fh>;

Found out that this piece of code runs REALLY fast. The way he was doing it was building an array using map. However, my theory is that when you're reading a file in line-by-line, it's more memory/IO intensive, compared to storing the whole content into a scalar value. I think in the former case, because you're building a data structure, it's also slower. We tried each scenario with a file around 143 MB. The code above ran at 2 seconds compared to the other routines, which all ran slower.

I swear, it's a totally different world than being at the Anti-Productive company (i.e. HLIKK). I get so much done at work these days. Heck, I have to force myself to leave because my work can be so interesting at times. Considering I've been here only a little over 4 months, I've accomplished a lot and learned a tremendous amount. It makes me wonder how much more I can produce in a year's time?]]> Thu, 14 Feb 2008 09:17:17 -0700 http://www.keithwatanabe.net/blogs/2008/2/14/69f343033cd927b333aba268df2adb28.html Re-sharpening My Perl Skills http://www.keithwatanabe.net/blogs/2008/4/23/13f7bab8a7369e6b5e5490db552a0a06.html Perl scripts recently at work into 1-3 line wonders. I've been influenced a bit (perhaps in a geeky negative way) by some people over at ValueClick in the past in creating obfuscated, but killer Perl code. The great thing is that I'm learning how to really utilize some of the more lesser known features that you probably won't see much in anything but the most hardcore type of modules out there.

For instance, I started using the following paradigm:

sub func {
+{ map { $_->{something} => $_->{value} } @{$_[0]->someMethod($_[1], $_[2])} };
}

this is a cool little piece of code that i finally got to use the +{. I found that little bit of code in the O'Reilly SOAP book, the author of SOAP::Lite.pm had a few statements like that. I scratched my head for a while trying to figure out what it did. Later, I found out that it's a type hint to the interpreter to return back a hash reference.

I used it here because if I just did something like:

{ map { ....} };

I'd receive an array, which isn't what I wanted. The +{ sign will convert this into the appropriate hash reference. I showed my boss to see if he knew what the heck it did, but it's a pretty obscure thing in Perl that I don't see often times used. But I'm finding it immensely useful with statements like that.

Of course, your next comment might be, well why the heck would you need a statement like that in the first place? I'm working quite a bit with various types of data. Sometimes, I have lists of data in the array format. But I occasionally want to convert it over to a hash format. Map partly helps here, but if I want to stay true to my virtue of one liners and avoid returning another array, then the +{ becomes quite useful in conjunction with map.

I really enjoy programming in Perl the most because it's like a puzzle where you're constantly trying to optimize what you're doing. I've seen people use tons of variables or less obscure syntax, but I think that it's really not that great of a thing in the end. I mean, in theory, you're replicating memory by creating more variables and the function call potentially grows, whereas a one liner, for a true veteran of Perl, can easily be deciphered without having to painfully scroll through unnecessary pieces of code. I mean, if you want verbose, code Java or COBOL. Then tell me how readable your code is and how long it took you to get a simple idea out the door.]]> Wed, 23 Apr 2008 10:35:47 -0600 http://www.keithwatanabe.net/blogs/2008/4/23/13f7bab8a7369e6b5e5490db552a0a06.html Neat Perl Tricks http://www.keithwatanabe.net/blogs/2008/6/30/0e94daf300bfbb59ec41bffad4459384.html Using qw for an array ref: [qw(item1 item2 item3 item4)];


Extracting parts of a split list

my ($item1, $item2, $item3) = (split(/s+/, $str))[2,4,5];

Converting An Array To Key-Value Pairs For A Hash

my @list = qw(key1 val1 key2 val2 key3 val3 key4 val4);
my %h = %{+{@list}};

Calling a function inside of a quoted element

Very useful when you don't want to end a quote or heredoc.

my $var = "hello @{[getName()]}n";

Checking if the correct number of parameters are passed into a subroutine

sub func {
die unless @_ == 4;
}

Using A Lookup Table To Quickly Validate If Arguments Exist


Good for checking input.

sub validate {
my %args = (arg1 => 1, arg2 => 1, arg3 => 1, arg4 => 1);
return exists $args{$_};
}

Converting a subroutine's arrayref argument to an array

some_func("arg1", "arg2", ['item1', ['item2'], ['item3'], ['item4']);

sub some_func {
my $arg1 = shift;
my $arg2 = shift;
my @items = @{shift()};
print "$_n" for @items;
}

Dynamic Subroutines With Hashrefs

Nice technique when you want to create callbacks and require that the function calls are a little dynamic (for instance, when you don't know what function you might need to call).

my $h = { progname => 'some_func' };
eval "$h->{progname}('David')";

sub some_func {
print "Hello $_[0]n";
}

Getting Local Time in Epoch Seconds

use Time::Local;
my $sec = timelocal( (localtime)[0..5] );

Efficient File Slurping

open (FILE, $dir) || die $!;
my $file = do { local $/; <FILE> };
close (FILE);

Getting All Files in A Directory

opendir( DIR, $dir ) || die $!;
my @segdirs = grep { !/^./ } readdir( DIR );
closedir( DIR );

Better Inheritance in Perl

use base(Path::MyClass);

Creating A Basic Constructor

sub new {
my ($class, %args) = @_;
my $self = {};
bless $self, ref $class || $class;
}

Creating A Singleton Instance

Using the constructor from above:

sub instance {
my $class = shift;
strict 'refs';
my $instance = ${"$class::_instance"};
defined $$instance ? $$instance : ( $$instance = $class->new( @_ ) );
}
]]> Mon, 30 Jun 2008 03:10:22 -0600 http://www.keithwatanabe.net/blogs/2008/6/30/0e94daf300bfbb59ec41bffad4459384.html