DHP Technologies, Inc. on DHP Technologies, Inc.

Site Redesinged

danap@dhptech.com (Dana H. P'Simer) — Wed, 30 Sep 2015 00:00:00 +0000

I have redesigned the site to be more efficient to host. I hope you like it.

Remembering Steve Jobs

danap@dhptech.com (Dana H. P'Simer) — Wed, 05 Oct 2011 00:00:00 +0000

I was 12 years old in 1980 when I first saw an Apple computer. It was at a friends house. He showed me some games, used a synthesizer program to create some music and showed me a program he had written and I was hooked. I went home that night with a recording of the music and played it for my father. I said, if we had an Apple II we could do things like that. I really wanted it. Well my dad, being an electrical engineer, was into electronic gadgets and I guess he thought it would be good to have a computer in the family, so he bought one! We got the Language Card with it so that we would have an extra 16KB of memory and UCSD Pascal.

I remember playing a ton of games on that thing. I also learned to program in AppleSoft BASIC, Pascal, and 6502 Assembler. I loved computer graphics so I tried to write a Space Invaders clone in UCSD Pascal. That did not work well. The UCSD p-System was just too slow. So I learned how to do it in 6502 Assembler. I got pretty far with it but eventually, I eventually gave it up. I wrote other things and continued to learn.

I remember learning just about everything about that computer. I knew all the peek and poke addresses to do all kinds of stuff. I knew how the disk format was laid out so I could better understand how software was copy protected. I think I explored just about every aspect of that computer.

I remember reading about the 2 men who started Apple Computers, Steve Wozniak and Steve Jobs. I remember Steve Jobs as the dynamic spokesman. He was inspiring then.

Late in the 80’s I moved away from my Apple roots and started using IBM’s & Microsoft’s products. There were some interesting times then. Businesses were using micro computers more and more and there was a lot of money to be made writing software for them. I am not ashamed to say that I took not a small piece of that pie.

When he returned to Apple I was excited to hear it. I wanted them to do well but I had drifted away. I could not go back to Apple when all my business was on PCs. It wasn’t until I started looking for a UNIX that ran well on a laptop that I came back to Apple in 2006. Since then I have not looked back. The products that Steve Jobs brought into this world have not just revolutionized the industry they, more importantly, have revolutionized my life and my relationship with my computers. For the longest time I struggled to make Windows do what I want and now my computer does what I want. One of the reasons I became a computer programmer was because I loved making them do what I wanted.

After that, he kept coming out with new stuff that I loved. I have an iPhone, an iPad, an AppleTV, and a MacBook Pro. My wife has a MacBook Pro, my son a Mac Mini, and my daughter a MacBook.

Thanks, Steve, for the great ride and inspiration. You will be missed.

AWS Framework for Mac OS X

danap@dhptech.com (Dana H. P'Simer) — Tue, 04 Oct 2011 00:00:00 +0000

I have ported the AWS for iOS Framework to Mac OS X and pushed the code to bitbucket. There's not a lot to say about it.

I had to hack up the browser id line. I am planning on fixing that.
There were some issues with the structure of the source code directories and import statements that needed to be ironed out.
Also, there were some mismatches in variable types that changed size between iOS and OS X so I fixed those up as well

I have tested the S3 APIs to a small extent and am working on more unit tests but I think this establishes that the underlying communication mechanism is working fine under OS X.

Feel free to fork and submit pull requests. I am going to try to keep the code as close to the original as possible so that changes from the iOS version and be merged in easily. If you have a significant change we can push them into a branch.

You don't exist, go away!

danap@dhptech.com (Dana H. P'Simer) — Wed, 24 Aug 2011 00:00:00 +0000

Today I tried to push my latest changes from a git repo on my laptop to a remote repo and got the following output:

moe:~/dev/ihg/endeavor-stats-analyzer 
danap$ git push
You don't exist, go away!
fatal: The remote end hung up unexpectedly

I did some googling and found that it might have something to do with SSH not being able to find out what user I am. So I looked in /etc/passwd file and could not find my user! I use a Mac OS X 10.7.0 system so I was not terribly alarmed. Of course the “it just works” operating system would keep my user information in a place other then the standard Unix location. There was a comment in the file stating that most user information was stored in opendirectory. So I did a “ps -ef | grep opendirectory” and I found the process. So figuring it was managed and watched by launchd, I killed it. That worked. I was able to SSH again.

So whenever you are accused by your Mac OS X system that “You don’t exist” and are commanded to “go away” try killing opendirectory. That might just do the trick.

Hosting Maven Sites & Repos at Google Code

danap@dhptech.com (Dana H. P'Simer) — Sat, 14 Aug 2010 00:00:00 +0000

When hosting an Open Source software project you want to keep things simple and cheap. I was struggling to figure out where I was going to put my SNAPSHOTs and site for a simple BOM striping plugin I had written and was hosting at Google Code. I came across this article but it assumes you are going to use Subversion. I prefer Mercurial so I came up with a similar method.

What I came up with was this: Since Google uses http/https to access the Hg repository, I decided a similar arrangement would work. However with Hg you don't push revisions directly to the remote repo. First they have to go into the local clone then they get pushed. For Hg based projects Google Code provisions two source repositories: one for the wiki and one for the code. So I decided to use the wiki source repo to hold the maven repo and site.

To see the entire project source code and layout go to The Google Code Site for the Strip BOM Maven Plugin. The following are a set of steps that should help you use the same strategy in your project:

In order to know where the local wiki repo directory is, I needed a property to hold that value and then we would set it in the settings.xml, however I am a fan of not having any external dependencies that could cause the build to fail. So I added this to my POM to set a default:

  <properties>
    <strip-bom.deploy.directory>${basedir}/target/deploy</strip-bom.deploy.directory>
    ...
  </properties>

Next I added the following to my POM to define the distributionManagement settings

  &lt;distributionManagement>
    &lt;repository>
      &lt;id>strip-bom-deploy&lt;/id>
      &lt;name>Repo&lt;/name>
      &lt;uniqueVersion>true&lt;/uniqueVersion>
      &lt;url>file:${strip-bom.deploy.directory}/repo&lt;/url>
    &lt;/repository>
    &lt;site>
      &lt;id>strip-bom-site&lt;/id>
      &lt;name>Site&lt;/name>
      &lt;url>file:${strip-bom.deploy.directory}/site&lt;/url>
    &lt;/site>
    &lt;downloadUrl>http://code.google.com/p/strip-bom-maven-plugin/downloads&lt;/downloadUrl>
  &lt;/distributionManagement>

The <repository> tag defines where the repo will be stored. The <site> defines where the site will be deployed. These will be in my Hg controlled local repo.

Next, I added this to my settings.xml:

  &lt;profiles>
    &lt;profile>
      &lt;activation>&lt;activeByDefault>true&lt;/activeByDefault>&lt;/activation>
      &lt;properties>
        &lt;strip-bom.deploy.directory>${user.home}/dev/dhptech/strip-bom-maven-plugin-wiki&lt;/strip-bom.deploy.directory>
      &lt;/properties>
      &lt;id>default&lt;/id>
    &lt;/profile>
  &lt;/profiles>

Now, when I do a snapshot build, I can execute mvn deploy site-deploy, commit and push the wiki repo, and the snapshot and site are deployed at the same time.

Subversion Version Mismatch

danap@dhptech.com (Dana H. P'Simer) — Wed, 07 Apr 2010 00:00:00 +0000

I installed a new 320GB hard drive into my MacBook Pro last night. Time Machine makes this stuff really easy now. I left it restoring last night around 1am and came back to it around 8am and was able to simply reboot into my restored disk with 170GB free space and 7200RPM speed. Nice.

However, when I went to build the latest version of the software my team develops, I got an odd error:

svn: Mismatched RA version for 'https': found 1.6.2, expected 1.6.5

I had never seen this before. I am not sure why after restoring from a backup this could have happened but it did. So I start googling. I found this forum post over at svnforum.org. They say reinstalling the 10.6.2 Combo patch for OS X solved their problem. So I tried using Software Update to update the Mac's software. There was a 10.6.3 update available so I applied it. After that the error changed to:

svn: Mismatched RA version for 'neon': found 1.6.2, expected 1.6.5

At this point, I did not think downloading a 10.6.2 patch and applying it to a 10.6.3 OS install was a good idea, to say the least. So I thought I would just install the latest version of subversion from Collab.Net. That solved my problem, somewhat. The installation of subversion that came with Snow Leopard is still there. There is a new installation in '/opt/subversion' that was installed by Collab.Net's installer. As long as the '/opt/subversion/bin' directory appears first in the path, my SVN commands execute. Please see this article for information on how to set environment variables in Mac OS X.

The Common Denominator of Successful Programmers

danap@dhptech.com (Dana H. P'Simer) — Sat, 27 Jun 2009 00:00:00 +0000

I just read The Common Denominator of Success by Albert N. E. Grey. Please take the time to read it now as I will be referring to concepts in it. My boss, Ashley, had suggested it as an inspirational piece. As I read the piece I was struck by how relevant it is to so much more than just Life-Insurance salesmanship. As he discussed some of the things that insurance salesmen do not like to do I started to list off in my head the things that Programmers do not like to do but should do if they want to be successful. When I read about how having a purpose makes the formation of these habits possible I started to think about what purpose a programmer would need to make forming the habits of successful programmers possible.

I consider myself a successful programmer. I have been working in this field since 1988 and have programmed in many environments and languages. I have held positions ranging from junior programmer to architect. I have written software that received awards from prominent publications and software that only a handful of people ever saw but generated significant revenue for my customers. If you are interested you can find a copy of my resume in the "People" section of this site. I have found that many of the things that I do out of habit my less successful colleagues resist doing. I have always been frustrated by this. Mr. Grey's article has given me some insight into why it is that people do not do the things that are required for success.

How can we, programmers, measure success? For insurance salesmen it is easy to measure success because the amount of money earned is directly proportional to the success of the salesperson. For programmers the story is more complicated. Success can be described in many ways. For some applications, the revenue generated by the application may very well be a good measure. However sometimes applications that make money do so despite significant flaws in the application. Another way to measure it is by looking at the numbers of bug reports and enhancement requests. Still another way could be to look at your own personal income since, generally speaking, better programmers get paid more money. Yet another way to look at success is in terms of time to market. Many applications are extremely sensitive to time to market and therefore the speed with which a product can be brought to market can determine success vs. failure. I think how you measure success depends on your purpose.

I currently work as the Technical Lead for a development group at IHG. IHG is the largest hospitality company in the world but you may never have heard of them. However, you have heard of our brands. Holiday Inn is one. As well as Holiday Inn Express, Crowne Plaza, Intercontinental Hotels, Candlewood Suites, Staybridge Suites, and Hotel Indigo. We get daily revenue reports from our VP. He obviously measures our success, at least in part, by how our revenue numbers match our target numbers. Since our group is responsible for all revenue generating technology channels, that is a fair way to measure our success. One way I, personally, measure our team's success is by keeping an eye on the number of defects that impact revenue.

How you measure success will depend, significantly, on what your purpose is. I will get back to that later down the line.

To apply the "tagline" at the top of The Common Denominator of Success we need to ask what do successful programmers do that failures do not like to do and, therefore, do not do? A number of things come to mind immediately. Like testing, code reviews, and documentation. However, I think two words sum up the habits that successful programmers have: Verification & Planning.

Successful programmers seek verification that their code works as intended. This takes the form of unit tests using tools like JUnit or TestNG, for Java. It takes the form of code reviews, design reviews, and just reaching out to our fellows to bounce ideas around. It takes the form of gathering/identifying requirements. Many of these tasks are tedious and time consuming and seem to eat up precious time to get other things done. However, those that form the habit of doing these things fit them into their normal flow of work and can therefore save the time that will be spent tracking down an elusive bug that could easily have been caught by good unit testing or a code review.

Successful programmers plan their activities. I am not talking about hyper-planning. I am talking about simple things like creating some form of requirements, creating a design that lays out what changes/new code needs to be written and how that code is to be laid out. Also, they plan how their software will be verified and how it will be documented.

Planning can also include developing tools and automation techniques that make the development of your software easier. Giving thought to how you will build and deliver your application can save hours, even days, later on down the line. The process of determining what tools will be used for development can be essential to success. Many programmers do not take the time to learn their tools, either. They learn just enough to get the code they write compiled and deployed. However, sometimes knowledge of the tool can be essential to success or allow you to cut time when it is of the essence.

Planning and Verification feedback on one another and that feedback is essential to successful software development. Just as successful programmers plan to verify they must also verify their plan. This means reviews by competent colleagues. This does not need to be a terribly onerous process.

In a previous engagement I worked for a medical device company, ResMed, and we developed a medical telemetry system for them that would transmit CPAP usage data using the narrow-band PCS wireless network. We had a device that would attach to the back of the CPAP machines and we could send queries to the device to retrieve data. As such, this product fell under the regulation of the FDA as a medical device and we had to obtain 510(k) approval to market the device in the US. The documentation requirements for software developed under 510(k) regulations are extensive. However, we devised a way to meet these requirements without creating a ponderous and onerous process. One example of the kind of documentation that was required was that we needed to devise testing plans for all features of the system. These testing plans needed to be reviewed by qualified colleagues and then executed by a member of the team other than the feature's developer. We accomplished this using ticketing system with some custom workflow capabilities and notes added to the feature/bug's ticket. Very simple and easily reproduced.

Now, back to purpose. What is the purpose that drives us as Programmers? A the end of The Common Denominator of Success, Mr Grey gives an example of a young man that he met whose purpose was to give his family a better life then he, his mother, and his sister had. If that is your purpose, then your measure of success must be the amount of compensation you receive. This is a good purpose. It has the emotional context that Mr. Grey says is necessary to carry us past our needs. It is certainly one of my purposes.

Let's be frank. Most of us work for businesses. Businesses do not write software because they like to. They do it either because they hope to generate more revenue or reduce their costs. They enter into the endeavor with an understanding that paying for the development will be out weighed by either the revenue generated or the costs saved. Therefore, the measure of success of a software solution is its impact on profit. Given that, the best way to reward the people who write the software is to give them money. There is an equilibrium between software costs and software benefits. The higher the benefit the higher the potential compensation. To maximize compensation one must know the market in the area they are working. Even the best programmers will find it hard to command compensation well outside the going rates in the local market. Even if the profit impact of the software being written is very high. How does one command the highest range of compensation? They must demonstrate through their previous work experience that they are capable of a high degree of productivity. They must also interview well and, once on the job, perform beyond expectations. To do that, one must make a habit of things which they do not like to do.

Another purpose that drives me and has just such an emotional context is my desire to leave things better then how I found them. I feel that it is the impact our life has on those around us that is the measure of our life. I am a programmer and therefore the best way for me to impact those around me is through that skill. This does not mean that I wish only to improve the code. I also wish to improve the coders. Those men and women I have been privileged to work with in this endeavor we call programming, I hope, are better programmers because of my example.

I encourage you to find a purpose that drives you beyond your needs and supports you in developing the habits necessary for success, whether you are a programmer or an insurance salesperson.

A Throttling CompletionService

danap@dhptech.com (Dana H. P'Simer) — Mon, 08 Jun 2009 00:00:00 +0000

The CompletionService interface defines a service that allows the caller to submit tasks to be completed in the future. A commonly used implementation is the ExecutorCompletionService, which uses an Executor to run the tasks that have been submitted.

In most cases the Executor used will be the ThreadPoolExecutor which creates a pool of threads to use in executing submitted tasks. ThreadPoolExecutors are very expensive things to create. They should not be created on-the-fly because of this. ThreadPoolExecutors are excellent at limiting the total number of threads running a particular type of task and therefore provide a safeguard against thread leakage or other scenarios that may result in running out of threads. CompletionServices are, on the other hand, rather inexpensive to create.

In a recent use case I was presented with I realized that I needed to create a varying number of tasks that needed to run in parallel but I did not want one particularly large request to starve out other requests and make them wait for an available thread from the pool to execute their tasks. That’s when I came up with the idea that if I could have a CompletionService that would limit the number of tasks that would simultaneously be submitted to the Executor, I could have one thread pool that is shared by all requests.

At first I thought I would extend the ExecutorCompletionService. As I wrote the code I realized I was just delegating all the behavior to the methods defined in CompletionService. So, I created the “ThrottledCompletionService” as a Decorator which takes another CompletionService. In this way I was able to add this functionality to any CompletionService not just a ExecutorCompletionService.

Here is the code:

 package com.dhptech.utils.concurrent;
 
 import java.util.LinkedList;
 import java.util.Queue;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletionService;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorCompletionService;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 
 import com.dhptech.utils.concurrent.ConcurrentUtils;
 
 /**
  * This CompletionService decorates another CompleationService and throttles the
  * number of concurrently submitted tasks that will be submitted and any given time.
  *
  * This can be used in conjunction with an Executor to complete tasks but keep
  * larger batches of tasks from starving out smaller batches.  Each &quot;batch&quot; whould
  * get a new ThrottledCompletionService but all of them use the same central
  * Executor.
  *
  * This object is lightweight enough to be created and destroyed for each batch
  * of tasks that need to be submitted to a common Executor.
  *
  * @author danap
  */
 public class ThrottledCompletionService<V> implements CompletionService<V> {
 
   /**
    * Acts as a base class to implement the Future interface for the Runnable
    * and callable variants.
    *
    * @param <T> the return type of the task.
    */
   private abstract class ThrottledTask<T> implements Future<T> {
     private CountDownLatch submitted = new CountDownLatch(1);
     private Future<T> delegateFuture = null;
     private boolean cancelled = false;
 
     /**
      * Sets the delegateFuture and counts down the submitted latch.
      *
      * @param delegateFuture the future from the decorated completion service.
      */
     protected void setDelegateFuture(Future<T> delegateFuture) {
       this.delegateFuture = delegateFuture;
       submitted.countDown();
     }
 
     /**
      * Should submit the task to the completion service.
      */
     public abstract void submit();
 
     /**
      * @see Future#cancel(boolean)
      */
     public boolean cancel(boolean mayInterruptIfRunning) {
       if ( submitted.getCount() > 0 || delegateFuture == null ) {
         cancelled = true;
         return true;
       } else {
         return delegateFuture.cancel(mayInterruptIfRunning);
       }
     }
 
     /**
      * @see Future#isCancelled()
      */
     public boolean isCancelled() {
       if ( cancelled ) {
         return true;
       }
       if ( submitted.getCount() == 0 ) {
         return delegateFuture.isCancelled();
       }
       return false;
     }
 
     /**
      * @see Future#isDone()
      */
     public boolean isDone() {
       if ( submitted.getCount() == 0 ) {
         return delegateFuture.isDone();
       }
       return false;
     }
 
     /**
      * @see Future#get()
      */
     public T get() throws InterruptedException, ExecutionException {
       submitted.await();
       return delegateFuture.get();
     }
 
     /**
      * Get the value from this future.
      *
      * @see Future#get(long, java.util.concurrent.TimeUnit)
      *
      * NOTE: because this operation will first wait for the task to be submitted and
      * then wait for the future returned by the decorated completion service, the
      * timeout is converted to nanoseconds and the time taken to wait for the
      * task to be submitted is subtracted from it before passing it to the get
      * method of the future returned by the decorated compleation service.
      */
     public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
       // Convert the timeout unit to nanoseconds.
       long timeoutNanos = ConcurrentUtils.convertTimeUnitToNanos(timeout, unit);
       // record the time we started waiting.
       long start = System.nanoTime();
       submitted.await(timeoutNanos, TimeUnit.NANOSECONDS);
       // remove the time we waited from the timeout.
       long elapsed = System.nanoTime() - start;
       timeoutNanos -= elapsed;
       // wait the remainder of the timeout for the result.
       return delegateFuture.get(timeoutNanos,TimeUnit.NANOSECONDS);
     }
   }
 
   /**
    * An implementation of ThrottledTask that handles Runnables.
    */
   private class ThrottledRunnable extends ThrottledTask<V> implements Runnable {
     private Runnable delegate;
     private V value;
 
     /**
      * Contructs a new ThrottledRunnable.
      *
      * @param delegate the runnable that we will delegate to.
      *
      * @param value the value to return from this task.
      */
     public ThrottledRunnable(Runnable delegate, V value) {
       this.delegate = delegate;
       this.value = value;
     }
 
     /**
      * @see ThrottledTask#submit()
      */
     public void submit() {
       setDelegateFuture(mDelegate.submit(this,value));
     }
 
     /**
      * @see Runnable#run()
      *
      * calls {@link ThrottledCompletionService#submitNext()} when the task is done.
      */
     public void run() {
       try {
         delegate.run();
       } finally {
         submitNext();
       }
     }
   }
 
   /**
    * An implementation of ThrottledTask for Callables.
    */
   private class ThrottledCallable extends ThrottledTask<V> implements Callable<V> {
     private Callable<V> delegate;
 
     /**
      * Construct a ThrottledCallable.
      *
      * @param delegate the callable we will delegate to.
      */
     public ThrottledCallable(Callable<V> delegate) {
       this.delegate = delegate;
     }
 
     /**
      * @see Callable#call()
      *
      * calls {@link ThrottledCompletionService#submitNext()} when the decorated
      * task is complete.
      *
      * @return the return value of the callable.
      *
      * @throws java.lang.Exception an exception when something bad happens.
      */
     public V call() throws Exception {
       try {
         return delegate.call();
       } finally {
         submitNext();
       }
     }
 
     /**
      * @see ThrottledTask#submit()
      */
     public void submit() {
       setDelegateFuture(mDelegate.submit(this));
     }
   }
 
   private int mThrottle = 1;
   private CompletionService<V> mDelegate;
 
   private int mSubmitted = 0;
   private Queue<ThrottledTask<V>> mTaskQueue = new LinkedList();
 
   /**
    * Creates a new ThrottledCompletionService wrapping the given completion service
    * as a delegate.
    *
    * @param delegate
    */
   public ThrottledCompletionService(CompletionService<V> delegate) {
     this.mDelegate = delegate;
   }
 
   /**
    * Creates a new ThrottledCompletionServices wrapping a new ExecutorCompletionService
    * that references the passed executor.
    *
    * @param executor the executor.
    */
   public ThrottledCompletionService(Executor executor) {
     this.mDelegate = new ExecutorCompletionService<V>(executor);
   }
 
   /**
    * Creates a new ThrottledCompletionService wrapping the given completion service
    * as a delegate.
    *
    * @param delegate
    */
   public ThrottledCompletionService(CompletionService<V> delegate, final int throttle) {
     this.mDelegate = delegate;
     this.mThrottle = throttle;
   }
 
   /**
    * Creates a new ThrottledCompletionServices wrapping a new ExecutorCompletionService
    * that references the passed executor.
    *
    * @param executor the executor.
    */
   public ThrottledCompletionService(Executor executor, final int throttle) {
     this.mDelegate = new ExecutorCompletionService<V>(executor);
     this.mThrottle = throttle;
   }
 
   /**
    * Decrements the submitted count, attempts to submit the next task.  Callled
    * when a submitted task completes.  If there are no tasks to submit, simply
    * return.
    */
   private synchronized void submitNext() {
     mSubmitted -= 1;
     if ( mSubmitted < mThrottle ) {
       while(true) {
         ThrottledTask<V> task = mTaskQueue.poll();
         if ( task != null ) {
           // skip any tasks that were cancelled before we submitted them.
           if (task.isCancelled()) {
             continue;
           }
           task.submit();
           mSubmitted += 1;
         }
         break;
       }
     }
   }
 
   /**
    * @see CompletionService#submit(java.util.concurrent.Callable)
    *
    * @param task the task to submit
    *
    * @return a future for
    */
   public synchronized Future<V> submit(Callable<V> task) {
     ThrottledCallable ttask = new ThrottledCallable(task);
     if ( mSubmitted < mThrottle ) {
       mSubmitted += 1;
       return mDelegate.submit(ttask);
     } else {
       mTaskQueue.offer(ttask);
       return ttask;
     }
   }
 
   /**
    * @see CompletionService#submit(java.lang.Runnable, java.lang.Object)
    *
    * @param task the task to be run.
    * @param result the result to return from the Future<V> object.
    * @return a future object that can be used to access the result of the submitted task.
    */
   public synchronized Future<V> submit(Runnable task, V result) {
     ThrottledRunnable ttask = new ThrottledRunnable(task,result);
     if ( mSubmitted < mThrottle ) {
       mSubmitted += 1;
       return mDelegate.submit(ttask,result);
     } else {
       mTaskQueue.offer(ttask);
       return ttask;
     }
   }
 
   /**
    * @see CompletionService#take()
    */
   public Future<V> take() throws InterruptedException {
     return mDelegate.take();
   }
 
   /**
    * @see CompletionService#poll(long, java.util.concurrent.TimeUnit)
    */
   public Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException {
     return mDelegate.poll(timeout, unit);
   }
 
   /**
    * @see CompletionService#poll<span class="javaComment">()
    */
   public Future<V> poll() {
     return mDelegate.poll();
   }
 }

Will Apple Announce a New iPhone at WWDC?

danap@dhptech.com (Dana H. P'Simer) — Mon, 08 Jun 2009 00:00:00 +0000

The author of this article seems to think so. There is also this article that seems to be reporting the same thing. Rumors are flying around what Apple, who always keeps its announcements well under wraps, will be announcing at the keynote for its World Wide Developer Conference next week. I am looking forward to hearing what Jobs and Crew have in store for us next week. There is also talk of them making an announcement about “Snow Leopard”.

PHP File Upload Size Issues

danap@dhptech.com (Dana H. P'Simer) — Sat, 21 Jun 2008 00:00:00 +0000

Ran into a problem when I was maintaining a customer’s site today. They wanted to upload 10 - 20 MB movies as attachments to their Drupal blog posts. The standard limit set in Drupal is 2MB. I changed the setting to no avail. There was a note at the bottom stating that my PHP settings limited the upload to 4MB. So I did a search and come up with this post. So I changed my upload_max_filesize setting to “20M” this still did not work. The problem is that PHP also limits the post size and my default config limited post size to 8MB. So to increase the PHP upload limit one must check both the upload_max_filesize and the post_max_size settings are setup to allow the size of uploads they want to do.

So my new settings became:

  post_max_size = 20M

  ...

  upload_max_filesize = 20M

Resin and Session Clustering

danap@dhptech.com (Dana H. P'Simer) — Wed, 30 Apr 2008 00:00:00 +0000

In a world where AJAX is becoming the norm instead of the exception we need technology platforms that allow us to scale these applications. I have been working on an application for a major hotel chain that is used by their call center agents to book reservations at their hotels. The application uses AJAX techniques to run several queries simultaneously and presents the data in a very dynamic interface that closely resembles a traditional desktop application. There are multiple tabs in many areas of the application that load data in the background so that it is available when the user wants to see it.

The application is deployed on Resin Pro v3.1.2 and we are attempting to use Resin’s session clustering technology. It seems that our sessions are too large and that Resin’s session clustering does not take into account the possibility that two requests could be accessing and even modifying the session at the same time. However, this is the nature of AJAX applications.

So we are looking for solutions. The problem with highly concurrent systems that require replication of changing data is that the less granular the replication capabilities of a clustering technology the more chance you have for conflicts. Take, for example a problem from the 90’s of database replication. Some of the first replication technologies worked at the record level. Changes to a record were replicated with the entire record so when the replicated change arrived at its destination, the entire record was either applied or not depending on conflict resolution policies. In a system that I worked on, we chose to use field level replication. In doing so, we were able to avoid most conflicts.

What we need is a finely granulated replication technology that will only replicate the changes to the object graphs rooted at the session. Resin’s session clustering technology serializes the session and writes it to disk and sends it over the network to the backup server. Once the serialized session reaches it’s destination, it replaces the session that may already be there based on conflict resolution policies.

We could put in our own session replication mechanism that increases granularity by replicating at the attribute level. However, since some of our objects contain significant amounts of data this may not be granular enough.

Another option that we are exploring is Terracotta. This is very interesting technology. It instruments the byte code as it is loaded into the JVM altering the behavior of PUTFIELD and GETFIELD opcodes. The Terracotta system uses a back-end server to hold the distributed shared object (DSO) state. On PUTFIELD, changes are replicated back to the back-end server and on GETFIELD, the referenced object is “Faulted In” if it is not yet present in the current JVM.

There are a number of things that Terracotta has to do to get this working.

Each ClassLoader needs to have a unique and predictable name that will match the corresponding ClassLoader in all the nodes of the cluster.
There are certain classes that cannot be replciated, like any of the java.lang.ref Reference classes. There is a list on Terracotta’s website. Most of these are quite obvious, like Thread
For performance reason, we should not be instrumenting every class. Therefore Terracotta gives a way to include/exclude classes from instrumentation
For session clustering, a Servlet Filter (javax.servlet.Filter) must be injected into the beginning of the filter chain so that the session can be watched and new attributes can be added to the cluster and removed attributes can be removed from the cluster.

To accomplish these tasks, Terracotta uses Terracotta Integration Modules ( TIMs ). These are modules that are configured using a subset of the OSGi standard and what they do is implement ASM ClassAdapters that will instrument classes in the container to inject the ClassLoader naming logic and the Filter.

Currently there is no Resin integration module that is fully functional. There is a project on terracotta forge. It is somewhat incomplete since it does not name all the ClassLoaders that need names and it does not inject the session filter.

Since we have not decided to go ahead with Terracotta for our sessions, we have not continued to work on this. I did, however, get a rudimentary application working with Terracotta session clustering. I ran into issues, that I knew I would run into, when I attempted to call our in house SDK to retrieve Hotel information and put that in the session. No go, but I know why that is and it is the subject of another blog article.

iPhone SDK and OCUnit

danap@dhptech.com (Dana H. P'Simer) — Sun, 09 Mar 2008 00:00:00 +0000

I have started fooling around with the iPhone SDK. I am planning to release a product soon but the plans are quite preliminary so mums the word on exactly what is coming. However, I ran into a little problem right off the bat.

I am a Java Developer. I am trying to add iPhone/Mac OS X development to my skill set. But given my strong Java background I have an absolute commitment to unit testing. It is extremely important that you construct unit tests for your code. As such, I immediately went looking for tools to help me do just that.

It seems that the iPhone SDK projects are not setup to be compatible with OCUnit out of the box. In this, Test Driving Your Code with OCUnit, article at developer.apple.com you are told to simply:

create a new "Cocoa > Test Framework" target. Actually, under the newest XCode it is called "Cocoa > Unit Test Bundle"
Add the "SenTestingKit" Framework to that target. You will need to look for this in "/Developer/Library/Frameworks" (assuming you installed XCode into /Developer) instead of the default "/System/Library/Frameworks".
Create a group for test cases

I did these things and it still did not work. The first error I got was in regards to the “Cocoa.h” not compiling. This is because the target I created used the project’s “Base SDK” which is the “Device - Aspen 1.2” so I changed it to “Mac OS X 10.5”. As such, you cannot compile source that includes “UIKit.h” with this SDK. So, for now, I guess unit testing will have to be confined to classes that do not depend directly on UIKit.

The next error I got was because the default compiler dialect is set to C99, This should be changed to GNU99. I found this answer in this article: Stupid Issue with OCUnit.

Setting Environment Variables for Mac OS X Programs

danap@dhptech.com (Dana H. P'Simer) — Fri, 09 Feb 2007 00:00:00 +0000

For the most part, Mac OS X programs do not use environment variables or the PATH. They behave in a very different way from other Unix environments on this score. However, as Java developer I use several tools that require that other command line programs be available on the system PATH. In Windows and Unix there are well known places to put this kind of information but in Mac OS X the location for these changes is obscure.

Adding the variables to the /etc/profile, /etc/bashrc, ~/.profile, or ~/.bashrc files does not accomplish the task since these files are not used to setup the environment of the WindowServer process, the parent of all Mac OS X programs. I did, eventually, find some information on the subject.

There are these articles: Environment Variables, QA1255 and QA1068.

These articles were really hard for me to find, I think, because they were written mostly for folks wanting to port Unix applications to Mac OS X. In my case, I am attempting to use Java applications like Eclipse and Netbeans. Specifically, they needed the subversion commands on the path and they were installed into /usr/local/bin instead of /usr/bin. A good policy but not on the default PATH variable.

NOTE: I forgot to mention, you have to logout for these changes to have any effect.

Acegi Filter Does Not Work in WebSphere 6.1.0.3

danap@dhptech.com (Dana H. P'Simer) — Tue, 06 Feb 2007 00:00:00 +0000

It seems there is a bug in WAS that was introduced with 6.1.0.3. I found this forum post on the subject.

Apparently, WAS looks for a resource in the WAR that matches the URL before allowing the servlet filters a chance to process the URL. Despite the fact that the design of the Servlet Filter mechanism is to allow web applications more control over their URLs and how they are accessed.

This affects all servlet filters not just Acegi's. IBM has had similar issues in the past like this one and this one. You'd think they could get it right after a few tries.

Some of the wording in these bug reports and the reply from IBM posted on that Springframework thread appear to indicate that IBM sees nothing wrong with this behavior. I disagree. The servlet specification does not place any restrictions on how a Servlet filter can transform a request URL so it stands to reason that no check for the existence of the referenced resource should be performed until the filter are processed.

IE Rendering Problems Solved

danap@dhptech.com (Dana H. P'Simer) — Wed, 29 Nov 2006 00:00:00 +0000

Well I figured out what was causing my IE Rendering problems. I was using a "code" tag and that seemed to throw off the floating of the right hand navigation elements. Weird but it looked great in Firefox. This is not new but, damn I wish IE would just implement the standards. Perhaps a meta tag could be created that tells IE to use a standards compliant interpretation of CSS and HTML. That way, a standards compliant web site can just add a meta tag and IE will render it correctly without all the weirdnesses that are left in for "backwards compatibility".

For a great site on the power of CSS check out the CSS Zen Garden.