idiot, posing, wala lang

Thoughts at the End Of 2010

Looking Back...

It's interesting that this year has been quite interesting for me. 2010 will forever go down in my memory as That Year. Some of it has been good, some bad — however, I am tremendously grateful for everything, one way or another, as they have all contributed to my tuition in the School Of Life.

Where do I begin? I guess I should begin at the very beginning.

I started the year out with a whole lot of plans and dreams. I'm not really one to share my thoughts on the matter, but 2010 started out on quite a hopeful note. My cousin and I had made some plans to start building our own products; we talked a lot about it during the Christmas break last year here in Baguio. We were gung-ho; we knew that we had to start soon. Work was still interesting, and still fulfilling. I had just worked out some kinks in the system we were building for a client, and we were at the verge of full deployment. I also had plans for the project, moving forward, to allow it to grow beyond what I perceived as the limitations of the initial design.

Fast forward to six months later.

My plans with my cousin didn't quite solidify. Long story short: life happened. I was thinking of quitting my job and going headlong into the business, but not immediately— my plan was to leave in six months' to a year's time, in fact, and some things happened to rush that decision. So, I ended up leaving Orange & Bronze at the end of May, a decision that I do not take lightly. It is a decision that had to be made.

Of course, that's not the end of the story.

After leaving, I was able to take in a few odd jobs here and there, mostly freelancing for another startup, but this time around I got to play around with wholly different technology stack: Ruby, Sinatra, and Redis, among other things. It was heady stuff. After years of writing Java code, Ruby was a breath of fresh air; after years of writing servlets and Struts 2 actions and editing XML files and what-not, the magic of Sinatra's DSL for what it calls route handling was an eye opener. Admittedly, I've also been writing a ton of Python code as well, using Django in a major project at O&B, but this was different and it was deep magic for me.

And then there was Redis. It felt liberating to simply store stuff. No SQL, indeed. Working with Redis gave me a healthy appreciation of storage beyond the SQL database; heck, it gave me a better and deeper understanding of the mechanics of the SQL database. I hacked my way through the creation of indices and searches and what-not. I wrote code man, and I loved it.

I didn't stay long with them. Although the whole stack was an eye opener, a breath of fresh air, a pleasure to work with— it simply wasn't meant to be. Ruby ain't my shtick. Not yet, at least. I felt like a tourist in those parts, struggling to express myself in a foreign tongue. I will definitely come back to it in the future, but not right now. In my journey as a programmer/journeyman, Ruby isn't just an interesting side road— I think I'll want to go back to it, someday, perhaps with a personal project or two.

I went on to other projects. And, although I can only motion vaguely about what happened next, I can say that I felt like Aristotle's proverbial caveman, turning around to see the daylight. Something happened. I will say more about this in the coming weeks, I promise.

What I can say is this: I'm now engaged in a very interesting yet very difficult project right now. It's been a roller coaster ride with this project, and although I hate the codebase with a vengeance, I see that there is still hope, and things can be fixed.

...And Moving Forward

So what's in store in 2011 for me? I'm quite hopeful that the upcoming year will be awesome, if not as interesting as this one was.

  • On my non-work hobbies, hopefully, I can take more pictures and learn composition (or at least learn from others)
  • I'm also hoping to get some of my personal projects finished. I'm hoping to release some of them as open source; I'm planning to get at least one project out this coming year
  • Travel? Maybe. I really wish I could go out and travel more this year, but I strongly doubt it. But one can hope, and plan for it.

In the end, I can only be open to opportunities and misfortunes, and handle myself accordingly.

desperation, House, insanity

Sporadic Update #42

(And Yes, I am Still Alive).

Notably, I've grown a year older, I'm still working at one of the best companies to work for, in the Philippines, in my opinion, and I'm still taking pictures. Mostly.

There's a lot on my mind, actually. I'm not sure whether I should keep this LJ or simply return to lurk mode, but what the hey.

In other news, I bought myself a personal laptop (my previous laptops were all work-assigned). Since I decided I needed something that'll last me quite a while, and that'll also be very usable as a development machine, I decided to buy a MacBook Pro. Yes, a MacBook Pro. Admittedly, I'm still an open source guy; the first thing I did to get an inhabitable work environment on it was to download Emacs :)

On the personal front: my body clock is out of whack, yet again. I experimented with doing a detailed log of my activities, and kept a small notebook at hand for several months the last time I had this problem— and I must say, it worked for me at the time. I was able to keep a handle on the times I slept and woke up, and it kept me aware of how much sleep I was actually getting, and how much work I was getting done. I only stopped keeping the log fairly recently, after work suddenly piled up on me and I couldn't integrate my log-keeping into my workflow. I'll try it once more, and I'll probably make it more "sticky".

That is all, I guess. Until several months from now, or the next post (whichever comes earlier).
desperation, House, insanity

Still Alive

Yes, this blog is still alive, although a little... quiet.

While I'm figuring out a good topic to write (and while I flesh out a workable blogging schedule), here are a few pics from the various trips I've taken recently. I've been getting more and more into photography, having bought a DSLR, a Nikon D80.


Laoag, Ilocos Norte

duke, semi-techy, javaman

Quick Updates

Two things:

  • Work on tool that will be released as open source. I'm currently finishing up a component that we'll be releasing as open source in the coming week or so, once I get the bits cleaned up and checked in. It's a case of an "itch to scratch", and I'll be using it for a possible work project.
  • Another haircut. I got rid of my long hair today. That is all.


  • Current Mood
    accomplished accomplished
desperation, House, insanity

My git-svn workflow

I recently gave a lightning talk on git-svn at Barcamp Manila, and I thought some people might be interested in my day-to-day workflow when I work on projects.

When I get started on a project here at work, I usually first do a clone of the upstream tree, whatever that might be. I run:

git-svn clone --stdlayout

which checks out a copy of the SVN repository of project; this might take a while, so I usually go out for coffee or move on to other tasks while it completes. Sometimes, however, I don't want the whole history, so I do a partial clone:

git-svn clone --stdlayout -r HEAD

This then does only a checkout of HEAD, without history.

When I begin work for the day, I cd to the project's directory in a terminal, and do a status check to see what I've been up to recently, just to refresh my memory:

git status
git diff HEAD | less
git log | less

This gives me a) the status of my current work tree and the branch I'm working on, b) the changes since the last git commit I made, and c) notes from the log history. Sometimes, I'll be lazy and just pull up gitk for the tree, since it gives me pretty much everything above:

gitk --all

The gitk(1) command above allows me to visualize the commit history of the project, which is a boon when trying to nail down when something changed.

Once I know where I am on the tree, so to speak, I do a checkout of master, and I pull any changes from upstream SVN:

git checkout master
git-svn rebase

I usually checkout a branch when working on a particular feature or item. If I'm starting work on that feature, I do:

git checkout -b feature-name

However, usually I have already started on something, and I want to go back to that branch:

git checkout feature-name

This allows me to sandbox different work (bugfixes vs. features). I avoid touching the master branch, and instead work in other branches. Note that these branches are not visible on the SVN side; they're local to my git tree.

If master has changed (i.e. I've pulled in new changes from upstream SVN), I usually want to rebase my work on top of that:

git rebase master

I then bang on the code, making frequent commits for every small atomic unit of work completed. Once done, I review the code (in gitk(1) or by checking the git logs), and see what needs to be pushed. I also take this time to edit the commit history (which I'll explain in another post). When I'm ready to push upstream, I do another pull from upstream SVN (just so I'm sure my code is built on top of HEAD), and rebase. I also run unit tests to make sure I didn't break anything. When I now know everything's peachy and ready to be published, I do a push to upstream SVN via dcommit:

run tests...
git-svn dcommit
git checkout master
git rebase remotes/trunk

The last two lines simply fast-forward master to whatever the current SVN HEAD is. At this point in time, I'm ready to work on another task/feature/bugfix.

duke, semi-techy, javaman

Xlib, XWMHints, XGetWindowProperty and 64-bit

I've been hacking on a small panel for my current desktop environment— I've switched to using a really minimal no-frills environment consisting of openbox-3 and a small dock/notification area, since I was getting antsy about the GNOME 2 panel. I only wanted a simple list of open windows on a particular desktop and a clock, and I didn't need too much chrome on that. I couldn't quite set up the GNOME 2 panel to not use buttons or alternatively maximize the space for window title text, so I decided to simply ditch the panel altogether.

So, enter fsp-h. The hacked version of F'ng Small Panel is what I needed. Plus, to get the minimal window footprint needed, I added in a Openbox theme designed for people who don't need the titlebar text.

Openbox 3 + fsp-h (my hacks) + custom theme

As you can see, I've been trying to get as close to my old Ion3 environment as possible, and I think I've gotten close enough. I hacked in support for quick window switching, ala ion3, where hitting 'W-1' will switch to the first window on the desktop, hitting 'W-2' will switch to the second, etc. I also got some 64-bit issues cleared up (the original code was built on 32-bit, and icons were broken on 64-bit).

All in all, I think I'm getting to like this. Plus, I'm using GNOME Do for quick opens etc., as well as for doing Ion3's quick SSH (which I use to open a terminal to SSH to hosts).
  • Current Mood
    accomplished accomplished
desperation, House, insanity

Emacs as a Java IDE

(Note: Geek post ahead. You have been warned.)

Admittedly, I'm an Emacs power user (and no, I am not as hardcore as some people). Emacs has been my primary text editor for the longest time— the first time I picked up Emacs was way back in 2004, a little over four years ago, when I decided to just sit down and learn the little bugger. Now, I do a lot in the editor: my mail is handled and served by Gnus, I handle my TODO lists and outlines through Org Mode, and I do the majority of my text editing and coding in it.

The last item bears a little explanation. My work entails a lot of heavy text editing in the form of code. I am a programmer by profession, and that means that I spend a majority of time looking at code if not writing it. We do a lot of Java where I work, and most of the company uses Eclipse as the IDE of choice. I use Emacs.

Now, Emacs has some decent support for editing Java files in the form of java-mode, which features basic syntax coloring. That's a good bit, but it isn't exactly what I need— if syntax coloring was all I needed, I could just edit files in gedit. And, admittedly, there are a lot of goodies that a full blown IDE such as Eclipse can bring to the table— code completion comes to mind, especially since Java can get somewhat verbose.

So, my Emacs config also includes JDEE, the Java Development Environment for Emacs. Unfortunately, JDEE development has been relatively stagnant of late, what with it only supporting ant and not Maven— and the latter is a big deal in our shop, as we use AppFuse 2 in a lot of our projects.

Fortunately, someone wrote a decent parser for Maven 2 POMs (which isn't really a parser as it simply asks Maven for the classpath, but what the hey, it works). Unfortunately, it doesn't work for multi-module projects, for one reason or another (and I'm bad at debugging elisp. So, I decided to write a custom macro to handle it. I simple place the following in a JDEE prj.el file (in the root directory of my project):

 '("pom.xml" "core/pom.xml" "web/pom.xml") ;; Path to module POMs
 ('(jde-project-name "My JDEE Maven Project") ;; Other JDEE variables set here
  '(jde-expand-classpath-p t)
  '(jde-lib-directory-names '("^lib" "^jar" "^java" "^plugins"))
  '(jde-expand-classpath-p t)
  '(jde-ant-enable-find t)
  '(jde-gen-k&r t)
  '(tab-width 4)
    (quote ("-Xlint:all" "-Xlint:-serial")))))

Et, voila. I get multi-module support. The macro is pretty simple, but it's the first I've ever written (and I'm thinking I could have written it as a function, if not for the expansion of the JDEE variable list at the end):

;; Project file helper for multi-module Maven projects
(defmacro jmi/load-multi-module-pom (base-path pom-path-list other-variable-setters)
  "Macro to load multi-module projects into JDEE. BASE-PATH is
the path to the root of the multi-module project, POM-PATH-LIST
is a list of paths to the submodule pom.xml (relative to
BASE-PATH). Pass in a list of JDEE variables to set in OTHER-VARIABLE-SETTERS."
  (let ((my-classpath (make-symbol "my-full-classpath"))
        (my-sourcepath (make-symbol "my-sourcepath")))
       (require 'pom-parser)
       (setq ,my-classpath  '("/usr/share/java"))
       (setq ,my-sourcepath  '())
        (lambda (pom-name)
            (message "Reading %s" pom-name)
            (with-pom (concat ,base-path pom-name)
              (pom-set-jde-variables *pom-node*))
            (setq ,my-classpath (append ,my-classpath jde-global-classpath))
            (if (stringp jde-sourcepath)
                (setq ,my-sourcepath (append ,my-sourcepath (list jde-sourcepath)))
              (setq ,my-sourcepath (append ,my-sourcepath jde-sourcepath)))))
        '(jde-global-classpath ,my-classpath)
        '(jde-sourcepath ,my-sourcepath)))))

I'll probably elaborate on more of my Java development environment under Emacs in future posts...