Fresh Notes

How those Spring @Enable* Annotations work

2012-08-28T08:47:00.000-04:00

Spring's Java Config is a great way to configure your application without writing a lot of configuration code. One reason is those awesome @Enable* annotations that let you magically set up things like Transactions (@EnableTransactionManagement), Spring MVC (@EnableWebMvc) or timed jobs (@EnableScheduling) with a simple class level annotation on your configuration class. These simple statements provide a lot of functionality but their machinations are fairly obscure. On the one hand, it's great to get so much functionality for so little work, but on the other hand, if you don't understand how something works it makes debugging and problem solving much harder. I couldn't find any posts or documents that covered how those annotations work so I figured I would write up one based on the research I did while debugging. I don't work for Spring and I didn't write any of this code so please post any corrections or improvements in the comments and I'll update the post.

Design Goals

From what I can tell, the design goal of those @Enable* annotations is to allow the user set up complex functionality with a minimal amount of code. In addition, it seems clear that users must be able to use either a simple default or be allowed to manually configure that code. Finally, the complexities of the code are intended to be hidden from the user. In short, let the user set up a lot of beans and optionally configure them without having to know the details of those beans (or really what's being set up). I think there are a lot of pros (and some cons) to this approach but I'll discuss that at the end.

Case #1: @EnableScheduling (importing an @Configuration class)

The first thing to note is that the @Enable* annotations are not magic. Nothing in the Bean Factory knows anything about them specifically and there are no dependencies in the Bean Factory classes between the core functionality and specific annotations (like @EnableWebMvc) or the jars they're stored in (like spring-web). Let's take a look at @EnableScheduling and see how it works. You might have a MainConfig class that looks like this:

@Configuration
@EnableScheduling
public class MainConfig {
// some beans go in here
}

There's nothing special in the above. Just a standard Java Config that's annotated with @EnableScheduling. @EnableScheduling lets you execute certain methods at a set frequency. For example, you can run BankService.sendMoneyToDoug() every 20 minutes. The @EnableScheduling annotation itself looks like this:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(SchedulingConfiguration.class)
@Documented
public @interface EnableScheduling {

}

If we look at the annotation above, we can see that it is just a standard Class level annotation (@Target/@Retention) that should be included in JavaDocs (@Documented), but it has one Spring-specific annotation: @Import. @Import is the key that ties everything together. In this case, since our MainConfig is annotated as @EnableScheduling, when the Bean Factory is parsing the file (technically the ConfigurationClassPostProcessor is parsing it) it will also find the @Import(SchedulingConfiguration.class) annotation and it will import the class defined in the value. In this case SchedulingConfiguration. What does it mean to import? Well, in this case it's just treated as another Spring bean. SchedulingConfiguration is actually annotated as @Configuration, so the Bean Factory will see it as another configuration class and all of the beans defined in that class will get pulled into your Application Context just as if you had defined another @Configuration class yourself. If we inspect SchedulingConfiguration we can see that it only defines one bean (a Post Processor) which does the scheduling we described above.

@Configuration
public class SchedulingConfiguration {

 @Bean(name=AnnotationConfigUtils.SCHEDULED_ANNOTATION_PROCESSOR_BEAN_NAME)
 @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
 public ScheduledAnnotationBeanPostProcessor scheduledAnnotationProcessor() {
  return new ScheduledAnnotationBeanPostProcessor();
 }

}

OK, but what if I want to configure the beans defined in SchedulingConfiguration? Well, at this point we're just dealing with regular beans. So the same mechanisms that you would use for any other beans apply here. In this case, the ScheduledAnnotationBeanPostProcessor uses a standard Spring Application Event to find out when the Application Context is refreshed. When this happens it checks to see if any beans implement SchedulingConfigurer and if so, uses those beans to configure itself. This is not at all intuitive (or easy to find with an IDE) but it is completely separated from the Bean Factory and is a fairly common pattern for a bean to be used to configure another bean. And now that we can connect all of the dots it is (somewhat) easy to find (or you could google the documentation or read the JavaDocs).

Case #2: @EnableTransactionManagement (importing an ImportSelector)

In the previous case we discussed how an annotation like @EnableScheduling can use @Import to pull in another @Configuration Class and make all of its beans available (and configurable) to your application. But what happens if you want to load a different set of beans based on some configuration? @EnableTransactionManaged is a good example of this. You might have a MainConfig class that looks like this:

@Configuration
@EnableTransactionManagement(mode=AdviceMode.ASPECTJ)
public class MainConfig {
// some beans
}

Once again, there's nothing special in the above. Just a standard Java Config that's annotated with @EnableTransactionManagement. The only thing that's a little different from the previous example is that the user specified a parameter to the annotation (mode=AdviceMode.ASPECTJ). The @EnableTransactionManagement annotation itself looks like this:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
 boolean proxyTargetClass() default false;
 AdviceMode mode() default AdviceMode.PROXY;
 int order() default Ordered.LOWEST_PRECEDENCE;
}

As before, a fairly standard annotation, although this time it has some parameters. However, I mentioned previously that the @Import annotation was the key that ties everything together and that is true once again. The distinction though, is that this time we are importing TransactionManagementConfigurationSelector.class which is not a class that is annotated with @Configuration. TransactionManagementConfigurationSelector is a class that implements ImportSelector. The purpose of ImportSelector is to allow your code to choose which configuration classes to load at runtime. It has one method that takes some metadata about an annotation and returns an array of class names. In this case, the TransactionManagementConfigurationSelector looks at the mode and returns some classes based on the mode:

 protected String[] selectImports(AdviceMode adviceMode) {
  switch (adviceMode) {
   case PROXY:
    return new String[] { AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName() };
   case ASPECTJ:
    return new String[] { TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME };
   default:
    return null;
  }
 }

Most of these classes are @Configuration classes (e.g. ProxyTransactionManagementConfiguration) so we know that they'll work like before, but some of them are not (let's ignore those for now). For the @Configuration classes they get loaded and configured in the exact same way that we previously saw. So in short, we can use @Import with an @Configuration class to load a standard set of beans or we can use @Import with an ImportSelector to load a set of beans that are decided at run time. Sweet! But what about those classes we ignored?

Case #3: @EnableAspectJAutoProxy (importing at the Bean Definition Level)

@Import supports one last case which is when you want to deal with a Bean Registry (Factory) directly. If you need to manipulate the Bean Factory or work with beans at the Bean Definition level then this case is for you and it's very similar to the ones above. Your MainConfig might look like:

@Configuration
@EnableAspectJAutoProxy 
public class MainConfig {
// some beans
}

Once again, there's nothing special in the above. Just a standard Java Config that's annotated with @EnableAspectJAutoProxy. Here's the source for @EnableAspectJAutoProxy:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
 boolean proxyTargetClass() default false;

}

As before, the @Import is the key, but this time it's pointing to AspectJAutoProxyRegistrar which is neither an @Configuration class nor implements ImportSelector. The trick this time is that it implements ImportBeanDefinitionRegistrar. This interface gives access to the Bean Registry and Annotation Metadata so that we can manipulate the registry at runtime based off of the parameters in the annotation. If you look at the previous case you can see that the classes we ignored were also ImportBeanDefinitionRegistrars. These classes directly manipulate the Bean Factory for those times when @Configuration classes aren't enough.

So now we've covered all of the different ways the @Enable* annotations use @Import to pull various beans into your Application Context. They either pull in a set of @Configuration classes directly and all of the beans from those classes get imported into your Application Context. Or they pull in an ImportSelector which chooses a set of @Configuration classes at runtime and imports those beans into your Application Context. Or finally, they pull in an ImportBeanDefinitionRegistrars which can directly work with the Bean Factory at the Bean Definition level.

Conclusion

In general I think this approach to importing beans into an Application Context is great because it makes set up very easy for the developer. Unfortunately it obscures how to find the available options and how to configure them. In addition, it doesn't directly take advantage of the IDE so it's hard to tell which beans are being created (and why). However, now that we know about the @Import annotation we can use our IDE to dig a little into each Annotation and its related configuration classes and understand which beans are being created, how they're being added to your Application Context and how to configure them. I hope this helps! Please leave comments to let me know what you think and what I've missed / messed up.

In Place Editor Custom Binding for Knockout.js

2012-05-23T09:30:00.000-04:00

I recently discovered knockout.js and was totally blown away. It does a great job of removing the need for (most) DOM manipulations which lets you focus on your data model and get complex UIs running with a minimal amount of code. That said, those complex UIs are by default made up of simple widgets (input boxes, buttons, etc) and if you want more complex widgets (date pickers, inline editors, etc) you need to either find them elsewhere or roll your own. Ryan Niemeyer gives a great explanation of how to create a date picker (or any custom binding) and I quickly incorporated it into my own site. Since I also needed an inline editor I figured I would post my results so others could reuse and improve upon them. The following code is very much based on the Custom Bindings article referenced above and the Jeditable inline editor.

The Goal:

The goal is to create something that looks like text but when you click it becomes editable. I also wanted when you click off or hit enter for the text to be saved to the model. Finally, I want hitting "Esc" to undo the latest change. Here is a live example you can play with:

Click this:
Current value:

The Prerequisites:

The following code is based on:

Knockout.js 2.1.0 (obviously)
JQuery 1.7.x (parent of Jeditable)
Jeditable (inline edit control that does most of the work)

The HTML:

The HTML is pretty simple:

Click this: <span data-bind="jeditable: name, jeditableOptions: {}"></span>
Current value: <span data-bind="text: name"></span>

If you're comfortable with Knockout.js this should look pretty familiar. The first line uses a custom binding called "jeditable" to tie a model property called "name" to a span tag. Knockout.js will be responsible for keeping the model and DOM in sync. As a developer I just tell it to use the "jeditable" binding for this element and the "name" property. There is also an optional "jeditableOptions" property which I can use to pass options to the jeditable binding.

The second line uses the standard text binding to display the current value of the "name" property in the span. Once again, as a developer, I don't have to think at all about what to update when the model changes. It all happens automatically.

The Model

The model can also be super simple:

     function myViewModel() {
      this.name = ko.observable("Innocent looking text");
     };
  
     ko.applyBindings(new myViewModel());

In this case I just need a single property called "name" that I default to "innocent looking text". I pass an instance of my model to Knockout as is the KO way and it handles all of the heavy lifting. All that leaves is...

The Custom Binding

The Custom Binding is the reusable code that knows how to update the DOM when the model changes and update the model when the DOM (or control) changes:

ko.bindingHandlers.jeditable = {
     init: function(element, valueAccessor, allBindingsAccessor) {
         // get the options that were passed in
         var options = allBindingsAccessor().jeditableOptions || {};
         
         // "submit" should be the default onblur action like regular ko controls
         if (!options.onblur) {
          options.onblur = 'submit';
         }
         
         // set the value on submit and pass the editable the options
         $(element).editable(function(value, params) {
          valueAccessor()(value);
          return value;
         }, options);

         //handle disposal (if KO removes by the template binding)
         ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
             $(element).editable("destroy");
         });

     },
     
     //update the control when the view model changes
     update: function(element, valueAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor());
         $(element).html(value);
     }
 };

This is a little more complicated and requires some explanation. The binding consists of two functions "init" and "update". "init" is called only once, when the binding is initially evaluated. Here we can create our control and pass it any options that the user specified. We also listen for any changes so we can notify the model. "update" is called every time the model changes and gives us a chance to alter the control to match the state of the model.

The work begins at line 4. Here we check to see if the user passed in any options. This gives the user the ability to customize the Jeditable control using any of the options allowed by the plugin. One option allowed is "onblur". This tells the control what to do when the user clicks outside of the control. By default Jeditable will cancel any edits onblur but since the default Knockout.js controls will save onblur we follow this convention and set the default onblur value to be "submit" (that is, save) on lines 7-9.

Lines 12-15 are where we create the control with the specified options and tie it to the appropriate DOM node. The function that we pass in is what gets called when the user saves a new value. In this function we simply update the model with the new value and return that value so that Jeditable thinks everything is ok.

Lines 18-20 are just housekeeping. That's where we clean up our control if Knockout.js tells us that the DOM node should be cleaned up.

Finally, it's time to update at lines 25-28. Here we simply get a reference to the new value in the model and update the Jeditable control to display that new value. And that's it! Now we have a custom binding that can be reused many times throughout the site.

The Conclusion

Knockout.js bindings may seem a little scary at first but they're not that complicated and can be very powerful. Even someone like me who is new to Knockout.js (and JQuery) can easily whip one up and reuse it throughout a site. My only wish is that it was easier to distribute custom bindings so that some nice libraries could be written and shared across the 'net. Please give me any feedback or improvements you have in the comments!

Euphemisms: When Good Words Go Bad

2012-05-15T10:53:00.000-04:00

A euphemism is a nice way of saying something not so nice. The problem with euphemisms is that the more successful they are, the more likely they are to take on the not so nice meaning of the thing they're trying to be nice about. Once this reversal happens, they transition from a euphemism to a synonym and a new euphemism must be created. It's an interesting quirk of language that a word or phrase can be intended to mean one thing and then become so popular that it comes to mean something entirely different.

One example is the phrase "making love". The original meaning of the phrase was exactly what it sounds like, creating love. In other words, flirting. If you were wooing someone you might send them love letters, make them fancy meals and generally put in lots of effort to create love. This is a beautiful and somewhat innocent idea. Which is exactly why it makes such a great euphemism. Back in olden tymes one could have said "Ebeneezer and I were 'making love'", implying that you were in the process of forming a relationship when really the only thing you were forming was the beast with two backs.

The problem with this euphemism is that it's too good. Everyone started using it and that was its downfall. By becoming so successful the phrase grew more popular and consequently more people started to catch on. It got to the point where today "making love" only means "having sex" and has completely lost its original meaning.

This isn't specific to this one phrase. Almost every successful euphemism faces this burden because by becoming successful it means that people use it and if people use it then they know what it means and consequently its meaning changes to what people are actually using it for (as opposed to its original meaning). There's even a a phrase to describe this phenomenon: The Euphemism Treadmill.

Another great example is the word "retarded". The verb retard means to make slow or to delay. It was, at one point, a gentle way of describing a mental deficiency. In fact it's very elegant. It didn't mean that a person was incapable of anything, merely that they could arrive at the same place as everyone else, it just took them a little longer because they were slowed. In essence, something was delaying their progress not impeding their completion. I think this is a lovely way of describing a phenomenon, but alas so did a lot of people. And once again, that was the problem. When everyone started to use "retarded" in this way it took on a negative connotation. As with other euphemisms, it's gotten to the point today where most people think of the insulting definition first and the slowed definition second (if at all).

I think there are a lot of people who see language as static; that a word means something which can never change; that there is a correct usage which cannot grow or evolve. Euphemisms are one example that clearly show how languages are affected by the way that they are used. I think it is this feature of language, that they alter and self-correct over time to better reflect the people that use them to communicate, that makes language and etymology so interesting.

Pagination with Spring MVC, Spring Data and Java Config

2012-05-08T10:16:00.000-04:00

Spring 3.1 has a lot of features for limiting the boiler-plate code you have to write for common functionality. One great example is pagination. Getting paged data from a database and presenting it to the user is one of those tasks that everyone seems to reinvent even though it's common functionality that is never specific to your business. Spring Data provides some facilities to add pagination to your application with a minimal amount of code. The documentation on this is pretty good and it includes some steps on how to set up both in the data tier and the web tier. Unfortunately, the documentation is unclear in a few places (see below) and doesn't explain at all how to use a Java Config. This post tries to fill those gaps.

Data Tier

The first thing we need is a data tier that can return paged data from a database. Spring Data provides a way to access the database without writing any code (almost). Instead of having to define and implement common CRUD methods you simply define an interface. You don't have to write the implementation because Spring will create a proxy that automagically fulfills your interface. You just wire the interface and Spring does the rest. I'm using JPA and here's a real example:

package com.fawnanddoug.gmailsyncer.repository;

import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;

import com.fawnanddoug.gmailsyncer.domain.SyncJobDetail;

public interface SyncJobDetailRepository extends JpaRepository<SyncJobDetail, Long> {
 
 public Page<SyncJobDetail> findBySyncJobIdOrderByLastUpdateDesc(long syncJobId, Pageable p);
  
}

Most of the work occurs on line 9 where I extend the JpaRepository interface. Simply by extending that interface I get common CRUD methods like save(), findAll(), delete(), etc. I also give my Entity Type (SyncJobDetail) and the key (Long) so that I get a strongly typed interface. Now I have a repository that can create and modify Objects in my domain and all I did was extend an Interface.

I get some additional help on line 11. There I define a method to grab the SyncJobDetails by their parent's Id and I sort them by the last updated time. Spring can automatically infer what the implementation should look like based on the method name (which is admittedly ugly) and once again I don't have to write any implementation. The first parameter will map to the SyncJobId in the query and the best part is it automatically adds support for Paging just by adding the Pageable parameter. Pageable has methods like "getPageNumber" and "getPageSize" so I can easily specify that I want pages with 20 items per page and give me page number 7. The only trick here is the configuration which I'll describe below.

Web Tier

Now that we can pull the data from the database we need some way to serve it over the web. This also requires a minimal amount of code. Here's an example:

@Controller
public class HomeController {

 private final SyncJobDetailRepository repo;

 @Inject
 public HomeController(SyncJobDetailRepository repo) {
  this.repo = repo;
 }

 @RequestMapping(value = "/history/detail/{id}", method = RequestMethod.GET)
 public String historyDetail(Model model, @PathVariable long id, Pageable p) {
  Page<SyncJobDetail> page = this.repo.findBySyncJobIdOrderByLastUpdateDesc(id, p);
  model.addAttribute("page", page);

  return "historyDetail";
 }

Injecting the repository (line 6) and using the request mapping (line 11) are pretty basic Spring MVC concepts. In short, if the user requests a page like /history/detail/123 then the historyDetail() method will get automatically invoked. The real magic is on line 12 where the Pageable parameter is automatically inferred from the parameters that are passed into the request. This also requires some configuration magic which is described below. Once we have the Pageable we can just pass it on to our repository to get the appropriate data. The returned Page is then exposed to the View so that it can be displayed to the user. The page has useful information like which page we're looking at, how many total items exist and which items were returned in this page. Once again we have barely any code written and we get Paging essentially for free.

The View

Now that the Page Object is exposed to the view we can use that Page to display useful information to the user. Here's an example JSP:

There's nothing particularly special here. I created a pagination util tag lib since I reuse pagination in a few places. It shows things like the total number of pages, the current page and how many elements are on the page. As you can see all of this information comes from the Page object on lines 1 and 2. The only other interesting item is that the content is exposed from the Page object at line 14. Pretty straight forward and I didn't have to manually calculate or even query any of this information.

The only thing left is to post back to the controller when we want a new page. In this case we just have to specify the right parameters for the page size and the requested page and we're done. Here's an example of how I generate the URL for my "Next" button:
In line 1 I use "" as the url value so that we post back to the same page. I then add the "page.page" parameter for the next page (current page plus one) and use the same size that we're currently using. Nothing particularly special here and all of the values come from the Page object that was returned from the data tier.

The Gotchas

The code, as you can see above, is pretty minimal and can apply generically to any domain. There are, however, a number of gotchas. Let's explore these gotchas by working backwards from the View to the Web Tier to the Data Tier.

View Gotchas

The first one is related to the documentation. In the above example I specify the next page parameter with the key "page.page". The gotcha is that the docs say the parameter name is just "page" so it took me a little while to catch. Technically you can specify any prefix you want (so it could be "foo.page"), but the important bit is that you must specify a prefix and then the parameter name. The prefix can be configured on the PageableArgumentResolver which is described below.

The next gotcha is that the Java Doc for PageRequest (the Pageable implementation) says that it is 0-based but the Java Doc for Page says that it is 1-based. In other words, when you request data the first page is 0 but when it returns data the first page is 1. This can be pretty confusing and may lead you to try to compensate in your code for potential one-off issues. In fact, I think it's intentional and the goal is that when you display data it uses numbers that a User wants to see (e.g. page 1 is "1") but still plays nice with databases that think of the first page as 0. The PageableArgumentResolver (described below) will automatically handle the conversion which means you won't need code to compensate for this, but it can still be confusing. In short, it does the right thing but may be hard to wrap your head around.

Web Tier Gotchas
I mentioned above that to get the Pageable parameter to work in your controller you need some configuration magic. In order for Spring to know how to convert the parameter to a Pageable object you need to configure a HandlerMethodArgumentResolver. Spring Data provides a PageableArgumentResolver but it uses the old ArgumentResolver interface instead of the new (Spring 3.1) HandlerMethodArgumentResolver interface. The XML config can handle this discrepancy for us, but since we're using Java Config we have to do it a little more manually. Luckily this can be easily resolved if you know the right magic incantation:

@Configuration
@EnableWebMvc
public class WebMvcConfig extends WebMvcConfigurerAdapter {
        
        @Override
        public void addArgumentResolvers(
                        List<HandlerMethodArgumentResolver> argumentResolvers) {
                
                PageableArgumentResolver resolver = new PageableArgumentResolver();
                resolver.setFallbackPagable(new PageRequest(1, 10));
                
                argumentResolvers.add(new ServletWebArgumentResolverAdapter(resolver));
        }

The above is a standard Spring MVC Java Config. It extends WebMvcConfigurerAdapter so that it can override some common methods and add functionality. In this case we are overriding addArgumentResolvers so that we can add our PageableArgumentResolver. The key here is that on line 12 we wrap the PageableArgumentResolver in a ServletWebArgumentResolverAdapater. This lets us reuse the PageableArgumentResolver and still wrap it in the new Interface. Now we get the Pageable object injected into our methods for free.

One other note is that I set the FallBackPageable to use Page 1 and a Page Size of 10. This means that if there is no Page parameters set it will use Page 1 and a Page Size of 10. However, if you were paying attention above you would note that Pageable is supposed to be 0-based. The magic here is that the PageableArgumentResolver tries to automatically compensate for 0-based and 1-based issues so it will treat both "0" and "1" as the first page. "2" is always the second page. This can be a little disconcerting at first, but as long as your view is passing in the values that the user wants (e.g. page "1" is "1") then you'll be fine.

Data Tier Gotchas
I said above that this was about using Java Config but the sad news is that you can't use the JPA Data Repository scanning without XML. A typical approach is to import the XML using something like this:

@Configuration
@ImportResource("classpath:com/fawnanddoug/gmailsyncer/config/jpa.xml")
public class MainConfig {

// beans go here

}

Then you can have a simple xml config that looks something like this:

In the above, line 11 searches the specified package to find our repository interfaces. It then generates the appropriate implementations. Now we can wire our repository into the Java Config and use the cool new features. In our case the SyncJobDetailRepository will get autowired into the HomeController so we don't have to add any additional configuration.

Conclusion

And that's it. With a minimal amount of code you can add paging to your application and still use strongly typed methods and services. Just make sure to configure the appropriate parts and look out for 0-based / 1-based issues.

I wrote A Facebook To GMail Syncing App

2012-05-01T09:30:00.000-04:00

I wrote an app that syncs your Facebook Friends and GMail Contacts! Actually, I rewrote an app that syncs your Facebook Friends and GMail Contacts. The first version had some flaws. But this version is new and improved. Let me count the ways:

Brand New User Interface:

I tried to redesign the UI with an eye towards a few things:

Clearly convey information with large text and bold icons
Feel consistent within Facebook's style while adding a touch of whimsy
Provide simple calls to action (errors are big and red with simple buttons that indicate the next step)
Limited options that respond immediately (e.g. you can change the Sync Frequency without reloading the page or clicking submit)

I'm really interested in your feedback! What do you think? Please post a comment!

World Wide Appeal:

I'm not sure how this is a new feature but the all new GMail Contact Syncer has been used in 47 countries in the first month. Above is a world map from Google Analytics (I'm big in India).

Cloud Based Development Platform

I moved the server out of my basement and now have a full data center with redundancy and and horizontal scaling. There's lots of other buzz words like "Platform as a Service", "Open Stack" and "Virtual Jabberwockies" (I made up some of those). Not that I really need it but it's cool (and free). Thanks CloudFoundry.com!

Completely Rewritten Syncing Infrastructure:

The original syncing infrastructure was written by hand. It put each Sync Job in a single transaction, was single threaded and periodically brought my Athlon 3200+ to its knees. The new infrastructure was rewritten using Spring Integration for Enterprise Integration and Spring Social for Social Networking Integration. It's fast enough that I actually had to artificially limit its speed so that Facebook would stop rejecting my requests for being too fast. Also it partitions each job into logical steps to make failover more convenient (e.g. when Facebook randomly fails requests).

Totally doesn't steal your passwords:

The original version of the GMail Syncer required you to enter your GMail password and it stored it in the database. This is a bad idea™. The new version never knows your passwords. Using a technology called OAuth your passwords stay with your services (Facebook & Google) and the GMail Syncer stays completely ignorant. You give access using the providers that you're comfortable with (Facebook & Google) and can revoke it at any time.

Set it and forget it:

As of May 1st, 2012 the GMail Syncer has processed over 1000 jobs, but you don't have to care. Just set it up once, pick your sync frequency and forget about it. It'll sync forever (or until you revoke access).

It's Free:

And it's free. I aught to figure out a way to monetize this bad boy, but I'm not sure how to do that yet. So take advantage of my bad business sense and get in while the getting's good.

Please give it a try and give me any feedback you have in the comments or at doug [at] fawn and doug [dot] com.

Thanks!

In which I accuse New Wave rockers "The Romantics" of defiling Rick James' Grave

2012-04-24T09:24:00.000-04:00

Update: The below is officially facts because it is cited in Wikipedia.

In the low stakes world of accusing 80s rock bands of ripping off Rick James, few have the gumption to publicly post their assertions on the Internet. What with the rabid fanaticism of "The Romantics" die-hards and the Internet's strict requirements for rock solid proof, no one is willing to touch this red hot topic with a serial mouse. But people of the Internet, live in fear no more - for I shall lead you out of the dark as I raise my keyboard and shout for all to hear that The Romantics totally ripped off "Super Freak" in their modest 1983 hit "Talking in your sleep".

"What?" you say in exasperated disbelief. "Why would a hard rocking New Wave band whose fourth album totally went to number 14, stoop so low as to jack Rick James, the paragon of demure sensibilities, the very image of 80s sobriety? Well, the dastardly "The Romantics" might as well have been twirling their riff-stealing mustaches while they tied genteel Rick to the train tracks of financial oblivion. And gentle reader I'm getting all up in there because they totes did. Poor damsel Rick could only wait for a super hero to appear out of nowhere and save the day. And that's what I've done. All Rick had to do was wait 21 years and then die and then wait 8 more years and here I am with my Jones-like ability to show up just in time and save the day.

The Facts:

Fact: "Super Freak" was released in 1981
Fact: "Talking in your sleep" was released in 1983
Fact: Wikipedia is indisputable

The Damning Evidence:
Everyone knows the famous "Super Freak" riff. Listen closely to seconds 2-6 or the whole thing because it repeats like a 1000 times. Now listen to the exact same thing as perpetrated by The Romantics. Bam! They don't call it "Gotcha Journalism" for nothing. Ok, no one would call this Journalism but still. Bam?

The Superfluous Conclusion:
There's not much more to say. The Romantics are evil thieves what profited from an innocent man's paean to his love of skanks. It's time we brought these heartless bastards down and finally give a little praise to a humble man who quietly lived the bard's life, writhing and suffering for his art.

p.s. If your spell checker doesn't recognize "skanks", don't try to check your spelling by Googling it. The results are disgusting.

I find interesting things interesting

2012-04-18T12:36:00.000-04:00

I'm fascinated by design in general and web design in particular. The domain of Design always seemed complex and inaccessible to me even though as a professional programmer I do a particular kind of design on a regular basis. Capital "D" Design has seemed to me like a far away land with it's own language, culture and secret societies that were all unapproachable to the lay person. However, as I started to read and learn more about the process of Design it seems in many ways to be just like programming (a wild land I am nevertheless at home in).

In programming we often talk about "elegant design" meaning a simple solution to a complex problem. "Elegant Design" is a lofty goal that is often difficult to achieve. Programmers try to increase our odds of success by carefully limiting the scope of the issue we're trying to solve and then focusing on a smaller and thus more manageable problem.

As one might expect, this is a guiding principal in creative pursuits of all kinds, from Writing to General Relativity to Axle Differential. Thus, the overwhelming topic of Design started to become approachable to me when I realized that I didn't need to understand everything at once and could just focus on the particular bite size portion I wanted to address that day like intro to Typography or beginning Color. As I expand my vocabulary and get introduced to the world of Design, I hope to further my education by posting about the various items that I learn about. Thus reinforcing my new knowledge and hopefully sharing it as well.

Killing a Joke: Cannibal Joe's

2012-04-10T21:51:00.001-04:00

I have no idea how professional comedy writers work, but for some reason I'm convinced that one of their favorite things to do is come up with a simple set up and then write 200 punchlines for it. This isn't based on any facts or empirical research, other than sometimes in sitcoms you'll see a set up that every character in the room gets to riff on. Also, it's something I like to do. I think it's a fun mind exercise to see how many punchlines I can come up, especially when I'm bored. Here's an example from a recent Facebook post that none of my friends seemed to care about. I like the last one the best. Post your own slogans below!

I convinced 100s of people to give me their GMail passwords

2012-04-03T09:11:00.000-04:00

Honestly, it wasn't intentional. My goal was just to sync my Facebook Friends with my GMail Contacts. I tried searching for an app that could do it, but I couldn't find one and so I figured this might be a good opportunity to learn a little about developing with Facebook & Google. My only intention was to scratch an itch that had been bothering me for a little while, but then it got popular.

My first pass at the app was just for myself so I hard coded my Facebook username & password and my Google username & password. I figured it would just be for me and running on my machine at home so why bothering making it generic. Really I just wanted to play with the APIs and get something that worked. But then the Missus saw it, thought it was cool and asked if I could hook her up too. I could have continued with the hard coded approach, but now that I had multiple users, it seemed like a good excuse to make it a full fledged Facebook app.

Rather than just have it run on my server at home I could make it an official apps.facebook.com app with a User Interface and everything. I could use the Facebook login mechanism so I didn't have to hard code my username & password and I could play with all of the cool Facebook APIs. I was particularly excited about posting a message to my wall every time it synced. Wouldn't everyone want to see how cool my app was? Every day? Surely they would.

So I whipped it all up. Whipped is maybe overstating it. I had a young son and another on the way and a full time job. I worked on it when I could. Eventually, though, it was working. Anyone could sign up as long as they had a Facebook account. I didn't need to know your Facebook username & password , but the catch was that I did need your GMail username & password. The site had a nice clean interface (if I say so myself) with the slightest touch of whimsy and a great big text box for your GMail username & password.

I filled it out. My wife filled it out. And I thought that would be the end of it. But a weird thing happened. Every day the app posted a message to my wall that said that I had just synced my Facebook & GMail contacts with a link to the app. That's when the questions started. My friends started asking me: "What is this thing?" "Does it really work?" "Can I try it?" Pretty soon a bunch of my friends had signed. up. People who never in a million years would have given me their GMail password if I had asked, were all too happy to type it into a website. Even though it was a website they knew I made. Then it got even weirder.

I rarely ever checked the logs on my app. It was working fine for me so I didn't have much reason to care. Nevertheless, out of curiosity one day I checked the logs and noticed that I had over twenty users. Wow! Twenty of my friends checked this thing out? Wow, that's pretty cool. Then I noticed one of the users was someone I had never met. Apparently some friend of a friend had seen the app and signed up. That's pretty cool I thought.

A few weeks later I checked again and this time I had over 100 users.80% of which I didn't know and all of which had given me their GMail username & password. "This is getting out of hand" I would have thought if I had time to think but my kids were yelling and the bills needed to get paid.

By November of 2011 I had over 500 users all of whom gave me their GMail username & password, the vast majority of whom had absolutely no reason to trust me. It turns out that I'm not interested in exploiting these fine people but they didn't know that. They blindly entered their GMail username & password into a website and just like that could have given up tons of personal information and potentially financial information too.

In November 2011, Facebook instituted a new security requirement that all Facebook apps support HTTPS. This does add some amount of security to your transactions but doesn't really help when you're giving a website your GMail password. Anyway, I was doing this as a hobby and wasn't really paying attention to new Facebook requirements. And even if I was, I wasn't about to shell out $100+ for an SSL certificate so that I could be HTTPS compliant. Especially for a service that I wasn't making money on. In fact, you could argue that I was losing money on it if you count the time/effort I put into it plus the cost of running my server. In fact, I wouldn't have even noticed that Facebook had stopped access to the service if people hadn't started complaining to me that the Syncer wasn't working any more. These were people I never met. People who had started relying on this service. It was crazy!

I didn't have time to fix the service so I just let it languish. I started getting angry service complaints from people who wanted their Syncer but I didn't have the free time to figure out any solutions. I figured I would let it run so that people who already signed up could continue to sync and not get pissed off at me.

Finally in March 2012 I decided to rewrite the application. This time my first priority was to avoid having anyone's username or password. There are actually standards for this and it wasn't terribly difficult to implement but I never thought the app would reach the kind of audience it did. And that was with all of the odds against it. The new version of the app doesn't require any usernames or passwords. It uses the Facebook / Google APIs to let you authenticate with those services directly and my app never sees your personal information. I also signed up with a service to provide HTTPS so that Facebook will play nice as well. You can find the new app at https://apps.facebook.com/gmailsyncer. However, the moral of this story is NEVER GIVE YOUR GMAIL PASSWORD TO ANYONE OTHER THAN GMAIL!

A Letter to Ari's kids about Ametropes

2012-02-24T21:08:00.002-05:00

This letter was requested by my friend Ari in response to my previous letter.

Dear Jacob & Abby,

There are some things in this world that can be seen. There are also some things that cannot be seen. Unfortuntately for you, your parents' compromised gene pools have likely condemned you to a life of stumbling around grasping for the later. But despair not! There is a solution. In 1784 God bestowed upon Man the means with which to focus the unseen and render it knowable. He called them Glasses and were it not for them you may never have been born in the first place. Glasses will undoubtedly become a fixture in your life just as they were the fixture that made your life. You need to know and love glasses. Fear and respect glasses. Or at a bare minimum, don't pull them off your father's God damn face. The man needs to see and you need to live. You can accomplish those two goals by the simple act of not impairing your father's sight. Also, don't stab him with them once you've got them. That's just cruel. Plus he can't find you to stop you so he's got to yell until Mommy comes. And she's got better things to do than defend her husband from a toddler. So be a sport and leave the damn glasses alone.

Love,
Uncle Doug

A letter to my toddlers about women

2012-02-23T20:34:00.002-05:00

Dear Tyler & Aidan,

There are some things in this world that can be known. There are also some things that are unknowable. Part of life is learning to accept that some things cannot be known. You will find and rebel and eventually accept that much about women is simply unknowable. It is frustrating and difficult and ultimately insurmountable. Accepting it will be one of the great triumphs in your life. But there is at least one thing about women that is knowable. And that, is that you do not fuck with their hair. If there is a woman that you like/respect/would enjoy ever seeing again, you are to compliment them on their hair and then shut the fuck up. It is simple, but it is critical to your future happiness. Women are not impenetrable magical sphinxes with mysterious vails and complex machinations. They are human, with everything that entails. So do yourself a favor, respect all women and show them that by at a bare minimum praising their hair and being quiet. It is hard fought wisdom that is as true today as it will be when you care to remember it. But for now, please stop pulling your mother's hair every time she gives you a hug. I'm sick of hearing her complain about it. Just give her a kiss and go away.

Love,
Dad

I hate Children's Music, but are my kids ready for Hip Hop?

2012-01-18T09:30:00.000-05:00

A little while ago my friends at Urban Rhetoric, progenitors of all things cool, asked me to write a piece on being a parent and a fan of Hip Hop. Below is a reprint of the original article.

Children's music is universally atrocious. It is trite and tedious. An endless sea of monotony that crushes ones humanity with unrelenting waves of banal tedium. At first it laps gently at the shores of your sanity. A barely felt current, swathing your new baby in passivity and lulling him to sleep. Slowly it seeps into diaper changes and car rides, please touch museums and toy stores. It's suddenly everywhere and you are caught in the swell of its undertow. You gasp for Nas, Mos Def, Kanye, but it's too late, your lungs are already saturated with Three Blind Mice, Itsy Bitsy Spider and something called "Raffi". Children's music is devious. It's born of platitudes and gentle hell fire. It's boring and insidious. It is the incarnate soul of the devil.

Perhaps I've tipped my toe into hyperbole but while some hazards of parenthood are often discussed: the lack of sleep, the constant worrying, the lack of free time - no one ever talks about the terrible and omnipresent music. Car rides, play time, diaper changes, bath time, museums, stores - all come with the regular and insistent jack hammering of fairy tales and nursery rhymes and dead eyed automatons and all manner of sonic daemons numbing your humanity and sapping your will to fight back. But not entirely.

Any music lover thusly assaulted, will, after some time, come to rebel against this aural malaise and ultimately arrive at the same cure: Either find children's music by artists you can tolerate (in my case nearly impossible) or introduce your children to the music you love. I wanted my kids to know Hip Hop (and all the music I love) but, for me, there were two key drivers. On the one hand, Hip Hop is such a looming and significant part of my life that it is important to me to introduce my kids to the culture and the music that I immerse myself in daily (or at least I used to). On the other hand, I can't listen to "Wheels on the bus" another damn time. So I made up my mind, but that's where the trouble started.

My first thought was: "Just turn on the radio, dummy! The radio has good music and it's censored. It's a win-win". Actually, it's a lose-lose as I was wrong on both accounts. Here are the top five most played songs on Hot 97 (the local Hip-Hop & R&B station) for the week of December 27th 2011:

Dance (Ass) - Big Sean featuring Nicki Minaj

This track must have the record for the most times "Ass" is said in a single song.

Ni**as in Paris - Jay-Z & Kanye West

This song is awesome but it seems like they're actively trying to do the worst censoring job they can.

She Will - Lil Wayne featuring Drake

There is nothing redeeming about this song.

Work Out - J. Cole

Same old "shake that ass girl" garbage that reminded me why I don't listen to the radio any more.

Make me proud - Drake featuring Nicki Minaj

This passes for positive. *sigh*

One good song in the top 5? And none I want my kids to hear? Radio is not the move. For the record, the Pop and Rock stations are just as unacceptable. That said, I don't want to begrudge any adult from listening to whatever they want. Even on the radio. I don't even care if they play uncensored screaming on the radio. Just have a way to warn me and let me shield my kids from it. And you can make judgments about what's appropriate for your kids. That said, I still want to listen to *my* songs and while I want to expose my kids to the music that I love, I'm wary of them getting over-exposed. So it occurred to me that maybe I should think through exactly what my criteria are for songs I want my kids to hear. I came up with what I thought were two reasonable rules:

No words I didn't want to hear repeated at Grandma's house
No phrases or concepts I didn't want to explain

At first blush these seem reasonable and should leave me with a huge selection. I think of myself as a *real* Hip Hop fan. I love the golden age, backpack, underground, modern classics etc. I hate "Bitches & Bling", "Da Club" and all the crap that goes with that (with some exceptions). Surely it should be easy to find some tracks that meet my criteria. In truth, it's possible but it requires some serious leg work. Here are some classics I thought would obviously work until I re-listened to them with an ear to the above rules. Note that my kids are 2.5 and 6 months so my criteria might ease up in a few years:

Don't Curse - Various Artists

How could this possibly offend? Kool G Rap: "Even made a record on how I'm doing on my B-I-T-C-H-es"

I can - Nas

Great message but lots of drug and other references

Definition - Black Star

"Mos Def & Kweli just, make a pussy freeze up, thinking of it, ease up"

They Reminisce Over You - Pete Rock & C.L. Smooth

"We laughed all night about the hookers at the party"

Me, Myself & I - De La Soul

Cool message until problems are resolved with violence: "I'll calmly punch them in the 4th day of July"

Jesus Walks - Kanye West

Hell no

My Philosophy - Boogie Down Productions

Great until: "How many MCs must get dissed, before somebody says 'Don't fuck with Kris'"

Woo-Ha!! I got you all in check - Busta Rhymes

The chorus is: "I got that head nod shit to make you break your neck"

Cha Cha Cha - MC Lyte

"Well Well Well, I'll be damned"

It Takes Two - Rob Base & DJ Easy Rock

"I like the whopper, fuck the big mac"

Public Enemy #1 - Public Enemy

"I'll show you my gun; my Uzi weighs a ton"

Case of the P.T.A. - Leaders of the New School

"What the Hell's going on"

Even a song called "Don't Curse" fails the criteria? Wow. In all honesty though, some of these are not really that bad. The censoring in "It Takes Two" is pretty blatant but I don't think that's really a deal breaker and "Case of the P.T.A." and "Cha Cha Cha" are really kind of a stretch. That kind of stuff I think I can probably let slide. What hurts more is songs like "I can" which I think have a good message but too much other content that I'm not ready for my kids to start grappling with.

I think what it comes down to is that I was hoping for an easy solution. Unfortunately, like everything else with kids, I needed to step up and be a parent first. It's not easy to vet a ton of songs from my library but if I want to listen to them with my kids then it's something I've got to do. Of course, once I put in that initial work it's not so bad. I ended up making a playlist of songs that I thought were appropriate. It started out small (mostly instrumentals) and when I found time I added a song here and a song there. At this point its well over 2000 songs of both children's music and songs I like. It fits on my phone, so I can bring the list on car rides or play it during dinner time and I don't have to worry about what might come up next or hearing the same awful tune over and over. Much like the children it's intended for, the process was a huge pain in the ass but ultimately I think it's worth it.

Simple Photoshop Star Burst Effect

2012-01-11T11:00:00.000-05:00

One effect that I really like, especially for a splashy or retro type feel, is the star burst effect. I think the spinning color adds a lot of energy and can be a fun way to add a little pep. There are many tutorials on the web but they seem to either be complicated or time consuming. That said, the two linked above do provide additional flexibility. The only advantage to this technique is that it is simple and fast. So let’s start:

1. Create a new file
Here’s an example:

2. Fill the background layer with a color

I chose this color:

3. Get our magic shape

3a. Create a new layer
3b. Set the foreground color to White
3c. Select the custom shape tool

3d. Select these options:

The key option is the shape. You want the “Symbols” shape list and the “Registration Target 2” shape.

4. Drag the shape over the layer so the Star Burst covers the whole image
I hold “Shift” so it’s an evenly distributed burst.

5. Set the layer Blending Mode to “Overlay” and the Opacity to taste
I like ~75% Opacity in this case

6. Slap an image over the center
Like this one:

And you’re done!

Greatest Game Ever Still Pretty Great

2011-12-28T10:54:00.000-05:00

There are a number of criteria that reviewers use to mistakenly calculate the greatness of a game. By "game", of course, I mean Video Game since I am writing this after 1982. Some of these mistaken criteria are "Graphics Quality", "Story", or "Fun". All of these are crocker. There is only one criterion by which you can judge any game's true Greatness: hours played.

At first blush, "Hours played" seems awful as it doesn't take into account for the factors that reviewers routinely write about like "Maximum Resolution" and "Frames Per Second" and other similarly quantifiable values. And to make it even worse Reviewers always gussy up the statistics with wobbly gushy feelings like "playability" and "character exposition". But all of these are bunk because they muddle up the only thing that truly identifies greatness. How long are you willing to put up with it? You might have had a hot girlfriend or a sweet girlfriend but the one you're willing to spend your life with is by your own actions the one you think is greatest. Even if her graphics appeal and audio fidelity average lower than girl A or girl B, the one that's actually great is the one that you want to spend your time with, not the one with the cool effects that gets boring after a while.

This is why the greatest game ever is Team Fortress 2. I've logged over 500 hours in this bad boy and it's still bringing me joy. Valve has made a huge effort to continually add additional content (for free) and this has gone a long way toward keeping the community attuned and vibrant. They've even recently started adding content from the community into the game and this has reinvigorated the cycle with more to do and more people involved who make more to do and so on and so forth.

One of my favorite annual updates is Scream Fortress, which is a limited time Halloween themed update with events and achievements intended to embrace the holiday. It's silly and gratuitous but every time I think I'm out, they give me a new reason to stick around and try out the new stuff and revisit my old TF2 friends. Congratulations Team Fortress you're still the Greatest Game Ever.

Resurfacing: It's not just for parking lots and Joan Rivers' face

2011-12-21T11:00:00.000-05:00

Many years ago in a land far away I had a super long commute and a pressing need for the constant adulation that can only be provided by strangers commenting on my thoughts. So, I started a blog. As it turns out, the pressing need persisted but the strangers' comments did not. Actually, the strangers' comments never materialized (unless you count comment spam) and as you might expect the flow of unread posts dried up while the ads for fake Canadian Cialis kept popping up.

Nevertheless, a pressing need will need pressing and so I'm back again to blog at the internetz until you respond in the way that sates my hunger for attention. This time however, I'm armed with a better spam filter and some significantly more modest goals. Specifically, I want to try out different writing styles like those in the blogs I read and more importantly I'm not going to commit to posting a lot (and thus fail and stop posting at all). The blog is resurfacing, let's see how it goes. And by "let's" I probably mean "I'll". And by "see how it goes" I mean "delete a bunch of spam and then give up".

For posterity's sake, here's the original post from the original blog:

Hey all! Well, I got a Treo from the 'rents for my bday - and what with its keyboard and my two hour daily commute it seems inevitable that fawnAndDoug.com will soon be overrun with trite (and yet verbose) missives on my various musings, opinions and incindiary votives. So let's begin. For starters the keyboard on this badboy is kinda tight so my usual explitive laced comments may be slightly censored since my thumbs aren't nearly as quick with the curses as my ten fingered assault. Damn! I dont really have much else to say today - so I'll just suggest you check out sahara hotnights (specifically a jam called kicks) and I'm out! Wow - we're already at my stop - I guess i'll continue offending you tomorrow .