2nd Player Revived

Michael, Bucky and I have cranked out another 2nd Player Episode. We cover where we have been, and plans we have for the site and podcast. We are not sure if we are going to stick with the bi-weekly schedule we had before, but we are going to attempt to be more regular than we have been recent. Any comments are welcome as always, thanks for listening.

Posted in gaming, project | Tagged , | 2 Comments

New Layout and Great T-Shirt

For some reason, I decided to upgrade WordPress to 2.3.3 tonight. In the process I decided my layout was a little dated, so I updated that too. As an added bonus, the RSS Widget began working, I guess it didn’t work on the old WordPress engine for some reason.

I even took the time to tweak the layout a little to include tags and categories, as well as updated the header image to be one of my own. You are looking (if you are on my site and not reading this in your rss reader) at Lake Eola at Downtown Orlando.

In completely unrelated news, I put together an Infant T-Shirt for my son at CafePress in honor of TallyHoh launching.

Posted in software | Tagged , , , | 3 Comments

My First Bookmarklet for TallyHoh

One of the things Tyler and I discussed doing to make the user experience with TallyHoh a little better, was to create a bookmarklet. I had never done this before so I did a little research to see what was currently out there. I knew del.icio.us had an active bookmarklet community so I started there.

What I found was pretty amazing, everything from bookmarklets that simply redirected you to delicious, to full blown javascript rendered forms that allow you to tag your feeds as they are submitted. After taking all that in I decided to start with a simple redirect.

At first everything went great, unfortunately I needed to do a post, and the examples I saw didn’t suffice. So putting on my javascript hat, I came up with the idea to create a form via javascript and submit the form. I realize I am not the first to come to this conclusion, I was just excited that I thought of it. This ended up working like a charm, and what I ended up with was this.

Add Feed To TallyHoh

If you drag that link into your toolbar you will have all the power of TallyHoh at your fingertips. Well at least the ability to add feeds and subscribe to them. Basically what happens is this crafts a request to add a feed to TallyHoh, if you are logged in (via remember me) it will automatically subscribe you to the feed. If you are not logged in, it will explain that you are a chump and should log in, and allow you to subscribe at that point.

Overall I was pleased with how it turned out. My first bookmarklet went off without a hitch. Feel free to try it out and let me know what you think. Eventually this will live somewhere on TallyHoh but Tyler and I are still figuring out where.

Posted in project | Tagged , , | Leave a comment

Tally, Tally, TallyHoh HOH!!!! …The Social RSS Reader

You have to read the title as if your are Lion-O from ThunderCats. You remember…”Thunder, Thunder, ThunderCats…HO!!!!!”. The new product that Tyler and I are pushing out has nothing to do with ThunderCats, that is unless you subscribe to a ThunderCat News Feed like Thundercats The Movie.

Without further ado…

You have heard me talk about it, and now the wait is over! Tyler and I (mostly Tyler) have been working to prepare our beta initial release of TallyHoh. We officially launched it today and are taking the Better, Not Beta. We have some updates we plan to do with the UI, but we want to see if people actually like the product. I have been using our builds for the last 9 months now, and I couldn’t live without it. The end goal is to provide a place for you to aggregate all your feeds (RSS Reader) with the functionality to share and express your opinion about the content you are reading (Social) to other users (tally = positive, folly = negative, nully = don’t care). We are attempting to implement as many web standards as we think makes= sense, hReview tags for our review sections, OpenID for our authentication, OPML for importing and exporting (boo) your subscription list and RSS and ATOM for our syndication methods. You may notice a friends feature missing when you sign up. This is mainly because we are hoping a project like DiSo will gain enough momentum or at least get to a point where we can use the standards they produce as an open friend network so we don’t have to recreate the wheel for the 1 Billionth time.

Thanks to everyone who takes the time to try out our first creation. And to all those who don’t…well thanks for reading my blog ;-). If you have any issues or comments at all please don’t hesitate to email me (daniel [at] protoh dot com).

Posted in social, software | Tagged , , , | 2 Comments

Basic Buildr Tutorial

About a week ago now someone commented on my Buildr review post about a possible tutorial on how to use Buildr. I thought about writing something up, but then I remember that I had purchased the MacHeist Bundle a few weeks back and that came with Snapz Pro x. So I decided to take a stab at screen casting. It turned out to be harder than I anticipated to get a solid pass through. The final video I published was still not of the quality that I would have liked but maybe if I decide to try it again I will get better at it. The hardest thing was getting the recording to look good on the flash video sharing sites. I ended up going with Revver. Not because of the monetary aspects, although that is nice, but because it seems to produce the highest quality output. Unfortunately that wasn’t automatic. I originally recorded the screencast at my full resolution, capturing pretty much everything on my screen. That was a huge mistake, that scaled down to 640×480 for the flash version did not scale very well. Apparently video is not like picture, where the big images squash well to small images. Ultimately I ended up recording a 640×480 window of my desktop and I think the quality is acceptable for a tutorial.

Enough rambling about how hard it was to produce this, here is the final product. Please let me know what you think.

Posted in build | Tagged , , , , | 7 Comments

The JVM is not Java

Is this another rant?….Yes. I apologize for all the rants lately, but hopefully there is some educational value woven throughout my posts, and besides I promised this one.

Lets start with a history lesson…

In the beginning there was assembly, the language that changed with each machine architecture. The machines ran quick and required little resources, but the programs were error prone and took a lot of effort to develop.

Then came the Titans; FORTRAN, COBOL, and LISP, the ancestors of all modern programming languages. We learned a lot from these Titans but just as the gods of olympus had to dethrown the titans, so too did the gods of the programming languages. These gods I speak of are C, Java and Smalltalk.

All these languages have something in common, they were all developed to serve a specific need. We might even say each language tackled a specific domain of programming. FORTRAN was built to do scientific and mathematical computations, COBOL was created to do business applications, and LISP was created to do lambda calculus but turned out to be great for AI programming.

Notice I haven’t mentioned the implementations of these languages. That is completely intentional, the language itself does not rely on, or developed around the implementation. In the olden days there was two different ways of running an application. First you could compile the source code for your machine architecture and run it. Second you could install an interpreter on your machine and have that translate the program on the fly. Ultimately the language does not dictate this, although typically one type of implementation exists for each language (e.g. c is compiled, LISP is interpreted).

Lets take this thought process a little further. If the language and the implementation are separate then what affects performance? That is right…the implementation. If you want a really really really fast application you should compile it for the specific machine it needs to run on. If you want a highly distributable program you will want to use an interpreted language. If you want the best of both worlds you want a hybrid, which is compiled into a intermediate language (e.g. Java bytecode, Microsoft’s Common Intermediate Language “CIL”). Java and C# both happen to fall into this realm, but what does that really mean? To me it means there are two languages at work here, Java and Java bytecode. Java is a high level language that is compiled into a lower level language Java bytecde, that is interpreted. Two programs are required to make this work, the first is the Java compiler and the second is the Java bytecode interpreter.

If you think about it this way it should be easy to see that Java is not the great technology that Sun has provided for us. Java bytecode is the great platform that Sun has provided for us and Java is just the first language to compile into that bytecode. Interesting enough Microsoft seems to be the one who stumbled upon the power of the intermediate language as they originally created compilers for C# and VB.NET, but not until recently did they release a tool kit, DLR, that truly allows multiple languages to run on CIL.

That brings me to my point. Java is not the JVM! Java is just any other language, if someone wanted to they could write a compiler that took C# and compiled it into Java bytecode, JAVA doesn’t MATTER! All the Java Servers, and JVMs run bytecode and if you can get to bytecode you get all the benefits of Java. The one advantage Java has over certain other languages that are implemented on the JVM is type safety. And the Java community doesn’t even seem to be embracing that except for a reason to claim they are better than JRuby.

If there is anything I want you, the reader, to get out of this it is to remember/realize that Java is no different than Actionscript, C#, Ruby, or VB. They are all just languages, the implementation of that language is what determines performance and deployability. For a perfect example look at Ruby, ruby is interpreted using MRI, it can be a hybrid using JRuby, Rubinius or Ruby 1.9 which all use virtual machines like the JVM. The real power in the Java community is it’s runtime the JVM and fortunately Sun realized this and is encouraging the development of new languages on the JVM like Scala, JRuby, Groovy and JYthon. I am very excited about these possibilities because it means all the work in creating an efficient server will be transfered to these great dynamic languages, thus combing the benefits and safety of a mature server environment with the power and possibilities of a dynamic language.

If there was one other thing I want you to get out of this rant it is that the JVM is to operating systems what C was to hardware. C could be compiled into assembly for many different machine architectures, just like Java can be compiled and executed on many operating systems. The JVM just so happens to be a better abstraction than C did, because they added the benefit that you don’t have to recompile your code for every OS. Regardless of this added benefit it does the same thing. You write your code once and it runs in multiple OSs, just like with C you wrote your code once, and compiled it for many hardware architectures.

There it is one more rant under the belt. I have a few more things I need to get off my chest, but I also have some real content coming soon. I just updated my first screencast to a video sharing service. As soon as it is approved and I can verify the quality is to the point I want it at, I will post it here.

Posted in development, languages, theory | Tagged , , , , , , , , | Leave a comment

FlexUnit Presentation at Adogo

Just a quick reminder, to the millions of two readers of my blog, that I am going to be speaking at the Adogo on March 4, 2008. The talk will be on FlexUnit and how to use it. I will probably push some of my testing adgenda, but the focus of the talk will be how to use FlexUnit to test various aspects of your Flex applications. I am putting together a primer that will be up on the Adogo website within the next week or so, so check their for updates.

Posted in presentation | Tagged , , , | 2 Comments

The tools we use

A few months ago I made an observation about the software development profession that I simply brushed off as unimportant. Now I still feel it is equally unimportant, but in the spirit of Obi Fernadez’s talk at acts_as_conference I figured I would bring it up.

As I look across many different professions I see one thing in common about the stages of development. I will use construction as an example, because my father is a part of this industry. When you start off, you rely heavily on your crew for the tools you need. You will buy yourself the basics, like a hammer, and a pair of pliers, but the bigger stuff like drills etc.. you will have to rely on the company you work for, or the team you are a part of to supply certain tools. I went through this one summer when I worked in the field as a electrician’s helper installing rough packages on new construction houses.

When you progress to a journeyman in the profession you tend to acquire more and more of your own tools. In construction this would be items like drills and saws. At this point you have committed to this job as a profession for some substantial amount of time. But you may still rely on your company to provide you with specialized equipment.

Finally after you have been working in the field for numerous years you will have acquired pretty much every piece of equipment you need to accomplish any task your job requires without any assistants from tools from outside sources. At this point you can move from job to job and be a huge asset to the company because you have all the equipment you need.

The Positives

Which brings me to my point, you can look at numerous professions and this will be the case, construction, painter, sculpture, mechanic, and even professional athletes choose the tools (e.g. bats, sticks, clubs and cleats) they use to practice their craft. For whatever reason this is not how most software development shops work. I see a few benefits of choosing your own tools (computer, os, IDE) in our profession.

Built-in platform testing

The easiest one, is automatic OS testing. If you have a few PCs, a few Mac users and that one Linux user, than you have all the basis covered. Since each user is testing on each OS respectfully you will find platform problems much easier

Local development in a box

If a developer works on his own machine enough, he/she is probably going to have it setup to run whatever code he is working on.

Less cost to hire a new developer

This one is a double edge sword. Like I said above it is customary for a new construction worker to buy his first set of tools, and have the big stuff provided. I think this could work in our profession as well. Thinking back to my electrician’s helper job I had to purchase a specific set of tools in order to even start work. Those tools probably equated to ~$150 and with the drill I was supposed to buy, that probably would have pushed me into the $225 range. A quick search on dell shows me that you can buy a desktop for between $350 – $500 or a laptop for $500. I will admit this is a greater cost to entry than a construction worker, but it is also something you will probably already have as a developer coming out of college, or trying to get into the profession. Not to mention your base salary as a developer should be higher than an entry level electrician’s helper. In an ideal world, the base salary should be increased sightly, since the cost to hire has decreased for the employer.

The Negatives

This is by no means an exhaustive list of all the benefits to using your own machine at work, but it is something to whet your appetite. I wouldn’t be doing my job if I didn’t point out some of the negatives as well.

Network Security

I personally think this is a false sense of security but I will speak to it anyways. When you have a locked down set of hardware it is much easier for a sys-admin to do his/her job. In certain situations this is good, for instance not letting junior developers log into production boxes. But that isn’t the kind of security that you get from having locked down security. The protection you get is from having outside virus’s enter the work place. And that goes completely out the door if you have anyone on your team that has a laptop. Actually in this case, the developers are the ones you need to worry about least because they usually have a firm grasp one how to not let virus’s happen. The non-technical business people are usually the ones that you need to worry about, and they are usually the ones with the laptops.

On top of that you could require a certain protection package for anyone who wants to add their computer to the network. This would have to be specific to each operating system, but I think is a small price to pay if you are overly worried about security.

Added cost of entry

This is the counter point to the above benefit to the employer. Yes their is a great perceived cost of entry, but what developer doesn’t have their own machine at home? How did you become a ‘developer’ without owning your own computer? Because I think this is a perceived negative I am going to ignore it.

However I will point out, my Father is allowed to write off many of his tool purchases, and thus purchase tools more regularly. If developers were able to count their ‘personal’ machines at work machines, then we would probably upgrade our machines on a regular basis.

Standardized Work Environment

Some people believe their is a benefit to having everyone using the same setup so that if you need to move developers/machines, or work together on something everyone will be comfortable in the new environment. I think this is breaking the 80/20 rule. I think at most 20% of your time will be working/looking at someone else’s machine so why should I have to standardize my habits/behaviors so someone else is comfortable? Which sets me up for an entirely other rant about standardized work environments.

Enterprise Software

Much enterprise software only works on Windows. I am referring to the HP Quality Center and the IBM Rationale of the world that are available to make us so much more productive. I am not going to debate the quality or helpfulness of these tool, but their are ways to run these on any machine, using emulation or dual boot setups. Again 80/20, I would much rather switch between a windows and mac install for these two tasks, or even have a box dedicated to modeling.

On top of that, we are these enterprise product customers. If we as an industry move to allowing multiple machines in our development space, they will have to move to allow this as well. Or someone else will come along to replace them. Vendor lock-in is the worst, and for some reason we have allowed Microsoft to lock us in, even when we fight against it from other vendors.


So enough ranting, I am willing to bet that most of my arguments are shallow and probably inaccurate, but I think it is something to think about. Even though I drew a parallel to the construction industry, we do have different problems to address in our work environment. I don’t however think that is reason enough to ignore this situation.

Posted in development, programming, rant, software, workplace | Tagged | Leave a comment


This past weekend I had the pleasure to attend a local conference, acts_as_conference. The conference was described as an event that was focused on Ruby on Rails, but it seemed to be much more focused on Ruby, with Rails in mind. Overall I think the conference was a great success at $100 a seat it was well worth the money.

If you want a full rundown you should head over to Brian LeGros’s blog as he did a write up on each talk. Max took a few pictures and put up some thoughts of his own, so if you want to get a British opinion go check there ;-).

I went looking forward to both Dan Benjamin’s and Obie Fernandez’s keynote and Charles Nutter’s JRuby talk. I was impressed to find all the quality content that came up, especially Smarticus (Bryan Liles), who I hadn’t heard about before this conference. He did a great presentation on BDD and what it really is, and how we are all doing it wrong. I found this especially refreshing because I am the ‘testing nazi’ at work and I have come to very similar conclusions that he did about TDD and BDD. At the very least he seemed to give some sort of credibility to my co-workers about the whole idea of test first and how it works.

If you didn’t get a chance to go this year I would encourage you to keep your heads up for next years event, because it is definitely worth it for all levels of ruby developers.

Posted in community | Tagged , , , , , , | 3 Comments

Java is not Statically Typed (right now)

What?!?1?!/!? That is right, I said it Java is not statically typed and by proxy is not safer than dynamic languages. Zealots HALT! We can fix this, and I intend to add some gas to the fire that people like Bob Lee over at crazybob.org have started.

So let me start by saying this is the second version of this article. I completely scraped the first one for now, but it was basically a rant about how Java people are full of themselves for thinking that Java is safer than those dirty dynamic languages. The article was inspired because I have heard different people from both sides suggesting that Java is type safe and thus better to build on top of. Ola Bini wrote an article suggesting his language layer idea where he proposed that Java was currently the only viable solution for a stable layer. I happen to agree with Ola but only because I know Java can be that stable layer, but currently isn’t. The guys over at Software Engineering Radio are big Java junkies and I often get the impression that they feel it is a safer language.

The original post was a good way to get out my feelings, but it was horribly structured and not very productive (not that this post is much better). Fortunately one of my colleagues knew I was getting frustrated with this, and pointed me at a couple resources that might help with my frustration. One episode of The Java Posse was especially helpful, but not for the reason I think he intended. When he told me about the episode he told me it would be good to know what the other side might use as counterpoints to my complaints. Instead he directed me to the one Java developer who seems to have a passion for static typing. In this episode he was very vocal about how far he felt Java had moved away from static typing, and I agree with him on every point. Frameworks like Spring and Hibernate worked within the constraints of Java 1.4 and unfortunately that did not allow for static typing. The language itself made it impossible for these frameworks to be created with static typing, but that is not the case since Java 5 because of the additions of generics and annotations. Unfortunately we are on Java 6 now and these frameworks have not changed their approach.

Enter …Google? It seems Google has incubated a few projects that are brining type safety back to the Java language (note I said Java language I am setting up for an entirely different rant for later). Google Collections is the older of the two, and from what I understand is gaining popularity in the Java community. Brian has been talking about them for awhile and I usually just ignore him because I haven’t been interested in another collection API. The project owner of this project is co-owner of another great tool Google Guice.

Guice seems to be where Bob Lee spent a lot of time at Google although he has not moved onto android from what I can tell. Guice is a Dependency Injection Framework. Guice != Spring, instead Guice is what Spring started as. From what I can tell it does a great job at being a dependency injection framework and brining type safety back to Java. The greatest thing about Guice in my opinion is there is no XML! What?1!/?!?1? No XML how do you configure your application? Use Java! This is a whole other pet-peeve of mine (which will probably get an article very soon) and ColdFusion developers are the worst at it! XML is a great tool, but don’t use it just because you can! It was great for Java 1.4 because we didn’t have enough meta-programming facilities to configure our apps easily without it. But now with annotations and generics we can configure our code, using our code! What a novel idea to just write your code.

So there is hope, and because of projects like Guice I think the established frameworks are making changes. Spring 2.5 has implemented annotations like @Configurable and @Component spring is slowly removing the beans.xml file. At first I thought this was bad because, I believed the config file was used to be able to change things out without having to recompile the jar, but then I realized that was ridiculous and not a viable use case. I am not as familiar with Hibernate so I don’t know what steps they have taken to become more Java current, but I know iBatis has not taken many if any steps, as I they don’t even have generics for their SqlMapClient methods.

Does this mean I am now a Java fan boy and think dynamic languages are silly little toys that script kiddies use? Quite the contrary, I just have faith in the Java language. I was slowly giving up on Java, but now I realize their are passionate developers out there like Bob who want to bring Java back to it’s roots and give it frameworks that work within the language instead of around the language. I believe just like Ola Bini that their is a place in the development eco-system or both a static and a dynamic language, and over the next weeks I intend to describe where I think it would be best for these languages to live. As well as describe the advantages and disadvantages to each language type. Because as with everything else their is always a trade-off, there is almost never a perfect solution. I hope that my ramblings will help me and others understand those differences better so we can all become better developers.

Posted in development, languages, programming, rant, software, theory | Tagged , , , , , , , , , | 4 Comments