Archives

Anybody who has been to our office knows I am an Android fan. My prediction is that the Android platform will end up with a much, much larger install base than iPhone OS. Originally, I felt this way because you can get a Android phone on every carrier for a lower cost than the iPhone – many of them are now free with a contract. This is good enough, but I have a new insight. The Android OS does a great job of directing your attention to highly important information. As such, its easier for new users to pick up and for busy people to use. How can this be? You should argue that the the Android OS so similar to the iPhone OS. You are right. However, it comes down to usability. The majority of people out there won’t explore their device to find information. They just want the phone to do the work for them. If it doesn’t smack them in the head it might as well not exist. Android has two crucial features that make it a helper more than just a smart phone.

The value of wireframing even with incomplete information

The task of wireframing in application development, as I’ve come to know it, should begin after user research has been performed, and a complete set of requirements gathered.  But what happens when, for whatever reason, you just don’t have access to user research, or a full set of requirements?  What if all you have are some rather unspecific, vague notions of what the user should and should not be able to do?  Is wireframing at this juncture useful?  I say yes.  With incomplete or even almost non existent information about target users and or requirements, wireframes can still be a valuable tool in the interface designers toolkit.

The key to a wireframe’s usefulness is that it is a visual document.  Presumably it will be presented to one or more product stakeholders, and they will have the opportunity to review it and comment.  Having something visual to respond to is one of the easiest ways to generate ideas, and identify incomplete specifications.  A good assumption is that if a product’s requirements are incomplete, someone at the wireframe review will notice the gap by responding in the context of the visual presentation.  “Where is the Cancel button?  Oh…not in the requirements?  Well it’s obvious that on this screen the user will need to be able to cancel, so we have to add that as a requirement.”

In this way, a wireframe can be an ever evolving document, which begins by starting the requirements conversation.  Of course ultimately, just prior to feature development, the wireframe should have all of the necessary specifics so that the developers can use it as a guide (along with the relevant user stories).

I’ve just come across Yahoo’s new home page, which features a clean streamlined look, the ability to add your favorite pages as links right on the homepage, and most interestingly, a module that gives you access to (a subset of) your Facebook account. This module, which appears when you hover your mouse over the Facebook link on the let hand side of the page, will–after sign in–open up your facebook friend feed right there on the Yahoo home page.
Apparently Facebook has been giving third party websites the ability to connect to their users via Facebook for 8 months now (through a set of API’s collectively called Facebook Connect). But the Yahoo home page is the most high profile example yet. This is certainly the first time I’ve come across it.

The benefits of Facebook connect Facebook is obvious. It’ll gather more information about its users, and become more ubiquitous within the wider web, as users remain connected to its platform even while not actually on the facebook.com.

Spent some time playing around with Flash Catalyst, which was released by Adobe as a public Beta yesterday. I downloaded it today and got started on some of the tutorials Adobe labs has put up.
My impressions:
It’s pretty neat stuff. I could see myself prototyping with it, although Keynote and Acrobat are my tools of choice at the moment.
From my limited time working with it, Catalyst’s main function is to make it very easy to take Photoshop or Illustrator compositions and turn them into fully (front end) functional interfaces, complete with animations, transitions, fades, buttons states etc. One of the tutorials had me import artwork of a scrollbar, in 4 layers. Creating an actual scrollbar and hooking it up to a canvas was as easy as selecting the individual layers and telling catalyst which part of the scroll bar it was (up button, down button, track and thumb). It;s also super easy to connect user actions to specific screens (or states, as Catalyst calls them).

Another Chicago area conference coming up: FITC Chicago 2008, from June 22-23 at the Chicago City Centre Hotel & Sports Club, 300 E. Ohio. We’re even supporters. So what is it beyond the platitudinous “design and technology” event?

Obviously there’s going to be lots of talk about how to develop Flex and Flash applications. Also how to develop online/offline apps with Adobe Air. Heck you’d think Adobe was a sponsor.

If designing RIA’s with Flash/Flex/Air is your thing, you want to be here. It’s not free, but based on last year’s event, well worth the $125-$250 (depending on which sessions you go to).

Update: If you sign up here with our special ninja supporter code of PATH15, you get 15% off.

In Java, it is perfectly fine to declare an interface with static-final properties as follows:

public interface QuestionFactory
{
public static final int QTYPE_INPUT = 1;
public static final int QTYPE_RADIO = 2;
public static final int QTYPE_CHECKS = 3;

public Question createQuestion(int questionType);
}

This cannot be translated in to .NET as. The following won’t work:

public interface IQuestionFactory
{
// won’t work in .NET (Err: Interfaces cannot contain fields)
public static readonly int QTYPE_INPUT = 1;
public static readonly int QTYPE_RADIO = 2;
public static readonly int QTYPE_CHECKS = 3;

public Question CreateQuestion(int questionType);
}

The general recommendations in such a scenario is to externalize the const(s) in another class.

public class QuestionType

{
public const int QTYPE_INPUT = 1;

public const int QTYPE_RADIO = 2;

public const int QTYPE_CHECKS = 3;
// disclaimer: I used “const” ’cause I wanted to use it in switch/case.
// However, I assume “static readonly” could have been used as well.
}
Why is this so? The notion seems to be that interfaces cannot have states (they are stateless) and hence do not allow fields. Coming from Java world, I am not entirely sold on this argument though. I prefer one interface with all static readonly/final fields as well method-contracts (that consume those fields).

One may argue use of enum instead of int(s)… but that is a different discussion.

Flash Player 9 introduced the ability to decode H.264 video format.  However, it cannot encode video as H.264 (although it does encode as H.263).

This is a problem for people who want to take advantage of H.264′s ability to encode at a higher quality with a lower bitrate. There are a few vendors out there who propose to offer a solution, but some of the solutions require an extra download which isn’t necessarily cross platform.

With the release of AIR, Adobe seems to be targeting the Desktop market as one of their future goals. Many existing desktop applications already support H.264 encoding (see iChat for a good example).  If Adobe wants to keep up with the desktop application market, it might be prudent to add support for encoding as H.264 soon.

I’ve been looking at some of the new features in the .NET 3.5 framework and have found Object Relation Mapping (ORM) very similar to IBatis.NET and NHibernate. In .NET 3.5, they use attribute based mapping between the underlying data table and entity class (Domain Object). For instance

using System.Data.Linq;
using System.Data.Linq.Mapping;
[Table="Books"]
public class Book {
    [Column="Name"]
    public string _Name;
    [Column="ISBNNo"]
    public string _isbn;
    ...
}

What you notice is the the class Book is mapped to a table called Books using the Table attribute and particular table columns are mapped using the column attribute on the Book class instance fields. Compared with IBatis.NET XML files; you would have to:

1. Reference the Book class using the <typedalias type=”Namespace.Book, Namespace”/>
2. Create a ResultMap that exposes the Book class internal fields using <property name=”ISBN” Column=”ISBN”>
3. Create the sql statement that references the resultmap for the Book class so IBatis.NET and hydrate the results. Below is sample sqlmap.xml file for Ibastis.net

<sqlMap namespace="Surveys" xmlns="http://ibatis.apache.org/mapping">
    <alias>
        <typeAlias alias="Book" type="Namespace.Books, AssemblyName"/>
    </alias>
    <resultMaps>
        <resultMap id="BookMap" class="Book">
           <result property="Name" column="Name"/>
            <result property="ISBN" column="ISBN"/>
        </resultMap>
    </resultMaps>
    <statements>
        <select id="GetBooks" parameterClass="map" resultMap="BookMap">
            select name, isbn from books
        </select>
    </statements>
</sqlMap>

Furthermore, much of the guesswork required to create the parameterizes queries used to pull information from the database and load a collection of Book objects has been added. Simply creating a new Linq DataContext object, passing the connection string to the database and calling the generic GetTable<T> (where T is class name. in this case Book) is all you need to get the results, versus creating the individual sql in the xml file and calling one of the QueryForObject or QueryForList methods found for IBatis.NET.

Last but not least, Linq provides the programmer with built-in sql like keywords used to build expressions that sort, aggregate and limit the original result set to some more specific or limited result result set without going back to the underlying database.

Although, this is a very simplicity view of mapping a database table to .NET class. This does give you a good picture to the additional overhead required to using IBatis.NET xml file mapping versus Microsoft’s Linq to Sql attribute base mapping, and demonstrates how ORM is now built right into the .NET Framework. And, you be happy to know that your .NET 3.5 Linq to Sql applications will still run on .NET 2.0 because the new features are specific to the specific 3.5 .NET compiler.

After several years in Java/J2EE world, I recently started working on a .NET project. The motivation was to get to know the pros and cons of both world and leverage better ideas from each going forward.

Having used Apache Commons/Collections in Java, I longed for similar library in .NET. I am not sure if one already exists (quick google didn’t turn up any result). However, considering that fact that Commons/Collections uses Callback interfaces a lot, it was clear that any such attempt would leverage .NET’s “delegate” feature extensively. I couldn’t resist trying to implement it myself. Here is what I ended up with.

So, in my case, I wanted CollectionUtils.collect() method, which transforms a list of object into a list of some other type of objects. This is a handy utility to unwrap/wrap an exising list into another list. So, for example, I have a List<StringWrapper> object in which each StringWrapper object is simply a wrapper around a “String” object. And let’s say that I need to get a List<String> from List<StringWrapper> object.

In Java’s Commons Collection I would use a call like this:

class StringWrapper {
public String a;
public StringWrapper(String a) {
this.a = a;
}
}

…
List<StringWrapper> aColl = new ArrayList<StringWrapper>();
aColl.add(new StringWrapper(“x”));
aColl.add(new StringWrapper(“y”));
aColl.add(new StringWrapper(“z”));
List result = CollectionUtils.collect(aColl, new Transformer() {
public Object transform(Object o) {
return ((StringWrapper) o).a;
}
});
…

Here CollectionUtils.collect() would be something like (a very lame version of what is in Apache’s Commons/Collection library):

class CollectionUtils {
public static <T, N> List<N> collect(List<T> list, Transformer<T,N> transformer) {
List<N> result = new ArrayList<N>();
for(T t: list) {
result.add(transformer.transform(t));
}
return result;
}
}

// Callback interface
interface Transformer<T,N> {
public N transform(T o);
}

In .NET, we could replicate this code 1-for-1 and get the same result. However, .NET’s delegate keyword helps cut the fat and provides for a lean implementation as follows:

public class Collections
{
// a ‘delegate’ defines a method signature. Any method with same method signature can be used as callback method.
public delegate N Transformer<T,N>(T o);

// a function that takes a delegate method whose signature is declared by ‘Transformer’
public static IList<N> Collect<T, N>(IList<T> originalList, Transformer<T,N> transformer)
{
IList<N> returnList = new List<N>();
foreach (T oo in originalList)
{
returnList.Add(transformer(oo));
}
return returnList;
}
}

Here, a delegate is like an abstract method and my concrete implementation could be like:

string transform(StringWrapper str) // this method’s signature should match the delegate declaration
{
return str.a;
}

And the client call then becomes:

…
IList<string> result = Collections.Collect<StringWrapper, string>(listOfStringWrappers, transform);
…

Or I can do away with an anonymous delegate implementation as:

…
IList<string> result = Collections.Collect<StringWrapper, string>(listOfStringWrappers, delegate(StringWrapper str) { return str.a; });
…

Be a Good Listener. We’ve all heard this phrase. As I experienced recently, it applies readily to pair programming as well.

I am currently helping a student learn Java while she is taking an algorithms class. Having had teaching experience in the past, I was able to teach her the basic stuff fast and well. It was mostly a one way street where I talked and she listened. As she grew more comfortable with Java, she starting asking non-trivial questions. I quickly realized that it was no longer a one way street. I had to make conscious effort to not discount what she said/asked and say what I had to say. It took us longer to arrive at a solution _together_ if I talked more than I listened. I had to resist the temptation to arrive at a solution _alone_ and bring her along; at her speed. To bring her along, I had to listen more and make an effort to understand what she understood and where she missed. This may seem counter-intuitive but I realized that it was best (in terms of code quality and long term sustainability of happy pairing relationship) when I listened to her and gave her just enough information to find her way instead of imposing my way onto her.

I understand that pairing with a newbie is distinct from pairing with your co-developer. But still, being able to align yourself to someone else’s thoughts goes a long way in achieving better results.

Happy Pairing !