from google.appengine.ext import search  

class Entity(search.SearchableModel):
  Name = db.StringProperty()

This allows queries like:
lst = Entity.all().search(”john”)

Very nice indeed.

<#@ template debug="false" hostspecific="false" language="C#" #>
<#@ output extension=".js" #>
<#@ import namespace="System.Reflection" #>
<#@ import namespace="System.IO" #>

<#
// Assembly you want to load
String fileName = @"C:\Icris\Icris.MDADemo.Model.dll";
byte[] fileContent;
using (System.IO.FileStream dll = System.IO.File.OpenRead(fileName))
{
   fileContent = new byte[dll.Length];
   dll.Read(fileContent, 0, (int)dll.Length);
}
var assembly = System.Reflection.Assembly.Load(fileContent);

foreach(var type in assembly.GetTypes())
{
#>
	//
function <#=type.Name#>(){
<#
			foreach(var property in type.GetProperties())
			{
#>
	this.<#=property.Name#>=null;
<#
			}
#>
}
<#
}
#>

Thanks to this guide: http://heisel.org/blog/2009/11/21/django-hudson/ I was able to use nose for my unit tests publishing the coverage results for cobertura (Hudson plugin). Now the complete picture looks somewhat like this:

I’ve whipped up an Ubuntu 10.04 desktop VM with all the prerequisites installed: a turnkey solution. If you want a copy I’ll share it with you, leave me an email below. (1,5 GB rarred download).

It gives a short overview of the developer’s context in which to operate when developing Python-based App Engine Apps. Three main tools are at the developer’s disposal: the Google App Engine Launcher (download via the tutorial), a browser to run/test your apps and an IDE for writing the Python code, IDLE for example. The GAE launcer can interact with a local development server which serves the code files from a local development folder (with a subfolder for each project). Using the same app, the launcher can deploy the app to the Google Cloud where it can be accessed by the customer, among other Google services.

I’ll try and put my own appengine experiences (handy patterns / examples etc) here regularly, but blog promises are rarely kept… .

The result of my efforts can be downloaded here (2-A4 ref sheet): ASP.NET

I can say we’re doing EDA in practice at Sogyo and I love the loosely coupled nature and all of this approach, but why o why do we all of a sudden need to call it CQRS in the software development world? We don’t go and rebrand something like object oriented design and call it someting hypish like “domain driven design” now do we? (oh, stupid me, we did a few years ago ).

No flame intended to Greg Young, I believe he has done great work with CQRS for certain problems but come on, don’t over-hype it people…

Merry christmas to all for now, I’m going to enjoy my holiday. More on EDA will follow in 2010!

partial class EmployeeBrowser : System.Windows.Forms.DataGridView
{
    EmployeeRepository repository = new EmployeeRepository();
     public EmployeeBrowser()
        : base()
    {
        this.VirtualMode = true;
        this.Columns.Add("Id", "Id");
        this.Columns.Add("Name", "Name");
        this.CellValueNeeded += new DataGridViewCellValueEventHandler(Browser_CellValueNeeded);
        this.RowCount = repository.Count;
        repository.CachefetchingStart += new EventHandler(repository_CachefetchingStart);
        repository.CachefetchingDone += new EventHandler(repository_CachefetchingDone);
    }
    void repository_CachefetchingDone(object sender, EventArgs e)
    {
        Cursor.Current = Cursors.Arrow;
    }
    void repository_CachefetchingStart(object sender, EventArgs e)
    {
        Cursor.Current = Cursors.AppStarting;
    }
    void Browser_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e)
    {
        if (repository[e.RowIndex] != null)
            e.Value = repository[e.RowIndex].GetValueForIndexedProperty(e.ColumnIndex);
        else
            e.Value = null;
    }
}

As you can see, I’m using an “EmployeeRepository” class to fetch my data. This is where the real magic occurs. I chose to implement an IList in this class so it can be generally accessed. For the DataGridView component, a few methods in this class are interesting. The index based access method for example:

public Employee this[int index]
{
    get
    {
        if (localcache.ContainsKey(index))
            return localcache[index];
        else
        {
            AddToCache(index, Get(index));
            if (localcache.ContainsKey(index))
                return this[index];
            else
                return null;
        }
    }
    set
    {
        throw new NotImplementedException();
    }
}

As you can see, there is a localcache dictionary that performs a lookup in the getter. If a cache miss occurs, the AddToCache() fed with the Get() method is performed, which looks something like this:

private List Get(int startindex)
{
    if (CachefetchingStart != null)
        CachefetchingStart(this, null);

    OdbcCommand cmd = new OdbcCommand(
        @"
		With tmp AS
		(SELECT *,
			ROW_NUMBER() OVER (order by name) as RowNumber,
			(select count(*) from Employee) as TotalRows
		    FROM Employee)
			select *
			from tmp
			Where RowNumber Between " + startindex + " and " + (startindex + Constants.CacheSize), connection);

    List items = new List();

    DataTable dt = new DataTable();
    OdbcDataAdapter da = new OdbcDataAdapter(cmd);
    da.Fill(dt);

    foreach (DataRow row in dt.Rows)
    {
        Employee instance = new Employee();
        instance.id = (Guid)row["id"];
        if (row["name"] != DBNull.Value)
            instance.name = (String)row["name"];
        items.Add(instance);
    }

    if (CachefetchingDone != null)
        CachefetchingDone(this, null);

    return items;
}
This shows how a page of data is loaded for insertion into the cache. This weird SQL Query is explained in this previous post. A configurable cachesize can be set in a Constants class.

I tested this code using a database in which I generated one million (1 000 000) customer objects and it performed nicely. The cachesize may be tweaked in order to enable faster scrolling with little steps (e.g. using arrow keys; a larger cache size can be benificial here) or making large jumps (a smaller cache size is better for this).

The entire working solution can be downloaded here.


[ServiceContract(CallbackContract = typeof(IEventCallback))]
public interface IEventsService
{
[OperationContract(IsOneWay = true)]
void Subscribe(string name);

[OperationContract(IsOneWay = true)]
void NotifyAll(string eventName);
}
[ServiceContract]
public interface IEventCallback
{
[OperationContract]
void Notify(string eventName);
}


Pretty straightforward. Note the IsOneWay=true and CallbackContract settings. The implementation of the service is equally straightforward:


[ServiceBehavior(InstanceContextMode=InstanceContextMode.Single,
ConcurrencyMode=ConcurrencyMode.Multiple)]
public class EventsService : IEventsService
{
List callbacks = new List();
public void Subscribe(string name)
{
callbacks.Add(OperationContext.Current.GetCallbackChannel());
}

public void NotifyAll(string s)
{
foreach (IEventCallback cb in callbacks)
cb.Notify(s);
}
}


Note the concurrencymode and the instancemode here. The service needs to be a singleton in order to distibute all events to all subscribers (a real single broker infrastructure), and the concurrencymode is necessary in order to be able to fire all the callback notifications. The callbacks are listed via the subscribe method using the GetCallbackChannel method.

I added an extremely simple windows forms client that subscribes and can send events. Multiple instances of this client can be executed in order to test if this works. Note that I used the NetTCPBinding in this solution. Please download it here.