The Macadamian Files

The Anti-social web - Twitter for the socially inept

2008-11-12T11:25:00.006-05:00

Twitter was mentioned during Macadamian's corporate blogging presentation. "Useless! Bah! Humbug!" were the first thoughts to enter my head. Then the speaker pointed out that corporate bloggers should strive to see the positive side of any situation, and I figured making Twitter useful to a neo-Luddite was a good challenge; there must be an itch to scratch here, right?

All I knew about Twitter was that people think it's slow, and it's written in Ruby (on Rails.) After exploring a little more, I found out that it can provide private Atom feeds of your messages, and exposes a REST API (ooh, new, shiny!) That was enough to get me coding.

To keep things simple I decided to be boring and test out Twitter using Ruby (normally, I plan epic posts with 5 different languages, communicating through at least 2 protocols... and a database for no good reason.) The process I followed was:

Install Ruby (one-click installer)
In the Gems package manager: gem install rest-client
Install the Ruby Development Tools for Eclipse
Read the Twitter API

require 'date'
require 'rest_client'
require 'rexml/document'

username = "your_twitter_id_here"
password = "your_twitter_password_here"

twitter = RestClient::Resource.new 'http://%s:%s@twitter.com' % [ username, password ]

# Send a message to twitter
result = twitter['statuses/update.xml'].post(
   :status => "This is your computer.  You have no life as of %s" % DateTime.now()
)
# print result

timelineXML = twitter['statuses/user_timeline.xml'].get({ :count => 5 });

# Make the XML usable
# (Use XmlSimple for even easier handling)
timeline = REXML::Document.new(timelineXML)

# Display the text element of every status returned by the service
# (print timelineXML to learn more about the structure of the result.)
puts "%s's timeline:" % username
timeline.elements.each('statuses/status/text') { |message|
   puts message.text
}

As Twitter restricts you to 70 calls per hour, it's a good job Ruby (on REST) made this so easy. REST is a nice change from the usual URL gobbledygook that frameworks throw up - I can't wait to try it out in Struts2.

So, what can people with no interest in socializing do with Twitter?

Free yourself from your desk by monitoring that 45 minute long J2EE build from your iPhone
Monitor your computers by receiving disk capacity warnings, CPU performance reports, and IP address changes
Find out when someone is breaking into your home
Know when your plants need to be watered
Search for signs of life in the Mars lander

One final note, until the authentication framework is more robust, don’t rely on anything you twit staying private.

Breadth-First Coding

2008-10-29T00:41:00.005-04:00

"Look Ma! I'm inventing my own buzzwords!"

The problem

A little while ago, some of us at Macadamian held discussions on behaviors we would like to encourage among younger developers. One thing we agreed was that "stubbing" (coming up with methods containing as little code as possible, in order to stabilize the API interactions faster) was becoming a "lost art". And so we resolved to start encouraging "top-down development", as we were used to call it.

So far, we've met with little success. Despite our explicit encouragements, it seems hard for people to adopt a "top-down" approach.

And lately, I've been wondering: what if we're not communicating right? After all, "top-down" is a pretty generic term. After all, it's even used to describe an entire programming methodology which predates Object-Oriented Design. So perhaps some of the people in our teams are thinking: "Of course I'm going from top to bottom, what are they complaining about!?"

That's when I thought of something...

Mandatory flashback to the author's younger days

Back at school, I followed this neat AI course which taught me some general problem-solving heuristics. Overall, it showed two ways to attack a problem by brute force: breadth-first and depth-first.

Let's say we're looking for a file within a directory structure. A depth-first approach will recursively explore each solution by first going to the lowest node possible. Only then will it work its way back up, before going down again.

A breadth-first approach, on the other hand, would attempt to fully explore one level of nodes before jumping to the next one.

For additional details, you check out breadth-first search and depth-first search on Wikipedia (where I borrowed these graphs from).

And so...

I'm beginning to think that younger developers show a natural tendency to code depth-first. They pick a single feature/functionality/API call, then implement it down to the lowest level, at which point they consider to have a "valid iteration". Then they go back up a few levels, and start again. Doing things that way can make you feel good because you've added a lot of code, but it makes things harder to test, and might complicate future integration.

We'd like people to try out breadth-first coding, which would mean getting a wider range of partly-implemented methods in the early stages.

First, you'd define the APIs of the first layer, providing a "bare-bone" implementation of each method. Then you'd define the second layer, once again with a minimal implementation, at which point you'd be able to properly implement the first layer. Repeat for each layer of implementation.

So, as my first step, I'll start using the term "breadth-first" when talking about this approach. I'm hoping that by using this term instead of "top-down", I'll get a few "Huh? WTF?" responses, which may be just what we need in order to break some old habits...

Bridge SharePoint - User Profiles and User Profile Properties (part 2 of 2)

2008-09-12T09:28:00.004-04:00

As we have found out in part 1, SharePoint can manipulate data using the user profile management objects and can accept data from external sources. Using these two features apart we have two limited tools with limited usage, but using them together gives us a powerful, flexible and efficient method of storing and using data from any internal or external resource.

It’s time to see this solution to our problems in action.

Code example of getting/setting the profile property from a C# application

The concept is the same for any source of information (web services, web applications, etc.):
Get the user’s profile->Get the required profile property->Get/Set profile property value

Code example: (note that to access profile properties, this code must run with elevated privileges)

string value;
try
{
 SPSecurity.RunWithElevatedPrivileges(delegate()
 {
  
     // Change the site address for different deployment environments
     // Note: WIN2003STD is a place holder for your environment, usually your server name
     SPSite site = new SPSite("http://WIN2003STD/");
     SPWeb web = site.OpenWeb();

     // Get the profile manager object for the site
     UserProfileManager profileManager = new UserProfileManager(ServerContext.GetContext(site));

     // Use the username from the User Information Item to get the full profile of an user
     UserProfile user_profile = profileManager.GetUserProfile(System.Web.HttpContext.Current.User.Identity.Name);

     // Get the required profile property value from the profile
     value = user_profile["MyProperty"].Value.ToString();

  
 });
}
catch (Exception e)
{
 return "Error getting user info: " + e.Message.ToString();
}

user_profile["MyProperty"].Value gets or sets the profile property value.

This is a very convenient way of using profile properties to store required information for each user. Properties can be set as read-only or not to appear in the user’s profile, which gives you even more control.

System.Web.HttpContext.Current.User.Identity.Name returns the username (the login username) and it is used in the code example above to get the profile of the currently logged-in user.

Tools You Never Knew You Had… (and what to do with them now that you’ve wised up!)

With this simple solution to getting/setting a user’s profile property value, endless opportunities are now at hand. This small code snippet helps developers control, validate and use values stored for each user, without corrupting the database or resorting to other more complex and error-prone solutions.
For those not needing to use an external application to get information from the users, a custom SharePoint web application can be developed and deployed on SharePoint. This way all the controls offered by ASP .NET or custom controls can be used to perform required operations on the data before it’s stored.

External applications running on the server can access this information the same way, so a bridge between SharePoint and applications like web sites, game servers, messaging apps, etc. can be easily created.

SharePoint Complications, As Usual

Watch out that the profile property might be set as read-only in SharePoint. Even if it’s the case however, the above code should still be able to access the profile because it’s running with elevated privileges. So if there is a situation in which the user is allowed to see the data but only modify it by using a service (like a web application or web service), this is a good way of doing it.

Another gotcha is that the code above can only be used on the SharePoint server machine. This is due to the framework that SharePoint uses. To get information or to change data from a network on internet location, a SharePoint custom web service or web application can come in handy. Other ways of passing information will work too, like server-client applications, as long as the part running the above code is on the SharePoint server machine.

So we now have a way to store data and manipulate it according to our needs. We can control it, we can validate it and most important of all, we decide how the user interacts with the data.

We’re now ready to start doing some serious SharePoint development!

Bridge SharePoint - User Profiles and User Profile Properties (part 1 of 2)

2008-09-10T11:51:00.000-04:00

There is a constant need in SharePoint feature development to bridge SharePoint 2007 with other web applications. In order to create such a bridge, a variety of user information must be stored in the SharePoint database.

Warning: Do not tamper with the SharePoint database! No matter how tempting it is!

Although this might sound as simple as a small SQL application, tampering with SharePoint’s database could lead to disastrous results and even complete and irreversible server crashes, since many of SharePoint’s recovery features rely on the database being intact. “Feeding” information to SharePoint through its database is unadvisable and sometimes very hard to do, mainly due to the complex structure of the database.

Fortunately there is a built-in solution to this problem that is both simple and efficient: User Profiles and User Profile Properties.

In this post we will see how SharePoint’s user profiles and profile properties can help us do our job fast and easy without worrying about crashing the server or breaking more features than we create.

Let’s start with the storing information problem.
Many developers have already considered using Profile Properties as way to store the required data, but have given up on using them due to their limitations (limited validation, control, variety). Controlling the user’s input and making sure that the values are correct is essential in any bridge, and often auto-generated values based on that data are necessary. SharePoint can only do so much, and this is usually the main reason why developers avoid using the custom profile properties.

Solution: Manage information using the Microsoft.Office.Server.UserProfiles namespaces.

SharePoint Server 2007 stores user profiles in SQL Server, but the information can be imported from other data sources, such as:
· Active Directory
· Lightweight Directory Access Protocol directories (which is not Active Directory)
· Databases
· Enterprise applications (such as SAP or PeopleSoft) by defining a Business Data Catalog connection
· Web applications
· Custom SharePoint web services
· Standard .NET applications, etc.
The main classes are found in the Microsoft.Office.Server.UserProfiles namespaces. The assembly is Microsoft.Office.Server.dll found in C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI.
The main objects to handle information within the User Profile store are:
UserProfile
Allows you to access profile properties, the My Site, personalization links, and so on.

UserProfileManager
Gives access to a collection of UserProfile objects and allows you to create, edit, and retrieve user profile objects and properties from the user profile store.

UserProfileConfigManager
Manages the user profile configuration.

Note: In order to manage data in a custom user profile property, the property must be first created. You can use the following steps to create a profile property:

1. Start > Administrative Tools > SharePoint 3.0 Central Administrator
2. In the left panel, under Shared Services Administration, click SharedServices1
3. Click User Profiles and Properties
4. Under User Profile Properties, click Add Profile Property
5. Fill in the required data and click OK

Now that we know that SharePoint accepts data from external sources and that it stores individual user values in user profile properties, it’s time to put the two together and find out how to store user data in profile properties from external data sources. This is the topic for part two of this post: Getting/Storing user data from external sources.

SharePoint says "Unknown Error"

2008-09-04T15:50:00.002-04:00

ERROR: Only Content controls are allowed directly in a content page that contains Content controls.

By default, SharePoint doesn't seem willing to share some of its internal errors with developers opting instead to use a generic "Unknown Error" page. The informative (and I use the term loosely) error string above wasn't displayed in the browser until the file C:\Inetpub\wwwroot\wss\VirtualDirectories\80\web.config was modified to disable custom error messages.

By changing <SafeMode CallStack="false" ...> to <SafeMode CallStack="true" ...> and changing <customErrors mode="On" /> to <customErrors mode="Off" />, the generic error page is replaced with a more detailed error message and maybe even a callstack.

As for the error above? It was caused by a comment that had been added to an .aspx file. For some reasons, comments were not allowed because they didn't qualify as "content controls".

Performance reality check for web developers

2008-08-03T19:33:00.000-04:00

When I work on a web application, I usually have the luxury of running everything that I need locally on my developer machine. My browser, Web-server and database all working together without ever having to put a single packet on a real network.

With today's web applications growing more complex and making use of asynchronous calls to the web server, this idealistic development environment makes it very difficult for the developer to assess the performance characteristics of the application. This can lead to surprises when the application is deployed to a real environment where users actually access it from remote locations.

A good way to bring reality back to this equation is to make use of a proxy server. I like to use Don's Proxy. It is simple Java-based application that takes 1 minute to setup and lets you inject latency, errors and throttle your connection bandwidth. All of this is made in a manner that is independent of your browser or your web server. Most importantly. it does not require any changes to your application's code or setup.

To use Don's Proxy, simply download the package, unzip and double-click the jar file. A simple GUI will open (screenshot) that will prompt you for a port for the proxy to listen to and a host/port for the destination of your test web server. In the example screenshot, the test web server is running locally at port 8080 and the proxy is setup to listen on port 9090.

Once the proxy is started, you just redirect your browser to the proxy's port and everything should work as before. The difference is that now, you can inject realistic network parameters like latency and bandwidth limitations. Don's Proxy also allows you to capture traffic as it goes through and perform other diagnostics without the use of a packet-sniffer.

Hopefully, a more common use of tools like this will help curb developer enthusiasm for flashy Ajax behavior. Your users will thank you.

Snake On A Phone

2008-07-30T16:30:00.005-04:00

For a few years now, my main task at work has been working on the firmware of an IP phone. The phone runs VxWorks on a MIPS32 CPU; the firmware is written in C and C++.

For slightly less time, I've been dabbling in python on my own time. Freedom from explicit typing was a refreshing change, and python's tendency to Just Work was a nice bonus.

It was perhaps inevitable that I would one day try to combine phone and language. (why? because they were both there)

It wasn't obvious that the idea stood a chance. VxWorks is a bit off the OS beaten track, and might not provide all the functionality needed by Python's "core" (not with the same names, anyway). There might be some processor-specific pieces that would rule out MIPS32. And even if I could get something built, would it fit in the 2 or 3 MB of RAM (and even less flash) I could spare?

As it turns out, there was very little to worry about. Python's code is impressively (if perhaps unsurprisingly) portable, only needing a couple of tweaks to its build system and none at all to its source code. There doesn't seem to be anything CPU-dependant; and in the end, adding python to my firmware only cost me 1MB. It took me only a few evenings of tinkering to get a libpython built, linked into my firmware, and loaded on my phone, to the point that I could run this little experiment at the VxWorks shell:


  -> Py_Initialize()
  value = 42 = 0x2a = '*'
  -> PyRun_SimpleString("print 'Hello, World!'\n")
  Hello, World!
  value = 0 = 0x0

(the VxWorks shell being a peculiar animal that allows calling C functions by name, in this case giving me access to Python's C Extension API for a near-REPL experience)

For my purposes, that's enough; I know it can work, and that's all I wanted. I don't expect to ever go further than this. But as little as it is, publishing how I got there might help someone get started on a real project; so here goes:

Porting python in 10 easy* steps

*for a suitable definition of easy

As far as embedding Python in an existing application (or firmware) is concerned, Python's own documentation should give you most of what you need

You'll need a cross-compiling toolchain, i.e. a compiler that can be used on one platform (e.g. x86) and produces executables for use on a different platform (e.g. MIPS32). GCC is your best bet; it's what will make python's build system happiest, and there's lots of resources on getting a GCC cross-compiler working on the web, though it looks a bit daunting to me. I was fortunate in that, since I was already set up to build firmwares, I already had all the needed tools; I would guess that most people engaging on a similar project would be in the same position.

In addition to the compiler (and assembler, linker, etc), you'll want to have a Unix-like environment to run Python's configure script and makefiles. If you're on Windows, cygwin will serve nicely.

The 'configure' script needs some tweaking: it contains a few uses of AC_TRY_RUN, which will fail when cross-compiling.
- If you have a working 'autoconf', the simplest is to edit the 'configure.in' file. You can either remove the AC_TRY_RUN tests altogether or replace them by the newer, more cross-compiler-friendly AC_RUN_IFELSE. Then run 'autoconf' to regenerate the 'configure' script.
- If you don't (as I didn't), you can brace yourself and go edit the 'configure' script directly. Running the script produces error messages that gives something to search for. The fix is actually simple: just remove the calls to 'exit' to allow the error to get ignored.

The makefile also needs tweaking: just like 'configure', at some point it tries to compile and run a program. This appears to be in order to autogenerate some source files, which fortunately are already provided in the source distribution; so it's safe to disable this step. The simplest way:
- open "Makefile.pre.in"
- find the place where "$(PGEN)" shows up AFTER a ':'
- remove "$(PGEN)"
(this will only prevent the executable from getting built. The makefile will still attempt to run it, but it's written so that the resulting failure is ignored)

The configure script and makefile try to guess at the name of tools to use; you can give them a hint with environment variables. In my case I needed to set CC (the C Compiler) and AR (the "archiver", ie. what creates static libraries)

If you need to specify special command-line options to the compiler, environment variables can also be used. Annoyingly, 'configure' and the makefiles use different variable; you'll want to set CFLAGS and BASECFLAGS to the same thing.

Finally you'll be ready to run the 'configure' script. You need to give it the special options --build and --host to tell it you're cross-compiling, something like:
```
$ ./configure --build=win32 --host=vxworks
```
(win32 and vxworks were a wild guess that happened to work for me. I got the impression the specific values didn't particularly matter)

You can then run 'make' to compile everything. If, like me, all you need is a static library, this will do it:
```
$ make libpython2.5.a
```

There's a good chance some files under Modules/ will fail to compile (in my case, posixmodule.c). The file Module/Setup specifies (in a rather well-documented way) which Python modules (written in C) should be built into the python library; comment out the failing one, and re-run 'make'. I only had to disable posixmodule and pwdmodule; YMMV.

And for me, that was it; nothing else needed manual intervention. If you run into more troubles (e.g. trying to build the actual python.exe), I'm afraid you're on your own.

My next step was to figure out how to integrate the python library into my firmware; you'll have to figure out the corresponding steps for your own firmware/embedded application/whatever. Start with the 'embedding' link for how to access python code from your code.

If you want to be able to load python source files with 'import', pay particular attention to what that page says about PYTHONHOME; as for me, I put a putenv(PYHONHOME=/whatever") before the Py_Initialize call, letting me import /whatever/python2.5/*.py files (and possibly, though I haven't tried, .py files contained in a /whatever/python2.5/libpython2.5.zip)

Happy cross-compiling!

Outlook Entry IDs Made Easy

2008-07-24T07:00:00.001-04:00

When developing for Outlook you will quickly realize that there's more than one way of doing things. For example, take a look at the number of APIs for interacting with Outlook:

Outlook Object Model (OOM)
MAPI
CDO
Office/Outlook COM Add-in (_IDTExtensibility2)
Exchange Client Extensions

That doesn't even include the six libraries included in the Outlook 2003 Integration API or the excellent 3rd-party Redemption library. I'm positive there are others. Usually you won't use all these APIs in the same project. However, if you want to do anything significant in Outlook, you'll need to use the OOM and MAPI libraries.

It's important to understand the relationship between MAPI and the OOM:

The MAPI API dates back to the early Outlook days. It's used for the messaging and storage subsystems in Outlook.
The Outlook Object Model sits on top of MAPI and wraps a minimal amount of its functionality. It also exposes some of the Outlook UI to the developer.

When you work with these APIs, you'll hit on the problem of linking them together. Outlook Entry IDs are a good example. Entry IDs uniquely identify most objects in the OOM and MAPI. Being very flexible, Entry IDs can take many shape or form and can cause headaches when you try to handle them.

At its simplest, an Entry ID is a variable length byte buffer, sometimes represented with a simple byte array. In MAPI, most Entry IDs are represented by the ENTRYID structure:

mapidefs.h

typedef struct { 
    BYTE abFlags[4]; 
    BYTE ab[MAPI_DIM]; 
} ENTRYID, FAR *LPENTRYID;

This structure usually comes wrapped in the SBinary structure.

mapidefs.h

typedef struct _SBinary { 
    ULONG cb; 
    LPBYTE lpb; 
} SBinary, FAR *LPSBinary;

In the Outlook Object Model things take a turn for the worst:

Most times you see Entry IDs as a BSTR that is hex encoded (i.e. the strings look like this: "000F1329EC29A0382BC...").
Sometimes it still uses a BSTR, but it doesn't encode the buffer, instead using the BSTR as a binary blob. Although inconsistent, this is perfectly valid.
Sometimes it's useful to represent the Entry ID as a SAFEARRAY of VARIANT VT_UI1 (this is the format VB uses for its byte arrays). For example, I've needed to have a function that can return a property any type from a MAPI object that needs to be called through automation (i.e. VB). For example, the IMAPIUtils::HrGetOneProp method from the Redemption Library does this.

Is your head spinning? Mine was.

I solved the problem by creating a class (yet another format!) to facilitate manipulation of all these formats:

class EntryId
{
public:
    EntryId(EntryId const& entryId);

    // All explicit so that it's always clear what we are doing.
    explicit EntryId(BSTR const* str, bool hexEncoded = true);
    explicit EntryId(SBinary const* binary);
    explicit EntryId(SAFEARRAY const* array);
    explicit EntryId(unsigned long count, unsigned char const* bytes);

    // Again, no implicit conversion
    CComBSTR toString(bool hexEncoded = true) const;
    CComSafeArray toSafeArray() const;
    std::vector toByteArray() const;
    // ... add more as you need them

    // TODO: Add more custom helper functions.
    bool isLongTermId() const;

    // TODO: Add comparison operators for convenience and ordered 
    // container support (such as std::map keys). When comparing 
    // Entry Ids, remember you need to use the 
    // IMAPISupport::CompareEntryIDs method.
    
private:
    std::vector<unsigned char> m_buffer;
}

Now whenever I get an Entry ID in any format, the first thing I do is convert it to an EntryId instance. This adds many convenient functionalities:

Standardized interface to all ids.
Easy comparison of entry ids.
EntryId is a copyable class and can be passed by value.
EntryId can be held in a STL container.
Your other helper classes and methods can use the EntryId as parameter instead of other formats.

Software Testers - Don't Underestimate Their Worth for Success

2008-07-23T12:14:00.003-04:00

Sometimes, testing your application isn’t enough: sometimes your test cases need to be tested! Testing doesn’t always give you what you’d expect. In extreme cases, it can even give you a false sense of confidence in a product that is a complete failure.

Recently, I was managing an offshore team developing a component for our client's core enterprise application. We wrote extensive test cases and, because we were concerned about a lack of domain knowledge, we even had architects write some of the test cases. Things were looking good as we approached the end of the development cycle: the product was behaving as it was supposed to; we were passing test cases; we were greenlighted by the QC ‘process’.

Our confidence was high, and we were ready to move on to automated testing. Then we found the problem. It turns out that our test cases were written with a single user in mind. The minute we started to use this component with concurrent user access, the system would pretty much lock up. Our confidence evaporated.

This was a big mistake. Architects and technical leads both reviewed the test cases. Nobody found the oversight at the time. This was compounded by an ‘if it passes the test cases then it works’ mentality.

Unfortunately, a solution to this problem isn’t as easy as ‘follow these three steps’. But if we can take away a lesson learned from this, it is that testing the right way is not only very important to the success of a product, but it also shouldn’t be taken for granted. If you haven’t noticed, QC/QA and testers were not included in the writing of test cases, thus bypassing all kinds of valuable experience that would most likely caught our newbie mistakes.

Bottom line - Don’t underestimate the worth of your testers and their experience, it might just come back to bite you in the future.

Maintenance Nightmares: Commented out code

2008-07-17T23:50:00.000-04:00

I was working on an estimate for a prospective customer, and luckily I had the code to examine beforehand to see what it was doing.

While examining the code, I noticed code like this:

// Fix for bug 1021892
// some code that was commented out.

There were instances of this throughout the code.

When I see this I instinctively cringe, I immediately think that there is no proper source control or defect tracking procedures (or tools) in place. While there may be the odd corner case where commented out code is acceptable, in general it is not and should be avoided.

There are many better ways of dealing with this, the first way is to just delete the line of code, and when you commit/check-in the code, make sure you put a meaningful comment in the commit logs that ties it to the defect it was changed for. You can often search the commit logs, and if you put the bug id in the commit log, you will get the change in your search.

Another easy way to do this is to delete the line of code, make a patch, and when resolving the bug in your bug tracking software, attach the patch file to that issue. Then you can always see what you changed to fix the bug.

Does anyone else having any suggestions for this?

Alignment Matters

2008-07-11T14:25:00.009-04:00

When do these two snippets behave differently?


void* p = something();
int i = *(int*)p;


int i;
void* p = something();
memcpy(&i, p, sizeof(int));

Answer: when 'something' returns a value that's not a multiple of "sizeof(int)".

Some processor architectures only allow loading memory into N-byte registers from memory addresses that are a multiple of N (e.g. multiple of 4 for 32-bit registers). Using misaligned addresses can have some various interesting consequences, depending on the CPU; I've heard of at least these:

It works fine
It works, but slowly (e.g. because the misalignment is detected and alternate instructions are used to load 1 byte at a time - I've heard that x86 works this way)
The program may crash due on an "invalid address" trap
The CPU may load data from the wrong address (e.g. if only multiples of 4 are valid addresses, the instruction might ignore the bottom 2 bits of the address)

Last week, I got lucky: I discovered that the MIPS32 CPU on the phone I was programming falls in the "crash" category. (why lucky? because an "address load exception" message is much easier to debug than some corrupted data)

Usually, we don't have to worry about such alignment issues; the compiler and runtime make sure that all objects it allocates go at addresses that have the right alignment for their type (e.g. malloc must return memory "suitably aligned" for all possible types).

Trouble comes when we lie to the compiler, such as telling it by a cast that "p" points to an "int" when such is not the case. This is what happened to me: I was parsing a file, and the 4-byte-value-that-should-be-put-in-an-int followed an arbitrary-length string. It ended up on an odd address, and boom. (Here's another way I was lucky: it COULD have been a nice multiple of 4 in all my tests, only to come out odd on a client's desk)

Functions like memcpy, of course, are required to work with all addresses (as expressed by taking void* parameters, which require no cast).

Lesson of the day? Don't lie to your compiler!
(alternate lesson: "casts: evil AND chaotic"?)

Compile Time Semantic Checking

2008-07-10T14:43:00.003-04:00

C# is a TypeSafe language, what about SemanticSafe?

In a project I'm working on we have a lot of database records ids being passed around as integers. Today I needed to add a new record id to this list. Adding the new item to the function signature is easy. The hard part comes in making sure the right value is being assigned.

Public void MyFunction(int TableA_ID, int TableB_ID, String someOtherValue);

int A_ID = 5;
int B_ID = 4;
MyFunction(B_ID, A_ID, "Hello World");

So what happens when I compile? Nothing, it works fine. Yet that line where I called the function has just corrupted the entire database because those database ID's were transposed. Which kinda sucks.

It's one thing to guarantee type safety, what what about semantic safety? An idea popped into my head to use the existing type-checking to accomplish this.

    public struct UserID
 {
     private int value;
     public static implicit operator int(UserID source)
     { return source.value; }

     public UserID(int intValue)
     {
         value = intValue;
     }
  }

 private void TryToFail(UserID test) { } 

 UserId works = new UserId(5);
 int fails = works;

 TryToFail(works) //compiles fine
 TryToFail(fails) //Doesn't compile

Even though both works and fails contain the exact same value, the function can be made to fail if the values are put in the wrong order. I used an implicit operator so that I didn't lose the convince of having a simple integer, neato.

Obviously this technique is not something you would want to use for every possible field as there is one extra step involved in getting the value. But if you only did this for the record IDs I think it would be enough gain to make it worthwhile.

I would like to think of a way to do this so that it has compile time checking, but once compiled only contains the primitive value. Any ideas?

Trouble Getting Your Custom Protector Called?

2008-07-09T11:31:00.009-04:00

You might be getting a lot of grey hair by developing your own custom protector for SharePoint. Until recently, I was right there with you. Having troubles getting your custom protector to be called by SharePoint? I'm here to help. I'm happy to tell you that it could be a simple fix. A simple flag as a matter of fact. If you haven't heard of the IrmAddInsEnabled flag, then this is what you must do.

You need to set the IrmAddInsEnabled flag to true in the Central Admin page to get SharePoint to call any of the protector function calls (HrIsProtected, HrProtect, HrUnprotect). This sets a Boolean value that specifies whether to enable Information Rights Management (IRM) addins.

You can do this directly on the MOSS server from the 12 Hive (C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\12\BIN) by calling the following:

On the MOSS server:


'stsadm -o setproperty -propertyname irmaddinsenabled -propertyvalue "yes"'

Alternatively, you can do this programmatically by using SharePoint via the IRM Settings by using SPIrmSettings.IrmAddins. This can be done at the farm level or as granular as a per-list basis.

IRM Settings for the FARM:


SPWebService svc = SPFarm.Local.Services.GetValue();
SPIrmSettings irmSettings = svc.IrmSettings;

//Specifies whether to enable Information Rights Management (IRM)
//locally for sites
irmSettings.IrmRMSEnabled = true; 

//Specifies whether to enable Information Rights Management (IRM)
//addins
irmSettings.IrmAddinsEnabled = true;

//Sets the number of times the Information Rights Management (IRM)
//settings have been changed
irmSettings.IrmChanges += 2; 

svc.Update();

IRM Settings for the Individual Lists on FeatureActivated:


SPWeb web = (SPWeb)properties.Feature.Parent; 
foreach (SPList list in web.Lists)
{
  // Specifies whether to enable Information Rights Management (IRM)
  // for the list
  list.IrmEnabled = true;

  // Specifies whether to allow users to upload documents that do
  // not support IRM 
  list.IrmReject = true;
 
  list.Update();
}

After you have done this, your custom protector should be called when the documents are checked in and out of your SharePoint system via the HrIsProtected, HrProtect, HrUnprotect methods.

Goodluck!

Mining Project Scope with Python + SVN

2008-07-07T11:38:00.009-04:00

After developing a component for a fairly large enterprise application, I was tasked with coordinating a complete review of all code touched by our team. As the project involved hundreds of commits across every tier of the application, this was not a trivial task. I didn’t want to make developers hunt through SVN logs and JIRA - even if the result was accurate, producing meta-documentation in the time allotted for actual documentation seemed wasteful. There had to be a way to automate it. After failing to find an appropriate SVN tool via Google, I weighed the pros and cons [1] then decided that using an SVN API would be easy enough.

~~To make it interesting~~ As part of my commitment to Macadamian’s core value of continual improvement, I decided to try out Python. The following script was maybe an hour of entertaining work that saved at least a day of tedium.


import pysvn

# Script variables.  Could be read from a command line or config. file.
username = "jlennon"
password = "yoko"
projectFirstRevision = 103991
svnRoot = "http://path/to/svn/trunk/"

# Team members’ names for SVN commits.
users = set([
          "gharrison",
          "rstarkey",
          "jlennon",
          "pmccartney",
          "gmartin",
          "pbest"
          ])


# Set up SVN callbacks.
def get_login(realm, username, may_save):
   return True, username, password, False;

def get_log_message() :
   return True, "log message called"

client = pysvn.Client()
client.callback_get_login = get_login
client.callback_get_log_message = get_log_message


# Convert the revision number into a pysvn revision.
projectFirstRevision = pysvn.Revision(pysvn.opt_revision_kind.number, projectFirstRevision)

# Get all commits since the project's first commit.
items = client.log(
           svnRoot,
           pysvn.Revision(pysvn.opt_revision_kind.head),
           projectFirstRevision,
           discover_changed_paths=True,
           )

# Set up variables for storing commit information
allPaths = set([])
removedPaths = set([])

# For each commit entry *made by one of this project's users*
#   Add any deleted files in the commit to removedPaths
#   Add any added/updated files to the list of all paths
for item in [ e for e in items if e.author in users ]:

   for changed_path in item.changed_paths:

      if changed_path.action == "D":
         removedPaths.add(changed_path.path)
      else:
         allPaths.add(changed_path.path)

# Remove deleted files from allPaths, then display
allPaths = allPaths - removedPaths

for path in sorted(allPaths):
   print path

Overall, I was impressed by Python. My biggest problem was with the structure of the documentation, but that’s to be expected with any new language. My biggest surprise was that the indentation rules didn’t bother me – why is this cited as a show-stopper by so many developers? I’ll definitely be coming back to Python to test its OO facilities.

[1] The main con being that a developer would much rather write a neat SVN spider than write documentation. In a leadership role, you have to think twice before eagerly firing up your compiler to solve a problem.

Getting RIL!!

2008-07-02T11:25:00.000-04:00

Have you ever wanted to mess around with calling functionality of a mobile phone running Windows Mobile?

I have this nifty phone but how do I control it programmatically?

Well, first of all, the Windows Mobile Radio Interface Layer works by having specific modules control the cellular component. Since we are in North America there are two different cellular protocol implementations: GSM and CDMA. Above this layer is an abstraction layer that hides the implementation of the underlying protocol so that applications/OEM phone developers can use the functionality of call handling (and other useful information) without getting down to how things work under the hood. So how do we, as an application, talk to this abstraction layer, which we'll just clump together and call it the RIL( Radio Interface Layer )? Good Question!

Since cellular devices are really just modems that use AT commands, the RIL operates mainly from an asynchronous callback system. In fact most of the RIL functions really just map to AT commands. The application accessing the RIL makes a request to the RIL, and the RIL takes some time to process this request and sends back a result code indicating the success or failure of the request. In addition the RIL spits out notifications which our application can hook into and be informed of status changes related to the cellular network. So let's dig a little with some RIL examples.

There are a few pitfalls by going down this path. Firstly you might run into situations where you're fighting for control with the resident dialer (the default phone application supplied to the mobile device; developed by Microsoft). There may also be some undocumented internal states that need to be obeyed or else it can lead to unintended behavior (i.e. device lock up).

There are also some differences to note between CDMA and GSM RIL implementations. With GSM devices there can be multiple lines, and as such the RIL can fetch call information for each line. RIL can also manage the GSM lines to perform actions such as putting the call on hold or switching lines. In the CDMA environment, there is only one "real" line and one "virtual" line. That is, one line is used to represent two lines. Access between the two lines is achieved by sending a "flash" command. Call management is also not possible with CDMA. So when you call "RIL_GetCallList" for GSM, for example, you may be returned information for one or more lines depending on the call state. For CDMA, you will only see at most one line.

You will have to get your hands on the ril.h and ril.lib files. Both of these files are floating around somewhere on the internet (try here). If you can get both of these files, link your application with ril.lib and away you go. If you can’t find ril.lib but have ril.h, you can dynamically link with the ril.dll file (contained in the “windows” folder on the device) since you know what some of the prototypes are.

First we need to initialize our application with the RIL so that we can receive both results and notifications callbacks. Here’s some code to do this:


...

// keep this handle handy as we need it for further RIL commands
HRIL rilHandle;

...

HRESULT hr = RIL_Initialize(
   1,                  // index of the RIL port to use (e.g., 1 for RIL1:)
   &resultCallBack,    // this is a pointer to your result call back method
   &notifyCallback,    // this is a pointer to your notify call back method
   RIL_NCLASS_ALL,     // all notification (except device specific)
   (DWORD) this,       // custom param (could be a pointer to an instance of a class)
   &rilHandle);        // returned handle to RIL instance


...

void CALLBACK resultCallback(
   DWORD dwCode,
   HRESULT hrCmdID,
   const void *lpData,
   DWORD cbData,
   DWORD dwParam)

{
   // handle the results

...

void CALLBACK notifyCallback(
   DWORD dwCode,
   const void *lpData,
   DWORD cbData,
   DWORD dwParam)
{
   // handle the notification

...

Note that we’ve initialize the RIL with a reference to our class as the user parameter which is passed to the result and notification callbacks. The parameter is optional; however having the class reference would be especially useful if you would like to perform further actions after receiving a result or notification. More on this later.

OK so what - I've just initialized myself with RIL - what can I do now?
To answer that question, anything under the Sun related to call handling, and then some!!

For example if you wish to check the call status of the phone you can do the following. First send a request for call list:


HRESULT cmdID;

...

void getCallList()
{
   // call RIL_GetCallList with RIL handle from the initialization
   cmdID = RIL_GetCallList(rilHandle);
}

Next we have to wait for the results:


...

void CALLBACK resultCallback(
   DWORD dwCode,
   HRESULT hrCmdID,
   const void *lpData,
   DWORD cbData,
   DWORD dwParam)
{
   If (cmdID == hrCmdID && RIL_RESULT_OK == (dwCode & 0xff))
   {
       // lpData points to an array of  structures.
       RILCALLINFO *lpCallInfo = (RILCALLINFO *)lpData;
       // extract the call info from the structure and do something...
...

Notice how the cmdID return value of RIL_GetCallList matches hrCmdID in the callback. In a realistic scenario, multiple commands are sent and the results do not necessary return in the same order the commands were sent. As a result we would need to queue up the command IDs in order to properly identify the command represented by each callback

Now what is notifiyCallback useful for? This function is called basically whenever an event occurs that is of a notification class that was registered during initialization (we registered with RIL_NCLASS_ALL in this case). For example, for an incoming call you would receive and handle the “ring” notification as follows:


void CALLBACK notifyCallback(
   DWORD dwCode,
   const void *lpData,
   DWORD cbData,
   DWORD dwParam)
{
   if(dwCode & RIL_NCLASS_CALLCTRL)
   {
       switch(dwCode & (0xff | RIL_NCLASS_CALLCTRL))
       {
       case RIL_NOTIFY_RING:
           // do something here
...

Since the phone is ringing, it is probably best to get more information about the incoming call. If you remember from initialization we use the class reference as the custom parameter. This gives us the flexibility to send further RIL commands by either passing in the RIL handle (HRIL) or point to a function in the class. In this case we can point back to the getCallList function created earlier.


MyClass* myClass = (MyClass*)dwParam;
myClass->getCallList();

If we don’t have a function to point to, we can always send an RIL command on the fly by passing in the RIL handle from our class. For example to answer the call right away:


MyClass* myClass = (MyClass*)dwParam;
HRESULT hr = RIL_Answer(myClass->rilHandle);

As a note, if we're not using the interface anymore we'll need to de-register ourselves:


RIL_Deinitialize(rilHandle);

To learn more about RIL and all its wonders, you should closely examine the ril.h header. There is some information on the msdn site as well. The best way to learn about it, of course, is to just try it out yourself.

(Originally written and concept by Quan Nguyen; modified and edited by Henry Yi)

Pure CSS Image Rollover without background-image

2008-06-27T18:52:00.004-04:00

The other day I was in a situation where I had an image that changed to another image when the user mouses over it. Usually I will do this in one of two very standard ways:

The typical javascript approach: using the onMouseOver and onMouseOut events to swap the images.
The typical css approach: an element that sets its background-image attribute to the default image, and changes its background-image attribute to the rollover image when the :hover pseudoclass is activated.

Unfortunately, neither of these solutions were optimal as I was looking for a pure-CSS solution (so no javascript) and needed the image to have its own <img> tag (so no background-image). After playing around with my selectors a little, I came up with this little gem:

The HTML:

<div class="buttonContainer">
 <img class="rest" src="link_rest.png" />
 <img class="roll" src="link_roll.png" />
</div>

The CSS:

div.buttonContainer img.roll {
 display: none;
}
div.buttonContainer:hover img.roll {
 display: inline;
}
div.buttonContainer:hover img.rest {
 display: none;
}

This neat CSS trick leaves the images in the html and changes the image on rollover with minimal mark-up. It works by abstracting the :hover pseudoClass to the container, loading both images into the page, and controlling the rollover effect using the images' display attribute.

One word of caution: some older browsers (I'm looking at you, IE6) have poor support for the :hover pseudoclass, which renders this example ineffective; thus if you're supporting a lot of legacy browsers, this may not be for you. However, if you need a rollover that uses actual image tags and want to avoid using javascript, this may be just what you need.

Obtaining the voicemail number on Windows Mobile phones

2008-06-17T17:19:00.021-04:00

The voicemail number, if available, may be stored in various locations on the Windows Mobile phone device depending on the type and carrier. In most cases, the number will show up somewhere in the registry. From experience I have found them in one of several locations under HKEY_CURRENT_USER:

\Software\Microsoft\Vmail\PhoneNumber1
\Software\Microsoft\Vmail\PhoneNumber2
\Software\Microsoft\Vmail\UserProvidedNumber1
\Software\Microsoft\Vmail\CarrierProviderNumber1
\System\State\Messages\vmail\VMailNumber
\Palm\State\Messages\vmail\VMailNumber

On some GSM devices however the number isn’t always updated properly in the registry. In that case you would have to fetch it direct from the SIM card. In fact it is probably safest to fetch it from the SIM card first since this ensures a more accurate number.

If you do some internet searches and dig through some of the 3GPP specifications for (U)SIM (i.e. 3GPP TS 31.102, 51.011) you will find that the voicemail number is stored in the EF_MBDN (Mailbox Dialing Numbers) file located at either 6FC7 for 3G devices or 6F17 for 2G.

We can get the voicemail file from the SIM using the SIM Manager API. Note that some of these are privileged functions. You also have to make sure to add “cellcore.lib” as a dependency to your project. The code would look as follows:


// include the SIM Manager API
#include 

// set the voicemail addresses
#define EF_MBDN_2G 0x6F17
#define EF_MBDN_3G 0x6FC7


std::string getVoicemailNumber()
{

std::string number;
HSIM hSim = 0;
HRESULT hr = S_OK;

// initialize
hr = SimInitialize (0, 0, 0, (LPHSIM)&hSim);

if (S_OK == hr)
{
    DWORD address = EF_MBDN_2G;
    SIMRECORDINFO simRecordInfo = {0};
    simRecordInfo.cbSize = sizeof(SIMRECORDINFO);

    // check the 2G address for the file
    hr = SimGetRecordInfo(hSim, address, &simRecordInfo);

    // The file may hold more than one number for devices with
    // multiple lines; however we will assume only one line.
    // A valid file needs to be "linear" type and at least 14 bytes.
    if ( S_OK != hr ||
         SIM_RECORDTYPE_LINEAR != simRecordInfo.dwRecordType ||
         simRecordInfo.dwItemCount == 0 ||
         simRecordInfo.dwSize < 14 )
    {
        // no valid 2G file, check the 3G address
        address = EF_MBDN_3G;
        memset(&simRecordInfo, 0, sizeof(simRecordInfo));
        simRecordInfo.cbSize = sizeof(SIMRECORDINFO);
        hr = SimGetRecordInfo(hSim, address, &simRecordInfo);
    }

    if ( S_OK == hr &&
         SIM_RECORDTYPE_LINEAR == simRecordInfo.dwRecordType &&
         simRecordInfo.dwItemCount > 0 &&
         simRecordInfo.dwSize >= 14)
    {
        // allocate the specified size
        LPBYTE buf = (LPBYTE)LocalAlloc(LPTR, simRecordInfo.dwSize);
        DWORD bytesRead = 0;
        
        // read the SIM file
        hr = SimReadRecord(hSim, address, SIM_RECORDTYPE_LINEAR, 1,
                buf, simRecordInfo.dwSize, &bytesRead);

        if (S_OK ==  hr && bytesRead >= 14)
        {
            // handle the bytes received
...

Now that we have the file, we need to interpret the bytes into a useful number. The 3GPP specifications show the EF_MBDN structure as follows:


Bytes        Description                                 M/O  Length
----------------------------------------------------------------------
1 to X       Alpha Identifier                             O   X bytes
X+1          Length of BCD number/SSC contents            M   1 byte
X+2          TON and NPI                                  M   1 byte
X+3 to X+12  Dialling Number/SSC contents                 M   10 bytes
X+13         Capability/Configuration2 Record Identifier  M   1 byte
X+14         Extension 6 Record Identifier                M   1 byte

The first few bytes (1 to X) are the optional identifier. In most cases it will just show the words “voicemail”. The last 14 bytes describe the voicemail number with up to 10 bytes representing the number as binary coded decimals. For our purpose we can ignore Capability/Configuration2 Record Identifier and Extension 6 Record Identifier. The way to interpret the bytes is described in the 3GPP specifications 31.102 clause 4.4.2.3 for EF_ADN (Abbreviated dialing numbers). We can proceed to get the number from the bytes as follows:


...

        // use the last 14 bytes
        char data[14];
        memcpy(&data, &buf[bytesRead-14], 14);

        // byte 0 (X+1) is the length of dialing number
        int length = data[0];

        std::stringstream ss;

        // TON and NPI determines the type of number
        // see 3GPP specifications 31.102 clause 4.4.2.3
        if (0x90 == (0xF0 & data[1]))
        {
            // add the + for international numbers
            ss << '+';
        }

        // convert the BCD bytes to Ascii chars
        for (int idx=2; idx < length+1; idx++)
        {
            // break the byte into 2 nibbles
            BYTE nibble[2];
            nibble[0] = data[idx] & 0xF;
            nibble[1] = (data[idx] >> 4) & 0xF;

            for (int i=0; i<2; i++)
            {
                if (nibble[i] == 0xA)
                {
                    // 0xA represents a *
                    ss << '*';
                }
                else if (nibble[i] == 0xB)
                {
                    // 0xB represents a #
                    ss << '#';
                }
                else if (nibble[i] < 0xA)
                {
                    // add the number
                    ss << (char) ('0' + nibble[i]);
                }
            }
        }

        // set the voicemail number
        ss >> number;

Now that we have the voicemail number we should free the buffer and sim handle and return the number:


        // free the buffer
        LocalFree( buf );
    }

    // deinitialize
    SimDeinitialize( hSim );
}
return number;

}

There are a couple of things to note. Here I’ve handled both the 2G and 3G cases, however it is probably better to detect which type is being used beforehand. Also note that I have assumed the case of only one voicemail number. For a multi-line scenario you would have to check if there are more than one number stored in the SIM file. For a more detailed look on how the numbers are stored please refer to the 3GPP specifications.

Detecting the phone buttons on WM5/6

2008-06-09T13:15:00.015-04:00

When working on a project that involved creating a custom dialer for Windows Mobile devices, one of the more important tasks is enabling the detection of the Send (green, off-hook) and Hang-up (red, on-hook) button presses at all times. The difficulty with this feat is that the Windows Mobile OS has specific needs for these buttons so you have to be careful with how you go about using them.

For example the Send button is used for launching the phone application (cprog.exe by default), and also perform phone related tasks like making and answering calls or calling a contact. The Hang-up button is used to minimize dialogs and hang up active calls.

On some devices the Hang-up button can have other behaviors such as acting as a power button or enabling keyboard lock. It’s important to know these facts, because depending on what you intend to do with the Send or Hang-up buttons, you may cause existing features of the OS to not function.

There are several methods to detect the Send and Hang-up buttons, but only a few methods will let you safely co-exist with the existing features of the Windows Mobile OS. I’ll first talk about obtaining the key presses through use of keyboard hook (SetWindowsHook) and why you shouldn’t use it. This is the first method I used for the project but quickly learned about the various limitations. If you do an Internet search for “Windows Mobile SetWindowsHook” you will obtain several pages explaining how to use SetWindowsHook on the device to detect each key press. Using this method to detect the Send or Hang-up keys you may discover several set backs.

You are not just intercepting the Send or Hang-up keys but every key press so you’ll have to be extra careful about handling them.
If an existing application already has the keyboard hook, you may not be able to use it. On a device like the Palm Treo 700/750 you may find that the Key-guard feature no longer works. This is because the Palm Key-guard also relies on the keyboard hook and can no longer use it if another application has control of it.
You may find that certain features that rely on Send/Hang-up no long work. For example you can no longer dial a number from Contacts with the Send button.

There are ways around these limitations of course, but it would require a lot of manual handling from your application.

Another method of key detection is the use of hotkey registration. Microsoft provides us with the “RegisterHotKey” function which essentially allows you to register any button with your application window as a hotkey using the virtual key codes (VK_TTALK for Send, VK_TEND for Hang-up). What this does is, when the registered key is pressed; it will send you a WM_HOTKEY message, even if your window is not in the foreground, allowing you to handle it.

However there are a couple limitations when dealing with the Send and Hang-up keys. You may find that attempting to register either buttons as a hot key will fail. The reason is that the TaskBar (PPC) or Tray (Smartphone) already has Send button registered as a hotkey and the phone application has the Hang-up button.

You can forcibly “steal” the hot key using either the “UnregisterHotKey” function or the hidden “UnregisterFunc1” function; however taking the hot key away from their respective owners would render some features useless as with the cases when using “SetWindowsHook”.

After some experimentation I have found that there is a unique way in which you may register the Send and Hang-up buttons (and possibly other buttons) as hot keys. I’ve discovered that it is possible to register a button using 0x2001 as a modifier (some others will work as well such 0x2002, etc). What this does is it will generate a WM_HOTKEY message for you when pressing the Send button without interfering with the existing hot key registration held by the TaskBar or Tray or phone application. The limitation here, however, is that you will only get “one shot”; that is, only one WM_HOTKEY is generated and successive key presses will have no notifications. The solution is simply to register the key again. The code would look as follows (note that error and results checking are left out for simplicity)


// setup the window to receive the hot key message
ON_MESSAGE(WM_HOTKEY, &MyappDlg::OnHotkey)

...

// define some of the values to use for registering hot keys
#define ONE_SHOT_MOD        0x2001
#define VK_TTALK_ID         0x07
#define VK_TEND_ID          0x08

...

// register the Send and Hang-up buttons with the unique modifier
::RegisterHotKey(m_hWnd, VK_TTALK_ID, ONE_SHOT_MOD, VK_TTALK);
::RegisterHotKey(m_hWnd, VK_TEND_ID, ONE_SHOT_MOD, VK_TEND);

...

// wait for and handle the hot key messages
afx_msg LRESULT MyappDlg::OnHotkey( WPARAM wParam, LPARAM lParam )
{
switch (lParam >> 16)
{
case VK_TTALK:
// reregister VK_TTALK to get the next key press
::RegisterHotKey(m_hWnd, VK_TTALK_ID, ONE_SHOT_MOD, VK_TTALK);
// handle the keypress...
break;
case VK_TEND:
// reregister VK_TEND to get the next key press
::RegisterHotKey(m_hWnd, VK_TEND_ID, ONE_SHOT_MOD, VK_TEND);
// handle the keypress...
break;

...

So there you have it. Each time the Send and Hang-up buttons are pressed you get a notification and you don’t have to worry about interfering with the normal operations of each button.

UMPCs And The Race To The Bottom - Or how much more does a Flash SSD weights, when it's full with data?

2008-05-23T12:36:00.005-04:00

Our last Macadamian Barcamp session focused on Ultra Mobiles and Netbook PCs. The whole race to the bottom seem to have started when the One Laptop Per Child project took the initiative of creating an affordable ultra-mobile PC aimed at developing countries school children. Asus followed shortly and its Eee PC grabbed most of our attention with its slim size and crispy screen.

On top of portability, we found that most UMPCs offer the following advantages:

Bigger screens compared to smartphones, Wi-Fi and now WiMAX support (some Phillips devices already support WiMAX, and Nokia tablets will have WiMAX this summer).
Most can be used as a car GPS, most have GPS built-in, others can use a Bluetooth or USB GPS receiver.
They're good for note taking, Web browsing, email writing - They're great for common tasks and while most don't handle Vista very well, they have enough horsepower to run most applications written for desktop PCs.

There's always the power versus battery life aspect, which is generally slim compared to smartphones. The One Laptop Per Child PC battery lasts longer but its intentional Fisher-Price looks and ruggedness make it only valuable for either elementary-aged children or front line military soldiers.

The Nokia Internet Tablets looks very promising since they seem to have a good balance between battery life, available applications and horsepower.

Now that most computer vendors have embraced the idea of making Asus Eee-like PCs, we can only expect UMPCs will follow the same fast-paced evolution as cellphones and competition should keep their costs low. Both Eee PC and OLPC can now run WindowsXP. This doesn't make them gain an extra gram, they might even cost cheaper but personally, I feel using them without their native OSes just ain't Kosher.

Software Metrics : What are they, and what can they do for you

2008-05-22T09:35:00.005-04:00

What are software metrics?

This might be a term you have heard before. Simply put, they are a way to quantify aspects of source code.

These aspects vary, and each have a different significance. ... it will make more sense if you see some examples:

LOC - Lines of code. This metric is simply the line count per file, per project, per function, per class, etc. Its value is that you can determine when code is growing beyond control. The refactoring remedy is to split up the file/class/method into smaller, more manageable parts.
NSM - Number of static methods/fields. Excessive use of the static modifier is an indication that something is amiss. The refactoring remedy may include using a Singleton design pattern, or reworking the class design.
LCC - Lines of comments. This is the total number of lines of comments. When taken in ratio with the lines of code, you get a vague idea of how well documented your code base is. It is a fairly common practice to generate API documentation from source, so this metric can be especially valuable if the project is a library.
VG -Cyclomatic Complexity. This metric is not as complex as the name sounds. It is simply the count of the possible linearly independent paths the code may take. Every IF, FOR, WHILE, DO, CASE and trinary operator increments the count. This can help identify poorly written code (ie huge if-else statements), as well as potential slow spots.
LCOM - Lack of Cohesion of Methods. LCOM is a formula for detecting the cohesiveness of a class. It can indicate when it may be time to split a class into two or more specialized classes.
DIT - Depth of inheritance tree. This metric is the number of levels a class is sub-classed. On its own, the value doesn't necessarily indicate a need for refactoring, unless the base class wasn't designed for such a task.
NORM - Number of overridden methods. NORM can be useful for detecting classes that have evolved beyond their original design. It might indicate better abstraction is needed at a low level.
NOM - Number of methods. The number of methods can be useful for detecting when a class has become over grown.

This is only a partial list of some software metrics that can identify weak spots in your code base. It is also certainly possible to dream up software metrics of your own, such as the number of preprocessor "#if" statements used.

How to harness software metrics

All these numbers are quite meaningless without context. What is needed are tools. An ideal tool should run the software metric calculator on every file that is checked into a software repository. The metrics could then be stored and compared per file, and an action could be taken when a particular metric threshold has been crossed. From that trigger an appropriate action could be applied, such as sending out an email to the project manager, or creating a JIRA task to refactor the file. By using the type of metric, a list of possible refactoring remedies could be supplied to steer the developer on the right track.

Another desirable feature would be instant red/yellow/green status on projects and individual files, and trend when refactoring will be needed as metric counts increase. This would be the real power of such a system, being able to see instantly when a project is becoming "design sloppy" and being able to forecast early and schedule time for the issues to be refactored.

Most managers don't like refactoring. It's unpredictable, and has no immediate beneficial output. Experienced managers know that refactoring early is key to keeping a large code base manageable, and will save them time down the road. Using software metrics, you can take such abstract and intangible notions, and turn them into hard numbers. Those hard numbers can then be used for prediction, and prediction is the key to getting software estimates right. This is the most vital step to get right for a software outsourcing company.

Some useful tools for generating software metrics:

Transitioning from ASP.Net to JSP/J2EE

2008-05-21T11:41:00.004-04:00

Note: This is my first blog post ever - and I call myself a web developer (I'm ashamed of myself... really I am).

There is a sub title to this post, I like to call it a little tongue in cheekly:
half-whip-soy-mohca-latte dev frameworks vs single dev frameworks

Having a very strong ASP.Net and MS development background as well as a significant amount of PHP and Perl programming under my belt, I thought transitioning to JSP/J2EE would be very simple, or at least not much of a challenge. I mean web development and development in general all subscribe to the same metaphors and design patterns, the only difference is the implementation details of the language and environment.

Well, I couldn’t be more wrong. This transition has been tough. I write this blog as a small warning for people looking to do the transition from .Net to Java (and not necessarily the other way around) and might be a little overzealous or confident in how easy it might be.

I truly believe that JSP + insert web framework here + J2EE is a good platform for web development and if you are looking for an argument in favor of one framework vs. the other, look elsewhere. The major challenge moving from a predominantly single web framework environment (ASP.Net) to a multiple web framework environment (JSP, Struts, JSF etc… see a lengthy list of web frameworks for JSP) is exactly that. There is no one rule book when you move to Java, there are many and one rule book will not necessarily tell you how you are going to choose your ‘flavour of the day’ half-whip-soy-mocha-latte framework. Some people will want JSP/Struts/Spring/Hibernate; some will want JSP/Struts and others JSP/Spring and others JSP/Spring/Struts/JSF trying to lean on the benefits of each framework. The challenge for an ASP.Net developer here is that these frameworks don’t just work together. You need to spend time figuring out how each of them will communicate and cohabitate in a fashion that will work and then you can start developing. This is huge paradigm shift, as suddenly you need to do some significant set up and tweaking to just get a web dev environment working. Furthermore, suddenly you have to start thinking about Application Servers, not just web servers. In the IIS+ASP.Net world, IIS will just about handle everything for you and an application servers were about architecture and scaling up or out using remoting or web services. In the JSP/J2EE world, your application server is NOT your web server, it’s something completely different – it’s a built in load balanced remote application server that can be separated from your web server with moderate ease.

These two major paradigm shifts, once fully integrated into your knowledge help you take the small shifts that will come along, such as eliminating the event driven model of ASP.Net for whatever MVC model you go with for Java (some will be similar), or having to work update a number of xml configuration files to get Struts 2 up and running (And for any addition you make). Whatever your implementation troubles might be, keep in mind, these two software languages/frameworks/philosophies are very similar in concept but worlds apart in implementation.

Hopefully this quick blog will help another ASP.Net developer stuck on a Java project transition just a little bit quicker or an ASP.Net developer looking at JSP and not jump in too quickly and find themselves drowning in the details.