Developer Resource

Visual studio resolve usings.

2011-01-19T17:16:00.001-08:00

I had the absolute joy of hanging out at the Tampa .NET Developer Group Meeting last night. Here is a tip I mentioned briefly at the meeting around resolving and optmizing namespaces.

I know a lot of us are hardcore ReSharper users and can do all kinds of jedi-like moves in the Visual Studio 2008 IDE. However, get us without ReSharper at times and we just stare at the keyboard in bewilderment wondering why namespaces aren't resolving, usings are being optimized, and refactorings are not taking place at blinding speeds, etc.

It turns out, Visual Studio 2008 actually has good support for resolving namespaces and optmizing using statements that can get you the functionality if you are not using ReSharper.

Resolving Namespaces

When you are writing code and Visual Studio places a small red notification rectangle at the end of the class,

Pressing Ctrl + . will bring up a context-sensitive menu that allows you to add a using statement or optionally fully qualify the path to the class.

Clicking the Enter Key will automatically add using System.Collections.Generic; with the other using statements, requiring no touch of the mouse.

This also works with attributes as well. Adding an attribute that needs a using statement to qualify its namespace will cause the same red notification rectangle to appear:

and pressing Ctrl + . will allow you to add the using statement, etc.

Optimizing, Removing, and Sorting Unused Using Statements

The other nice thing that ReSharper does is remove unused using statements using Ctrl+Alt+O.

We can get that using Visual Studio 2008, because you may have noticed the cool context-sensitive Organize Usings Option:

Very, very cool, but this needs to have a shortcut because we will be using it often. I want to use the familar Ctrl+Alt+O shortcut that I get from ReSharper ( you can choose your own ) so I need to map the shortcut to the Edit.RemoveAndSort Command in the keyboard options:

Now when I type Ctrl+Alt+O in the code editor it will remove all unused using statements in the current file as well as sort those using statements that are being used.

Very cool! Hope this helps.

A simple distributed lock with memcached

2011-01-03T22:56:00.000-08:00

When you have a cluster of web application servers, you often need to coordinate the activity of your servers to avoid the same expensive work being done at the same time when a condition triggers it.

Most people use memcached as a simple key/value store but it can also be used as a simple distributed lock manager: along with the put(key, value) operation, it also has an add(key, value) operation that succeeds only if the cache wasn't already holding a value for the key.

Locking then becomes easy:

if (cache.add("lock:xyz", "1", System.currentTimeMillis() + 60000))

try

      doSomeExpensiveStuff();

 finally

    cache.delete("lock:xyz");

} else {

   // someone else is doing the expensive stuff

The code above tries to get the lock by adding a dumb value for our lock's idenfitier, with an expiration of one minute. This is the lock lease time, and should be more than the estimated maximum time for the lengthy operation. This avoids the lock being held forever if ever things go really bad such as your server crashing.

Once the operation is completed, we delete the lock, et voilà.

If you want the system to be rock-solid, you should check that you still own the lock before deleting it (in case the lease time expired), but in most cases this simple approach works nicely.

And if the expensive operation resets in the database the condition that triggered it, the lock should be released once the transaction has been committed to prevent a race condition in the time interval between the end of the expensive operation and the actual commit that would allow other servers to restart the same work. Spring's transaction synchronization helps doing that.

Registering an Application to a URL protocol

2011-01-03T22:55:00.000-08:00

Registering an Application to a URL Protocol

The About Asynchronous Pluggable Protocols article describes how to develop handlers for URL protocols. In some cases, it may be desirable to invoke another application to handle a custom protocol. To do so, register the existing application as a URL Protocol handler. Once the application has successfully launched, it can use command-line parameters to retrieve the URL that launched it. These settings apply to protocol handlers launched from within Windows Internet Explorer and from Windows Explorer using the Run... command (Windows logo key+R).

Security Alert Applications that handle URL protocols must consider how to respond to malicious data. Because handler applications can receive data from untrusted sources, the URL and other parameter values passed to the application may contain malicious data that attempts to exploit the handling application.

This topic contains the following sections:

Registering the Application Handling the Custom Protocol

To register an application to handle a particular URL protocol, add a new key, along with the appropriate subkeys and values, to HKEY_CLASSES_ROOT. The root key must match the protocol scheme that is being added. For instance, to add an "alert:" protocol, add an alert key to HKEY_CLASSES_ROOT, as follows:

HKEY_CLASSES_ROOT
alert
URL Protocol = ""

Under this new key, the URL Protocol string value indicates that this key declares a custom protocol handler. Without this key, the handler application will not launch. The value should be an empty string.

Keys should also be added for DefaultIcon and shell. The Default string value of the DefaultIcon key must be the file name to use as an icon for this new URL protocol. The string takes the form "path, iconindex" with a maximum length of MAX_PATH. The name of the first key under the shell key should be an action verb, such as open. Under this key, a command key or aDDEEXEC key indicate how the handler should be invoked. The values under the command and DDEEXEC keys describe how to launch the application handling the new protocol.

Finally, the Default string value should contain the display name of the new protocol. The following example shows how to register an application, alert.exe in this case, to handle the alertprotocol.

HKEY_CLASSES_ROOT
alert
(Default) = "URL:Alert Protocol"
URL Protocol = ""
DefaultIcon
(Default) = "alert.exe,1"
shell
open
command
(Default) = "C:\Program Files\Alert\alert.exe" "%1"

When a user clicks a link registered to your custom URL protocol, Internet Explorer launches the registered URL protocol handler. If the specified open command specified in the registry contains a %1 parameter, Internet Explorer passes the URL to the registered protocol handler application.

Launching the Handler

By adding the above settings to the registry, navigating to URLs such as alert:Hello%20World would cause an attempt to launch alert.exe with the complete URL on the command line. Internet Explorer decodes the URL, but the Windows Run... command does not. If a URL contains spaces, it may be split across more than one argument on the command line.

For example, if the link above is followed through Internet Explorer, the command line would be:

Copy

"C:\Program Files\Alert\alert.exe" "alert:Hello World"

If this link is followed through Windows Explorer, the Windows Run command, or some other application, the command line would be:

Copy

"C:\Program Files\Alert\alert.exe" "alert:Hello%20World"

Because Internet Explorer will decode all percent-encoded octets in the URL before passing the URL to ShellExecute, URLs such as alert:%3F? will be given to the alert application protocol handler as alert:??. The handler won't know that the first question mark was percent-encoded. To avoid this issue, application protocol handlers and their associated URL scheme must not rely on encoding. If encoding is necessary, protocol handlers should use another type of encoding that is compatible with URL syntax, such as Base64 encoding. Double percent-encoding is not a perfect solution either; if the application protocol URL isn't processed by Internet Explorer, it will not be decoded.

When ShellExecute executes the application protocol handler with the URL on the command line, any non-encoded spaces, quotes, and slashes in the URL will be interpreted as part of the command line. This means that if you use C/C++'s argc and argv to determine the arguments passed to your application, the URL may be broken across multiple parameters. To mitigate this issue:

Avoid spaces, quotes, or backslashes in your URL
Quote the %1 in the registration ("%1" as written in the 'alert' example registration)

However, avoidance doesn't completely solve the problem of quotes in the URL or a backslash at the end of the URL.

Security Issues

As noted above, the URL that is passed to an application protocol handler might be broken across multiple parameters. Malicious parties could use additional quote or backslash characters to pass additional command line parameters. For this reason, application protocol handlers should assume that any parameters on the command line could come from malicious parties, and carefully validate them. Applications that could initiate dangerous actions based on external data must first confirm those actions with the user. In addition, handling applications should be tested with URLs that are overly long or contain unexpected (or undesirable) character sequences.

For more information, please see Writing Secure Code.

Example Protocol Handler

The following sample code contains a simple C# console application demonstrating one way to implement a protocol handler for the alert protocol.

Copy

using System; using System.Collections.Generic; using System.Text;  namespace Alert {   class Program   {     static string ProcessInput(string s)     {        // TODO Verify and validate the input         // string as appropriate for your application.        return s;     }      static void Main(string[] args)     {       Console.WriteLine("Alert.exe invoked with the following parameters.\r\n");       Console.WriteLine("Raw command-line: \n\t" + Environment.CommandLine);        Console.WriteLine("\n\nArguments:\n");       foreach (string s in args)       {         Console.WriteLine("\t" + ProcessInput(s));       }       Console.WriteLine("\nPress any key to continue...");       Console.ReadKey();     }   } }

When invoked with the URL alert:"Hello%20World" (note extra quotes) from Internet Explorer, the program responds with:

Copy

Alert.exe invoked with the following parameters.  Raw command-line:         "C:\Program Files\Alert\alert.exe" "alert:"Hello World""   Arguments:          alert:Hello         World  Press any key to continue...

How to make your ASP.Net label multiline (how to wrap text in your label)

2010-12-29T17:35:00.001-08:00

First off, sorry for the absence. Things got a little busy in life as well as work. Not to mention having to get up to speed on 2.0 in a big hurry. All good things, but it left less time for fun stuff.

With that said, I want to offer a little tip to help with formatting your ASP.Net pages. Getting a label to be multiline within a set width. Now many of you know this trick, but I always have to re-remember the trick every time I need it, so this post can be a reference for you as well.

The trick is actually this - Don't use a label. Use a textbox instead. Since all the controls inherit from the same base class, the text box and the label are very similar anyway. But only the textbox has the multiline capability.

Once you have the textbox on your page the trick is to make it look like a label for the end user. To do this you need to set the following properties (This is the part I can never remember):

Wrap = true; (obviously)
rows = {some number greater than 0} (I use the rows property rather than the height property as it tends to be earier to get the formatting right)
ReadOnly = true (makes sense, right)
TextMode = multiline (or there no real reason to wrap the text...)
BorderStyle = None
BorderWidth = 0

Those last two are actually VERY important, and here is why. They get rid of that pesky border that you see around text boxes. That border is a common visual signal to the end user that says "ENTER INFO HERE!". If you leave the border up expect a lot of phone calls from folks saying "The web page is broken. It won't let me enter text."

So use this in good faith. More controls soon. Even my first 2.0 controls.

C# Caching

2010-12-21T17:33:00.000-08:00

For asp.net apps there are many different kinds of caching available. This includes browser caching, partial page caching, data caching, and others.

The first and foremost is browser caching. Browsers will automatically cache references to your js, css, and images. Although you might need to add the following to your web.config to give it a hint about the js files:

The can also have the following to give it a hint on how long to cache the static content:

For the actual pages, see one of the links above. You have pretty good control over what is and isn't cached in the app itself.

Hello World RPC Server

2010-12-17T12:22:00.001-08:00

package org.mortbay.gwt.example.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface HelloWorldService extends RemoteService
{

public String sayHello(String sender);

}
package org.mortbay.gwt.example.client;

import com.google.gwt.user.client.rpc.RemoteService;

public interface HelloWorldService extends RemoteService
{

public String sayHello(String sender);

}
package org.mortbay.gwt.example.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface HelloWorldServiceAsync
{

public void sayHello(String sender, AsyncCallback callback);

}
Using Continuations (RetryRequest) | jetty6

package org.mortbay.gwt.example.server;

import javax.servlet.http.HttpServletRequest;

import org.mortbay.gwt.AsyncRemoteServiceServlet;
import org.mortbay.gwt.example.client.HelloWorldService;
import org.mortbay.util.ajax.Continuation;
import org.mortbay.util.ajax.ContinuationSupport;

public class HelloWorldServiceImpl extends AsyncRemoteServiceServlet implements HelloWorldService
{

private static final long serialVersionUID = 1L;

public String sayHello(String sender)
{
HttpServletRequest request = getThreadLocalRequest();
Continuation continuation = ContinuationSupport.getContinuation(request, null);
if(continuation.isNew() || !continuation.isPending())
{
request.setAttribute("ts", Long.valueOf(System.currentTimeMillis()));
continuation.suspend(5000);
}
long elapsed = System.currentTimeMillis() - ((Long)request.getAttribute("ts")).longValue();
return "Hello world *" + sender + "* resumed after " + elapsed + " ms";
}

}
Using Servlet-3.0 suspend/resume api | jetty7

package org.mortbay.gwt.example.server;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mortbay.gwt.AsyncRemoteServiceServlet;
import org.mortbay.gwt.example.client.HelloWorldService;

public class HelloWorldServiceImpl extends AsyncRemoteServiceServlet implements HelloWorldService
{

private static final long serialVersionUID = 1L;

public String sayHello(String sender)
{

HttpServletRequest request = getThreadLocalRequest();
HttpServletResponse response = getThreadLocalResponse();
System.err.println("HANDLING: " + request + " | " + request.hashCode() + " | " + response.hashCode());

if(request.isInitial())
{
request.setAttribute("ts", Long.valueOf(System.currentTimeMillis()));
request.suspend(5000);
return null;
}
// timed-out or resumed
System.err.println("RESPONDING");
long elapsed = System.currentTimeMillis() - ((Long)request.getAttribute("ts")).longValue();
return "Hello world *" + sender + "* resumed after " + elapsed + " ms";
}

}

SetWindowsHookEx

2010-12-17T12:21:00.001-08:00

Installs an application-defined hook procedure into a hook chain. You would install a hook procedure to monitor the system for certain types of events. These events are associated either with a specific thread or with all threads in the same desktop as the calling thread.

Syntax

Copy
HHOOK WINAPI SetWindowsHookEx(
__in int idHook,
__in HOOKPROC lpfn,
__in HINSTANCE hMod,
__in DWORD dwThreadId
);

Parameters

idHook [in]
Type: int

The type of hook procedure to be installed. This parameter can be one of the following values.

Value Meaning
WH_CALLWNDPROC
4
Installs a hook procedure that monitors messages before the system sends them to the destination window procedure. For more information, see the CallWndProc hook procedure.

WH_CALLWNDPROCRET
12
Installs a hook procedure that monitors messages after they have been processed by the destination window procedure. For more information, see the CallWndRetProc hook procedure.

WH_CBT
5
Installs a hook procedure that receives notifications useful to a CBT application. For more information, see the CBTProc hook procedure.

WH_DEBUG
9
Installs a hook procedure useful for debugging other hook procedures. For more information, see the DebugProc hook procedure.

WH_FOREGROUNDIDLE
11
Installs a hook procedure that will be called when the application's foreground thread is about to become idle. This hook is useful for performing low priority tasks during idle time. For more information, see the ForegroundIdleProc hook procedure.

WH_GETMESSAGE
3
Installs a hook procedure that monitors messages posted to a message queue. For more information, see the GetMsgProc hook procedure.

WH_JOURNALPLAYBACK
1
Installs a hook procedure that posts messages previously recorded by a WH_JOURNALRECORD hook procedure. For more information, see the JournalPlaybackProc hook procedure.

WH_JOURNALRECORD
0
Installs a hook procedure that records input messages posted to the system message queue. This hook is useful for recording macros. For more information, see the JournalRecordProc hook procedure.

WH_KEYBOARD
2
Installs a hook procedure that monitors keystroke messages. For more information, see the KeyboardProc hook procedure.

WH_KEYBOARD_LL
13
Installs a hook procedure that monitors low-level keyboard input events. For more information, see the LowLevelKeyboardProc hook procedure.

WH_MOUSE
7
Installs a hook procedure that monitors mouse messages. For more information, see the MouseProc hook procedure.

WH_MOUSE_LL
14
Installs a hook procedure that monitors low-level mouse input events. For more information, see the LowLevelMouseProc hook procedure.

WH_MSGFILTER
-1
Installs a hook procedure that monitors messages generated as a result of an input event in a dialog box, message box, menu, or scroll bar. For more information, see the MessageProc hook procedure.

WH_SHELL
10
Installs a hook procedure that receives notifications useful to shell applications. For more information, see the ShellProc hook procedure.

WH_SYSMSGFILTER
6
Installs a hook procedure that monitors messages generated as a result of an input event in a dialog box, message box, menu, or scroll bar. The hook procedure monitors these messages for all applications in the same desktop as the calling thread. For more information, see the SysMsgProc hook procedure.

lpfn [in]
Type: HOOKPROC

A pointer to the hook procedure. If the dwThreadId parameter is zero or specifies the identifier of a thread created by a different process, the lpfn parameter must point to a hook procedure in a DLL. Otherwise, lpfn can point to a hook procedure in the code associated with the current process.

hMod [in]
Type: HINSTANCE

A handle to the DLL containing the hook procedure pointed to by the lpfn parameter. The hMod parameter must be set to NULL if the dwThreadId parameter specifies a thread created by the current process and if the hook procedure is within the code associated with the current process.

dwThreadId [in]
Type: DWORD

The identifier of the thread with which the hook procedure is to be associated. If this parameter is zero, the hook procedure is associated with all existing threads running in the same desktop as the calling thread.

Return Value

Type: HHOOK

If the function succeeds, the return value is the handle to the hook procedure.

If the function fails, the return value is NULL. To get extended error information, call GetLastError.

Remarks

SetWindowsHookEx can be used to inject a DLL into another process. A 32-bit DLL cannot be injected into a 64-bit process, and a 64-bit DLL cannot be injected into a 32-bit process. If an application requires the use of hooks in other processes, it is required that a 32-bit application call SetWindowsHookEx to inject a 32-bit DLL into 32-bit processes, and a 64-bit application call SetWindowsHookEx to inject a 64-bit DLL into 64-bit processes. The 32-bit and 64-bit DLLs must have different names.

An error may occur if the hMod parameter is NULL and the dwThreadId parameter is zero or specifies the identifier of a thread created by another process.

Calling the CallNextHookEx function to chain to the next hook procedure is optional, but it is highly recommended; otherwise, other applications that have installed hooks will not receive hook notifications and may behave incorrectly as a result. You should call CallNextHookEx unless you absolutely need to prevent the notification from being seen by other applications.

Before terminating, an application must call the UnhookWindowsHookEx function to free system resources associated with the hook.

The scope of a hook depends on the hook type. Some hooks can be set only with global scope; others can also be set for only a specific thread, as shown in the following table.

Hook Scope
WH_CALLWNDPROC Thread or global
WH_CALLWNDPROCRET Thread or global
WH_CBT Thread or global
WH_DEBUG Thread or global
WH_FOREGROUNDIDLE Thread or global
WH_GETMESSAGE Thread or global
WH_JOURNALPLAYBACK Global only
WH_JOURNALRECORD Global only
WH_KEYBOARD Thread or global
WH_KEYBOARD_LL Global only
WH_MOUSE Thread or global
WH_MOUSE_LL Global only
WH_MSGFILTER Thread or global
WH_SHELL Thread or global
WH_SYSMSGFILTER Global only

For a specified hook type, thread hooks are called first, then global hooks.

The global hooks are a shared resource, and installing one affects all applications in the same desktop as the calling thread. All global hook functions must be in libraries. Global hooks should be restricted to special-purpose applications or to use as a development aid during application debugging. Libraries that no longer need a hook should remove its hook procedure.

Examples

For an example, see Installing and Releasing Hook Procedures.

Requirements

Minimum supported client

Windows 2000 Professional
Minimum supported server

Windows 2000 Server
Header

Winuser.h (include Windows.h)
Library

User32.lib
DLL

User32.dll
Unicode and ANSI names

SetWindowsHookExW (Unicode) and SetWindowsHookExA (ANSI)
See Also

Reference
CallNextHookEx
CallWndProc
CallWndRetProc
CBTProc
DebugProc
ForegroundIdleProc
GetMsgProc
JournalPlaybackProc
JournalRecordProc
LowLevelKeyboardProc
LowLevelMouseProc
KeyboardProc
MouseProc
MessageProc
ShellProc
SysMsgProc
UnhookWindowsHookEx

Conceptual
Hooks

Send comments about this topic to Microsoft

Build date: 12/1/2010

CCR Introduction

2010-12-17T12:20:00.001-08:00

Microsoft Robotics
Concurrency and Coordination Runtime (CCR) is a managed code library, a Dynamically Linked Library (DLL), accessible from any language targeting the .NET Common Language Runtime (CLR).
The CCR addresses the need of service-oriented applications to manage asynchronous operations, deal with concurrency, exploit parallel hardware and deal with partial failure. It enables the user to design applications so that the software modules or components can be loosely coupled; meaning they can be developed independently and make minimal assumptions about their runtime environment and other components. This approach changes how the user can think of programs from the start of the design process and deals with concurrency, failure and isolation in a consistent way.

Problem Areas

Asynchrony - When communicating between loosely coupled software components, like programs running across the network, or User Interface (UI) code communicating with the user input and the file I/O subsystem, asynchronous operations enable the code to scale better, be more responsive, and deal with failure across multiple operations. Asynchronous programming however, considerably reduces the readability of user code, since logic is often split between callbacks and the code that originates the operation. In addition, it is an almost impossible task to correctly handle failure across multiple outstanding operations.
Concurrency - Code that needs to better utilize multiple execution resources, must be split into independent logical segments, that can run in parallel, and communicate when necessary to produce results from the combined execution. Often, that logical segment is captured by the thread OS primitive, that is nothing more than a long lived iteration. Because of thread performance implications on thread startup, the thread stays active for long periods of time. This forces a particular pattern. Code is structured as long sequences that use blocking or synchronous calls, and only deals with one thing at a time. Further, threads assume that the primary communication between them is shared memory, forcing the programmer to use very explicit, error-prone methods to synchronize access to that shared memory.
Coordination and Failure Handling - Coordinating between components is where most of the complexity in large software programs lies. A mismatch of interaction patterns, such as calling methods on objects versus using OS signaling primitives versus using queues plus signaling, leads to unreadable code, where the runtime behavior changes drastically between coordination approaches. More importantly, the error handling approaches are ill-defined and again vary drastically.
Application Model

CCR is appropriate for an application model that separates components into pieces that can interact only through messages. Components in this model need means to coordinate between messages, deal with complex failure scenarios, and effectively deal with asynchronous programming. This application model is also very similar to how heterogeneous hardware is integrated and how network applications are built. Most software programs have the same needs, from traditional client PC programs to server applications, to applets running in the Web browser. The software needs to coordinate user input, storage input/output and UI presentation. Although disguised in layers of mostly synchronous application code interfaces, asynchrony is inevitable since the devices operate at different speeds, have large differences in resources available, and we in general know how to use queues to isolate them.

The following sections introduce the CCR programming model and its implementation that addresses the above areas in an efficient, robust and extensible way.

© 2010 Microsoft Corporation. All Rights Reserved.

Array of Tuples

2010-12-17T12:19:00.001-08:00

Q: How would use tuples in C# 4.0 to create an array of tuples containing various types of data (i.e. Employee Name, Employee ID#)?

A: Listed below is a sample code snippet to implement an array of tuples.

//Array of Tuples (i.e. EmpName, EmpIDNum)
Tuple[] EmpRecs =
{
Tuple.Create("Sam Nasr", 891),
Tuple.Create("Jim Smith", 358),
Tuple.Create("Lisa Jones", 962)
};

string FirstEmpName = EmpRecs[0].Item1;

string SecondEmpName = EmpRecs[1].Item1;
int SecondEmpIDNum = EmpRecs[1].Item2;

More information can be found at http://msdn.microsoft.com/en-us/library/dd413854(VS.95).aspx

NTLM Authentication for Java http clients

2010-12-17T12:17:00.000-08:00

I was working to provide NTLM authentication to a RSS aggregator plugin http://confluence.atlassian.com/display/CONFEXT/RSS+aggregator+macro+plugin , in our implementation the rssaggregator needed to access rss feed from an IIS installed application within an AD intergrated setup, so our http request needed to go through NTLM authentication.
What I found out during this exercise is that if one is on the same AD domain as the server hosting the secure contents then JDK 1.5 and 1.6 does a transparent authentication at the backend, automatically transferring the login details from the http client to the server , however if the request is being made from a client outside the domain then the login details have to be provided using the username and password for the client accessing the protected resource, for that I found the Jave Authenticator class to be the best option, since you do not have to alter your existing code and just call the Authenticator before the http request and populate the authentication credentials in it. Worked really well for me.
References
Two exhaustive definitions of how ntlm works, and the interactions
http://www.innovation.ch/personal/ronald/ntlm.html
http://davenport.sourceforge.net/ntlm.html
Useful link to valid Java Implementation
http://oaklandsoftware.com/papers/ntlm.html
Ads by Google

Oh Yahoo!

2010-12-17T12:16:00.001-08:00

Yahoo has hit rock bottom. They’ve now, finally, had their layoffs. Those that are left are keeping their resumes fresh don’t expect to stay there over the long term. Everything we hear from employees boils down to this – the company is in “absolute disarray.”

Take yesterday as an example. They botch news about closing down products like Delicious. The Upcoming team is apparently wiped out, but an apparently timestamped blog post appeared on wednesday, after the team was gone, asking for feedback on a new design for the site. Except the blog post doesn’t have a link to the new design, and still doesn’t as of today. Probably because whoever wrote it is gone, along with the rest of the team.

And today Yahoo realized that people really care about sites like Delicious and put up a blog post saying that they’re going to sell it, not shut it down. Which is great except the Delicious blog is now offline and returns an error (we reprinted it here).

And finally, yesterday Yahoo announced internally that they would be shutting down an instant messaging product called MyM. Have you heard of it? Neither had we. Oh wait, we did – in 2008. It turns out is was an internal project that was never launched and formally shut down nearly three years ago. Apparently the executive team didn’t know that.

In May I spoke with CEO Carol Bartz on stage at TechCrunch Disrupt. The headline was the last few seconds of the talk. But that wasn’t really what was interesting about the interview. What really riled Yahoo up was when I asked if they were really even a technology company any more. I think it’s now clear to the world now that they aren’t. They’re just a nightmarish Dilbert-cartoon version of the old Yahoo, where employees fear for their jobs and stumble around the office trying to protect themselves, not build anything new and ambitious.

There is only one way a company recovers from this. They must have new leadership. And soon. Because at this point they are little more than a holding company for some lucrative Asian Internet assets. This can’t possibly be what the board of directors hoped for when they hired Bartz less than a year ago. So much has changed, so fast.

Zombie Farm

2010-12-14T21:33:00.000-08:00

A few days ago Apple released its top 10 list of iPhone apps for 2010 and only one freemium app was listed as top grossing, Zombie Farm. Zombie Farm combines all the fun of Farmville with zombies (!), allowing you to plant either crops or corpses (seriously). You can then use the zombies you’ve planted to attack your neighbors or pirates or aliens (no, I am not making this up).

Apparently this is a winning combination, as the game hit 7.3 million downloads in November, up from 6 million in October and growing about 25% a month. Currently it boasts about 2 million monthly active users, a number which has been doubling every couple of months since the app’s launch this February. Users have spent 2.76 billion minutes playing the game, which have resulted in 61.5 million Zombie Farm invasions. And despite complaints about the most recent updates’ slowness in the iTunes reviews, the developers are obviously doing something right.

To the tune of millions of dollars. Playforge developer Vince McDonnell and his wife were in danger of losing their house when he built the app, and now not so much. While McDonnell will not reveal how much total revenue the app has made thus far (people pay for in-game currency like $0.99 brains and tombstones) in comparison, Doodle Jump, the #10 app on the top grossing list sold about 3 million units in five months at $0.99 each which would project to about ($) 7 million sold for the year. Zombie Farm was at number #6 on the list, which means McDonnell has made at least a few million thus far.

GWT games

2010-02-08T22:58:00.000-08:00

Many years ago I wrote javascript application that took an image, broke it up into many pieces, then shuffled them into a puzzle for the user. It only worked in I.E. and was horribly written and hard to maintain.

I wanted to revisit this application and was trying to figure out what the best language/framework to use.

I decided that GWT (Google Web Toolkit) would be an excellent choice for this application.

To see the application go here: http://imageoverflow.appspot.com/puzzle.html?imageUrl=http://imageoverflow.appspot.com/get/3b20793dfc300d058ad04d411da152eb?f=t

Now to the code...

The code consists of the following main classes.

ImagePuzzleWidget
PuzzleGrid
ClickableImage

ImagePuzzleWidget

The ImagePuzzleWidget is the main widget that encapsulates the game. It takes no arguments and is added directly to the Root Panel in the GWT entry point.

public void onModuleLoad() {
RootPanel.get().add(new ImagePuzzleWidget());
}

PuzzleGrid

PuzzleGrid extends the Grid GWT component. Its constructor looks like this:

public PuzzleGrid(final String url,final int cols,final int rows)

This class takes the url of the image you want to scramble as well as how many rows and cols you want.

We add an onLoadHandler that will get executed after the image has been loaded:

image.addLoadHandler(new LoadHandler() {

public void onLoad(LoadEvent event) {
setWidth(image.getWidth() + "px");
setHeight(image.getHeight() + "px");

int blockWidth = image.getWidth() / cols;
int blockHeight = image.getHeight() / rows;
for (int col = 0; col <>
for (int row = 0; row <>
setWidget(row, col,
new ClickableImage(url, blockWidth * col, blockHeight * row, blockWidth, blockHeight, row, col));
}
}
shuffle();

setVisible(true);
}
});

It is this class that does most of the work by splitting the image into sub parts and making ClickableImages out of them.

The class then shuffles the images and sets it as visible.

So now we have an image displayed broken into sub parts and displayed in a grid fashion.

ClickableImage

ClickableImage class, as its name implies embodies a section of the image that can be clicked.

The class basically just extends Image and adds a ClickHandler. I add some extra convenience methods like select and unselect which I won't show for the sake of brevity.

public ClickableImage(String url, int left, int top, int width, int height, int row, int col) {
super(url, left, top, width, height);
this.row = row;
this.col = col;
this.addStyleName("unselected");
this.addClickHandler(new ClickHandler() {

public void onClick(ClickEvent event) {
toggleSelected();

}
});
}

And that is really all there is to it. By using GWT we can focus on writing our OO style code and not worry about the browser.

Make sure you check out the app at: http://imageoverflow.appspot.com/puzzle.html?imageUrl=http://imageoverflow.appspot.com/get/3b20793dfc300d058ad04d411da152eb?f=t

This post was written hastily, if there is any interest or question leave a comment and I'll ake the time to expand.

HTH

Extend JSF Command Link

2009-10-05T17:01:00.000-07:00

I found myself adding a Remove link throughout my JSF application. It looked like this:

<h:commandlink value="Remove" actionlistener="#{MyBean.remove}">

I wanted to add a confirm dialog. So I added this.

<h:commandlink value="Remove" actionlistener="#{MyBean.remove}" onclick="javascript return confirm('Are you sure')">

But as I copied and pasted this through 5 or 6 different pages, I got to thinking, there has to be a better way.

So I created a custom jsf component by extending Command Link.

Step 1

First step was to create my new tag. It simply wraps the default command link.

package com.acme;

import com.sun.faces.taglib.html_basic.CommandLinkTag;
import javax.el.MethodExpression;
import javax.el.ValueExpression;
import javax.faces.component.UIComponent;
import javax.faces.component.html.HtmlCommandLink;
import javax.faces.event.MethodExpressionActionListener;
import javax.faces.webapp.UIComponentELTag;

/**
* @author cmcintosh
*/
public class RemoveCommandLinkTag extends UIComponentELTag { // Declare a bean property for the hellomsg attribute.

CommandLinkTag commandLink = new CommandLinkTag();
ValueExpression value;
MethodExpression actionListener;

// Associate the renderer and component type.
public String getComponentType() {
return commandLink.getComponentType();
}

public String getRendererType() {
return commandLink.getRendererType();
}

@Override
protected void setProperties(UIComponent component) {
super.setProperties(component);
component.setValueExpression("value", value);
((HtmlCommandLink)component).addActionListener(new MethodExpressionActionListener(actionListener));
((HtmlCommandLink)component).setOnclick("javascript:return confirm('Are you sure you want to remove?')");

}
@Override
public void release() {
super.release();
commandLink.release();

}

public void setValue(ValueExpression value) {
this.value = value;

}
public void setActionListener(MethodExpression actionListener) {
this.actionListener = actionListener;
}
}

Step 2
Next I needed to create a tld.

<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee" xsi="http://www.w3.org/2001/XMLSchema-instance" schemalocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd">
<tlib-version>1.0</tlib-version>
<short-name>datastore</short-name>
<uri>/WEB-INF/tlds/datastore</uri>
<tag>
<name>RemoveCommandLink</name>
<tag-class>com.acme.datastore.web.components.tags.RemoveCommandLinkTag</tag-class>
<attribute>
<name>value</name>
<deferred-value>
<type>java.lang.String</type>
</deferred-value>
</attribute>
<attribute>
<name>actionListener</name>
<required>false</required>
<deferred-method>
<method-signature>
actionListener(javax.faces.event.ActionEvent)
</method-signature>
</deferred-method>
<type>String</type>
</attribute>

</tag>
</taglib>

This was one of the hardest parts note the deferred-method and deferredvalue. I've never encountered those before.

Step 3

Add it to the web.xml:
<jsp-config>
<taglib>
<taglib-uri>http://datastore.acme.com/datastore</taglib-uri>
<taglib-location>/WEB-INF/tlds/datastore.tld</taglib-location>
</taglib>
</jsp-config>

Step 4
Finally to use it:
<%@taglib prefix="ds" uri="http://datastore.acme.com/datastore"%>
.
.
.
<ds:removecommandlink value="Remove" actionlistener="#{ViewModifyTable.removeColumn}">
<f:param name="applicationId" value="#{ViewModifyTable.applicationId}">
<f:param name="tableName" value="#{ViewModifyTable.tableName}">
</f:param></f:param></ds:removecommandlink></h:commandlink></h:commandlink>

Configure logging level

2009-09-18T12:10:00.003-07:00

Here is how I disabled hibernate JPA logging level in code.

Logger.getLogger("org.hibernate").setLevel(Level.SEVERE);

Readling List

2009-08-18T16:09:00.000-07:00

XtraDb:

http://www.mysqlperformanceblog.com/2009/08/13/xtradb-the-top-10-enhancements/

Mysql performance blog

http://www.amazon.com/gp/product/0596101716?ie=UTF8&tag=perinc-20&linkCode=as2&camp=1789&creative=9325&creativeASIN=0596101716

Pro JSF and Ajax by Jonas Jacobi and John R. Fallows

2009-08-17T03:57:00.002-07:00

Read On: 8/17/09
Rating: 7 /10

Pros:

I liked this summary of other applications and which component of MVC they target: Examples of frameworks are Struts (an open source controller framework);
TopLink and Hibernate (model frameworks); and Tiles, Tapestry, XUL, and ADF UIX (so-
called view frameworks).

Cons:

Can be hard to read

Questions:

Why do so many frameworks model navigation these days?

2009-08-17T03:57:00.001-07:00

Comparing Web Frameworks: Struts, Spring MVC, Webwork, Tapestry & JSF

2009-08-17T03:45:00.000-07:00

Read on: 08/17/2009
Rating: 2/10

Way outdated, by the time I got my hands on it. No fault of the authors it was made in 2005.

Pros:

Concise

Cons:

Its just a bunch of slides

Beginning Spring 2 by Dave Minter

2009-08-17T03:22:00.000-07:00

Read On: 8/17/09
Rating: 8/10

Pros:

Very good introduction to Spring
Clear explanation of IoC and dependency injection
Made a strong case for using Spring for all applications

Cons

Would of liked more Spring annotation examples.
The database example could of been expanded. In particular I wasn't sure what the purpose of the DAO's were.
I would of liked a more detail on Spring MVC

My desired Java technology stack.

2009-08-07T18:32:00.001-07:00

This blogpost will be continually updated to list my favorite application stack for various projects. I welcome any comments to help me choose the best tools that will make me most productive.

Web Container
Currently I'm biased for tomcat its easy to setup and administer and I haven't had any problems with it.

I'm having good success with also using apache with mod_proxy_balancer as a load balancer mechanism. Still need to investigate how to make the apache instance not be my single point of failure.

I do not like glassfish. For a project a couple years ago we went with that and the app is still buggy and crashing a lot. Granted its probably more of the apps problem EJB 2.0 without a lot of other kruft but glassfish didn't impress me.

To consider:
I want to investigate JBOSS again. I used it in college and I wonder if features of JBOSS would be compelling enough for me to move off of Tomcat.

Possible reasons to consider JBOSS

uses tomcat, and you can configure it to run with almost no features but tomcat, but still have the ability to use enterprise class features at a later date.
Heard about their shard memory cache, this could be useful for some of my applications

Display Technologies
I don't know. I've tried GWT, JSF, JavaFX, JSP/JSTL. Nothing seems like the best technology here. I seem to spend most of my time writing the front end of the application which is the part i least enjoy.

What I'm looking for ideally is an easy to use set of components to layout without much fuss. Any suggestions? Note I'm not looking for something like struts, which as far as I understand it, helps with navigation.

Configuration
Spring, looks like a good standard way of handling application configuration.

Javascript Libraries
Need to investigate and choose between:

tablekit
jquery
fabtabulous
anything else?

Database
Mysql enough said, although I would use MSSQL in a heartbeat again but you can't beat the price of Mysql.

Need to investigate scaling, and replication of Mysql that is the next big task I need to tackle at work.

ORM
After EJB 2.0 hell I swore off ORM's, but using the Google Appengine I've grown found of JPA. Just started looking at Hibernate JPA. Early impressions: I like it!

Anyone else want to recommend something?

Current ordering of choices:

Hibernate JPA- using javax.persitence classes to not tie into a vendor.
Straight JDBC

XML Parsing
SAX/DOM/JAXB? I don't really know yet

JavaFX - Peg Game.

2009-07-26T23:22:00.001-07:00

JavaFX is a technology from SUN ( recently taken over by Oracle ) that competes against Adobe Flash and Microsoft Silverlight.

This article shows how to build a simple JavaFX program to play the 'Peg Game'.

The Peg game is played with a triangular piece of board with 15 holes in it. One hole (usually the top) is left open and golf tees are placed into the other 14. The objective is to hop over the pegs, removing the hopped peg, and in doing so remove all but one peg from the game.

Here it is in action: http://turnbasedgames.appspot.com/lastblock/Last_Block_Standing.html

To create this game I have four files:

Main.fx
TriangleBase.fx
GameSquare.fx
Util.java

Main.fx consists of:

package javafxapplication1;

import javafx.scene.paint.Color;
import javafx.scene.paint.LinearGradient;
import javafx.scene.paint.Stop;
import javafx.scene.Scene;
import javafx.scene.shape.Circle;
import javafx.scene.shape.Rectangle;
import javafx.scene.text.Font;
import javafx.scene.text.Text;
import javafx.stage.Stage;
import javafxapplication1.TriangleBase;

/**
* @author Lars Vogel
*/
Stage {
var rect: Rectangle;
var circ: Circle;
title: "Last Block Standing"
scene: Scene {
width: 500
height: 500
var myString = "Last Block Standing"
var gameInstance: TriangleBase = new TriangleBase;
content: [
gameInstance,
Rectangle {
x: 50,
y: 300
width: 50,
height: 15
arcHeight: 2
arcWidth: 2
stroke: Color.BLACK
strokeWidth: 2
fill: LinearGradient {
startX: 0.0
startY: 0.0
endX: 0.0
endY: 1.0
stops: [
Stop {
color: Color.ORANGE
offset: 0.0
},
Stop {
color: Color.DARKRED
offset: 0.3
},
Stop {
color: Color.ORANGE
offset: 1.0
},
]
}
onMouseClicked: function(me) {
gameInstance.restart();
}
}
Text {
fill: Color.WHITE
font: Font {
name: "Arial Bold"
size: 12
}
x: 55,
y: 315
content: "Restart"
}
]
}
}

Triangle Base:
/*
* TriangleBase.fx
*
* Created on Jul 23, 2009, 10:55:02 PM
*/

package javafxapplication1;

import javafx.scene.control.Control;
import javafx.scene.Group;
import javafx.scene.Node;

/**
* @author avalanche
*/

public class TriangleBase extends Control {
public override function create(): Node {
return group;
}

var group: Group =
Group {
content: [
]
};
public function buildContent() {
insert GameSquare{ SquareId:1 x1:50 y1:0 hasTee:false} into group.content;
insert GameSquare{ SquareId:2 x1:40 y1:20} into group.content;
insert GameSquare{ SquareId:3 x1:60 y1:20} into group.content;
insert GameSquare{ SquareId:4 x1:30 y1:40} into group.content;
insert GameSquare{ SquareId:5 x1:50 y1:40} into group.content;
insert GameSquare{ SquareId:6 x1:70 y1:40} into group.content;
insert GameSquare{ SquareId:7 x1:20 y1:60} into group.content;
insert GameSquare{ SquareId:8 x1:40 y1:60} into group.content;
insert GameSquare{ SquareId:9 x1:60 y1:60} into group.content;
insert GameSquare{ SquareId:10 x1:80 y1:60} into group.content;
insert GameSquare{ SquareId:11 x1:10 y1:80} into group.content;
insert GameSquare{ SquareId:12 x1:30 y1:80} into group.content;
insert GameSquare{ SquareId:13 x1:50 y1:80} into group.content;
insert GameSquare{ SquareId:14 x1:70 y1:80} into group.content;
insert GameSquare{ SquareId:15 x1:90 y1:80} into group.content;
}

public function restart() {
delete group.content;
buildContent();
println("performing restart");
}
postinit{
buildContent();
}

}

GameSquare:
/*
* Node.fx
*
* Created on Jul 23, 2009, 11:12:07 PM
*/

package javafxapplication1;

import javafx.scene.control.Control;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafxapplication1.Util;
import java.util.HashMap;

var clickedSquare: GameSquare= null;
var gameSquareMap = new HashMap();

public class GameSquare extends Control {
public var SquareId: Integer;
public var squareColor: Color = Color.GREEN;
public var x1: Number;
public var y1: Number;
public var hasTee: Boolean = true;

var rect: Rectangle =
Rectangle{

fill: bind squareColor;

height: (20 * 2)
width: (20 * 2 )
translateX: (x1 * 2 )
translateY: (y1 * 2)
stroke: Color.BLACK;
onMouseClicked: function(me){

// first click, and I have a tee
if (clickedSquare == null and this.hasTee == true) {
println("setting clickedsquare");
clickedSquare = this;
clickedSquare.setIsClicked(true)

// second click, and I don't have a tee
}else if(this.hasTee == false and clickedSquare != null) {
// Find square we jumped over.
var hoppedNode = Util.getHoppedNode(clickedSquare.SquareId, this.SquareId);
if (hoppedNode != -1 ) {
var hoppedSquare = gameSquareMap.get(hoppedNode) as GameSquare;
if (hoppedSquare.hasTee) {
// hopped square is now empty
hoppedSquare.setHasTee(false);
this.setHasTee(true);
clickedSquare.setHasTee(false);
}
}
clickedSquare.setIsClicked(false);
clickedSquare = null;
} else {
//invalid remove marker for first click so user can try again.
clickedSquare.setIsClicked(false);
clickedSquare = null;
}

}
}

public override function create(): Rectangle {
return rect;
}
function setIsClicked(arg:Boolean) {
if (arg==true) {
squareColor = Color.BROWN;
}
else {
setHasTee(hasTee); //set to proper color;
}
}

function setHasTee(arg:Boolean) {
hasTee = arg;
if (hasTee == true) {
squareColor = Color.GREEN;
} else {
squareColor = Color.RED;
}
}

postinit {
this.setHasTee(hasTee);
gameSquareMap.put(SquareId, this);
}
}

Util.java

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

package javafxapplication1;

import java.util.HashMap;
import java.util.Map;

/**
*
* @author avalanche
*/
public class Util {
static Map connections = new HashMap();
static {
connections.put("1,4", 2);
connections.put("1,6",3);
connections.put("2,7",4);
connections.put("2,9",5);
connections.put("3,8",5);
connections.put("3,10",6);
connections.put("4,6",5);
connections.put("4,11",7);
connections.put("4,13",8);
connections.put("5,12",8);
connections.put("5,14",9);
connections.put("6,13",9);
connections.put("6,15",10);
connections.put("7,9",8);
connections.put("8,10",9);
connections.put("11,13",12);
connections.put("12,14",13);
connections.put("13,15",14);
}
static public int getHoppedNode(int x, int y ) {
int lowest = Math.min(x,y);
int highest = Math.max(x,y);
Integer value = connections.get(lowest+","+highest);
if ( value == null )
return -1;
else
return value;

}

}

(This article is a placeholder, I'm going to come back and comment later)

Too many open files

2009-06-18T17:40:00.000-07:00

I owned a web server about a year ago that would crash every other night. I did everything I could to try to track down the exception (Too many open files), but I couldn't figure out what was causing it. I eventually chalked it up to a glassfish bug since they did have that problem before.

Well today I hit it again, this time in a tomcat instance. I ran across a form posting suggesting I try this command:

ls -l /proc/[pid]/fd

Which is an awesome command that I wish I knew about a year ago. This showed all the files that were opened which were indeed my fault. The problem came from a dom4j reader that wasn't being closed which was leaking the file connection. By closing the datastream the problem went away.

So if you have this problem on linux try the above command and see who is opening that file.

Hope that helps,
Chris

Use Python to post to twitter

2009-04-22T00:39:00.000-07:00

Here is an example of using python to post to twitter.

def twit(login, password, msg):

payload= {'status' : msg, 'source' : 'TinyBlurb'}
payload= urllib.urlencode(payload)

base64string = base64.encodestring('%s:%s' % (login, password))[:-1]
headers = {'Authorization': "Basic %s" % base64string}
url = "http://twitter.com/statuses/update.xml"

result = urlfetch.fetch(url, payload=payload, method=urlfetch.POST, headers=headers)

return result.content

Find all files that aren't in perforce

2009-04-21T16:12:00.001-07:00

dir /s/b/a-d | p4 -x- have > nul: 2>missing.txt

Returning immutable collections

2009-04-10T23:19:00.000-07:00

Many times it is desirable to return an internal collection object to consumers of your class.

For example:

class Foo {
  List _internalObjects = new ArrayList();

  List getList() {
    return _internalObjects;
  }
}

The method above works, but has a draw back. The elements of your internalObjects list are now mutable outside your control. In C++ you might try to return const& instead to get around this problem, but how do you solve this in Java?

The first approach might be to return a copy. e.g:

class Foo {
  List _internalObjects = new ArrayList();

  List getList() {
    List copy = new ArrayList();
    copy.addAll(_internalObjects);
    return copy;
  }
}

This has the desired effect but with a couple of disadvantages. First you had to perform the copy which could be a performance bottleneck. Second the consumer may no longer point to the same objects if you modify your internalObject class.

The best way, that I know of, to do this is as follows:

class Foo {
  final List _internalObjects = new ArrayList();

  List getList() {
   
    return new AbstractList() {
            @Override
            public Object get(int index)
            {
                return _internalObjects.get(index);
            }
            @Override
            public int size()
            {
                return _internalObjects.size();
            }
    };
  }
}

The returned list still points to internal list, but is read only. Also, just to be pedantic, I've marked the list as final which means the reference will never change which is more correct for this example.

I hope that helps, leave comments on what you think.

@developresource

Add new line at end of file.

2009-03-27T18:00:00.000-07:00

Working on a cross platform c++ project I find it annoying that Linux requires a new line at the end of each file. I constantly forget to do this.

I wrote this simple macro which will add the new line each time you save a file.

You don't need the whole thing. Most of this is generated in EnvironmentEvents but saved here for posterity.



Option Strict Off
Option Explicit Off
Imports System
Imports EnvDTE
Imports EnvDTE80
Imports System.Diagnostics

Public Module EnvironmentEvents

#Region "Automatically generated code, do not modify"
'Automatically generated code, do not modify
'Event Sources Begin
  Public WithEvents DTEEvents As EnvDTE.DTEEvents
  Public WithEvents DocumentEvents As EnvDTE.DocumentEvents
  Public WithEvents WindowEvents As EnvDTE.WindowEvents
  Public WithEvents TaskListEvents As EnvDTE.TaskListEvents
  Public WithEvents FindEvents As EnvDTE.FindEvents
  Public WithEvents OutputWindowEvents As EnvDTE.OutputWindowEvents
  Public WithEvents SelectionEvents As EnvDTE.SelectionEvents
  Public WithEvents BuildEvents As EnvDTE.BuildEvents
  Public WithEvents SolutionEvents As EnvDTE.SolutionEvents
  Public WithEvents SolutionItemsEvents As EnvDTE.ProjectItemsEvents
  Public WithEvents MiscFilesEvents As EnvDTE.ProjectItemsEvents
  Public WithEvents DebuggerEvents As EnvDTE.DebuggerEvents
  Public WithEvents ProjectsEvents As EnvDTE.ProjectsEvents
  Public WithEvents TextDocumentKeyPressEvents As EnvDTE80.TextDocumentKeyPressEvents
  Public WithEvents CodeModelEvents As EnvDTE80.CodeModelEvents
  Public WithEvents DebuggerProcessEvents As EnvDTE80.DebuggerProcessEvents
  Public WithEvents DebuggerExpressionEvaluationEvents As EnvDTE80.DebuggerExpressionEvaluationEvents
'Event Sources End
'End of automatically generated code
#End Region




    Private Sub DocumentEvents_DocumentOpened(ByVal Document As EnvDTE.Document) Handles DocumentEvents.DocumentOpened

    End Sub

    Private Sub DocumentEvents_DocumentSaved(ByVal Document As EnvDTE.Document) Handles DocumentEvents.DocumentSaved                

        Dim textSelection As EnvDTE.TextSelection

        textSelection = CType(DTE.ActiveDocument.Selection(), EnvDTE.TextSelection)
        textSelection.EndOfDocument(True)
        textSelection.EndOfLine()
        If textSelection.Text <> vbCrLf Then
            textSelection.Text = textSelection.Text & vbCrLf
        End If



    End Sub
End Module

Visual Studio Macros for source control.

2009-03-27T12:20:00.000-07:00

Visual Studio allows for users to customize the environment by writing macros. With Visual Studio 2008 the macros can be written in VB.Net. VB.Net is a very powerful language as it can use any of the standard .NET object, and in addition it has access to Visual Studios ENVDTE object.

The following set of macros replace the buggy Perforce source control plugin.


Imports System
Imports EnvDTE
Imports EnvDTE80
Imports System.Diagnostics

Public Module MiscCommands
    Sub P4Add()
        Dim filename As String = DTE.ActiveWindow.Document.FullName
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "add " + filename)        
    End Sub

    Sub P4Edit()
        Dim filename As String = DTE.ActiveWindow.Document.FullName
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "edit " + filename)        
    End Sub

    Sub P4Diff()
        Dim filename As String = DTE.ActiveWindow.Document.FullName
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "diff " + filename)        
    End Sub

    Sub P4Revert()
        Dim filename As String = DTE.ActiveWindow.Document.FullName        
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "revert " + filename)        
    End Sub

    Sub P4Opened()        
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "opened")
    End Sub

    Sub P4History()
        Dim filename As String = DTE.ActiveWindow.Document.FullName        
        ChDir("c:\p4")
        ExecuteCommand("p4.exe", "filelog " + filename)
    End Sub

    Public Sub ExecuteCommand(ByVal filename As String, ByVal arguments As String)        

        Dim p As New System.Diagnostics.Process
        p.StartInfo.UseShellExecute = False
        p.StartInfo.FileName = filename
        p.StartInfo.Arguments = arguments
        p.StartInfo.RedirectStandardOutput = True
        p.StartInfo.RedirectStandardError = True
        p.Start()
        p.WaitForExit()


        WriteToMyNewPane(filename + " " + arguments, p.StandardOutput.ReadToEnd + p.StandardError.ReadToEnd)


    End Sub

    Public Sub WriteToMyNewPane(ByVal command As String, ByVal results As String)
        Dim win As Window = _
           DTE.Windows.Item(EnvDTE.Constants.vsWindowKindOutput)
        Dim ow As OutputWindow = win.Object
        Dim owPane As OutputWindowPane
        Dim cnt As Integer = ow.OutputWindowPanes.Count
        owPane = ow.OutputWindowPanes.Item(1)
        owPane.OutputString(command & vbCrLf)
        owPane.OutputString(results & vbCrLf)
        owPane.Activate()
    End Sub


    Sub OpenFile()
        Dim fileName As String = InputBox("Open file:")
        If String.IsNullOrEmpty(fileName) Then
            Return
        End If
        Dim item As EnvDTE.ProjectItem = DTE.Solution.FindProjectItem(fileName)
        If item Is Nothing Then
            MsgBox("File not found", MsgBoxStyle.Exclamation)
            Return
        End If
        item.Open()
        item.Document.Activate()
    End Sub

End Module

C# Key Listener

2009-02-05T18:15:00.000-08:00

CodeGuru has this post:

Hi All

Looking for a little help..

I would like to create a process that runs on both a Windows XP and Vista Machines that loads on startup, what this process will do is, on the "F12" keypress it brings up a simple form that a user fills in some details then clicks on send, then it goes back to sleep and waits on the "F12" key being pressed.

Never created a process before so any help is appreciated.

Cheers

Djbell

This post will describe how to do this in C#. We will approach this by creating an executable that could be loaded at startup. It will listen for the F12 keyboard event and present a message box.

Create a new C# Console project in Visual Studio, call it 'ListenForHotkey.'

We will use a windows hook to notify our application when a key is pressed. So in the Program.cs file you should define four win32 API's. SetWindowsHookEx, UnhookWindowsHookEx, GetModuleName, CallNextHookEx. We'll also define a delegate for the callback, and some constants.

Here is the Program.cs with these definitions.

using System;
using System.Runtime.InteropServices;   //Used for dll import
using System.Diagnostics;               //'Process'

namespace ListenForHotkey
{
    static class Program
    {        
        [STAThread]
        static void Main()
        {        
        }        
        // Define win32 api calls.
        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool UnhookWindowsHookEx(IntPtr hhk);


        [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr GetModuleHandle(string lpModuleName);

        [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError = true)]
        private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
            IntPtr wParam, IntPtr lParam);

        //Define delegate for the callback.
        private delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);

        //Define constants
        private const int WH_KEYBOARD_LL = 13;
        
    }
}

In the code above we've defined a delegate called LowLevelKeyboardProc that is the signature of the callback. Let's add our callback.

// Callback, executed when hook is triggered. In our case on keydown.            
        private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
        {            
            System.Console.WriteLine("key pressed");
         
            //Call next hook in chain.
            return CallNextHookEx(m_hookId, nCode, wParam, lParam);

        }

Our callback simply prints that a key was pressed then calls the next hook if applicable. This is important else another application that register a hook may not be called.

Lastly we should register our hook, and run the app. This is done in the main method.

[STAThread]
        static void Main()
        {
            using (Process curProcess = Process.GetCurrentProcess())
            using (ProcessModule curModule = curProcess.MainModule)
            {

                m_hookId = SetWindowsHookEx(WH_KEYBOARD_LL, HookCallback, GetModuleHandle(curModule.ModuleName), 0);
            }
            System.Windows.Forms.Application.Run();
            UnhookWindowsHookEx(m_hookId);
        }

In main we register the callback then call Application.Run() which puts the app in an infinite loop by waiting for any system messages. When the program is ready to exit we unregister our hook.

That's it.

Hope it helps.

GWT Programming Concepts

2009-02-05T17:25:00.000-08:00

GWT Programming Concepts

This tutorial will introduce the architecture of GWT. It is aimed at programmers with little or no Java experience, but with reasonable experience with other programming languages using object oriented programming.

GWT is a single application. It consists of a series of panels. There may be a single panel onto which other panels are places, or multiple panels. You create and place Widgets onto these panels. Widgets are items like hyperlinks, textbox's, buttons, etc. With each of these widgets you can attach event listeners that will be execute when appropriate. For example you can attach a click listener to a button and when the user clicks the button, the action will be performed.

The important part of GWT is that panels and widgets are added using Java code.
Each widget (which includes a Panel) is an object that is derived from a number of base classes. For example:

UIObject : the base class with properties or methods:

* Size
* Width
* toString

Widget : derived from UIObject (so has its properties and methods), extended by:

* attached
* parent

FocusWidget : derived from Widget (so has its properties and methods), extended by:

* ClickListenerCollection
* addClickListener

Button : derived from FocusWidget (so has its properties and methods), extended by:

* getHTML
* setHTML

So through a series of inherited commands, the Panel object is instructed by GWT to deliver its HTML. Before delivering its own html, it instructs its children objects to deliver their html. Before their delivery, they also ask their children. And so on, until there are no unpolled children. In this way, the panel's html incorporates all the required html for all of its children.

So as a programmer, all you need to do is to slap down some panels, add some widgets containing the text, buttons, menu items, response to button clicks etc that you want and save it.

The command to "compile" the program takes all the Java objects you have created in your code, pulls out the required html and programmed actions and creates a final html container with a large amount of Javascript that writes the html you instructed through your Java objects.

far more functional and much more fun.

Protocol Buffers

2009-01-14T00:41:00.000-08:00

Protocol buffers is another way to serialize/deserialize data.

It was written by Google and supports Java, C++, Perl, and Python.

There website is at: http://code.google.com/p/protobuf/

I'm planning on trying this out for a c++ project I maintain where we need blindingly fast ( as fast we can get ) serialization, and de-serialization performance.

Once I've played with it, I'll post more information.

Flyweight Pattern

2009-01-13T20:39:00.000-08:00

Flyweight design pattern is a software design pattern used to minimize memory usage by sharing data. It enables use of large number of objects that would typically require a lot of memory.

A common example of the Flyweight pattern is string pooling. Consider the Java programming language. The String data type is immutable. Because it is guaranteed that the string can never be changed the strings are pooled to ensure that only one instance exists in memory at any given time.

So if you create two strings s1 and s2 which both point to "foo" you really have two pointers to the same location in memory.

Java also employs the Flyweight pattern for Integer object. new Integer(0) actually returns a pointer to pre-constructed object. So if you create one-thousand Objects which each contain an Object of type Integer you will only have one Integer(0) which is an excellent way to save memory.

While your writing your programs consider if you could use the Flyweight pattern to save memory. An example I used was for a Object that contained three Strings. This tuple uniquely identified a configuration of runs that were stored in the database. The Strings were loaded via JDBC so they didn't get the String pooling provided by Java. Instead I made the constructor to the class private and exposed a public static method called 'get'. This method took the three strings and created the object if not already existing and returned a pointer. This cut my memory usage drastically.

Here is an example of my use of the Flyweight pattern.


class Product {
  private Product() { } // don't let anyone explicitly create this object.
  private static Map products = new HashMap();
  public get(String arch, String chip, String config) { 
    Product p = products.get(arch + chip + config).hashCode());
    if (p == null)
      products.put(arch + chip + config).hashCode(),new Product(arch,chip,config));
    return products.get(arch + chip + config).hashCode());
  }
}

If your using c++ you should look at the boost flyweight class. It hides the implementation and makes adding a flyweight to your c++ code trivial. http://svn.boost.org/svn/boost/sandbox/flyweight/libs/flyweight/doc/index.html

Counting code lines.

2009-01-13T13:29:00.001-08:00

I was curious how many lines of code my Java application had. I found this script very useful in finding out.

Here it is, in case it is helpful:


find . -name "*java" -exec wc -l {} \; | grep -v "/test/" | awk '{print sum+=$1} END {print "Sum: "sum}'

First it finds all files with the extension java (change to cpp, or pl, or py if you need to). It runs wc -l on each file to count the lines.

Then it removes my test directory, you can use -vE for a regular expression of items to remove or remove that command all together.

I then use awk to sum up the file line count and print out the increasing amount as well as the sum at the end.

Hope that helps.

Google Chrome planned Mac rease middle of 2009

2009-01-12T14:58:00.000-08:00

The popular Google Chrome browser is planned to be released for Mac in the middle of 2009. This should bring competition for the current default browser, Safari.

Google Chrome is also planning to add pluggable extensions which Mozilla's firefox has had for sometime.

These two changes should make Google Chrome an even more likely choice for consumers. In the end more competition is always good and Google's entry into the market will help keep the innovations coming.

Boost scoped lock

2009-01-12T01:22:00.000-08:00

I have been very impressed with the Boost libraries. Each day I'm finding more and more uses of Boost that make C++ programming easier.

My latest enjoyment comes from boost::mutex::scoped_lock.

scoped_lock follows the RAII (Resource Allocation Is Initialization) pattern. When the lock is constructed it holds onto the mutex until it is destructed.

Here is a simple example:


class Foo 
{
   public:
   void bar() 
   {
       // Will grab the resource or wait until free
       ::boost::mutex::scoped_lock lock(m_mutex); 
       //Critical section

       // No need to unlock the lock will do that itself.
   }
private:
boost::mutex m_mutex;
}

One word of caution. Up to Boost 1.36 the behavior of the mutex was different on Windows vs Linux. On Windows the lock would be recursive, that is you could call another method and enter it your thread already held that lock. Whereas on Linux that would cause a deadlock. The 1.37 version has fixed this issue and the both behave like the Linux version.

Pro's and Con's of returing references

2009-01-07T22:27:00.000-08:00

I've recently began working on a moderate size C++ application. The previous developer loved the benefits of returning const&.

For those who don't know returning const& can avoid an extraneous copy. Example:


class Foo {
  Foo(std::string s) { m_name = s; }
  std::string m_name;
public:
  std::string const& name() { return m_name; }
}

The above code avoids the copy from m_name to the function return value that would have resulted with the following client code:


  Foo f("bar"); 
  std::string name = f.name();

After working in this code base for a while now I believe that returning references are evil and should be treated just like returning a pointer, which is avoid it.

For example the problem that arose that took a week to debug was the following:


  class Foo {
    std::vector< Bar > m_vec;
  public:
    void insert(Bar& b) { m_vec.push_back(b); }
    Bar const& getById(int id) { return m_vec[id]; }
  }

The problem in this example is clients are calling and getting references that are stored in the vector. Now what happens after clients insert a bunch of new elements? The vector needs to resize internally and guess what happens to all those references? That's right there invalid. This caused a very hard to find bug that was simply fixed by removing the &.

The conclusion I've arrived at is that returning a & is a pre-mature optimization. If your profiling shows you your code is very slow at this point than maybe consider it. But you should also be aware that most modern compilers optimize away this extra copy anyways.

Here is a contrived example that shows problems you can get into by blindly returning references. My advice avoid them until your profiler tells you that you have a problem.


#include 
#include 
#include 

using namespace std;

class foo {
    std::string m_string;
    public:
    std::string const  getName(){
       static int count = 0;
       count++;
       std::stringstream ss;
       ss << count ;
       m_string = ss.str();
       return m_string;
    }
};
foo f;
void fun(std::string const&s) {
    f.getName();
    std::cout << s;
}
int main() {
    std::cout << " print version " << std::endl;
    fun(f.getName());
}

Hope that Helps

VIM formatting

2008-11-19T12:42:00.000-08:00

To auto format a section of code in vim use '=' followed by a movement command.

For example if you want to format


void foo() {
  int blah;
      int foo;
          int bar;
}

Navigate the the first '{' and press '=%' = will tell it format, where '%' will tell it to go to the corresponding block.

PHP Sample Command Line Scrip

2008-09-25T01:19:00.000-07:00

Some co-workers of mine didn't believe that PHP could be used from the command line. I was rather suprised by this, and thought others might be under the same impression. To help spread the word, here's a very simple example of a php script meant to be run from the command line.

<?php

if ($argc != 2 || in_array($argv[1], array('--help', '-help', '-h', '-?'))) {
?>

This is a command line PHP script with one option.

  Usage:
  <?php echo $argv[0]; ?> <option>

  <option> can be some word you would like
  to print out. With the --help, -help, -h,
  or -? options, you can get this help.

<?php
} else {
    echo $argv[1];
}
?>

PHP Web Service example.

2008-09-25T01:01:00.000-07:00

Its been a while since I used PHP. The last time I used it was PHP 4. I felt it was time to revisit the language. I have good memories of PHP. It was better than perl and it worked reasonably well for a mediawiki installation I maintained.

If you view the other post I've made, you'll see that a first test of a language that I like to do is to see if it supports a simple SOAP call. This tutorial will be the same test for PHP.

First lets install it. If you use any *nix system you'll probably already have it installed. If not or if you want the latest copy then go to http://www.php.net/downloads.php and download the version for you install. I chose the windows installer. During the setup process it asked which extensions I would like installed I opted for the SOAP library which will be needed for the rest of the tutorial.

I installed PHP in the default location of c:\program files\php, so I opened a command prompt and browsed to that location.

Now for our simple web service test. We'll be accessing 'http://webservices.daehosting.com/services/isbnservice.wso?WSDL' and asking if a given ISBN is valid or not.

The first task is create a new SOAPClient object.


$client = new SOAPClient('http://webservices.daehosting.com/services/isbnservice.wso?WSDL');

Now we call our method which is named '>IsValidISBN13'. Like perl's SOAP::Lite we need to give a hash as our argument so the web service knows which variable were passing so we first create a parameter list, then call the function.



$params = array('sISBN'=>"9781565926103");
$result = $client->IsValidISBN13($params);

So far so good. Now the only tricky part I found of the process. The PHP Soap libraries return a stdClass. We need to unravel this into something meaningful to us. The documentation uses this function so I did as well.


function obj2array($obj) {
  $out = array();
  foreach ($obj as $key => $val) {
    switch(true) {
        case is_object($val):
         $out[$key] = obj2array($val);
         break;
      case is_array($val):
         $out[$key] = obj2array($val);
         break;
      default:
        $out[$key] = $val;
    }
  }
  return $out;
}

Then lastly I just print out the array which contains our result:


print_r(obj2array($result));

You can now experiment by passing different ISBN's ones that are both valid and invalid and you'll see the result is different. You can also call the method that checks for validity of a 10 character length ISBN.

Here is the entire code listing.

<?php

$client = new SOAPClient('http://webservices.daehosting.com/services/isbnservice.wso?WSDL');
$params = array('sISBN'=>"9781565926103");
$result = $client->IsValidISBN13($params);

function obj2array($obj) {
  $out = array();
  foreach ($obj as $key => $val) {
    switch(true) {
        case is_object($val):
         $out[$key] = obj2array($val);
         break;
      case is_array($val):
         $out[$key] = obj2array($val);
         break;
      default:
        $out[$key] = $val;
    }
  }
  return $out;
}


print_r(obj2array($result));


?>

Boost Python - Abstract Classes

2008-09-22T22:11:00.001-07:00

In the previous article I covered setting up Boost Python to work in Visual Studio.

In this article were going to get into a bit more detail of describing the bindings of classes. Specifically were going to deal with abstract classes and polymorphism.

Consider the following:

struct AbstractClass {
    virtual std::string speak() const = 0;
};

struct DerivedClassA : AbstractClass {
    virtual std::string speak() const {return "Derived Class A";}
};

struct DerivedClassB : AbstractClass {
    virtual std::string speak() const {return "Derived Class B";}
};

We have an Abstract Class and two derived class that implement the speak method. How do we model this in Boost Python such that in Python we can get a pointer to one of these objects and call speak on the proper derived class.

To do this we have to build a wrapper class:

struct WrapperClass : AbstractClass , boost::python::wrapper<AbstractClass> { 
    virtual std::string speak() const {
        return this->get_override("speak")();
    }
};

This wrapper class extends the AbstractClass, and extends a special boost::python::wrapper. For each virtual method you wrap it and call it with this->get_override().

Lastly you need to define the bindings for Python, this is similar to the Hello World example in article one:

BOOST_PYTHON_MODULE(PyHelloWorld)
{
    using namespace boost::python;
    def("getDerivedClassA",&getDerivedClassA,return_value_policy< manage_new_object >());
    def("getDerivedClassB",&getDerivedClassB,return_value_policy< manage_new_object >());
    class_<WrapperClass, boost::noncopyable > ("DerivedClass") 
        .def("speak",boost::python::pure_virtual(&AbstractClass::speak))
        ;
    
}

Here we added two test methods called getDerivedClassA and getDerivedClassB these will be in the package PyHelloWorld as dictated by 'BOOST_PYTHON_MODULE(PyHelloWorld)'

Lastly we want to be able to execute python in the same process as our executable. If you followed the instructions in part 1 then you simply need to add this method:

void start( ) {        
    using namespace boost::python;            
    Py_Initialize();    
    // Explicitly call the method that the BOOST_PYTHON_MODULE macro created.
    // This sets up our DLL to be used by python. 
    initPyHelloWorld();
    std::string pythonCommand;
    try {
        PyRun_SimpleString("import PyHelloWorld");        
        while(1) {
            std::cout << ">>> "; 
            getline(std::cin,pythonCommand);                           
            if (pythonCommand == "quit") {
                break; 
            }else {
                std::cout << PyRun_SimpleString(pythonCommand.c_str());
            }
        }
    } catch ( error_already_set ) {
        PyErr_Print();
    }
    Py_Finalize();                    
}

So now lets try it:


>>> import PyHelloWorld
0>>> a = PyHelloWorld.getDerivedClassA()
0>>> b = PyHelloWorld.getDerivedClassB()
0>>> print a.speak()
Derived Class A
0>>> print b.speak()
Derived Class B
0>>>

Boost Python

2008-09-18T22:20:00.000-07:00

Boost Python allows seamless interoperability between C++ and Python. In this article we'll setup Boost and build a simple hello world program that will be able to run in Python.

Boost, in case your unfamiliar, is a powerful set of libraries for C++. There website is at www.boost.org.

For this post we will be using Boost 1.36.0

Boost can be tricky to setup. Their documentation recommends using their own build tool called bjam, but I typically like to build it myself. For this article we'll walk through setting up Boost Python for Visual Studio 2005.

If you haven't already, download boost 1.36.0 library to your local machine. I've expanded the library to c:\download\boost\boost-1.36.0 on my machine.

Now open up Visual Studio 2005. New Project, Visual C++ -> Win32 -> Win32 Console Applicaion.

At the bottom of the screen enter the name for your project: PyHelloWorld, and the location, in my case c:\download\PyHelloWord. The solution name should be filled out for you (PyHelloWorld), and the check mark for 'Create directory for solution' should be checked.

Click Ok.

In the wizard click next. Select 'Dll' as application type, and Empty Project from additional options.

Click finish.

The project we just created will hold our client code, and our python bindings code. Before we can do that though we need to build Boost Python. To do this we'll create another project.

Right click on your solution 'PyHelloWorld', Click Add->Add New Project.

Like before we'll create a Win32 Console Application but we'll call it BoostPython this time. I've decided to keep the project located in the same solution folder of PyHelloWorld.

Follow the steps in the wizard again to create an empty, dll project.

In order to build boost python we need to include all the source files. Visual studio should have created a 'Source Files' filter in the BoostPython project. Right click and select Add->Existing Item...

You want to add all the files from

%PATH_TO_BOOST%\libs\python\src

%PATH_TO_BOOST%\libs\python\src\converter

%PATH_TO_BOOST%\libs\python\src\object

You now need to instruct the compiler that these are part of the boost source code. You do this by setting a preprocessor define. Right click on the BoostPython project, select c/c++ from the property pages, select Preprocessor, and append 'BOOST_PYTHON_SOURCE' to the end of the Preprocessor definitions. Its a semi-colon separated list so add a semi-colon then 'BOOST_PYTHON_SOURCE'.

Next set the include directory to find the Boost install. Right click on the BoostPython project, open the c/c++ -> General tab. Add your path to %PATH_TO_BOOST%, in my case that is C:\download\boost\boost_1_36_0

We've now set up the boost portion, we need to setup python by telling our project how to find our local python installation. First you'll need to download Python

The standard install saved Python under c:\Python25 on my machine. The standard python install comes with c++ headers so we'll point our BoostPython project at those headers.

Once again open the property page for BoostPython, C/C++ -> General , and add c:\Python25\include (or your python install) to the include path.

You can now build the BoostPython project, all the files should compile. The link step will fail though because it needs to link to the Python library as well. So one more tweak to the BoostPython project, this time Linker -> Input , Additional Dependencies. Add C:\Python25\libs\Python25.lib.

Build the project again and it should link successfully.

Okay now we have BoostPython ready to go. Lets Use it.

For the PyHelloWorld project we'll need to do the same steps as above to set the Include Path, and the Linker. More explicity you need to set:

include path to boost
include path to python
linker to python lib

If you don't remember how look above to see what we set.

Now create a new cpp file by right clicking on the project, add->New Item. Selecting cpp file. Call the file hello.cpp

Add the following to the file.

#define BOOST_ALL_NO_LIB
#include <boost/python.hpp>

char const* speak()
{
    return "Hello World!";
}


BOOST_PYTHON_MODULE(PyHelloWorld)
{
    using namespace boost::python;
    def("speak", speak);
}

The first define instruct boost that we have already build it. The first function is your standard c++ function, the second is our python bindings.

Before you build you need to tell visual studio that this project is dependent on the BoostPython Project. Right click on PyHelloWorld project and click Project Dependencies. Select BoostPython.

Now Build. Everything should compile and build succesfully.

So what have we accomplished? We've build a dll that exposes method that python can understand. Lets test it and see if it works.

Open a Command shell, and navigate to your output directory. In my case its c:\download\PyHelloWorld\PyHelloWorld\debug. In order to make it easier for Python to find our dll lets rename it to pyd.

move PyHelloWorld.dll PyHelloWorld.pyd

Now lets load up the interpreter and try it out:


c:\download\PyHelloWorld\PyHelloWorld\debug>c:\Python25\python.exe
Python 2.5.2 (r252:60911, Feb 21 2008, 13:11:45) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import PyHelloWorld
>>> print PyHelloWorld.speak();
Hello World!
>>>

There you go, python interacting with your c++ file. Now that you have the BoostPython project created it would be easy to do this binding for more complex types. The official docs cover how to use this for classes, virtual functions, etc. For more info I recommend you start there. http://www.boost.org/doc/libs/1_36_0/libs/python/doc/tutorial/doc/html/index.html

Hope that helps...

Enforce Noninstantiability With a Private Constructor

2008-09-17T23:33:00.000-07:00

Occasionally you'll want to write a class that is just a grouping of static methods and static fields. Such classes have acquired a bad reputation because some people abuse them to avoid thinking in terms of objects, but they do have valid uses. They can be used to group related methods on primitive values or arrays, in the manner of java.lang.Math or java.util.Arrays. They can also be used to group static methods, including factory methods, for objects that implement a particular interface, in the manner of java.util.Collections. Lastly, they can be used to group methods on a final class, instead of extending the class.

Such utility classes were not designed to be instantiated: an instance would be nonsensical. In the absence of explicit constructors, however, the compiler provides a public, parameterless default constructor. To a user, this constructor is indistinguishable from any other. It is not uncommon to see unintentionally instantiable classes in published APIs.

Attempting to enforce noninstantiability by making a class abstract does not work. The class can be subclassed and the subclass instantiated. Furthermore, it misleads the user into thinking the class was designed for inheritance (Item 17). There is, however, a simple idiom to ensure noninstantiability. A default constructor is generated only if a class contains no explicit constructors, so a class can be made noninstantiable by including a private constructor:

// Noninstantiable utility class
public class UtilityClass {
   // Suppress default constructor for noninstantiability
   private UtilityClass() {
      throw new AssertionError();
   }
   ... // Remainder omitted
}

Because the explicit constructor is private, it is inaccessible outside of the class. The AssertionError isn't strictly required, but it provides insurance in case the constructor is accidentally invoked from within the class. It guarantees that the class will never be instantiated under any circumstances. This idiom is mildly counterintuitive, as the constructor is provided expressly so that it cannot be invoked. It is therefore wise to include a comment, as shown above.

As a side effect, this idiom also prevents the class from being subclassed. All constructors must invoke a superclass constructor, explicitly or implicitly, and a subclass would have no accessible superclass constructor to invoke.

This pattern also works well when you want the ability to cache an object. For example if you were creating a String class that is immutable. For every String "FOO" created you want one instance. If you make the class notinstantiable and instead add a String.get("foo") method, you can ensure that you return one and only one instance. For example:

public class MyString {
  private MyString() { }
  private WeakHashMap<String,String> map = new WeakHashMap<String,String>();
  public get(String s) {
    if (map.get(s)) 
      return map.get(s); 
    else {
      map.put(s,s);   
      return map.get(s); 
    }
  }
}

In fact this pattern is used for the Java Integer class. It is recommended you use Integer.valueOf(int i). We can see why by looking at their code:

private static class IntegerCache {
    private IntegerCache(){}

    static final Integer cache[] = new Integer[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
        cache[i] = new Integer(i - 128);
    }
    }

    /**
     * Returns a <tt>Integer</tt> instance representing the specified
     * <tt>int</tt> value.
     * If a new <tt>Integer</tt> instance is not required, this method
     * should generally be used in preference to the constructor
     * {@link #Integer(int)}, as this method is likely to yield
     * significantly better space and time performance by caching
     * frequently requested values.
     *
     * @param  i an <code>int</code> value.
     * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
    final int offset = 128;
    if (i >= -128 && i <= 127) { // must cache 
        return IntegerCache.cache[i + offset];
    }
        return new Integer(i);
    }

For any value between -128 and 127 the class has already been constructed and when you call it, you simply get a pointer to that Object.

So in conclusion when you have a class that you don't always want instantiated you should consider making the constructor private.

QuickSort (c++)

2008-09-16T00:48:00.000-07:00

Quicksort is a popular sorting algorithm. It runs in O(n log n). The sort is not stable meaning equal values may not appear in the same order. For this post we'll write a simple quick sort implementation.

Lets start with the entire code listing then we'll break it apart:

void swap(int &a, int &b) {
    int temp = a ;
    a = b;
    b = temp;
}

int partition(int * arr,int left, int right, int pivotIndex) {
    int pivotValue = arr[pivotIndex];
    swap(arr[right],arr[pivotIndex]);
    int storeIndex = left;
    for (int i=left;i<right -1; ++i) {
        if (arr[i] < pivotValue) {
            swap(arr[i],arr[storeIndex]);
            storeIndex++;
        }
    }
    swap(arr[storeIndex],arr[right]);
    return storeIndex;
}

void quicksort(int * arr, int left , int right) {
    if  (right > left) {
        int pivotIndex = left;
        int pivotNewIndex = partition(arr,left,right,pivotIndex); 
        quicksort(arr,left,pivotNewIndex-1);
        quicksort(arr,pivotNewIndex+1,right);
    }
    
}


int main(int argc, char** argv) {
    int arr[10] = { 3, 6, 1, 5, 3, 2, 6, 8, 9, 6};
    quicksort(&arr[0],0,9);
    for(int i = 0 ; i < 10; ++i) {
        printf("%d" , arr[i]);
    }
}

We have 3 methods not including main. Swap is a utility method that swaps the values.

The heart of the algorithm is the partition method. We choose value in the array and do a O(n) walk of the list putting all elements with value less than the chosen value before and all elements greater than the chosen value after the value. Our code is optimized to do it in place without requiring an extra array by moving the pivot to the end and then swapping it back at the end.

Once we have the partition method we simply recursively call quicksort and the list will be sorted.

Javascript Hangman

2008-09-13T16:51:00.000-07:00

Hangman is a popular pencil and paper game. One player chooses a word and draws dashes to represent the length of the word.

The other player guesses letters. If the letter is in the word the dash is replaced with the letter. If the guessed letter is not in the word then a part of the hanging body is drawn (head, body, left leg, right leg, left arm, right arm) once the body is completely drawn or the entire word has been guessed the game is over.

I decided to re-create this game using Javascript and the html canvas object. Javascript is used to handle the game while the canvas is used to draw the hangman character when the guesses are incorrect.

To start lets define a simple html page that includes our canvas and a couple of spans to hold the word and messages for the user.

<html>
 <body onload="draw();" onkeyup="handleKeyUp(event);">
    <table>
        <tr>
            <td colspan=2>
                <span id='alreadyGuessed' style="visibility:hidden">Letter already guessed</span>
                <span id='strike' style="visibility:hidden">Strike!</span>
            </td>
        </tr>
        <tr>
            <td>
                <canvas id='hangman' width=150 height=150>
            </td>    
            <td>
                <span id='word'></span>                        
            </td>
        </tr>
    </table>
 </body>
</html>

When the page is loaded we call 'draw()' and we setup a keyboard listener to listen to keystrokes. We've defined a few simple span's that will be messages to the user, a canvas to draw the victim and a span to hold the word that the user will be guessing.

The game expects a character from A-Z so our keyboard listener should filter out all other values here is what our listener looks like:

function handleKeyUp(evt) {
  var e = evt ? evt : event; 
  if (e.keyCode >= 65 && e.keyCode < (65+26) ) {
    guess(String.fromCharCode(e.keyCode));            
  }
  draw();
}

The keyCode value is the ASCII representation we know that the ASCII characters are in sequence with capital 'A' being 65 and capital 'Z' being 65+26 characters away. If the user enters a valid character we enter our 'guess' function else we do nothing. After guessing our draw() function is called to redraw the screen.

The draw function as you have now seen is called when the game is first loaded and after each keypress lets see what it does.

function draw() {
        var str='';
        for(i=0;i<word.length;++i) {
            if (foundLetters[i]) {
                str += word[i];
            } else {
                str += '_';
            }
        str += ' ';
        }
        document.getElementById('word').innerHTML = str; 
    }

The draw function looks at our internal data structures which will explore later and determines if the user has guessed a letter yet or not. If the letter has been guessed the letter is shown, else a '_' is shown instead.

So now to the heart of the game, the guess function.

function guess(key) {
        hideMessages();
        if (guessedLetters[key]) {
            showAlreadyGuessed(); 
            return;
        }
        guessedLetters[key] = true;
        var found = false;
        for(i=0;i<word.length;++i) {
            if (word[i] == key) {
                foundLetters[i] = true;
                found=true;
            }
        }
        if(!found) showStrike();
        return found;

    }

The guess function iterates over the chosen word and determines if the character in the word has been guessed. If it has it marks foundLetters[index] where index is the index of the character that has been revealed. We saw in the 'draw' function how this is used to change the display.

The last thing to note is how we use the canvas element to draw a very crude hangman as the user guesses incorrectly.

function drawHangMan(numberOfStrikes) {
        var canvas = document.getElementById('hangman');
        if(canvas.getContext) {
            var ctx  = canvas.getContext('2d');
            ctx.save() ; 
            ctx.translate(45,45);
            ctx.clearRect(0,0,canvas.width,canvas.height); 
            ctx.beginPath();
            if(numberOfStrikes >= 1) ctx.fillRect(0,0,10,10);   //head
            if(numberOfStrikes >= 2) ctx.fillRect(-5,10,20,20); //body
            if(numberOfStrikes >= 3) ctx.fillRect(-20,10,20,5); //left arm
            if(numberOfStrikes >= 4) ctx.fillRect(0,10,30,5);  // right arm
            if(numberOfStrikes >= 5) ctx.fillRect(-5,30,5,10);  // left leg
            if(numberOfStrikes >= 6) ctx.fillRect(10,30,5,10);  // right leg
            
            ctx.fill();
            ctx.restore();
        }
    }

This method is pretty self explanatory. Based on the number of strikes more of the hangman's body will be revealed.

Here is the entire code listing, let me know if you have any questions. Enjoy...

<html>
 <head>
  <script type="application/x-javascript">

    var words = new Array();
    words[0] = "Ford";
     words[1] = "Chevy";
    words[2] = "Mazda";
    words[3] = "Volvo";
    words[4] = "Javascript";
    words[5] = "Google";
    words[6] = "Microsoft";
    words[7] = "Nvidia";


    var rand_no = Math.random();
    rand_no = Math.ceil(rand_no * words.length)-1;


    word = words[rand_no].toUpperCase();
    var foundLetters = new Array();


    var guessedLetters = new Array();
    function hideMessages() {
        document.getElementById("alreadyGuessed").style.visibility='hidden';
        document.getElementById("strike").style.visibility='hidden';
    }
    function showAlreadyGuessed() {
        document.getElementById("alreadyGuessed").style.visibility='';
    }

    function drawHangMan(numberOfStrikes) {
        var canvas = document.getElementById('hangman');
        if(canvas.getContext) {
            var ctx  = canvas.getContext('2d');
            ctx.save() ; 
            ctx.translate(45,45);
            ctx.clearRect(0,0,canvas.width,canvas.height); 
            ctx.beginPath();
            if(numberOfStrikes >= 1) ctx.fillRect(0,0,10,10);   //head
            if(numberOfStrikes >= 2) ctx.fillRect(-5,10,20,20); //body
            if(numberOfStrikes >= 3) ctx.fillRect(-20,10,20,5); //left arm
            if(numberOfStrikes >= 4) ctx.fillRect(0,10,30,5);  // right arm
            if(numberOfStrikes >= 5) ctx.fillRect(-5,30,5,10);  // left leg
            if(numberOfStrikes >= 6) ctx.fillRect(10,30,5,10);  // right leg
            
            ctx.fill();
            ctx.restore();
        }
    }

    var numberOfStrikes=0;
    function showStrike() {
        numberOfStrikes++;
        drawHangMan(numberOfStrikes);
        document.getElementById("strike").style.visibility='';
    }


    function guess(key) {
        hideMessages();
        if (guessedLetters[key]) {
            showAlreadyGuessed(); 
            return;
        }
        guessedLetters[key] = true;
        var found = false;
        for(i=0;i<word.length;++i) {
            if (word[i] == key) {
                foundLetters[i] = true;
                found=true;
            }
        }
        if(!found) showStrike();
        return found;

    }
    function draw() {
        var str='';
        for(i=0;i<word.length;++i) {
            if (foundLetters[i]) {
                str += word[i];
            } else {
                str += '_';
            }
        str += ' ';
        }
        document.getElementById('word').innerHTML = str; 
    }
    function handleKeyUp(evt) {
        var e = evt ? evt : event; 
        if (e.keyCode >= 65 && e.keyCode < (65+26) ) {
            guess(String.fromCharCode(e.keyCode));            
        }
        else {
            //alert("You entered " + e.keyCode);
        }
        draw();
    }


  </script>
 </head>
 <body onload="draw();" onkeyup="handleKeyUp(event);">
    <table>
        <tr>
            <td colspan=2>
                <span id='alreadyGuessed' style="visibility:hidden">Letter already guessed</span>
                <span id='strike' style="visibility:hidden">Strike!</span>
            </td>
        </tr>
        <tr>
            <td>
                <canvas id='hangman' width=150 height=150>
            </td>    
            <td>
                <span id='word'></span>                        
            </td>
        </tr>
    </table>
 </body>
</html>

HTML Canvas Element - Part 3

2008-09-12T21:04:00.000-07:00

This is Part 3 of the HTML Canvas Tutorial. If you haven't already you should read Part 1 and Part 2.

In this section we will create a key press listener and zoom our triangle in when we press 'z' and out when we press 'x'.

To do this we add a onKeyUp event to the body tag, and a corresponding handleKeyUp javascript function:

function handleKeyUp(evt) {
       var e = evt ? evt : event;
       if (e.keyCode == 90) {
           scale+=.1;
       } else if(e.keyCode == 88) {
           scale-=.1;
       }
       draw();
   }


<body onload="draw();" onkeyup="handleKeyUp(event);">
  <canvas id="canvas" width="150" height="150"></canvas>
</body>

The variable scale is defined as a global javascript variable and we'll use it to call 'ctx.scale(x,y)'

Before we do that though we'll have to call clearRect(x,y,width,height) to clear the image and redraw. The entire script is displayed below:

<html>
<head>
 <script type="application/x-javascript">

   var scale=1;
   function draw() {
       // Get Reference to the 'canvas' tag
       var canvas = document.getElementById("canvas");       
       if (canvas.getContext){
           // Get a context that allows us to draw on.
           var ctx = canvas.getContext('2d');
           ctx.save();
           ctx.clearRect(0,0,canvas.width,canvas.height);           
           ctx.scale(scale,scale);

           // Move cursor and draw the outline of the Triangle
           ctx.beginPath();
           ctx.moveTo(0,100);
           ctx.lineTo(50,0);
           ctx.lineTo(100,100);
           ctx.lineTo(0,100);

           // Actually Draw, you could call stroke instead which will draw the outline
           ctx.fill();
           ctx.restore();

       }

   }
   function handleKeyUp(evt) {
       var e = evt ? evt : event;
       if (e.keyCode == 90) {
           scale+=.1;
       } else if(e.keyCode == 88) {
           scale-=.1;
       }
       draw();
   }


 </script>
</head>
<body onload="draw();" onkeyup="handleKeyUp(event);">
  <canvas id="canvas" width="150" height="150"></canvas>
</body>
</html>

That's it! I hope that got you interested in the Canvas element. If you have any questions leave a comment and I would be glad to answer them.

For more information I recommend the following sites:
http://developer.mozilla.org/en/Canvas_tutorial
http://en.wikipedia.org/wiki/Canvas_(HTML_element)
http://blog.vlad1.com/2008/06/04/html-canvas-in-firefox-3/

HTML Canvas Element - Part 2

2008-09-12T20:03:00.000-07:00

In Part 1 of the series we set up a simple template to build the rest of the example on.

Our goal is to display a triangle and allow the user to zoom in and zoom out.

In this part we will display a black triangle on a white background. Replace your draw function with this one and then refresh your browser.

function draw() {
       // Get Reference to the 'canvas' tag
       var canvas = document.getElementById("canvas");       
       if (canvas.getContext){
           // Get a context that allows us to draw on.
           var ctx = canvas.getContext('2d');

           // Move cursor and draw the outline of the Triangle
           ctx.beginPath();
           ctx.moveTo(0,100);
           ctx.lineTo(50,0);
           ctx.lineTo(100,100);
           ctx.lineTo(0,100);

           // Actually Draw, you could call stroke instead which will draw the outline
           ctx.fill();
       }

   }

You should now see a black triangle on a white background. The code got a drawing context by calling canvas.getContext("2d").

We then use the moveTo command which picks up the cursor and moves to the location without drawing. Notice the coordinate system starts in the upper left with x extending to the right and y extending down.

We start our path with beginPath(). This will clear out any other draw commands and now your ready to trace your path with lineTo. One we have traced our triangle with the lineTo commands we call 'ctx.fill()' Which draws the shape and fills it with a solid color. Alternatively we could of called 'ctx.stroke()' which will draw the outline.

Continue to Part 3 to learn how to Zoom in/out the triangle.

HTML Canvas Element

2008-09-12T00:46:00.000-07:00

The canvas html tag element allows web developers to draw graphics in the browser through a scripting language, typically JavaScript.

In this tutorial, we will create a triangle and allow the user to zoom in or zoom out the picture. Before we get started lets set up our environment. All you'll need is your web browser and a text editor.

Open your text editor (notepad will work just fine) and enter the following:

<html>
 <head>
  <script type="application/x-javascript">

    function draw() {
        alert("hi");
    }


  </script>
 </head>
 <body onload="draw();">
   <canvas id="canvas" width="150" height="150"></canvas>
 </body>
</html>

This is our template that we will use for the rest of the tutorial. We've added a canvas element and when the HTML body is loaded our draw() function will be called.

If you save the text file and load it in your browser it should print a message box saying 'hi'. If not please re-read the above until you have this working.

Continue to Part 2

Google Web Toolkit - Monthly Payment Calculator

2008-09-12T00:23:00.000-07:00

This example displays a simple Loan Calculator. When the user clicks calculate a ClickListener is fired which calculates the monthly payment and dispays it.

This example illustrates GWT Labels, TextBox, and Button controls.


    /*
 * mcintoshEntryPoint.java
 *
 * Created on June 29, 2008, 1:46 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package com.client;

import com.google.gwt.core.client.EntryPoint;
import com.client.time.*;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.Widget;

/**
 *
 * @author avalanche
 */
public class mcintoshEntryPoint implements EntryPoint {

    final Label lblLoanAmount = new Label("Loan Amount:");
    final TextBox txtLoanAmount = new TextBox();
    final Label lblLoanLength = new Label("Loan Length (Month):");
    final TextBox txtLoanLength = new TextBox();
    final Label lblInterestRate = new Label("Interest Rate (Yearly):");
    final TextBox txtInterestRate = new TextBox();
    final Button calculate = new Button("Calculate");
    final Label lblResult = new Label("Payment per month:");

    public mcintoshEntryPoint() {
        calculate.addClickListener(new ClickListener() {

            public void onClick(Widget arg0) {
                
                //P = A (1 + r ) ^ N /( 1 + r ) ^ N -1                                                
                int loanAmount = Integer.parseInt(txtLoanAmount.getText());
                int loanLength = Integer.parseInt(txtLoanLength.getText());
                double interestRate = Double.parseDouble(txtInterestRate.getText())/1200;
                double temp = Math.pow(( 1 + interestRate ) , loanLength);
                Double result = new Double((loanAmount * interestRate * temp)   / (temp -1));                                
                lblResult.setText(result.toString());
            }
        });


    }

    /**
     * The entry point method, called automatically by loading a module
     * that declares an implementing class as an entry-point
     */
    public void onModuleLoad() {
        RootPanel.get().add(lblLoanAmount); 
        RootPanel.get().add(txtLoanAmount);        
        RootPanel.get().add(lblLoanLength);
        RootPanel.get().add(txtLoanLength);
        RootPanel.get().add(lblInterestRate);
        RootPanel.get().add(txtInterestRate);
        RootPanel.get().add(calculate);
        RootPanel.get().add(lblResult);

    }
}

Google Web Toolkit Data Grid Example

2008-09-11T02:20:00.000-07:00

At work I have a java J2EE application that displays a large table. The report is about 15 MB when rendered. I've been experimenting with GWT and I think it would be a good tool to rewrite this report with.

The main problem with the page is when someone updates a value it has to post back to the server then re-render everything. Using GWT it seems like it would be trivial to reload a single row at a time. Along those lines here is a simple DataGrid example that lets me add/remove rows.

See GWT Simple Example for more information on setting up your environment.


   /*
* mcintoshEntryPoint.java
*
* Created on June 29, 2008, 1:46 PM
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
package com.client;

import com.google.gwt.core.client.EntryPoint;
import com.client.time.*;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.SourcesTableEvents;
import com.google.gwt.user.client.ui.TableListener;
import com.google.gwt.user.client.ui.Widget;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

/**
*
* @author avalanche
*/
public class mcintoshEntryPoint implements EntryPoint {

   final Button addButton = new Button("Add Row");
   final Button deleteButton = new Button("Delete Row");
   final FlexTable table = new FlexTable();   
   final Set selectedTableRows = new HashSet();           

   public mcintoshEntryPoint() {
       addButton.addClickListener(new ClickListener() {

           public void onClick(Widget arg0) {
               table.insertRow(table.getRowCount());
               table.addCell(table.getRowCount() - 1);
               table.addCell(table.getRowCount() - 1);
               table.setText(table.getRowCount() - 1, 1, "foo" + table.getRowCount());               
           }
       });
       deleteButton.addClickListener(new ClickListener() {

           public void onClick(Widget arg0) {
               Object[] array = selectedTableRows.toArray();
               Arrays.sort(array);
               for(int i=array.length-1;i>-1;i-- ) {
                   int row = ((Integer)array[i]).intValue();
                   table.removeRow(row);
                   selectedTableRows.remove(new Integer(row));
               }
           }
       });
       table.addTableListener(new TableListener() {

           public void onCellClicked(SourcesTableEvents arg0, int rrow, int col) {
               Integer row = new Integer(rrow);               
               if (selectedTableRows.contains(row)) {
                   selectedTableRows.remove(row);
                   table.setText(rrow, 0, "x");
               } else {
                   selectedTableRows.add(row);
                   table.setText(rrow, 0, "y");
               }
           }
       });


   }

   /**
    * The entry point method, called automatically by loading a module
    * that declares an implementing class as an entry-point
    */
   public void onModuleLoad() {
       RootPanel.get().add(table);
       RootPanel.get().add(addButton);
       RootPanel.get().add(deleteButton);
   }
}

Modified Preorder Tree Traversal

2008-09-10T23:01:00.000-07:00

How do you represent an organizational structure in a SQL data table? When I ask this question in interviews the answer I always get is with an adjacency list (although no one refers to it as that)

An adjaceny list structure would look like this:


EmployeeId, EmployeeName,ManagerId
----------------------------------
         1,          Bob,   
         2,        Frank,        1
         3,         Stan,        1
         4,        James,        3

This structure shoes that Bob is the boss with no manager. Frank and Stan report to Bob, and James reports to Stan. This structure is very common. If you want to list all of Stan's reports, its easy:


select EmployeeName from Employees where ManagerId = (select EmployeeId from Employees where EmployeeName = 'Stan')

But what if you want to list all of Bob's reports? I have yet had anyone answer this question completely to my satisfaction. The typical response is to use a recursive look up. That is all well and good if your tree isn't very deep, but can we do better? Yes!

We can instead structure our table as follows:


EmployeeName,LeftId, RightId
----------------------------------
         Bob,     1,       8
       Frank,     2,       3
        Stan,     4,       7
       James,     5,       6

Huh you ask what did we just do? Let visualize it like this:


  1-bob-8
     /            \
 2-Frank-3      4-Stan-7
                  /
             5 James 6

We start at the left of Bob and assign the first id 1. We move down his org chart and hit Frank and assign him next id of 2. Frank has no children so we go to his right node and assign next id of 3. The next sibling is Stan with id 4. Stan has a child so we go to James with id 5, then work our way back up the tree assigning James Right 6, Stan 7 and Bob 8.

So our algorithm is:


AssignId(Node n)
  n.leftid = nextId()
  foreach(Node child : n.children)
     AssignId(child)
  // No more children assign my right
  n.rightid = nextId()

So what does this accomplish? Lets answer my orignal question. Display all reports of Bob:


(leftid,rightid) =select LeftId,RightId from Employee where EmployeeName = 'Bob'
select * from Employee where lft between $leftid, $rightid;

That's it. With this tree structure you can easily find all the children of a given node. Of course this method has drawbacks. Inserts are more difficult. But if you have a database that is mostly read only you may consider giving this a try.

Enjoy...

Cuda Hello World: Entire Code Listing

2008-09-10T22:22:00.001-07:00


/********************************************************************
*  CUDAWin32App10.cu
*  This is a example of the CUDA program.
*********************************************************************/

#include 
#include 
#include 

/************************************************************************/
/* Init CUDA                                                            */
/************************************************************************/
bool InitCUDA(void)
{  
   int count = 0;
   int i = 0;

   cudaGetDeviceCount(&count);
   if(count == 0) {
       fprintf(stderr, "There is no device.\n");
       return false;
   }

   for(i = 0; i <>= 1) {
               break;
           }
       }
   }
   if(i == count) {
       fprintf(stderr, "There is no device supporting CUDA 1.x.\n");
       return false;
   }
   cudaSetDevice(i);
   return true;
}

/************************************************************************/
/* Example                                                              */
/************************************************************************/
__global__ static void HelloCUDA(char* result, int num, clock_t* time,int foo)
{
   int i = 0;
   char p_HelloCUDA[] = "Hello CUDA!";
   clock_t start = clock();
   for(i = 0; i < time =" clock()" device_result    =" 0;" time            =" 0;" time_used        =" 0;">>>(device_result, 11 , time,1);


   cudaMemcpy(&host_result, device_result, sizeof(char) * 11, cudaMemcpyDeviceToHost);
   cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost);
   cudaFree(device_result);
   cudaFree(time);

   printf("%s,%d\n", host_result, time_used);

   return 0;
}

Cuda Hello World: part 2

2008-09-10T21:31:00.000-07:00

In Part 1 we setup a Visual Studio project to run our first cuda program. In this part we will look deeper into the template and explain what it is doing.

A Cuda program is structured as followed
1) Define a Kernel
2) Copy system memory to GPU memory
3) Execute the Kernel
4) Copy results from GPU memory back to system memory
5) Print our results, and cleanup

We'll look at each part.

Define a Kernel

A kernel is a function that is executed. For our example will follow the sample template from the Visual Studio plugin and create a HelloCuda method.


__global__ static void HelloCUDA(char* result, int num, clock_t* time)
{
 int i = 0;
 char p_HelloCUDA[] = "Hello CUDA!";
 clock_t start = clock();
 for(i = 0; i < num; i++) {
    result[i] = p_HelloCUDA[i];
 }
*time = clock() - start;
}

The __global__ declaration specifier indicates that the procedure is a kernel entry point. Our function takes in an:
array of characters
size of the array
pointer to clock_t structure

The kernel doesn't do much it copies into our character array "Hello CUDA!". As you can probably infer from the assignment of time we are planning on only calling this function one time.

Copy system memory to GPU memory

Now that our kernel is defined we need to prep our data structures such that we can execute the kernel. For this example we'll need to allocate a block of memory to hold the "Hello CUDA!" string, and a clock_t structure for the elapsed time.

To allocate memory on the GPU we use cudaMalloc.


char *device_result = 0;
clock_t  *time   = 0;
cudaMalloc((void**) &device_result, sizeof(char) * 11);
cudaMalloc((void**) &time, sizeof(clock_t));

The memory has now been set aside in the GPU and were ready to execute the kernel

Execute the Kernel

The following code will execute our defined kernel passing in the arguments we just created.


HelloCUDA<<<1, 1, 0&rt;&rt;&rt;(device_result, 11 , time,1);

At this stage the GPU will execute our program and will have our results, we need to copy those results back to the system so we can use them.

Copy results from GPU memory back to system memory

To get our results off of the GPU we use cudaMemcpy and copy the data back into our own storage. To do that we must define a char*, and a clock_t then memcpy the results back.


char  host_result[12] ={0};
clock_t  time_used  = 0;
cudaMemcpy(&host_result, device_result, sizeof(char) * 11, cudaMemcpyDeviceToHost);
cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost);

Print Results and Clean up

That's it the GPU has ran our program created a string called 'Hello CUDA!' copied that into the char * result that we have a pointer to called device_result. It has also filled in clock_t struct in gpu memory which we have a pointer to called time.

We've copied the gpu memory into local variables called host_result, and time_used and now can use it like an C program. So lets print it out.


cudaMemcpy(&host_result, device_result, sizeof(char) * 11, cudaMemcpyDeviceToHost);
cudaMemcpy(&time_used, time, sizeof(clock_t), cudaMemcpyDeviceToHost);

The last thing we need to do is free the memory on the device we use cudaFree.


cudaFree(device_result);
cudaFree(time);

That's it! If you run the program you should get output similar to the following:


CUDA initialized.
Hello CUDA!,0
Press any key to continue . . .

Click here for the entire code listing

Miscellaneous tools

2008-09-07T14:35:00.000-07:00

This is a short post to preserve some useful tools that I use from time to time but I always forget their names.

1) BackTrack: Very useful linux boot disk based off SLAX. It comes preloaded with a lot of cool tools but I like it so I can just boot into linux off of usb key and run firefox.

2) Driftnet, fun but useless tool. Shows all the images that you access by sniffing your own traffic

3) how to set up linux to connect to wirless network:
ifconfig down
ifconfig up
iwconfig essid 'name of network'
iwconfig key 'name of network'
iwconfig mode managed
dhcpcd

4) Syntax highlight code and covert it to HTML: http://www.tohtml.com/jScript/

5) Visual Assist X claims to to background compilation (crosses fingers) ( didn't work that well)

6) SQLylog Enterprise addition ( has auto complete for sql tables )

7) SiSoftware's SANDRA , useful for analyzing your computer and figuring out what components you have. For examle I couldn't get a used audio card to work. SANDRA identified the chipset then with a quick google I had the driver.

Perl CGI cached parameters.

2008-08-06T00:12:00.001-07:00

An intern at work today ran into a problem modifying a perl cgi script. It looked something like this


my $cgi = new CGI;
$cgi->param('foo');

The problem was this value appeared to be cached. Once I accesed the page with http://server/page?foo=bar it would remember bar no matter what I changed the value to.

First I thought it was a cache issue. So we changed the code to output a timestamp. On each page load we would see the time increment but the variable was still cached somehow.

We finally found out that putting the new CGI call inside a function made sure we got a new one each time.

So what happened? I'm not really sure, I'm guessing scope of the perl code is global per apache process? Is this configurable somehow?

Well if anyone knows please add a comment because i this point I'm still baffled by it.

c++ Windows Programing - Creating a window

2008-08-02T23:37:00.000-07:00

This tutorial will cover how to create a window. If you haven't already you should read the Hello World tutorial for Windows Programming first.

In the last tutorial I described how to create a windows program that displays a message box. We are going to extend on that tutorial and create a window this time.

This will consists of 4 parts.

1. Register a new windows class (not to be confused with a c++ class)
2. Create the window
3. Display the window
4. Process Events.

Part 1. Registering a new window class

The first step is to fill in a windows structure that describes how your new window will look like. We'll use the WNDCLASSEX structure.


WNDCLASSEX wc;

// clear out the window class for use
ZeroMemory(&wc, sizeof(WNDCLASSEX));

// fill in the struct with the needed information
wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = (WNDPROC)WindowProc;
wc.hInstance = hInstance;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
wc.lpszClassName = L"MyClass";

RegisterClassEx(&wc);

We first declare a new instance and zero out the memory of the instance. We then set appropriate parameters to define how the window will look. For full details on the paremeters you should consult msdn.

The lpfnWndProc is an important property. This defines a function that will be called back whenever this window needs to handle a message. We'll discuss more abot this in Part 4.

Part 2. Creating the window.

Now that we've defined the style of how our new window should look, we want to actually create the window. We'll use the CreateWindowEx function which has the following prototype:


HWND CreateWindowEx(      
    DWORD dwExStyle,
    LPCTSTR lpClassName,
    LPCTSTR lpWindowName,
    DWORD dwStyle,
    int x,
    int y,
    int nWidth,
    int nHeight,
    HWND hWndParent,
    HMENU hMenu,
    HINSTANCE hInstance,
    LPVOID lpParam
);

Part 3: Display the Window

Displaying the window is accomplished by calling ShowWindow which has the prototype:


 BOOL ShowWindow(      
    HWND hWnd,
    int nCmdShow
);

Part 4: Processing Events

We now have the parts to describe the style of a window, register it, create it, and display it. But if we don't process the windows events nothing will happen. Remember lpfnWndProc from Part 1?

We must define that call back method. Anytime a message is received it will need to run through that method.

So first we need to get message off the messaging queue than define our callback.


// this struct holds Windows event messages
    MSG msg;

    // wait for the next message in the queue, store the result in 'msg'
    while(GetMessage(&msg, NULL, 0, 0))
    {
        // translate keystroke messages into the right format
        TranslateMessage(&msg);

        // send the message to the WindowProc function
        DispatchMessage(&msg);
    }



// this is the main message handler for the program
LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    // sort through and find what code to run for the message given
    switch(message)
    {
        // this message is read when the window is closed
        case WM_DESTROY:
            {
                // close the application entirely
                PostQuitMessage(0);
                return 0;
            } break;
    }

    // Handle any messages the switch statement didn't
    return DefWindowProc (hWnd, message, wParam, lParam);
}

Conclusion:

Putting it all together we have a program that looks like this:


#include 
#include 

LRESULT CALLBACK WindowProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam); 

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
 //Our window structure.
 WNDCLASSEX wc;
 ZeroMemory(&wc,sizeof(WNDCLASSEX));

 wc.cbSize = sizeof(WNDCLASSEX);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = (WNDPROC)WindowProc;
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursor(NULL, IDC_ARROW);
 wc.hbrBackground = (HBRUSH)COLOR_3DSHADOW;
    wc.lpszClassName = L"WindowClass1";

 RegisterClassEx(&wc); 

 // create the window and use the result as the handle
    HWND hWnd = CreateWindowEx(NULL,
                          L"WindowClass1",    // name of the window class
                          L"Our First Windowed Program",   // title of the window
                          WS_OVERLAPPEDWINDOW,    // window style
                          300,    // x-position of the window
                          300,    // y-position of the window
                          500,    // width of the window
                          400,    // height of the window
                          NULL,    // we have no parent window, NULL
                          NULL,    // we aren't using menus, NULL
                          hInstance,    // application handle
                          NULL);    // used with multiple windows, NULL

 ShowWindow(hWnd,nCmdShow);

 MSG msg; 
 while(GetMessage (&msg,NULL,0,0)) {
  TranslateMessage(&msg); 
  DispatchMessage(&msg); 
 }
 return msg.wParam;
}

LRESULT CALLBACK WindowProc(HWND hwnd,UINT message,WPARAM wParam,LPARAM lParam) 
{
 switch(message) {
  case WM_DESTROY: {
   PostQuitMessage(0);
   return 0;
  } break;
 }
 return DefWindowProc(hwnd,message,wParam,lParam); 
}

Hello World - c++ Windows Application

2008-08-02T23:00:00.000-07:00

In this post I'm going to explain the details of writing a hello world program for windows. To start we should look at the version for a console application:


#include <iostream&rt;
using namespace std;
void main() {
  cout << "Hello World" << endl;
}

For windows it isn't much different. But instead of declaring a main we need to instead declare a WinMain.


#include <windows.h&rt;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShowCmd) {
 MessageBox(NULL,L"Hello World",L"MyCaption",MB_ICONINFORMATION | MB_OK);
}

1. We include windows.h to give us access to the windows library functions.

2. The keyword WINAPI instructs the program to reverse the argument list. For our purposes this doesn't matter but under the hood windows needs this.

3. HINSTANCE is a handle to an instance. The main program receives a instance to itself (hinstance) and a handle to a previous instance of the same program. The previous instance is legacy and is NULL for modern applications. But is still provided for legacy code.

4. lpCmdLine is the entire command string that was used to execute the program.

5. nCmdShowCmd are options indicating how the window should open.

6. Once our method is called we can then call MessageBox to display the message.

We can now look into the MessaegBox command in more detail. The signature for the command is:


int MessageBox(HWND hWnd,
               LPCTSTR lptext,
               LPCTSTR lpcaption,
               UINT utype);

The first argument HWND, is a handle to the window the created this message box. In our case we haven't created a window, so we supply NULL which instructs Windows to have the message box originate from the desktop.

lpText is a pointer to the text to display

lpcaption is a pointer to the caption of the message box.

uType is a parameter that specifies what type of message box, exclamation, information, etc. These are set by 'ORing' constant flags together.

Javascript - Adding options to select box

2008-07-24T15:31:00.000-07:00

Adding options to List Box in client side Javascript

Options to a drop down list box can be added dynamically using client side JavaScript.


function addOption(selectbox,text,value )
{
  var optn = document.createElement("OPTION");
  optn.text = text;
  optn.value = value;
  selectbox.options.add(optn);
}

Note that each time the function is called, it adds a new option to the list box. So we can add one option by calling the function once. Like this.

addOption(document.drop_list.Month_list,”January”, “January”);

So this way we can create a drop down list box of all the months by calling the function each time for a month. So with this now you can easily create the list box. But we will add another step to this by using one array of months. So from the array of months we will loop through and add each month to the list box. Here is how to create the array

var month = new Array("January","February","March","April","May","June",
"July","August","September","October","November","December");

So now once our array is ready with data, we will loop through the array by using for loop and then call the addOption function using the data of the array. Here is the code.

for (var i=0; i < month.length;++i){
addOption(document.drop_list.Month_list, month[i], month[i]);
}

And if you want to clear the options use:

document.drop_list.Month_list.options.length = 0;

Mysql on update key

2008-07-21T16:58:00.000-07:00

This is something cool that I found out today:

INSERT INTO table (a,b,c) VALUES (1,2,3),(4,5,6)
ON DUPLICATE KEY UPDATE c=VALUES(a)+VALUES(b);

I've known about the on duplicate key but I would typically have to specify the values again. Here you can say values() and it will return what would have been inserted.

Very useful!

2008-07-21T14:55:00.001-07:00

Iterate over map value in jstl



  ${entry.key} = ${entry.value}

SetWindowsHookEx Example

2008-07-18T01:48:00.000-07:00

Here is an example of using SetWindowsHookEx.

First create a dll project with this cpp file


#include <windows.h>
#include <iostream>
#include <stdio.h>

HINSTANCE hinst;
HHOOK hhk;


LRESULT CALLBACK wireKeyboardProc(int code,WPARAM wParam,LPARAM lParam) {  
 FILE * fileLog = fopen("C:\\sknl.txt", "a+");
 fprintf(fileLog,"OK");  
 CallNextHookEx(hhk,code,wParam,lParam);
 fclose(fileLog);
 return 0;
}

extern "C" __declspec(dllexport) void install() { 
 hhk = SetWindowsHookEx(WH_KEYBOARD, wireKeyboardProc, hinst, NULL);
}
extern "C" __declspec(dllexport) void uninstall() {
 UnhookWindowsHookEx(hhk); 
}

BOOL WINAPI DllMain(  __in  HINSTANCE hinstDLL,
  __in  DWORD fdwReason,
  __in  LPVOID lpvReserved
  ) {

 hinst = hinstDLL;
 return TRUE;
}

This method has a
* dllmain which simply records the HINSTANCE
* has an install and uninstall method
* defines the keyboardProc call back method

Now in another process ( this is important and is needed as SetWindowsHook will only work if your callback is in a dll and not in your own process) you simply loadlibrary and install.


int _tmain(int argc, _TCHAR* argv[])
{  

 HINSTANCE hinst = LoadLibrary(_T("KeyboardLogger2.dll")); 
 if (hinst == NULL) 
 {
  printf("null hinst");
 } 
 typedef void (*Install)();
 typedef void (*Uninstall)();

 Install install = (Install) GetProcAddress(hinst, "install");
 Uninstall uninstall = (Uninstall) GetProcAddress(hinst, "uninstall");
 
  
 install();
 int foo;
 std::cin >> foo; 

 uninstall();
 return 0;
 
}

Netbeans - Shortcuts

2008-07-17T01:03:00.000-07:00

Netbeans has a lot of neat shortcuts.

For example if you want to override a base class method, or create a getter, setter, or generate an equals or hashcode method you can do so easily by pressing alt-insert. This will bring up a dialog for you to choose what you want.

alt-shift-f will reformat your code to your liking

ctrl-click on an item will go to the definition of that item.

alt-o will bring up a dialog to search for by filename.

Cuda - Sieve of Eratosthenes

2008-07-17T00:23:00.001-07:00

Here is an example of how to use cuda to find all prime numbers within a range.

Its uses the Sieve of Eratosthenes which creates an array initialized to 0 ( indicates prime) then you iterate over the array starting at zero and for each multiple of zero you mark it 1. You then move to the next element and repeat. When your down iterating all the primes are still marked as 0.

As an example cuda program I wrote the following kernel


__global__ static void Sieve(int * sieve,int sieve_size)
{ 
 int idx = blockIdx.x * blockDim.x + threadIdx.x; 
 if (idx > 1) {
  for(int i=idx+idx;i < sieve_size;i+=idx) 
   sieve[i] = 1;
 }
}

The index is figured out by the special keywords blockidx, blockDim and threadIdx. I then go over the multiples for that index and mark them as not prime.

The code to call this looks like this:


/************************************************************************/
/* Init CUDA                                                            */
/************************************************************************/
bool InitCUDA(void)
{
 int count = 0;
 int i = 0;

 cudaGetDeviceCount(&count);
 if(count == 0) {
  fprintf(stderr, "There is no device.\n");
  return false;
 }

 for(i = 0; i < count; i++) {
  cudaDeviceProp prop;
  if(cudaGetDeviceProperties(&prop, i) == cudaSuccess) {
   if(prop.major >= 1) {
    break;
   }
  }
 }
 if(i == count) {
  fprintf(stderr, "There is no device supporting CUDA 1.x.\n");
  return false;
 }
 cudaSetDevice(i);
 return true;
}
int main(int argc, char** argv)
{
  
 int  *device_sieve;
 int host_sieve[1000]; 
 double sieve_size = sizeof(host_sieve)/sizeof(int);

 if(!InitCUDA()) {
  return 0;
 } 
 cudaMalloc((void**) &device_sieve, sizeof(int) * sieve_size); 

 Sieve<<<1, sqrt(sieve_size), 0>>>(device_sieve, sieve_size);
 cudaThreadSynchronize();  
 cudaMemcpy(&host_sieve, device_sieve, sizeof(int) * sieve_size, cudaMemcpyDeviceToHost);
 
 cudaFree(device_sieve);
 
 for(int i=2;i < sieve_size;++i) 
  if (host_sieve[i] == 0)
   printf("%d is prime\n",i);
 

 return 0;
}

For simplicity I simply create a new thread for each multiple. This is not very efficient as I may be using a value that is already found to not be prime.

wxWidgets keyboard shortcuts

2008-07-08T16:53:00.000-07:00

If you create a menu bar with wxWidgets you can add a keyboard shortcut by specifying \t

For example if you have a zoom in action Then you may add a menu entry like so:


actionMenu->Append( kZoomInButtonId  , "ZoomIn\tz" , "Click to zoom in on the current location.\n" );

Now if you press z it will execute this action.

C++ convert signals into exceptions

2008-07-08T13:44:00.000-07:00

Here is a technique to convert signals into exceptions:


#include "signal.h"

template  class SignalTranslator
 {
 private:
     class SingleTonTranslator
     {
     public:
         SingleTonTranslator()
         {
             signal(SignalExceptionClass::GetSignalNumber(), SignalHandler);
         }

         static void SignalHandler(int)
         {
             std::cout << "Signal handled and logged" << std::endl;
             throw SignalExceptionClass();
         }
     };

 public:
     SignalTranslator()
     {
         static SingleTonTranslator s_objTranslator;
     }
 };

 
 class SegmentationFault : public std::exception
 {     
 public:
     virtual const char* what() const throw() {
         return "Segmentation Fault"; 
     }
     static int GetSignalNumber() {return SIGSEGV;}
 };

I put the above in a SignalHandler.hpp. Then when I want to use it I include that file and instantiate the handlers that I want


// Set up signal handleing for Seg Fault. When SegFault occurs it will throw a exception
SignalTranslator g_objSegmentationFaultTranslator;

To test this code you can simply raise that exception ( raise(SIGSEGV); )

Google Web Toolkit - Suggest Box (RPC)

2008-07-04T03:33:00.000-07:00

The Google Web Toolkit provides many advanced features to make a web page come alive. One feature that is used commonly in AJAX webpages is a select box that has context sensitive options.

I have already covered the SuggestBox, this article will focus on retrieving your suggestion through an asynchronous Javascript call. You may want to read the following articles as this article builds off some of those concepts.

* GWT suggest box
* GWT RPC Call

To create an RPC Suggest Box you will need to do the following
* Create a Service to serve your suggestions. This service will take an input and return a collection of data.
* Create an oracle that wraps the calls to the Service

Create Suggestion RPC Service

Your client side Suggestion box will fire an onchange event when the user enters a keystroke. When this happens you want to send over the entered text and instruct the control to suggest only items that match the pattern.

To do this we need to define a Service. As we saw in GWT RPC Call we need to define two interfaces we'll call them:

IQuoteService
IQuoteServiceAsync

public interface IQuoteService extends RemoteService {

public static class Util {
  public static IQuoteServiceAsync getInstance() {
   IQuoteServiceAsync instance=(IQuoteServiceAsync) GWT.create(IQuoteService.class);
   ServiceDefTarget target = (ServiceDefTarget) instance;
   target.setServiceEntryPoint("/GWT/quote");
   return instance;
  }
}

   public SuggestOracle.Response getQuote(SuggestOracle.Request req);
}

public interface IQuoteServiceAsync {
   public void getQuote(SuggestOracle.Request req, AsyncCallback callback);
}

Your Oracle will need to return a class with a com.google.gwt.user.client.ui.SuggestOracle.Suggestion interface. To faciliate this we create a new class called ItemSuggestion.

Note: This class must reside on the client side else you will get serialization errors when you run the app.

public class ItemSuggestion implements IsSerializable, Suggestion {

      private String s;
      // Required for IsSerializable to work
      public ItemSuggestion() {
      }

      // Convenience method for creation of a suggestion
      public ItemSuggestion(String s) {
         this.s = s;
      }

      public String getDisplayString() {
          return s;
      }

      public String getReplacementString() {
          return s;
      }
   } // end inner class ItemSuggestion

Now define the actual service on the server side:

public class RandomQuoteService extends RemoteServiceServlet implements IQuoteService {
  
  
   public SuggestOracle.Response getQuote(SuggestOracle.Request req) {
      
       // req has request properties that you can use to perform a db search
       // or some other query. Then populate the suggestions up to req.getLimit() and
       // return in a SuggestOracle.Response object.
       SuggestOracle.Response resp = new SuggestOracle.Response();
      
       List<suggestion> suggestions = new ArrayList<suggestion>();
       suggestions.add(new ItemSuggestion("It is a good day to die"));
       suggestions.add(new ItemSuggestion("I shall return"));
       suggestions.add(new ItemSuggestion("There is nothing to fear but fear itself"));
      
       resp.setSuggestions(suggestions);
       return resp;
   }
}

Create Suggestion Oracle

So far we've created our service now we need to create the Oracle.

You simply extend SuggestOracle and instruct it to use the Service for its suggestions.

public class ItemSuggestOracle extends SuggestOracle {

       public boolean isDisplayStringHTML() {
           return true;
       }

       public void requestSuggestions(SuggestOracle.Request req,SuggestOracle.Callback callback) {
           IQuoteService.Util.getInstance().getQuote(req, new ItemSuggestCallback(req, callback));
       }

       class ItemSuggestCallback implements AsyncCallback {

           private SuggestOracle.Request req;
           private SuggestOracle.Callback callback;

           public ItemSuggestCallback(SuggestOracle.Request _req,
                   SuggestOracle.Callback _callback) {
               req = _req;
               callback = _callback;
           }

           public void onFailure(Throwable error) {
               callback.onSuggestionsReady(req, new SuggestOracle.Response());
           }

           public void onSuccess(Object retValue) {
               callback.onSuggestionsReady(req,
                       (SuggestOracle.Response) retValue);
           }
       }
   }

And now the result of all our work, we create a new SuggestBox with the new oracle.

public void display() {

       ItemSuggestOracle oracle = new ItemSuggestOracle();      
       SuggestBox sb = new SuggestBox(oracle);

       // Add it to the root panel.
       RootPanel.get().add(sb);
   }

That's it! It looks like its a lot of work but its mostly plumbing and you should find its pretty easy to do once you get the hang of it.

Give it a try and leave a comment to let me know how it goes.

JSON - JavaScript Object notation

2008-07-04T01:21:00.000-07:00

JavaScript Object Notation is a data interchange format. The JSON format is often used for transmitting structured data over a network connection in a process called serialization. Its main application is in Ajax web application programming, where it serves as an alternative to the traditional use of the XML format.

A simple example is :

This script will popup an alert dialog box with the text 'John.'

The JSON block can support nested types as well as arrays. For example:


{
     "firstName": "John",
     "lastName": "Smith",
     "address": {
         "streetAddress": "21 2nd Street",
         "city": "New York",
         "state": "NY",
         "postalCode": 10021
     },
     "phoneNumbers": [
         "212 555-1234",
         "646 555-4567"
     ]
 }

Typically the JSON request will come from the server, or through a Ajax callback or some other technique. This approach is must easier to work with then returning XML that the JavaScript client then has to parse.

Google Web Toolkit - Suggest Box

2008-07-03T13:04:00.000-07:00

There seems to be some confusion on the web about whether GWT supports an auto completion widget. I suspect this is because the first version of GWT didn't support it.

However 1.4 sure does, its called SuggestBox. SuggestBox takes a SuggestOracle that contains the data you want and is responsible for returning suggestions.

Here is an example of how to use it:


    MultiWordSuggestOracle oracle = new MultiWordSuggestOracle();
    oracle.add("foo");
    oracle.add("bar");
    oracle.add("baz");
    oracle.add("toto");
    oracle.add("tintin");

    SuggestBox sb = new SuggestBox(oracle); 

    // Add it to the root panel.
    RootPanel.get().add(sb);

Google Web Toolkit - RPC Call

2008-07-03T03:41:00.000-07:00

This post will document how to make a RPC call using the Google Web Toolkit.

For a more detailed walk through of the Google Web Toolkit I recommend this book: Google Web Toolkit Applications

To sum it up you must create 1 class and 2 interfaces.

1) Service Interface that extends RemoteService and defines the methods for your service
2) Asynchrounous interface which is a similar to the the above except:
** doesn't extend RemoteService
** all method return void
** one extra AsyncCallBack parameter to each defined method
3) Your actual service which extends RemoteServiceServlet and implements your interface created in step (1)
** This should be a servlet and mapped properly in your web.xml

The two interfaces will need to be in the com.ciient package, and the service in the com.server or on someother url on the same host where this will be deployed.

So on to the code.

First the interfaces and classes, following by a sample app that calls it:


package com.client.time;
public interface ITimeService extends RemoteService {
    public Date getDate(); 
}

package com.client.time;
public interface ITimeServiceAsync {
    public void getDate(AsyncCallback callback); 
}

package com.server.time;
public class TimeService extends RemoteServiceServlet implements ITimeService {

    public Date getDate() {
        return new Date(); 
    }
}

 public void loadDate(final Label label) {
        ITimeServiceAsync timeService = (ITimeServiceAsync) GWT.create(ITimeService.class);


        ServiceDefTarget endpoint = (ServiceDefTarget) timeService;        
        endpoint.setServiceEntryPoint("/GWT/TimeService");

        AsyncCallback callback = new AsyncCallback() {

            public void onSuccess(Object result) {                
                label.setText(result.toString());
            }

            public void onFailure(Throwable caught) {
                 label.setText("failure" + caught.getMessage());
            }
        };

        label.setText("pending");
        timeService.getDate(callback);

    }

Google Web Toolkit - Simple Example

2008-07-03T02:34:00.000-07:00

The Google Web Toolkit (GWT) is a framework that allows for web development using Java. The framework will convert the Java code into html/javascript.

This approach makes developing and debugging feature rich clients much easier than writing javascript yourself.

To get familiar with the framework I wrote a simple getting started app inspired from the GWT docs. It simply creates a button, label and grid.

It adds an event to the button to hide the label. Also adds a TableListener to the grid. I use this to capture cell clicks and popup a dialog.

Reading the docs you can then style this using css with the following attributes:


    *  .gwt-DialogBox { the outside of the dialog }
    * .gwt-DialogBox .Caption { the caption }


/*
 * mcintoshEntryPoint.java
 *
 * Created on June 29, 2008, 1:46 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */
package com.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.ClickListener;
import com.google.gwt.user.client.ui.DialogBox;
import com.google.gwt.user.client.ui.Grid;
import com.google.gwt.user.client.ui.HTMLTable;
import com.google.gwt.user.client.ui.Label;
import com.google.gwt.user.client.ui.PopupPanel;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.SourcesTableEvents;
import com.google.gwt.user.client.ui.TableListener;
import com.google.gwt.user.client.ui.Widget;

/**
 *
 * @author avalanche
 */
public class mcintoshEntryPoint implements EntryPoint {

    /** Creates a new instance of mcintoshEntryPoint */
    public mcintoshEntryPoint() {
    }

    private static class MyDialog extends DialogBox {

        public MyDialog(String text) {
            // Set the dialog box's caption.
            setText(text);

            // DialogBox is a SimplePanel, so you have to set its widget property to
            // whatever you want its contents to be.
            Button ok = new Button("OK");
            ok.addClickListener(new ClickListener() {

                public void onClick(Widget sender) {
                    MyDialog.this.hide();
                }
                });
            setWidget(ok);
        }
        }

    /**
     * The entry point method, called automatically by loading a module
     * that declares an implementing class as an entry-point
     */
    public void onModuleLoad() {
        final Label label = new Label("Hello, Chris!!!");
        final Button button = new Button("Click me!");
        final HTMLTable table = new Grid(5, 5);
        // Put some values in the grid cells.
        for (int row = 0; row < 5; ++row) {
            for (int col = 0; col < 5; ++col) {
                table.setText(row, col, "" + row + ", " + col);
            }
        }

        button.addClickListener(new ClickListener() {

            public void onClick(Widget w) {
                label.setVisible(!label.isVisible());
            }
            });

        table.addTableListener(new TableListener() {

            public void onCellClicked(SourcesTableEvents arg0, int arg1, int arg2) {
                new MyDialog("You clicked" + arg1 + "," + arg2).show();
            }
            });



        RootPanel.get().add(button);
        RootPanel.get().add(label);
        RootPanel.get().add(table);
    }
    }

Detours

2008-06-29T03:38:00.000-07:00

Microsoft's Research team maintains a project that allows you to intercept any function call. The library does this by injecting code into the memory of that process. You then have the ability to do whatever you want and if you choose pass the call through. This can be very useful for instrumentation for example.

Here's a very simple example that isn't of much use since everything is in the same process, but it shows how I can intercept the call to Window's sleep function.


//////////////////////////////////////////////////////////////////////////////
//
//  Detours Test Program (simple.cpp of simple.dll)
//
//  Microsoft Research Detours Package, Version 2.1.
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//  This DLL will detour the Windows Sleep API so that TimedSleep function
//  gets called instead.  TimedSleep records the before and after times, and
//  calls the real Sleep API through the TrueSleep function pointer.
//
#include 
#include 
#include "detours.h"

static LONG dwSlept = 0;
static VOID (WINAPI * TrueSleep)(DWORD dwMilliseconds) = Sleep;

VOID WINAPI TimedSleep(DWORD dwMilliseconds)
{
    DWORD dwBeg = GetTickCount();
    TrueSleep(dwMilliseconds);
    DWORD dwEnd = GetTickCount();

    InterlockedExchangeAdd(&dwSlept, 3636);
}

//BOOL WINAPI DllMain(HINSTANCE hinst, DWORD dwReason, LPVOID reserved)
int __cdecl main(int argc, char ** argv)
{
    LONG error;
    
    
     printf("simple.dll: Starting.\n");
    fflush(stdout);

    DetourRestoreAfterWith();

    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourAttach(&(PVOID&)TrueSleep, TimedSleep);
    error = DetourTransactionCommit();

    if (error == NO_ERROR) {
        printf("dwslept %d",dwSlept); 
  printf("simple.dll: Detoured Sleep().\n");
  printf("sleep5.exe: Starting.\n");

        Sleep(5000);

        printf("sleep5.exe: Done sleeping.\n");
  printf("dwslept %d",dwSlept); 
    }
    else {
        printf("simple.dll: Error detouring Sleep(): %d\n", error);
    }


    DetourTransactionBegin();
    DetourUpdateThread(GetCurrentThread());
    DetourDetach(&(PVOID&)TrueSleep, TimedSleep);
    error = DetourTransactionCommit();

    printf("simple.dll: Removed Sleep() (result=%d), slept %d ticks.\n",
           error, dwSlept);
    fflush(stdout);

    return 0;
}

//
///////////////////////////////////////////////////////////////// End of File.

In order for this to work you first need to download the detours package from http://research.microsoft.com/sn/detours/

Compile the source as a lib and link to it.

Give it a shot its pretty cool!

Enjoy...

c# using statement

2008-06-29T02:26:00.000-07:00

The C# 'using' statement provides a convenient syntax that ensures the correct use of IDisposable objects.

Example:


  using (BlackJackForm blackjackform = new BlackJackForm())
  {
    Hide();
    blackjackform.ShowDialog();
    Show();
  }

The above is the equivalent of the following more verbose code:


  BlackJackForm blackjackform = new BlackJackForm()
  try {
    Hide();
    blackjackform.ShowDialog();
    Show();
  }
  finally {
    blackjackform.Dispose();
  }

The using statement only works with items implementing the IDisposable interface.

C++ War Card Game

2008-06-27T15:56:00.000-07:00

While reading Data Structures in C++: Using the Standard Template Library (STL)

The author brought up the War card game. I thought it would be interesting challenge to see how fast I could create the game. So just for fun here is the source in case anyone is interested.

The rules are simple. Each player has half the deck they flip over the top card each time. Whichever card is higher (2 being lowest Ace being the highest) that person gets both cards. On tie each player flips over three cards and the fourth determines who wins everything.



#include <iostream>
#include <vector>
#include <queue>
#include <ctime>    // For time()
#include <cstdlib>  // For srand() and rand()
using namespace std;
struct Card {
 Card(int value) {
   this->value = value;
 }
 int getValue() {
   return value;
 }
 private:
   int value;
};
struct Player{
 queue cards;
};
struct Deck {
 vector cards;
 Deck() {
   for(int i=1;i<14;++i) j="1;j<5;++j)" j="0;j<10;++j)" i="0;i< cards.size();++i)" int="" r="(rand()" card="" temp="cards[i];" struct="" game="" void="" deck="" player="" cout=""><< "dealing" << i="0;i<<> undecided;
   int count =0;
   while(a.cards.size() >0 && b.cards.size() >0) {
     cout << ++count << ": A cards: " << acard =" a.cards.front();" bcard =" b.cards.front();"> bCard.getValue()) {
       int size = undecided.size();
       for(int i=0;i< size =" undecided.size();" i="0;i< size;++i)" else="" were="" in="" take="" three="" more="" from="" each="" player="" int="" i="0;i<3;++i)" if=""> 0 ) {
           undecided.push(a.cards.front());
           a.cards.pop();
         }
         if (b.cards.size() > 0 ) {
           undecided.push(b.cards.front());
           b.cards.pop();
         }
       }
     }
   }
 }
};
int main() {
 Game g;
 g.start();
 return 0;
}

C++ get random number

2008-06-27T15:34:00.001-07:00

#include // For time()
#include // For srand() and rand()
void foo() {
srand(time(0)); // Initialize random number generator.
int r = (rand() % 10) + 1;
}