.. thoughts ..

organization

2011-12-05T12:59:00.001-08:00

Many believe that the organization of your house reflects the level turmoil of your being. I believe this to be very true which is why tonight I clean. Along side this I also believe the same for thought. The more methodical a person is in forming opinion/strategy, the more defined the outcome and probable of being successful.

In the software arena it is ever important to anticipate your next step as it is in every aspect of our lives has human beings. If we can't / won't anticipate where we will be standing next then how can we intend to get there - even if where we anticipate to be standing is not exactly correct ... it's the journey not the destination I suppose. Like all things in life people have the tendency to remember the last bad thing that you did versus, the more optimistic, last good thing you did .. and hopefully it was more recent.

freemarker

2011-05-19T20:14:00.000-07:00

Two things.

1) Find a concern across many problems that you can standardize with sufficient metadata to drive an algorithm.
2) Use freemarker to standardize the code generation and save yourself a lot of time.

I recently did this by extending the hibernate-tools suite and the hibernate3-maven-plugin to give my organization what it needs -- well, part of what it needs -- a data access layer code generator that takes it to the next level. Generics, AOP and pseudo-partial classes. This solidifies the pattern and practice and is extremely extensible not to mention it slims down the application code drastically and development timelines.

There are a ton of code generation strategies but I'm a firm believe in the power of decoupling at the interface and not binding yourself to an implementation. With that said this generation code generates an injectable/autowireable manager, dao interfaces that extend a generic definition, genericized jpa implementations that extend an implementation specific generic dao (that happens to implement the same aforementioned dao interface as well).

If you have questions or need help with such things drop me a line. I'm more than willing to help especially considering the hibernate-tools code is not well documented nor is the context information passed into freemarker.

Loathe, Like, Love.: Loathe of the day...Ai WeiWei's Latest Predicament...

2011-04-21T08:31:00.000-07:00

Loathe, Like, Love.: Loathe of the day...Ai WeiWei's Latest Predicament...: "Ai WeiWei's Template Grapes Chandelier, 2002 Cube Light Forever Bicycles The artist/activist. I hate to get political w..."

android and aspect oriented programming (aop)

2011-04-19T21:57:00.000-07:00

When OOP appeared in the software world it was pioneering. Encapsulation! Abstraction! OOP became the next big thing and it's still huge. OOP is great; you can define an ontology and build out what the grammar of whatever your layer/application is. It's fantastic. But there are simply some things that don't really belong to an object. We'll call these cross-cutting concerns. These concerns are pervasive throughout an application (i.e. transaction registration, CRM auditing) and typically functional. Enter AOP (aspect oriented programming) brought to us some years ago by the guys at Xerox PARC. Some will say it's made things a lot easier, some would say I have no clue what is going on. AOP compliments OOP very well. Some will say that you can do the same with well defined interfaces or abstracts BUT that truly does require dead accuracy basically the first time, can cause drastic issues if refactoring is needed and simply can clutter your code. AOP is a new(er) strategy for modularization. Note: another good one is the decorator pattern.

Getting back to it. I've used many AOP technologies and am currently using AspectJ rather frequently in lower level framework development. Making some concerns declarative via an annotation, or simply flat out applied to all methods (i.e. tracing, execution auditing), for some reason makes it a lot easier to understand. Hide the magic.

Recently I've begun doing a significant amount of Android development across many products and have thought to myself Can I get AOP to work on the Dalvik VM?. Well, the answer is yes. Largely I've had a desire to do this b/c I lead a group of developers and unifying a development process always comes from the bottom up. This guarantees adherence to pattern and convention above and beyond coding standards and promotes a massive amount of re-use. This very important for making sure certain concerns are addressed in the same fashion (i.e. exception handling).

Granted AOP has taken off in certain areas and has not in others the challenge of introducing advice into Android code was a challenging one up front but not insurmountable. The reason being for this is that the first building block of Android is a Java development environment and the Java class byte code format. The next stage, after development, is the packaging of these java class files into the Dalvik Executable format (DEX). Unfortunately advice cannot be applied directly to DEX files b/c currently the Android runtime lacks a byte code generation scheme where Java supports several forms of advice introduction:

compile time -- byte code manipulation.
load time -- byte code manipulation. Has a slower startup time.
run time -- auto-proxies of various forms (an is-a relationship) or jdk interceptors (Spring for example can work in both of these paradigms but it is fundamentally the slowest).

With that said applying advice to an Android app, due to the lack byte code generation schemes, is option 1. With this we can write java code and compile aspects directly into it and finally convert it to the DEX format to run on android devices.

One thing to note about DEX is that it unpacks all jar files and packages all dependent classes into a single zip archive, classes.dex. This could be because of several historical reasons:

J2ME has proven to have issues in the past with class loaders and and a large number of classes.
not having the byte code in the java format mitigates the need for the OEM to have to pay Sun / J2ME licensing fees.

A bit of history....

Let's get back to it.

I'm a firm believer in logical architecture where your libraries represent modularized concerns. With that said I also like to create aspects that sit at a lower level or at that of an API. This can be done generally via abstract pointcut definitions to allow the application to define the fully qualified pointcut definition but the same advice is applied; or, by proceeding in a declarative fashion. This is great b/c it engages the developer and removes the need for them to understand pointcut definitions.

So, considering this, let's create a Java project in maven with an aspect to be applied to another module. We'll call it android.aop. The following is a boiled down maven build script for the android.aop project:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>some.group</groupId>
 <artifactId>android.aop</artifactId>
 <version>1.0.0</version>
 <packaging>jar</packaging>

 <dependencies>
  <dependency>
   <groupId>com.google.android</groupId>
   <artifactId>android</artifactId>
   <version>2.2.1</version>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.6.10</version>
   <scope>provided</scope>
   <optional>false</optional>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.6.10</version>
   <scope>provided</scope>
   <optional>false</optional>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjtools</artifactId>
   <version>1.6.10</version>
   <scope>provided</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.3.1</version>
    <configuration>
     <source>1.5</source>
     <complianceLevel>1.5</complianceLevel>
     <showWeaveInfo>true</showWeaveInfo>
     <verbose>true</verbose>
    </configuration>
    <executions>
     <execution>
      <goals>
       <goal>compile</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
   <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
     <source>1.5</source>
     <target>1.5</target>
    </configuration>
   </plugin>
  </plugins>
 </build>
</project>

The maven-aspectj-plugin will look for aspects beneath src/main/aspect.

An android apk maven build script (boiled down of course):

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>some.other.group</groupId>
 <artifactId>android.apk</artifactId>
 <version>1.0.0</version>
 <packaging>apk</packaging> 

 <dependencies>
  <dependency>
   <groupId>com.google.android</groupId>
   <artifactId>android</artifactId>
   <version>2.2.1</version>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>some.group</groupId>
   <artifactId>android.aop</artifactId>
   <version>1.0.0</version>
   <type>jar</type>
   <scope>compile</scope>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjrt</artifactId>
   <version>1.6.9</version>
  </dependency>
  <dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjtools</artifactId>
   <version>1.6.10</version>
   <scope>provided</scope>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>com.jayway.maven.plugins.android.generation2</groupId>
    <artifactId>maven-android-plugin</artifactId>
    <version>2.8.4</version>
    <configuration>
     <sdk>
      <platform>2.1</platform>
     </sdk>
     <extractDuplicates>true</extractDuplicates>
     <undeployBeforeDeploy>true</undeployBeforeDeploy>
    </configuration>
    <extensions>true</extensions>
   </plugin>
   <plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.3.1</version>
    <configuration>
     <argumentFileName>trace.lst</argumentFileName>
     <aspectLibraries>
      <aspectLibrary>
       <groupId>some.group</groupId>
       <artifactId>android.aop</artifactId>
      </aspectLibrary>
     </aspectLibraries>
     <source>1.5</source>
     <complianceLevel>1.5</complianceLevel>
     <showWeaveInfo>true</showWeaveInfo>
     <verbose>true</verbose>
    </configuration>
    <executions>
     <execution>
      <goals>
       <goal>compile</goal>
      </goals>
     </execution>
    </executions>
   </plugin>
   <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
     <source>1.5</source>
     <target>1.5</target>
    </configuration>
   </plugin>
  </plugins>
 </build>
</project>

Now that the build rigmarole is out of the way you can focus on aspect development. For instance, a declarative approach to audit use case execution perhaps.

/**
 * An annotation to be applied to methods of which we would like to track their execution
 * (i.e) createAccount
 */
public @interface Tracked {

 // add in whatever you need to track 

}

The example skeleton aspect that handles the hitting of the method:

@Aspect
public class TrackingAspect {

 @AfterReturning(value = "execution(* *(..)) && @annotation(tracked)", argNames = "joinPoint, tracked")
 public void track(JoinPoint joinPoint, Tracked tracked) {
  // whatever your tracking logic may be. 
  // The JoinPoint injection is only added with an execution pointcut is defined.
  // the tracked is passed in as an arg on the join point
 }
}

These two classes would end up in your android.aop jar and would allow for some bit of functionality to occur within your application whenever a method decorated with the @Tracked annotation appears. These annotations don't necessarily need to have a Runtime retention policy b/c we are actually applying the advice at compile time. If the Dalvik VM supported load time weaving (had a byte code generation scheme) you could leverage a Runtime retention policy.

Another that I've found useful with various declarative advice applications is leveraging JEXL (Java expression language) to pass runtime metadata to the interwoven advice via the call stack ... but we'll leave that for another post.

At any rate, that's the high and low of it. Much thanks to Nikhil Walvekar ( published an example of aspectj method tracing in Android ) for his assistance with helping me figure out a modular build in maven.

If you have questions don't hesitate to email me.

dan

Android and a GenericizedRequest structure

2011-04-14T06:37:00.000-07:00

One thing that I've noticed as of late as that there Android does have a great capacity for asynchronous processing via adapters to java.lang.Thread. However, I've found that when developing domain libraries it's best to hide as much of the synchronicity from the consuming developer to
a) standardized
b) simply

By providing a synchronous and asynchronous call you provide flexibility in how the API is consumed. AND you can guarantee to lighten the load of development by the integration developer. I'll create a standardized API that exposes to execute methods that derived off of a generic class which encapsulates the AsyncTask structure for say http calls if that is what you're wanting to hide. By doing this the API becomes very light, consistent and reusable across applications.

Callback is the key for onPost AsyncTask functionality. Will allow the dev to encapsulate as a reusable anonymous inner class.

public abstract class Callback {
 
 Object caller;
 
 Context context;
 
 public Callback(Object sender, Context context) {
  this.caller = sender;
  this.context = context;
 }
 
 public Object getSender() {
  return caller;
 }
 
 public final void handle(T response, Object... params) {
  doCallback(this.caller, response, params);
 }

 /**
  * The callback template
  * 
  * @param sender
  *            the activity that sent the request
  * @param response
  *            the response of T
  * @param params
  *            the input stack
  */
 protected abstract void doCallback(Object sender, T response, Object... params);
}

GenericRequest:


public abstract class GenericRequest {

 private static final String TAG = "GenericRequest";

 protected HttpRequest requestor;

 protected String url;

 public GenericRequest() {

 }

 public GenericRequest(HttpRequest requestor, String url) {
  this.requestor = requestor;
  this.url = url;
 }

 /**
  * Will make the request in a synchronous fashion
  * 
  * @return
  * @throws Exception
  */
 public T execute() throws Exception {
  assert url != null;
  assert requestor != null;
  requestor.makeRequest(url);
  String offTheWire = requestor.getStringResponse();
  return parseResponse(offTheWire);
 }

 /**
  * Will invoke an request as an AsyncTask on a thread and the
  * {@link Callback} will be invoked at the end of the execution cycle
  * 
  * @param callback
  *            the callback functionality to be made
  * @throws Exception
  *             any exception
  */
 public void execute(Callback callback) throws Exception {
  Log.d(TAG, "executing(..)");
  if (callback != null) {
   CallingAsyncTask caller = new CallingAsyncTask(callback);

   caller.execute(url);
  }
 }

 protected abstract T parseResponse(String httpResponse);

 /**
  * An inner class to handle AsyncTasks for {@link HttpRequest} if a
  * {@link Callback} method is passed to an
  * {@link GenericRequest#execute(Callback)}
  * 
  * @author Daniel Williams
  * 
  */
 class CallingAsyncTask extends AsyncTask {

  static final String TAG = "CallingAsyncTask";

  Callback callback;

  String url;

  public CallingAsyncTask(Callback callback) {
   this.callback = callback;
  }

  /**
   * Will execute a single URL and invoke the parent's
   * {@link GenericRequest#parseResponse(String)} method.
   *    * This method by default will return java.lang.Void as we are
   * leveraging the Callback to handle the return to the caller.
   */
  @Override
  protected T doInBackground(String... params) {

   Log.d(TAG, "doInBackground");

   T response = null;

   if (params == null || params.length > 1 || params.length == 0)
    throw new RuntimeException("Must handle a single URL.");
   else
    this.url = params[0];

   try {
    Log.d(TAG, "Requesting " + params[0]);

    requestor.makeRequest(new HttpGet(params[0]));

    Log.d(TAG, "request completed.");
   } catch (Exception e) {
    Log.d(TAG, e.getMessage());
    throw new RuntimeException(e.getMessage(), e);
   }

   response = parseResponse(requestor.getStringResponse());

   Log.d(TAG, "doInBackground complete");

   return response;
  }

  @Override
  protected void onPostExecute(T result) {
   Log.d(TAG, "onPostExecute");

   callback.handle(result, url);
  }
 }
}

And the API Request class:

public class Request extends GenericRequest {

 public Request() {
 }
 
 /**
  * Will by default call the parent
  * @param requestor
  * @param url
  */
 public Request(HttpRequest requestor, String url) {
  super(requestor, url);
 }

 /* (non-Javadoc)
  * @see com.nbc.cnbc.android.GenericRequest#parseResponse(java.lang.String)
  */
 @Override
 protected Response parseResponse(String httpResponse) {
      // parse your httpResponse
 }
}

By solidifying this pattern via templates, anonymous inner classes for Callbacks and encapsulated AsyncTasks your API can be easily executed as:

// synchronously

Request r = new Request(new HttpRequest(), "http://www.google.com");
Response response = r.execute();

// or Asynchronously

Request r = new Request(new HttpRequest(), "http://www.google.com");
Response response = r.execute(new Callback(this, this)( {
    @Override
    public void doCallback(Object sender, Response response, Object... params) ({
         this.context.......
         this.sender.notify();
      });

Android persistence framework

2011-04-12T11:26:00.000-07:00

Lately I've been doing a large amount of development work on the Android platform and have found with as many things standardizing at a lower level is a great way to enforce a concern. One of the things I've noticed is that many people have a difficult time dealing with entity relationships as well as the sqlite database in general. So, what I did was develop a genericized DAO structure as well as introduce a dao manager that can be grown by the applicaiton.

Unfortunately this strategy has a few limitations.
1) The sqlite api in Android does not support a datatype retrieval mechanism as does JDBC
2) There are a few tweaks that still need to occur in this to support CLOB and BLOB formats
3) The foreign key / entity relationship mapping still needs some work done on it for lazy loading
3) ... and some other random things

The basic grammar is simple.

An Entity has a Dao
An Entity has an ID which is a java.lang.Long
An Entity is persistable (save and delete)
An Entity can have relationships to other entities.
An Entity can be derived and its DAO can be derived as well.

Largely this is a light weight implementation of JPA for Android to simplify database persistence and remove the need for developers to have to hand code everything.

Largely the genericized DAO is a port of an implementation I've done for several other technologies including NHibernate, Hibernate and JPA and a lot of the following annotations and enumeration types are simply there to guide the engine.

Column.java:

@Retention(RetentionPolicy.RUNTIME)  
public @interface Column {
 String name() default "";
 
 /**
  * Should return a String, Long, Integer, BLOB
  * @return
  */
 EColumnType type() default EColumnType.String;
 
 /**
  * which direction are we going in relation to the {@link Entity}
  * @return
  */
 EOperation op() default EOperation.Inflate;
}

EColumnType.java:

public enum EColumnType {

 Integer(),
 Long(),
 String(),
 Blob(),
 Double(),
 Float(),
 Short();

 EColumnType() {  
 }
}

EOperation.java:

public enum EOperation {
 
 Inflate(),
 Deflate();

 EOperation() {  
 }
}

IGenericDao.java:

public interface IGenericDao<E extends IEntity> {

    public E findById(long id) throws Exception;

    public void save(E entity) throws Exception;
    
    public void delete(E entity) throws Exception;
    
    public List findAll() throws Exception; 
}

And all of the magic really happens in the Entity and GenericDao classes. The entity for all intensive purposes is a template that provides the ability to proxy to its concrete DAO and invoke the save method.

Entity.java

public abstract class Entity implements IEntity {

 static final String TAG = "Entity";

 protected Integer m_id;

 static Map inflationMap = null;

 static Map deflationMap = null;

 static Map methodAnnotationMap = null;
 
 static Gson gson = new Gson();

 /**
  * Default constructor for the generic. Will additionally normalize all
  * input methods for the column names to upper case
  */
 public Entity() {

  // load all of the column annotations related to a method
  synchronized (this.getClass()) {
   if (inflationMap == null && deflationMap == null) {
    inflationMap = new ConcurrentHashMap();
    deflationMap = new ConcurrentHashMap();
    methodAnnotationMap = new ConcurrentHashMap();

    Method[] methods = this.getClass().getMethods();

    for (Method m : methods) {
     if (m.isAnnotationPresent(Column.class)) {
      Column c = m.getAnnotation(Column.class);

      if (c.op() == EOperation.Inflate) {
       inflationMap.put(c.name().toUpperCase(), m);
       methodAnnotationMap.put(m, c);
      }

      if (c.op() == EOperation.Deflate) {
       deflationMap.put(c.name().toUpperCase(), m);
       methodAnnotationMap.put(m, c);
      }
     }
    }
   }
  }
 }

 public Entity(Integer id) {
  this();
  m_id = id;
 }

 public Integer getId() {
  return m_id;
 }

 public void setId(Integer id) {
  m_id = id;
 }

 private java.util.Date m_lastModifiedDate;

 /**
  * lastModifiedDate is exactly that. Will have column def of
  * last_modified_date
  */
 // @Override
 public java.util.Date getLastModifiedDate() {
  return m_lastModifiedDate;
 }

 // @Override
 public void setLastModifiedDate(java.util.Date date) {
  this.m_lastModifiedDate = date;
 }

 private java.util.Date m_createDate;

 /**
  * column definition create_date
  */
 public java.util.Date getCreateDate() {
  return m_createDate;
 }

 public void setCreateDate(java.util.Date date) {
  this.m_createDate = date;
 }

 @Override
 public boolean equals(Object o) {
  if (!this.getClass().equals(o.getClass()))
   return false;
  else {
   Entity e = (Entity) o;

   if (e.getId().equals(this.getId()))
    return true;
   else
    return false;
  }
 }

 public int hashCode() {
  int result;
  result = 29 * this.getClass().hashCode() + getId().hashCode();
  return result;
 }

 @Override
 public String toString() {
  return String.format("[%s#%d]", this.getClass(), getId());
 }

 public void onLoad() {
  doOnLoad();
 }

 protected void doOnLoad() {
 }

 public void save() throws Exception {
  Log.d(TAG, String.format("Save() called for: %s", this));

  doSave();
 }

 protected void doSave() throws Exception {
 }

 public void delete() throws Exception {
  Log.d(TAG, String.format("Delete() called for: {0}", this));

  doDelete();
 }

 protected void doDelete() throws Exception {
 }

 /**
  * Will generate a set of ContentValues to be persisted into the database
  * structure. This method does this by leveraging the creation of several
  * annotation driven maps based upon {@link Column}
  * * This method can be overriden to not leverage the reflection driven
  * strategy
  */
 public ContentValues deflate() throws Exception {
  ContentValues values = null;
  
  Log.d("DEFLATE", String.format("deflating %s", this.toString()));

  if (deflationMap != null && deflationMap.size() > 0) {

   values = new ContentValues();

   for (String s : deflationMap.keySet()) {
    Method m = deflationMap.get(s);

    Column col = methodAnnotationMap.get(m);
    
    Log.d("DEFLATE", String.format("Column identified as %s, %s, %s", col.name(), col.type(), col.op()));

    Object o = null;
    switch (col.type()) {
    case Integer:
     o = m.invoke(this, (Object[])null);
     Log.d("DEFLATE", String.format("Deflation value of: %s", o.toString()));
     values.put(col.name(), (Integer)o);
     break;
    case String:
     o = m.invoke(this, (Object[])null);
     Log.d("DEFLATE", String.format("Deflation value of: %s", o.toString()));
     values.put(col.name(), (String)o);
     break;
    case Short:
     o = m.invoke(this, (Object[])null);
     Log.d("DEFLATE", String.format("Deflation value of: %s", o.toString()));
     values.put(col.name(), (Short)o);
     break;
    case Long:
     o = m.invoke(this, (Object[])null);
     Log.d("DEFLATE", String.format("Deflation value of: %s", o.toString()));
     values.put(col.name(), (Long)o);
     break;
//    case Blob:
//     values.put(col.name(), m.invoke(this, (Object[])null));
//     break;
    }       
   }
  }

  return values;
 }

 /**
  * Will generate a set of ContentValues to be persisted into the database
  * structure. This method does this by leveraging the creation of several
  * annotation driven maps based upon {@link Column}
  * 
* This method can be overriden to not leverage the reflection driven
  * strategy
  */
 public void inflate(android.database.Cursor c) throws Exception {

  int idx = -1;

  // to find a possible permutation of id
  if ((idx = c.getColumnIndex("id")) != -1
    || (idx = c.getColumnIndex("ID")) != -1
    || (idx = c.getColumnIndex("Id")) != -1)
   setId(new Integer(c.getInt(idx)));

  if (inflationMap == null || inflationMap.size() == 0)
   return;

  String[] names = c.getColumnNames();

  for (String s : names) {
   Method m = null;

   if ((m = inflationMap.get(s.toUpperCase())) != null) {
    
    int index = c.getColumnIndex(s);

    setValue(m, c, index);
   }
  }
 }

 /**
  * Leverages the information from the {@link Column} and the
  * {@link EColumnType} to determine which set to pass.
  * 
  * @param m
  *            the method we are setting
  * @param c
  *            The data curosr
  * @param idx
  *            the column index
  * @throws Exception
  */
 final void setValue(Method m, Cursor c, int idx) throws Exception {
  Column col = methodAnnotationMap.get(m);

  switch (col.type()) {
  case Integer:
   m.invoke(this, new Integer(c.getInt(idx)));
   break;
  case String:
   m.invoke(this, c.getString(idx));
   break;
  case Short:
   m.invoke(this, new Short(c.getShort(idx)));
   break;
  case Long:
   m.invoke(this, new Long(c.getLong(idx)));
   break;
  case Blob:
   m.invoke(this, c.getBlob(idx));
   break;
  }
 }
}

GenericDao.java

import java.util.ArrayList;
import java.util.List;
import java.lang.reflect.*;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.util.Log;

@SuppressWarnings("unchecked")
public abstract class GenericDao
  implements IGenericDao {

 protected Class m_persistentClass;

 static final String TAG = "GenericDao";

 SQLiteDatabase db;

 public GenericDao(SQLiteDatabase db) {
  this.db = db;
  try {
   ParameterizedType genericSuperclass = (ParameterizedType) getClass()
     .getGenericSuperclass();
   this.m_persistentClass = (Class) genericSuperclass
     .getActualTypeArguments()[0];

  } catch (Exception e) {
  }
 }
 
 
 public SQLiteDatabase getDatabase() {
  return this.db;
 }

 public void delete(E entity) throws Exception {
  
  Log.d(TAG, String.format("Deleting a %s tfrom %s", entity.getClass().getName(), m_persistentClass.getSimpleName()));
  
  db.delete(m_persistentClass.getSimpleName(), "id = ?", new String[] { entity
    .getId().toString() });
 }

 public List findAll() throws Exception {

  List retVals = null;

  Cursor c = null;

  try {
   c = db.rawQuery("select * from " + m_persistentClass.getSimpleName(), null);

   if (c.moveToFirst()) {
    retVals = new ArrayList();
    do {
     E e = newInstance();

     e.inflate(c);

     retVals.add(e);     
    } while ( c.moveToNext() );
   }
  } finally {
   if (c != null) {
    c.close();
    c = null;
   }
  }

  return retVals;
 }

 public E findById(long id) throws Exception {
  Cursor c = null;
  E e = null;
  try {
   c = db.query(m_persistentClass.getSimpleName(), null, "id = ?",
     new String[] { Long.toString(id) }, null, null, null);

   if (c.moveToFirst()) {
    c.moveToFirst();

    e = newInstance();

    e.inflate(c);
   }
  } finally {
   if (c != null) {
    c.close();
    c = null;
   }
  }

  return e;
 }

 public void save(E entity) throws Exception {
  if (entity.getId() == null) {
   ContentValues cv = entity.deflate();
   
   Log.d(TAG, String.format("Saving a %s to %s", entity.getClass().getName(), m_persistentClass.getSimpleName()));

   long id = db.insert(m_persistentClass.getSimpleName(), null, cv);
   
   Log.d(TAG, String.format("ID returned as %s", Integer.toString((int)id)));

   entity.setId(new Integer((int)id));
  } else {
   Log.d(TAG, String.format("Updating %s", this.toString()));
      
   db.update(m_persistentClass.getSimpleName(), entity.deflate(), "id = ?", new String[]{entity.getId().toString()});
  }
 }

 /**
  * Will take in a string query and execute it
  * 
  * @param query
  *            the query to execute
  * @return a instance of E
  * @note possibly create a permutation of this method which takes in a set
  *       of objects and will infer the type to be added to the query
  */
 public E queryObject(String query) throws Exception {
  
  return queryObject(query, (Object[])null);
 }

 /**
  * Is expected to return a unique object
  * 
  * @param query
  * @param params
  * @return
  * @throws Exception
  */
 public E queryObject(String query, Object... params) throws Exception {

  E e = null;

  Cursor c = null;

  try {
   String[] vars = null;

   if (params != null) {
    vars = new String[params.length];

    for (int i = 0; i < params.length; i++) {
     vars[i] = params[i].toString();
    }
   }

   c = db.rawQuery(query, vars);
   
   if (c.moveToFirst()) {
    e = newInstance();
    e.inflate(c);
   }   
  } finally {
   if (c != null) {
    c.close();
    c = null;
   }
  }

  return e;
 }

 /**
  * Will take in a string query and execute it
  * 
  * @param query
  *            the query to execute
  * @return a list of E
  * @note possibly create a permutation of this method which takes in a set
  *       of objects and will infer the type to be added to the query
  */
 public List queryObjects(String query) throws Exception {
  return queryObjects(query, (Object[]) null);
 }

 public List queryObjects(String query, Object... params)
   throws Exception {
  List retVals = null;

  Cursor c = null;

  try {

   String[] vars = null;

   if (params != null) {
    vars = new String[params.length];

    for (int i = 0; i < params.length; i++) {
     vars[i] = params[i].toString();
    }
   }

   c = db.rawQuery(query, vars);

   if (c.moveToFirst()) {
    retVals = new ArrayList();
    
    do {
     E e = newInstance();

     e.inflate(c);

     retVals.add(e);
    } while ( c.moveToNext() );
   }
  } finally {
   if (c != null) {
    c.close();
    c = null;
   }
  }

  return retVals;
 }

 /**
  * Due to java type erasure we capture the meta data as input on the ctor to
  * factory later
  * 
  * @return
  */
 E newInstance() {
  E instance = null;
  try {
   instance = (E) m_persistentClass.newInstance();
  } catch (Exception e) {
   Log.e(TAG, e.getMessage(), e);
  }
  return instance;
 }

}

An example would be simple.

DaoManager.java:

public class DaoManager {

 Context context;

 MySQLiteOpenHelper helper;

 SomeEntityDao someEntityDao = null;

 private static DaoManager instance;

 private DaoManager(Context context) {
  this.context = context;

  helper = new MySQLiteOpenHelper(context);
 }

 public static void initialize(Context context) {
  if (instance == null)
   instance = new DaoManager(context);
 }

 public static DaoManager getInstance() {
  return instance;
 }

 public synchronized SomeEntityDao getSomeEntityDao() {
  if (watchListDao == null)
   someEntityDao = new SomeEntityDao(helper.getWritableDatabase());

  return watchListDao;
 }

 public class MySQLiteOpenHelper extends SQLiteOpenHelper {

  public MySQLiteOpenHelper(Context c) {
   super(c, "TEST", null, 2);
  }

  @Override
  public void onCreate(SQLiteDatabase db) {
   Log.d("DB", "onCreate");
   String table = "Your ddl";

   db.execSQL(table);
  }

  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
   Log.d("DB", "onUpgrade");
   db.execSQL("drop table watchlist;");

   String table = "Your ddl";

   db.execSQL(table);
  }
 }
}

SomeEntity.java:

public class SomeEntity extends Entity {
 
 public SomeEntity() {
  
 }
 
 public SomeEntity(String value, int i) {
  this.value = value;
  this.i = i;
 }

 @Override
 protected void doSave() throws Exception {
  DaoManager.getInstance().getSomeEntityDao().save(this);
 }
 
 
 @Override
 protected void doDelete() throws Exception {
  DaoManager.getInstance().getSomeEntityDao().delete(this);
 }
 
 
 String value;
 
 @Column(name="value", type=EColumnType.String, op=EOperation.Deflate)
 public String getValue() {
  return value;
 }

 @Column(name="value", type=EColumnType.String, op=EOperation.Inflate)
 public void setValue(String value) {
  this.value = value;
 }
 
 Integer i;
 @Column(name="intValue", type=EColumnType.Integer, op=EOperation.Deflate)
 public Integer getIntValue() {
  return i;
 }
 
 @Column(name="intValue", type=EColumnType.Integer, op=EOperation.Inflate)
 public void setIntValue(Integer value) {
  this.i = value;
 }
}

SomeEntityDao.java:

public class SomeEntityDao extends GenericDao {

 public SomeEntityDao(SQLiteDatabase db) {
  super(db);
  // TODO Auto-generated constructor stub
 }
}

The major advantage to this strategy is that it allows you to put your genericized persistence logic in a lower level shared library and develop a data access layer that is much more clean and extensible. Of course, with mobile (and or anything Android) not being as powerful as a server you'll want a lightweight implementation which is why the developer can additionally override the default implementation of Entity#deflate or Entity#inflate to make it less dynamic.

java vs .net exception model

2010-04-21T07:50:00.000-07:00

Lately I’ve been going back and forth between java and .NET and trying to keep as many of the architectural constructs the same because of the similarities in IL representation and concepts .... plus it’s just great to have analogous ported concerns to work with.

One issue I have not been able to get past is the throwable model between the two.

Java:
<code>
public class RandomClass
{
        public void doSomething throws Exception
        {
                // do something
        }
}
</code>

.NET/C#
<code>
public class RandomClass
{
        public void DoSomething
        {
                // do something
                // note the lack of a need to define the exception stack
        }
}
</code>

This poses issues for various architectures and/or frameworks when developed in one ported to another. It’s not a huge issue b/c you can always introduce an ExceptionHandler into java as a setter on the object. But that’s not the point of this blog. The point of this blog is the seeming why this is the case.

Java’s runtime is developed in C which is a language that does not have a throwable architecture for runtime exceptions; hence, why in the JNI interface the exception isn’t thrown it’s more set and evaluated at the end of the execution of the method when returning to the Java runtime.

<code>
JNIEXPORT jvoid JNICALL example_throw(JNIEnv *env, jobject obj)
{
jclass Exception = env->FindClass("java/lang/Exception");
env->ThrowNew(Exception,”some random exception);
}
</code>

It’s after the end of the execution of the throw method that the exception is actually detected.

Conversely the .NET runtime is implemented in C++ ... which has an inherent throwable architecture. This makes sense why there doesn’t have to be metadata around what the exception hierarchy is that is being thrown.

......

Java annotations and Lucene

2010-04-02T07:46:00.000-07:00

I’m about to start a project where I hope to write a loosely coupled, extensible framework for full indexing ... specifically for searching content. However, in doing so, I don’t want my work to need to be repeated. Ideally the engine that is responsible for building the index should be a factory driven system that wraps the implementation.


TextWriter writer = IndexFactory.getTextWriter();

writer.write(obj);

The getTextWriter() method would return a factoried, default instance of a Lucene TextWriter. The reason to do this is it allows you to completely decouple the concern. Now our API is based upon he API of the concern, not the implementation of the concern.

This can be loosely coupled even more by create a var args block at the end of the API methods.


package com.me.indexing;

public abstract class TextWriter
{
        public void write(IIndexable _indexable, Object... _data)
        {
                if ( Validate(_indexable, _data) )
                        return DoWrite(_indexable, _data);
        }

        public abstract boolean Validate(final IIndexable _indexable, Object... _data);

        private abstract void DoWrite(final IIndexable _indexable, Object... _data);
}

which is subclassed as


package com.me.indexing.lucene;

public class LuceneTextWriter extends com.me.indexing.TextWriter 
{
        @Override
        public boolean Validate(final IIndexable _indexable, Object... _data)
        {
                // validate that the _data block contains all data needed for the particular engine
        }

        @Override
        public void DoWrite(final IIndexable _indexable, Object... _data)
        {
                // write to the particular implementaiton
        }
}

This provides the ability to create a loosely coupled interface that all applications can implement against and removes the worry that the interface couple could change over time but provides the flexibility to change the engine on the backend.

We can take this one step further and introduce Java annotations into the objects that are being indexed to allow for metadata to be built into the object and consequently pushed into the index. This allows the contract to be solidified in the design phase, the metadata to be plugged into the object and to have an abstract implementation that is data driven and not product focused. Sound good? I think so.


package com.me.indexing;

import java.lang.annotations.*;

public @interface IndexData
{
        public string field();
        public boolean tokenized();
        public boolean additive();
}

Allowing for such information in the class that is passed to the writer as:


package com.me.someproductneedingindexing;

import com.me.indexing.*;

public class SomeClass implements IIndexable // this could additional be a class level annotation
{
        public SomeClass(String _someDescription)
        {
                m_description = _someDescription;
        }


        /**
         * Typical header
*/
        @IndexData(
                field = “DESC”,
                tokenized = false,
                additived = true
        )
        public string getDescription()
        {
                return m_description;
        }
}

Granted this entire post is barely a skeleton but it’s also 9.30 in the morning.

CNBC and remote collaboration

2010-03-31T08:27:00.000-07:00

As of yesterday I accepted a position with CNBC as the head of platform development. My ultimate personal goal in the team is to increase the stability and efficiency of the development through standardized process and practice (continuous integration, release cycles, change management, domain driven development).

CNBC is a Java shop currently focused mostly on web services exposed via Tomcat. I’m personally more a fan of moving towards app servers (JBoss or Glassfish) exposing EJB Stateless Session Beans internally and web services externally .... possibly backed by a lightweight, fast localized db (berkeley).

This will be a great opportunity to get back into the Java realm considering I’ve been in the .NET and C++ realm for as long as I have. I will be looking forward to keeping my .NET skills honed via my own projects and collaboration initiatives (Solace SCM -- really need to get that done and it looks like I’ll have some time here soon while in NYC).

One of the things that I really need to identify is a remote collaboration solution, a good wiki solution, a good team collaboration solution -- all preferably open source. After speaking to a friend about sharing remote white boards he mentioned they tried something at cisco with 2 camera, 2 projectors, 2 whiteboards and polarization filters. Brilliant. But I’m going to need a drawing solution that I can do UML on, share over webex and save to JPEG (hopefully works over USB).

If anyone has any ideas or suggestions going into this position I am all ears.

IoC

2009-06-04T20:52:00.000-07:00

I've recently developed an IoC engine based around the concepts of "actions", "handlers" and "managers" which key off of whatever the "KeyGenerator" is defined to be... any object. It's proving to be a highly scalable and distributable platform for a new runtime engine I'm dubbing "ActionEngine." Coupled with the ApplicationFW that has already been developed it's going to prove to be a, nearly, 100% uptime system. Imagine the ability to signal an application listen via a background thread to reload certain aspects of itself. This currently exists in most app containers (Java) but not in the .NET realm (well, somewhat) ... especially not geared towards typically business problem (e.g. monitoring, p2p, etc).

If I can actually get this done in a relatively short timespan it will most likely be deployed as the platform for our business.

If you can imagine it you can do it. The problem is it's many times difficult to explain the imagination.

impact

2009-02-23T15:00:00.000-08:00

Today my company laid people off. That sucks, simply put. I find myself completely irrevocably relieved it was not myself dismissed. Unfortunately some very close friends were. I find myself heavy and low dealing with the fact that I know what goes on in their lives outside of work. Life at times is never easy but that's why we have relationships (lovers, friends, parents) ... to help "support" us. I take solace in the fact that I can lean on these people and their words are like liquid jade, beautiful to my ear.

it's about that time

2008-12-02T15:51:00.001-08:00

It's been quite some time since I've written about the strengths of humanity. No matter how we all can become collectively selfish there always seems to be that spark that fires in each of us (mostly) that causes us to reach out to someone in their time of need. Whether it be someone having dropped something on the side of the street on a rather serious accident. There is that spark of humanity that unites all of us.

That very same humanity is what qualifies the need for the moment that we share. That grows the bond between us. Whether that bond be friendship or a relationship the one major key there is to foster that bond through communication. Communication being the most abstract concept of them all. We "speak" in so many fashions on a daily basis that we don't even realize. A grimmace of the brow, a smile, a passing touch and the all but most powerful, honesty! Yes folks. Believer it or not, but honestly is the one thing that is truly required to foster and grow the human moment. We're all deficient in some ways -- I know I am on many occassions.

One thing I've considering doing as of recent is walking up to a perfect stranger, engaging them in conversation, and telling them exactly what I think and seeing where that conversation goes. More often than not we're all hindered by what society qualifies as a "social norm." Let's all throw that convention out the window and share the smile of honesty with each other. Just look at where that's gotten everyone. I'm sure the next person you talk to would find it refreshing.

Linked

2008-11-30T20:06:00.000-08:00

I’ve been reading Laszlo’s “Linked” for some time but my in progress trip back to Denver has afforded the opportunity to finish his work. An absolutely stellar job done I must say. It’s opened my eyes to seeing things from a new perspective. Primarily the statistical possibility of certain networks unfolding the way they have/do which he refers to as “preferential growth.“ This concept primarily applies to in essence ”popularity“ or ”right place at the right time.“

A thought that I’d like to dig further into in relation to this is the effects of tangential networks and how they affect each other. In essence the effects of multiple variables in relation to an entity on multiple concepts (e.g. Apple). Apple has historically not had a solid market share of the compfuter space until really the past four years. It was until then that the network of links based upon market share of computer companies began to become skewed by pop culture. Apple was able to establish an image that ultimately grew into a sub culture throttling them into a higher market share and more innovation in the product space. The iPod was that fuel that has driven a brand and a generation. So the question becomes ”can it be quantified how the affect of the network of subcultures -- in this case Apple -- affect market share of computer hardware?“ I think so.

An XML driven configuration framework for Java

2008-11-29T13:12:00.000-08:00

I’m currently looking at some of the inadequacies that exist inside of the Java architecture vs. that of .NET. Microsoft definitely learned a good bit from watching other technologies grow -- what makes them successful and what hinders them. One of the things that MS did very well was their concept of <i>configuration</i>.

Microsoft’s configuration gives the framework the ability to define configuration sections where a section has a handler. This handler is responsible for not only converting the xml into an object (similar to JAXB) but also to give an extension point for the developer to define how the object is registered with the system.

My company uses this heavily for all sorts of configuration logic. We use it for database configuration (e.g. connection strings and properties of the connection), caching, threading. Ultimately this feeds very nicely into an IoC framework that has been development specifically for our business needs. This is above and beyond the point from this point. I’d like to replicate this pattern (including the core technologies that we’ve developed) into a standardized java library that a) solidifies the patterns b) their usage c) establish concrete practice in relation to abstracts and their derived grammar. Sound like a good idea? I think so. The library is already developed in .NET and is HEAVILY used in our systems. It was one of the more valuable things I’ve added to the organization. Now if I can only figure out a solid pattern to get this done in Java.

Limitations: the .NET framework handles the reflection and invocation for you (b/c it’s intrinsic to the framework) but java does not. This means all of the reflection assets that sit in the library will be heavily used by the library to accomplish the same goal. From a design perspective this will mean that I’ll have to focus more heavily on that minute details.

If anyone has any suggestions please let me know. This will probably be a really good open library....

MacJournal

2008-11-29T09:02:00.000-08:00

I’ve recently been looking for a blogging solution in the Mac world; something better than text edit. I enjoy the tangible of writing but sometimes it is just so much easier to type and express than it is to write.... definitely far more legible.

I’ve found a solution, MacJournal. MacJournal has a lot of great attributes to it. The ability to export if you want to print and archive -- there is nothing like going back and reading your thoughts on paper. The ability to publish to a blogging web solution -- very sweet.

This is my first test .... fingers crossed.

saml, inadequacies in communication between tech groups, and ineffective trouble shooting.

2008-01-14T07:54:00.001-08:00

Recently one of my developers was involved in an integration with a large service provider where a new[ish] specification/technology was used for the security layer. In this integration (SOAP w/ SAML) the service provider (while having chosen to use the technology) had a fundamental lack of understanding as to how the technology worked (as did I at the time). This was largely to do with the face that the application server chosen was wrapping this functionality and hiding its implementation which did not lend well towards debugging the integration. After five days of my developer chasing his tail trying to figure out a solution due to a limitation (or perceived limitation) in .NET based upon a series of supposed "facts" I was introduced into the mix where I initiated a restatement of FACTS (yes, as in actually facts not assumptions) in which case a solution was quickly identified and it became glaringly apparent that not everyone understood how the technology was used on their end or how the specification enforced their security model (going back to the application server) -- and this is fine. A lot of people have done this and I'm guilty of it as well. This does go back to proper trouble shooting. When faced with a problem always be able to verbalize your known facts in relation to your assumptions and your plain old I-don't-know's. This will give you the ability to identify the correlations between each set and apply an order of precedence to being trouble shooting. Will definitely speed up the process and prevent people from shooting in the dark.

So, if you're ever needing to do an integration of SAML into a WSDL generated SOAP proxy call in .NET then listen up. You can do this integration by deriving from the SoapExtension class and then defining an attribute to be placed on the SOAP proxy call ......


   public class MySoapExtension : SoapExtension
   {
       public bool outgoing = true;
       public bool incoming = false;
       private Stream outputStream;
       public Stream oldStream;
       public Stream newStream;
                   
       public override Stream ChainStream(Stream stream)
       {
           this.outputStream = stream;
           oldStream = stream;
           newStream = new MemoryStream();
           return newStream;
       }


       public string getXMLFromCache()
       {
           newStream.Position = 0; // start at the beginning!

           string soapString = ExtractFromStream(newStream);
         
           return soapString;
       }

       private String ExtractFromStream(Stream target)
       {
           if (target != null)
               return (new StreamReader(target)).ReadToEnd();
           return "";
       }

       public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
       {
           return null;
       }
       public override object GetInitializer(Type serviceType)
       {
           return null;
       }
       public override void Initialize(object initializer)
       {
           return;
       }

       public override void ProcessMessage(SoapMessage message)
       {
           // if we want to add a header we can hijack the output stream
           // and load the xml into a document and manipulate it as is  
           // here we want the AfterSerialize stage
     
           switch (message.Stage)
           {
               case SoapMessageStage.BeforeSerialize:
                   break;
               case SoapMessageStage.AfterSerialize:
               {
                   // assumed saml operations class
                   SAMLAssertion assertion = new SAMLAssertion();

                   // create assertion
                   assertion.CreateAssertion();

                   // generate signature
                   assertion.GenerateAssertionSignature();
                
                   Soap11 soap = new Soap11();

                   String soapBodyString = getXMLFromCache();

                   XmlDocument doc = new XmlDocument();
                 
                   doc.LoadXml(soapBodyString);

                   XmlElement soapHeaderElement = soap.CreateHeaderElement(doc);                  

                   XmlElement wsseSecurityElement = doc.CreateElement("wsse", "Security", "http://schemas.xmlsoap.org/ws/2003/06/secext");

                   wsseSecurityElement.AppendChild(doc.ImportNode(assertion.Xml,true));

                   soapHeaderElement.AppendChild(wsseSecurityElement);

                   doc.DocumentElement.PrependChild(soapHeaderElement);

                   Stream appOutputStream = new MemoryStream();
                 
                   StreamWriter soapMessageWriter = new StreamWriter(appOutputStream);

                   soapMessageWriter.Write(doc.InnerXml);

                   soapMessageWriter.Flush();

                   appOutputStream.Flush();

                   appOutputStream.Position = 0;

                   StreamReader reader = new StreamReader(appOutputStream);

                   StreamWriter writer = new StreamWriter(this.outputStream);

                   writer.Write(reader.ReadToEnd());

                   writer.Flush();

                   appOutputStream.Close();

                   this.outgoing = false;
                   this.incoming = true;
                 
                   break;
               }
               case SoapMessageStage.BeforeDeserialize:                                 
                   break;             
               case SoapMessageStage.AfterDeserialize:
                   break;
               default:
                   throw new Exception("invalid stage!");
           }          
       }
   }


   [AttributeUsage(AttributeTargets.Method)]
   public class MySoapExtensionAttribute :
     SoapExtensionAttribute
   {
       private int priority;
       public override Type ExtensionType
       {
           get
           {
               // return type of extension to load
               return typeof(MySoapExtension);
           }
       }

       public override int Priority
       {
           get { return priority; }
           set { priority = value; }
       }
   }
 
 
 
 
   // And finally the wsdl generated proxy call
   [System.Web.Services.Protocols.SoapDocumentMethodAttribute("http://www.somecompany.com/SomeAPI/SomeMethod",
       Use=System.Web.Services.Description.SoapBindingUse.Literal,
       ParameterStyle=System.Web.Services.Protocols.SoapParameterStyle.Bare)]
      [return: System.Xml.Serialization.XmlElementAttribute("SomeMethod_Response",
       Namespace="http://www.somecomapny.com/SomeAPI")]
      [MySoapExtensionAttribute]
   public SomeMethod_Response SomeMethod([System.Xml.Serialization.XmlElementAttribute(Namespace="http://www.somecompany.com/SomeAPI")] SomeMethod_Request SomeMethod_Request) {                                                  
       object[] results = this.Invoke("SomeMethod", new object[] {
           SomeMethod_Request});
       return ((SomeMethod_Response)(results[0]));
   }

So, if anyone finds themselves faced with a similar issue in .NET realize that you can hijack the output stream, process the xml as you see fit (and even validate yet again against another xsd) and retransmit the request over the wire... Just remember, what comes back has to be able to be proxied into the response object so Soap:Header information may be lost if not exposed appropriately on the server side to be consumed by the client.

Cheers.

dan

css difficulties

2007-09-16T21:12:00.000-07:00

All I have to say is the entire idea of developing elastic layouts is such a pain in the butt. I've been working on one for struts for the past week and am getting absolutely no where. In addition the person that is doing the html doesn't understand the technologies that are backing the page so it's making things all the more difficult. Done, going to bed.

the worst is there to comfort you

2007-07-24T07:35:00.000-07:00

I've recently gone through a relatively difficult breakup and I've found myself beginning to evaluate the direction of my life. Am I happy in my career? Am I happy where I am? Well, No. I was in Pittsburgh this past weekend for a friend's wedding and met some very interesting people that have enlightened a part of me that has been ever growing, the socially aware side of me. Class disparity, that sort of thing. I'm currently working on an initiative to start fund raising here in Denver around an idea that I brought back from PA. In fact, now I'm considering law school to go into public policy with a concentration on technology.

At any rate, that is not what this blog is necessarily about. This blog is about the fact that the worst is here to comfort us. We hit a certain point and we begin to ask "Why?". I asked why and did not come up with an answer but I did come up with a list of short comings in myself -- or rather short comings that had developed that are not "me." I would not have asked these questions or even begun writing again if I had not begun to look my life from a different perspective, I stood upon a chair if you will. So, the point is... when you hit a point where you feel stuck stop looking at your feet b/c you will never see the opportunity around you. Change your perspective... it's only a decision.

computer "science"

2007-07-13T08:19:00.000-07:00

I'm the architect of a mobile software company in Denver, CO. I've quite a few years in industry, nearly 10, writing everything from low level drivers, full blown enterprise software on Solaris in C++, IL based real time distributed software for health care claims processing backed by AI engines in Lisp, to shell scripts. I'm finding myself very frustrated these days when I meet new developers coming out of school. The education system seems to be focusing more on industry trend and less on design and understanding. It's about time we get back to fundamentals... b/c let's face it, there is nothing new under the sun save the virtual mapping of omega network resources across multiple machines in a virtual cluster (which has been going on for over a decade) and larger accessible memory. Everything comes down to a lowest common denominator and when students don't know how to work with that lowest common denominator things fails. I'm finding tons of people have no clue how IL works, why it works the way it does, why the way it works offers other intrinsic benefits to development (a single level of indirection has cured all of the problems in computer science -- this of course was in reference to the pointer and the reference ). Can we really call ourselves computer scientists if we don't understand what is occurring at the most basic of levels?

flagstaff

2007-07-13T08:09:00.001-07:00

Last night I was on Flagstaff working some problems, or attempting to work some problems, and saw an old man that had been climbing there for more than 35 years work the same problem with one hand. It didn't even phase him. He must be a true boulder institution. I have no clue who he was but it was nice talking to him.