Loving Software Blog

Having Trouble importing FragmentBasics Project into Eclipse?

noreply@blogger.com (Carlus Henry) — Sat, 23 Mar 2013 13:28:00 +0000

While doing some Android studying, I download the FragmentBasics project to learn more about fragments. After downloading it, I tried to import it into Eclipse. Unfortunately, this did not work. It complained about the project was overlapping with an existing project.

So you don't spend the time that I did trying to track down how to import the Android Tutorial projects into Eclipse, here is the fix that I found that seems to work.

While I still believe that Eclipse is the Best IDE in the World, it is still software, made by human beings, capable of creating bugs.

Thanks and Happy Coding

Interview with JavaWorld

noreply@blogger.com (Carlus Henry) — Mon, 01 Oct 2012 12:40:00 +0000

Recently, I was given the honor of being interviewed by JavaWorld in a series called The Full Java Life. In this interview I talk about various topics drawing on over 12 years of professional experience with Java and JEE. This interview was a lot of fun, and I thank Matt Heusser for selecting me for this great opportunity.

Gmail stopped working on iPhone :- FIXED

noreply@blogger.com (Carlus Henry) — Sat, 18 Aug 2012 15:56:00 +0000

Believe or not, for the past couple of weeks, Gmail has completely stopped working on my iPhone. I have been scouring the internet to try to find out why this happened. Just now, I finally found a solution to the problem. Unfortunately, according to the docs, it is merely a temporary fix, and the issue will resurface again in the future. However, this fix does work [1].

For brevity's sake, here are the instructions:

1. On your phone, navigate to the following page: https://www.google.com/accounts/displayunlockcaptcha

2. Now attempt to access you email through the iPhone

Once again, according to the place where I found this information, it appears as though this fix will last for about a couple of months before you have to apply it again.

Pay it forward!!!

[1] http://www.everythingicafe.com/forum/threads/gmail-error-cannot-get-mail.58359/

GRWebDev :- Git 101 / Git-SVN Presentation

noreply@blogger.com (Carlus Henry) — Mon, 21 May 2012 23:10:00 +0000

Just completed a presentation at Grand Rapids Web Developer tech group. What an awesome group of folks. I have pushed my presentation to Github.

Thanks
Carlus

Creating Git Patches for the Git-less

noreply@blogger.com (Carlus Henry) — Wed, 09 May 2012 21:32:00 +0000

Recently, I have had to flex my git skills in a way that I have never had to do before. I work for a client that does not use Git as their version control system of choice. They use a product that starts with an 'S' and ends with a 'VN'.

Problem Statement
At times, there is code that I need to enhance, however, I do not have write permissions to. If we were using Git, I would simply clone the project, create a branch for the specific feature, and once the feature was completed, have them pull from me. However, this is not possible if the other team members are using SVN. So how do you solve this issue?

Create a patch
The way to solve this problem is by creating a patch. This patch cannot be just any patch, it has to be a patch that does not include all of the "Git" information. Instead it is a patch that could be applied by using non-git tools. Here are the instructions for creating such a patch:

1.) Make sure you are on the feature branch where you just added your new feature. For our purposes, we will say that it is feature_123.
2.) This feature branch, let's say was created from the master branch.
3.) In order to create a non-git friendly patch, you would enter the following command: git diff --no-prefix master > feature_123.patch
4.) You would then send this patch to someone that does have commit access to the repository.
5.) They would apply the patch using their Editor of choice, or from the command line enter: patch -p0 < feature_123.patch

Happy Coding.

How to open multiple Gmail accounts in Chrome...

noreply@blogger.com (Carlus Henry) — Wed, 23 Nov 2011 13:46:00 +0000

[Although the title of this post relates specifically to Gmail, this feature / functionality can be used for a wide assortment of online applications.]

I love the Google Web Applications, including Gmail, Calendar and Reader. I also manage many Gmail accounts for various reasons. One thing that I find myself doing a lot is switching from one Google Account to another.

Typically, I start my day by logging into my personal Gmail account. However, there are times when I have to create a new appointment using a different Google Account. I used to do the following steps:

Log out of my personal account
Log into the account that I want to create the appointment in
Create the appointment
Log out of that account
Log back into my personal account

I always wished there was a way to stay logged into my own personal account, open a tab, log into the other account and do what needs to be done there, but unfortunately that does not work. If you are already logged into Google, when you open another tab to another Google resource (gmail, calendar...) it keeps you in the same account.

The way around it is to use Chrome's Incognito mode. If you are logged into a Google account, create a new window in Incognito mode (File -> New Incognito Window). In that window, you can access another Google Resource under a different account, all the while staying in your original account on the first browser window.

This neat little trick was introduced to me by a co-worker, and it has been a real time saver. I hope that it is a timesaver for you as well.

Pay it forward.

What has been keeping me busy...

noreply@blogger.com (Carlus Henry) — Thu, 17 Nov 2011 20:43:00 +0000

Every once in a while, your world gets turned upside down. Someone challenges you to think different, and because of it you will never be the same. After developing software professionally for the past eleven years, I have had the pleasure of being introduced to some new ideas and concepts, that have caused me to rethink how to develop software.

There will be more to come, but I thought I would send out this little teaser of what I have been spending time with.

Disruptor

Imagine someone suggesting that the way traditional way of scaling and boosting performance by adding more CPUs is not correct. Then imagine this same company that made this suggestion is proving it by processing more than six million orders per second on a single thread. LMAX has done just that, but more than that, they have completely open sourced their findings and their Java solution. Wondering how to write your next multi-threaded application? You should definitely give the disruptor some attention.

Event Sourcing

While learning about the Disruptor, I came across a new term that I had never heard of before, but one that I will never forget. The easiest way to think about Event Sourcing is when you think about your bank account. How does a bank determine your current balance? It rolls up the debits and credits of your account since the beginning of your account. What if we applied this same technique to our data model when developing software? We would be able to look at the system and our data at any point in time. Anyone likes to guess the state of the system at 2 o'clock in the morning after being woken up due to a production issue?

Events are not just for notifications, by Greg Young, is a great introduction to Event Sourcing.

CQRS

Last, but not least is my current obsession. During Greg Young's talk, he mentioned something called CQRS. Since I was so impressed with what he had to say about Event Sourcing, I thought I would look up what CQRS is all about. In a nutshell, it is an alternative to N-Tier Software Design (Database Tier, Services Tier, UI Tier). It allows software to be designed and tested with behavior. Grounded in the principles of Domain Driven Design, this architecture has taken me a while to understand, and I am still learning. The implications of what is possible with it, are amazing.

To learn more, I would recommend the following:

Udi Dahan's Blog
Greg Young's Blog
Udi Dahan's Talk: Command Query Responsibility Segregation
Distributed Podcast - bunch of guys that walk you through what CQRS is and why use it.
CQRS Mailing List
Axon Framework Mailing List

If you would like to get your feet wet in what it would be like to develop software using these principles, I would highly recommend the Axon Framework. I have been using it for a month now, and it is great. Not to mention the documentation is outstanding and the responses that I have received on the mailing list has been wonderful.

So, that is what has been keeping me busy.....there will definitely be more to come, but I thought I would offer this as a primer before digging in too deep.

Use compile errors like bookmarks....

noreply@blogger.com (Carlus Henry) — Tue, 11 Oct 2011 19:08:00 +0000

I have started a new practice and it is really working out great!!! I am using compiler errors as my means of knowing where I left off on a certain task. For example, it is 4:45, and my wife is cooking a mean meal (by "mean", I am saying that if I don't get home on time, then she is going to be very mean to me for the rest of the night). I don't have time to fix all of the compiler errors so I just check it in to version control. That way, when I come back to work in the morning, or after the weekend, I know just where I need to start again.

The best part of this new process, is that none of my co-workers mind. At all. They don't care one bit. They actually do not think that it impedes on our Test Driven Development practices or our Continuous Integration Builds......amazing, eh?

How am I getting away with this new process of mine? If you haven't guessed it by now, it is because I am using Git. My checkins that I do where things don't compile, are only checked in locally to a branch on my computer. The rest of the team doesn't see these compiler errors, and therefore, they are never affected.

Just one more reason why you should look at distributed version control - no more "mean" dinners for me.

:)

Groovy / Grails Training

noreply@blogger.com (Carlus Henry) — Wed, 27 Jul 2011 11:26:00 +0000

Today begins the second day of a four day Groovy / Grails training class that we are giving to Grand Valley State University. This is the second time that I have given this training and I couldn't have asked for a greater class. The students are experienced, energetic and fun. During the Object Oriented Analysis and Design portion of the class, they came up with solutions to the workshops that were very creative and interesting.

Today we will complete the Groovy portion of the training. We are going to review:

Collections
Closures
Groovy Sql
Testing
Meta Object Programming

The remainder of the week, we will be discussing Grails and the various technologies that make up the Grails framework.

If you or your team is interested in Groovy / Grails Training, feel free to contact us.

Git and Subversion :- New Subversion Branch Created

noreply@blogger.com (Carlus Henry) — Mon, 02 May 2011 13:30:00 +0000

If you have read any of my previous blog posts before, you know that I am use Git in order to track Subversion repositories. Recently, I had another experience that I had to resolve and I wanted to make sure that I share it with you.

The team decided to cut a branch of the code that I have been tracking. After they did that, I ran git svn fetch. After doing this, Git realized that a new branch was created and it started to search through the subversion repository to pull back any history that it might not have.

This probably is a good idea, if I were tracking the entire Subversion history, but I am not. The result was Git was starting to pull back history that I didn't have in my Git repo, nor history that I wanted. It would have taken hours to pull in that amount of history, and as I mentioned, I was not interested in retaining the whole entire repository.

In order to resolve this, I performed the following command:

git svn fetch -r:HEAD --no-follow-parent

I think that the most important part of this command is the --no-follow-parent. This tells git not to look back in time at the history, and just pull in the information from the specified starting point.

I hope that this helps someone else out there....

Pay it forward.

Git Push :- Only Current Branch

noreply@blogger.com (Carlus Henry) — Thu, 14 Apr 2011 13:01:00 +0000

Recently, when sharing a bare repository on my machine with one of the members on my team, we ran into a funny scenario. But first, it is probably worth mentioning the following information:

We are currently using git to push to svn
We have a master branch that is tracking the svn/trunk

I created a new bare repository that will allow us work together on a specific task. When using Git, you only want to push into a bare repository (a repo without a working directory), instead of the real one. He was able to pull the code just fine, but when he tried to push the changes into the bare repository, not only did it try to push the branch that we were currently working on, but it also tried to push the master branch as well. That is because the bare repository that I created, had a master branch, and so did his local, and therefore it was matching on that branches name. (Note: I was also experiencing this same behavior).

After Googling for an answer to the behavior and hoping to get the desired behavior of only pushing the changes from the branch that I am currently on, I found git push current branch, on StackOverflow. If you are like me, and want the desired behavior of only pushing the current branch that you are on to the remote repository, and not all of the branches, just run the following command in your git repository:

git config push.default tracking

There are other options besides 'tracking' but this is giving me the desired behavior that I was looking for...

Enjoy...

Git and Subversion :- Bringing others on board...

noreply@blogger.com (Carlus Henry) — Tue, 12 Apr 2011 12:41:00 +0000

In the previous post, Pulling a Subversion Repository into Git Locally, I shared the process that I went through in order to pull Subversion into Git so that I can start using Git locally with Subversion as my remote repository. Since that time, I have been trying to figure out the best way to get Git to Subversion repositories set up for others on my team. I have gone through a lot of trial and error and now I believe that I have finally come up with an easy step-by-step solution.

Before I begin, let me first say that you probably want to follow these instructions for two main reasons:

Cloning a Subversion Repository is very time consuming
If you have never cloned a Subversion repository using Git, you will be amazed at how long this process can take (depending on how much history you want in Git). I typically chose 1000 revisions in the past, and that could take up to an hour or more. This is no fault of Git, instead, Subversion is to blame. With this process, only one person has to incur that time investment. Everyone else, can just reap the benefits without the hassle

Fetching too much data
This was the problem that has stumped me for months. While I was able to alleviate the first challenge of the time investment for everyone, I could not figure out why Git was trying to retrieve so much history from Subversion. This amount of history was even earlier than the 1000 revisions of the initial clone. Finally, I figured out that it has to do with a property called branches-maxRev. Through the use of this property, we can make sure that when you perform git svn fetch, that it will not attempt to retrieve any more history than necessary. So, let's get started

By this time, I am already assuming that you have followed the directions from Pulling a Subversion Repository into Git Locally, and you already have a Git repository with the amount of history from Subversion that you desire. From that point:

Navigate to your git repo. Not the .git folder, but the folder containing that folder
Open your browser to the git svn man page
Scroll to the bottom section titled Basic Examples, and look at the third example
Locally, start the git daemon server by typing: git daemon. This will start a git server on your local machine that will allow others to pull from you.
Follow the instructions from the Basic Example starting with mkdir all the way to the end. Please note that the line that section that says server:/pub/project must be replaced with a valid git url (for instance git://jdcarlflip.blogspot.com/path/to/git/repo)
Once you have finished those instructions, in your newly created repo, open the file .git/svn/.metadata
Inside of there, you want to put a line under the uuid similar to the following branches-maxRev = 11111 where 11111 is the revision number that you do not want to go past. If you don't know what to put in there, look back at your original repo that you cloned from, and use the same number.
After you have done this, type in git svn fetch, and it should not attempt to retrieve any revisions that are older than the ones you have already

If there are any questions, please let me know.....Enjoy.

Mobile Dev Day :- iOS Development

noreply@blogger.com (Carlus Henry) — Fri, 25 Feb 2011 02:15:00 +0000

This past weekend, I had the wonderful experience of going to MobiDevDay Conference that was held in my hometown, downtown Detroit. It was an amazing conference, and a big thank you to all of the work and effort that went into making it such an excellent and wonderful experience.

Since I am familiar with the concepts of Android development, I decided to spend some time looking at what it takes in order to develop an iOS application. I have never, ever seen what Objective-C even looks like, before this conference, and I am glad that I made the decision to look at it.

....fast forward to yesterday....
I was having lunch with a friend of mine, who is a polygot programmer. He told me about a wonderful FREE series on iTunesU from Stanford University that really helped him learn how to develop Objective-C.

If you are interested, here is the iTunes link.

Enjoy....

Git feeling a little sluggish....?

noreply@blogger.com (Carlus Henry) — Fri, 09 Jul 2010 18:56:00 +0000

So after working in my Git repository for the past couple of months, I started to notice that things are starting to run slower. I remember the days when I first started using Git, it was lightening fast. Now, it is still fast....but I have been missing the lightening.

That is until I was told about the command

git gc --aggressive

This command has brought the lightening back to fast in git.

Share and Enjoy.

Git and Removing Empty Directories

noreply@blogger.com (Carlus Henry) — Wed, 28 Apr 2010 16:24:00 +0000

So, I encountered a very interesting annoyance yesterday with Git. I can't say that it was a problem since it is working as designed, and there is a solution.

I am tracking 7 different branches of Subversion in Git. What is really interesting, is that I actively work on most, if not all of those branches. When switching back and forth between branches, as you can imagine, there are some branches that has folders and code that other branches do not.

Git, by design, does not track folders. The side effect of this is that when I am working on Branch A that has a folder F, then I checkout Branch B, which does not have folder F, that folder F still remains. This is minor but it can quickly become very annoying especially when working in Java and there are a ton of empty packages (folders) in your source directory. So what do you do...?

There is a command that will clean up all of the files that are not part of your git repository - including the folders. This command is:

git clean -fd

Keep in mind, that any files or folders that are not part of the git repository will be removed when you issue this command. If instead, you would like to do a dry run and see what exactly would be deleted prior to actually deleting them, you can run

git clean -fdn

Happy Coding...

Git / Subversion :- Retrieving an Old Branch

noreply@blogger.com (Carlus Henry) — Mon, 26 Apr 2010 14:22:00 +0000

When I first started using Git and Subversion together, I decided that I didn't want the entire Subversion repository on my machine. Instead of cloning the entire Subversion repository, I cloned the last 1000 revisions. This has been working very well for me until today.

Today, we discovered a defect on a branch that was created and deployed well before the starting point in Subversion that I decided to clone from. If instead, the branch was created within the last 1000 revisions, I would have had that branch in my local Git repository. I could have checked that branch out, created a tracking branch, made the necessary code changes, merged it back into the master and sent it upstream to Subversion. But, this was not the case. The Subversion branch that needed code change was not in my local Git repository. How would I get it in there?

After doing some browsing on the internet, I think I came up with a solution that was inspired by a blog post titled Complex SVN repository conversion to Git, by Simeon Pilgrim. While Simeon was not dealing with the same problem that I was dealing with, the solution that he used for his situation could easily be molded to help me with mine.

What I ended up doing was hand modifying the config file that is located within the .git directory in the repository. I added another remote Subversion repository entry. This entry was just going to be used to track the one branch. Here are the details of that entry:


[svn-remote "0.5.0"]
       url = http://subversion.sagetech.com/svn/somethingReallyCool/branches
       fetch = 0.5.0:refs/remotes/svn/0.5.0

This entry above is telling Git that I have a remote Subversion repository that will be aliased as 0.5.0. It also tells Git the URL of the repository as well as the path that should be used for fetching. The fetch actually specifies two paths separated by a colon in the following format "origin:destination". This line is saying that it will pull the code that resides in...


http://subversion.sagetech.com/svn/somethingReallyCool/branches/0.5.0

and put it into the Git remote branch at refs/remotes/svn/0.5.0.

After this entry was made into the .git/config file, all that was left to do was to fetch the code. That was done with the following command:


git svn fetch -r1200:HEAD 0.5.0

This fetched from the Subversion branch 0.5.0 into my Git Remote branch all of the revisions starting at 1200, and allowed me to fix the defect and publish back to the 0.5.0 branch.

Happy Coding

Git Revert to the Rescue...

noreply@blogger.com (Carlus Henry) — Mon, 19 Apr 2010 16:09:00 +0000

Once again, Git has saved yours truly.

One of my current responsibilities is to merge a branch within Subversion to the main code line (trunk). Usually, this doesn't require a lot of effort in order to complete. For this merge, since there were relatively few changes, I decided to perform the merge using the command line.

I specified my range of revisions that I would like merged down to the trunk, resolved all of the conflicts, and then committed the merge to Subversion. Later, I realized that I did not specify the correct range of revisions, and therefore, the merge was incomplete. I was just about to revert my changes in the Subversion repository, when I realized that there had been some commits done to the trunk after my merge. Doh!!!

Why is this such a problem? Well, it is a problem because if I was to roll back the Subversion repository to the point right before the incomplete merge that I performed, then I would also be removing the commits of my teammates. That would not make me too popular amongst my co-workers.

At this point, what could I do? One option would be to take the commit that occurred after my incomplete merge and save it off somehow using a patch tool, then roll back the subversion repository, then reapply those changes. Another option would be to figure out all of the changes that I made as part of my incomplete merge, and roll each file back one by one to the previous version. Both of these options sounded horrible and time consuming. Luckily, I could use Git in order to solve this problem.

Git Revert to the Rescue

Git has a great feature called revert. In a nutshell, the revert feature of Git allows you to specify any commit, create a reverse-patch for that commit, and commit it to the repository using one command. In other words, it backs out the changes of a commit. For example, let's say that your repository has the following 4 commits:


A-B-C-D

You realize that there is a bug in the commit titled 'B', and you would like to roll the code back. You can do that using Git by typing


git revert B

which would change your repository to:


A-B-C-D-E

The commit titled 'E', is actually a reversal of the commit B.

Needless to say, this little trick saved me a lot of time and effort. All I did was revert the merge commit, and attempted the merge again, this time making sure that I specified the correct range of revisions. For this little feature alone, I am grateful that I am using git.

Happy Coding

Git :- Unrealized Productivity Gain

noreply@blogger.com (Carlus Henry) — Fri, 16 Apr 2010 15:57:00 +0000

After showing a co-worker my workflow using Git integrated with Subversion, he pointed out a productivity gain that I am getting that I have been taking for granted.

When I was using Subversion, I would have multiple directories that would represent different code lines. I had a directory for the trunk, and a directory for each of the branches of code for our code base. On top of that, when I wanted to work in one of the other code lines, I would have to restart my IDE, and then point it to the correct code line. This did not take too long to do, however, considering the amount of times I jump between code lines, it was definitely time that was not well spent.

Using Git, I now only have one directory with all of my code. If I want to switch to a different branch, then all I have to do is perform a checkout of that branch, and refresh the code in my IDE. Simple, elegant, fast and effective.

Yet another reason why I am loving Git.

Pulling a Subversion Repository Into Git Locally

noreply@blogger.com (Carlus Henry) — Wed, 14 Apr 2010 01:50:00 +0000

Over the past month, I have really enjoyed using Git with Subversion. However, when I was thinking about how I got Git all setup to access Subversion, I realized that I can't remember exactly how I did it. So in the interest of remembering how to get Git setup to work with Subversion, I am writing this post for myself and anyone else who is interested in using Git in a Subversion environment.

After installing Git, you are going to want to determine the URL of the Subversion repository that you are going to want to integrate with. For our purposes, let's use the Open Source project AppFuse, whose Subversion repository is hosted at https://appfuse.dev.java.net/svn/appfuse/trunk.

First thing to do is to clone the repository to your machine. This process of cloning is what is going to convert the Subversion repository into a local Git one. At this point, I am not interested in cloning the entire repository (all of the branches, tags). I am also not interested in cloning all of the revisions (at the time of this blog post, their Subversion repository is on revision 3333). Instead, I only want to clone the trunk with the past 100 revisions. Here is the command necessary to do just that:



git svn clone https://appfuse.dev.java.net/svn/appfuse -r3330:HEAD --prefix=svn/ -T trunk -b branches -t tags appfuse.git

(You can choose to omit the -T, -b, and -t options, if you so desire. We can always add those details later.)

If you are prompted for a user id and password, use the account 'guest' without a password.

During the cloning process you are going to notice that git is actually mapping the 100 commits in Subversion to a Git commit object in your local repository. As you might imagine, this process could take a very long time, depending on how many revisions you are cloning into your local repository.

After your clone has completed, you should have a directory called appfuse.git. Move to that directory and type the following



git log -3 --stat

This will show the last three revisions that have been made to this source code. The first commit looks like this:


Author: mraible 
Date:   Sat Feb 27 15:54:03 2010 +0000

    Turn off EhCache update checking.
    
    git-svn-id: https://appfuse.dev.java.net/svn/appfuse/trunk@3333 2aeb74e6-0f1c-0410-991c-92d95bb9df37

 web/common/src/main/resources/ehcache.xml |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

The most interesting thing about this log is the fact that you can tell what Subversion revision it came from by the line that begins with git-svn-id. You can see that it comes from the revision 3333. There are many other features of git log that I am not going to talk about, but do encourage you to look into.

Congratulations, you have successfully pulled the Subversion repository into Git locally. In the next couple of blog posts, I will spend some time discussing how to commit changes back to the repository, as well as how to track and commit to branches in Subversion.

Happy Coding.

Git Interactive Adding...now you tell me...

noreply@blogger.com (Carlus Henry) — Tue, 13 Apr 2010 01:02:00 +0000

First off, major thanks to Scott Chacon and his video post on how to do Interactive Adding in Git. Unfortunately, I am only now getting a chance to review this video, since it was crunch time at work today...

I spent most of the day today hunting down a defect. This defect was a good one. You know the kind. The kind that really stretches your brain and gives you a chance to flex your skills as a Software Developer. Of course, as always, there was a logical explanation for the erroneous behavior that we were seeing, however, it took quite a lot of time, and a lot of Tracer Bullets, in order to find the problem. After finding the problem, we made the appropriate code changes...I love team coding...and then I wanted to commit those changes. This is where Interactive Adding in Git would have helped out a ton...

I wasn't interested in committing all of those tracer bullets, instead, all I wanted to commit was the actual fix. Using interactive adding, I could have staged the changes that actually fixed the issue in one commit, and then I could have added the Tracer Bullets as another commit. Since these were separate commits, I could have then switched back to my master branch, and cherry picked the commit that had the fix in it. (Remember, I do not develop on the master branch and instead choose to merge in changes from other branches once I have completed development and testing). This would have resulted in a very nice and clean fix to the master branch.

Unfortunately, since I am not yet the git slinger that I aspire to be, I had to commit the tracer bullets and the fix underneath the same commit and merge all of those changes down to the master branch. So, I have a little code clean up to do...doh!!!

After watching Scott's video, I am more confident in my interactive adding git skills, and I look forward to using them the next time I want to selective commit a portion of my changes.

Happy Coding...

Distributed Version Control Systems.....how I love thee...

noreply@blogger.com (Carlus Henry) — Thu, 08 Apr 2010 19:48:00 +0000

Today, I was working with a developer at his station and we made some changes to some code. I asked if he could commit those changes, and he told me that he was not ready to commit those changes because he had made changes elsewhere in the system and those other changes were not yet ready. This reminded me of why I have made the switch to using Distributed Version Control.

You see, when you are using Distributed Version Control Systems, you can adjust your workflow in such a way that you do not run into these types of scenarios. With the advantage of creating branches of code locally, you can work on completely different efforts simultaneously. Currently I have 7 different branches that reside locally for one of my customers. This allows me to switch between different efforts that are currently underway. More than that, since I am using Git, I am able to synchronize with my customer's Subversion repository and delivery the changes that I want to delivery and retain the ones that I don't.

To illustrate the advantage of using DVCS, let's take the scenario I mentioned earlier. A developer approaches me and asks me for some help and would like to pair program a specific feature. I am smack dab in the middle of working on something (I mean the code doesn't even compile). Since I am using Git, I am able to commit this code that doesn't compile and create a new local branch based on the trunk of the source code that is in Subversion. I realize committing code that doesn't compile is a big NO-NO, but I believe that helping your co-workers / customers is much more important (besides, I would only be committing those changes locally, and not pushing them to Central repository anyways). Now the code that resides on my machine looks exactly like the code that is in the repository. We make the necessary code changes, I commit them locally to my local repository and push them back up to Subversion. My co-worker / customer goes on his merry way, and I switch back to the branch that I was working on when they came over for assistance.

DVCS...it is a beautiful thing...

I Love the Library...

noreply@blogger.com (Carlus Henry) — Wed, 07 Apr 2010 18:40:00 +0000

Yet another reason why I love the library...

Kent District Library has added Mango Languages to its growing list of patron resources. Mango is free to all KDL cardholders, and is an easy, effective way to learn to speak a foreign language. Mango is available in two versions

Read complete story

Coming back to my senses...

noreply@blogger.com (Carlus Henry) — Fri, 02 Apr 2010 12:34:00 +0000

In case someone happens upon my last post not realizing that it was April Fools Day, I just want to take a quick moment to clear the air...

I think that Java/JVM is one of the most fascinating language / technology of today. There is an incredible amount of innovation happening in the arena, and I don't forsee this changing anytime soon. There has been plenty of other languages out there whose claims of being the "Java Killer", has been proven false over time. I am not knocking those other languages - there are some very attractive features of those languages. I am just acknowledging the fact that after those claims, Java/JVM is still around. Not to mention there are plenty of companies who have an incredibly amount invested in the Java/JVM technology.

For these reasons and more, I think that Java is going to be around for quite a while.

Goodbye Java....

noreply@blogger.com (Carlus Henry) — Thu, 01 Apr 2010 17:23:00 +0000

That's right. I am done. Finished. The game is over.

I have finally decided to put my Java "badge of shame" down. I mean, let's face it, Java is not the Mercedes of Programming Languages anymore. There hasn't been a lot of innovation going on in the Java / JVM space for years now. I need to start working in a technology that is more relevant to the needs of my customers of today and tomorrow.

I just can't believe that I have wasted this much time of my career in Java. So to all, wish me luck as I venture on a new path in development, away from Java...

Eclipse Templates: Commons Logging

noreply@blogger.com (Carlus Henry) — Fri, 08 Jan 2010 19:24:00 +0000

For mostly my own benefit, but if you gain something out of this...awesome!!!

Here is a template that I use in Eclipse and I always have to recreate the syntax for when at another developer's workstation....


private static final Log logger = LogFactory.getLog(${primary_type_name}.class);
${:import(org.apache.commons.logging.Log,org.apache.commons.logging.LogFactory)}