Had a pleasant day looking at a few different languages at Kensington Town Hall again. Organized by Carsonified and StackOverflow, so sounded interesting and Darren Kenny offered me his ticket, so too good to miss really. I did sit there at one point, thinking that I should really be doing some work instead of hearing about languages that I haven’t enough time and energy for, but overall it was quite an inspirational day.

There was a view of python from Michael Sparks. Seems too easy when you have someone like this doing the demo. I will definitely look further at Django on the Google App engine.

Joel Spolsky walked us through the FogBugz system. We definitely need a simple system for project management, but is this simple enough? They have the experience, so perhaps I should give it a try. I would prefer a longer trial than 44 days. It’s not enough to commit to. The two person option is just not capable of using with a small team. I’m teasting teamworkPM at the moment and it would be an interesting comparison, but I’m not sure that I trust the system to interpret the dubbious information put in by the programmers.

The Android SDK is now version 2.0 and Reto Meir showed us a few of the new additions. Android now has control of Bluetooth connections, the contacts data on the phone and there are camera routines to play with the image effects.

Remy Sharp showed a quick view of the power of jQuery. It’s the most dominant of the javascript libraries and is really useful. Best support is probably on IRC at freenode.net#jquery.

Pekka Kosonen of Nokia showed a few slides on the Qt development system. It’s a system that Nokia have bought in and give away for free now. It is C++ based, capable of running on Windows and Mac as well so it will compete with Air, I suppose. Their demo at lunchtime was a bit unplanned and didn’t go too well, but that’s probably just down to installation. Looks interesting enough for a second view if you’re doing mobile development anyway.

Phil Nash showed a very simple iPhone demo, to show that it is really that simple once you have got past the initial shock of Objective-C. Once you can read the language, there are a huge number of libraries there to help do most tasks with only a few lines of code.

Joel talked about why StackOverflow has become a top site, and then Jeff Atwood talked about how it came about. Programming is not a simple task; programmers need the passion to deliver the best possible experience to the end user. Also suggested that writing is the biggest skill needed and suggested “Elements of Style” rather than some of the programming theory books.

Jon Skeet and the Pony were entertaining and showed that even maths, text and timezones have difficult problems. Jon is at Google (ex Yahoo) and has extensive experience of these while trying to make it all international. He blamed three types of people, the User, for making the obvious thing to do, different each time, the Architect for adding layers of abstraction and the Developer for not understanding the User and Architect.

Paul Biggar gave a talk about how not to design a scripting language, which made me think about all the simple versions that I’d done and how many of them are not in use any more. Interesting. Should I go back to threaded interpreters….? They’d be much quicker nowadays, but not enough time in my life, I’d better stick to plain old python and C#. He suggested “Engineering a Compiler” by Cooper and Torczon. He uses tracemonkey in Firefox. Not sure what the conclusion was – don’t use eval/include, use meta programming.

Christian Heilmann from Yahoo! gave a speedy look at their Developer Tools. YUI v3 is their latest cross browser sdk and is on all their and Googles edge servers around the world, so is really quick to load. They have a css grid builder which looks good for planning a quick page layout for any browser. His suggestions were to use events all the time and to not reinvent what someone else has already created. There are so many widgets out there, use mash ups to create your web site. Use APIs to specialist sites, YQL the query language to filter the data from the feed, then YML to layout the page. It all looked pretty simple. If you’re serving your own data, put it into openTable and this will give you a standard API for everyone to use.

All in all, I could probably have learnt as much of one or two of these languages in less than the time I was there, but the inspiration and networking is something that will add some karma to my life. An hour or two of relaxation. Thanks to StackOverflow and Carsonified.

We’ve had a look at some of the twitter-like systems that are based around enterprise usage. This is just a quick knee-jerk reaction from our experience over the last couple of weeks. We wanted to use a system internally, to see if there was any advantages over email, and perhaps to think about how to take advantage of some of the social momentum that is around at the moment.

Initially we used an installation of Laconica, now StatusNet, which is a twitter clone that runs internally on a Unix system and then we setup corporate sites at both Yammer and Present.ly to see the advantages the full connection to the web would bring. It will be interesting to monitor their usage over the next couple of months as we try them for a project or two.

The Laconica software gives a similar experience to Twitter, but is restricted to our intranet. This is one of the problems though. I think that people are already used to having Twitter clients on all sorts of devices; I twitter from home, from work, from an iPhone and from within other applications. Most of these clients cannot connect to any services other than Twitter, so there is not the richness of both facilities and locations available to the user on an internal system. Although it professes to have groups, there is no privacy there at the moment; they are simply like email groups for ease of ending messages. (Edit: StatusNet have just has a big investment to create a hosted solution, so it will be interesting to see how they develop)

Yammer and later Present.ly are more flexible. They have built themselves as enterprise aware and their availability is almost as wide as Twitter’s. The system runs on their own servers normally, but they could be installed internally for a more private experience. However, I think that users need to be able to get to it everywhere, any time, otherwise there isn’t the flexibility to stay with the conversation. They have clients for most devices, for Outlook and other mail systems. The ability to have private groups brings both privacy features and an ideal way to keep the conversations relevant to most other users. Yammer has been tested here before and didn’t get much of a take up. Once a project was established however, it has been taken up quickly because it has become the focal point for the group. It is a lighter and more specific conversaton than group emails, yet everyone can see what is happening. It also has a built in organizational chart, but I’m not sure quite where the benefits lie there.

Present.ly was tried slightly later and has the disadvantage that a couple of groups are already on Yammer. It has some advantages, such as having more clients (with source code!), better file sharing, more of a newsreader client in the browser where you can add your own feeds. It just has the feel of having more up-to-date facilities and a team with fresher momentum. It has not taken off here yet because there is not a project to give it that spark, but I think that it may live longer than the internal only Laconica system. Yammer and Present.ly should both have facilities to connect via email and twitter, but there have been a few hiccups with that. It either takes too long, or in the Yammer email case, it needs a confirmation email before the first email is sent to the system. This is hardly instant messaging. Present.ly has the advantage of being free. You can administer it and add other domains with the Admin account. If you need to Administer the Yammer system, you need to start paying, per user, per month. I think that’s a drawback; you need to be able to control your system from the start of the trial..

What might be needed is a corporate client version of FriendFeed which can connect to several systems. Let me Twitter normally but also send snippets to my corporate followers to keep up with technology. Let me send files to be available to other users, but only to a group of people within the company. What’s missing at the moment is more of the privacy and file versioning facilities that we are used to from project management systems such as FogBugz, Basecamp and the one that I’m testing at the moment teamworkPM. I’d like to be able to update tasks and projects through the same set of interfaces that I’m using for instant messaging; it could be the most convenient, so long as I don’t fill the stream with messages that put off the conversationalists.I definitely have the desire to move away from email and the unending noise of uninteresting communications. Twitter has that feeling of energy and the 140 characters makes it succinct enough to let the messages roll by. I want that experience in my corporate world.

Another paper from last year that gives a good flavour for these different systems is on the Pistachio Consulting site. They show a more in depth coverage of facilities, but it’s difficult to see how a particular will work for you until you try it. I suggest you try with a few users on one project. It’s also interesting to look back at this paper from 12 months ago and see how the systems have developed since. There will be some winners and some losers, no doubt.

If you do have some programming talent available, I would also think of rolling my own. All the systems have an API and many are similar to the Twitter API so clients can be built to fit a particular corporate situation. The Pownce system was taken over by SixApart who produce the TypePad blogging system. They have now released their API for their cloud based messaging backend and have an open source massaging system called Typepad Motion which is an evolvment of Pownce. I’m sure others will come up with similar systems but theirs looks pretty easy to develop for. On the .Net side, Yonkly has an opensource or hosted system that looked good. The flexibility of a custom development is that it can fit around your business and not be a mash-up of smaller applications that overlap and cause confusion.

This is another post about web services; previous one did a quick hello world app and talked more about setting up IIS on an internal web server. This one assumes a mapped drive onto the server, to which we shall upload the service apps. I’m using the F: drive in this case. The folder has been created previously. I’m using VS2008. I’m going to create a test web service to bring back XML from an Oracle database. I’ll give an example of both a SQL statement being used and a stored procedure.

The pdf of this page is OracleDBservices

To start with I’ll use the wizard to create a simple web service, File>New>Project>Web>ASP.Net Web Service. This gives a simple “Hello World” example.

I changed the name from Service1 in the code and the name of the file (with a comment about source control not being applied to the original Service1 – that’s OK),

Public class FootballService : System.Web.Services.WebService

then Build>Publish to the F drive

This is the remote view,(not the index.htm – this was a test page)

I had an error, so to see the details, we need to put <customErrors mode=”Off”> into the web.config file, somewhere in the <system.web> section.

I had renamed the class for the service from Service1 to FootballService. I needed to make the change in the asmx file. To open the file, just right click the asmx file and Open with the SourceCode editor, then change Service1 to your required name.

<%@ WebService Language="C#" CodeBehind="FootballService.asmx.cs" Class="FootballServices.Service1" %>

To get the Invoke button, add the following lines to the web.config file, system.web section.
<webServices>
<protocols>
<add name="HttpGet"/>
<add name="HttpPost"/>
</protocols>
</webServices>


Should then get this screen; click HelloWorld to get the next screen and Invoke should give the XML

<?xml version="1.0" encoding="utf-8" ?>
<string xmlns="http://tempuri.org/">Hello World</string>

It might take a few seconds while the compile occurs.

Changed the namespace to http://xxxx.com/footy/webservices as recommended

Now need to add the database parts. We shall add an Oracle data class – OracleData. Because this is common code between several (maybe) pages, we should put it into a shared App_Code folder. We can also put in there the main service and reference that file in the asmx file.

<%@ WebService Language="C#" CodeBehind="~/App_Code/FootballService.cs" Class="FootballServices.FootballService" %>

This should still give the xml,
<?xml version="1.0" encoding="utf-8" ?>
<string xmlns="http://bskyb.com/bc/webservices">Hello World</string>


First we’ll add a Version function, to show which version of the code and database is being used. Just some text the we shall keep up to date (!!?). Useful tho’.

Then the Oracle routines – simple SQL statement to begin with; create using a connection string, then a routine to send an SQL string and return a dataset.

public class OracleData
{
private string strConnection {get; set; }
/// <summary>
/// Create the object using this connection string
/// </summary>
/// <param name="connectionString">
public OracleData(string connectionString)
{
strConnection = connectionString;
}
/// <summary>
/// Get dataset from SQL String
/// </summary>
/// <param name="strSQLQuery">
/// <returns></returns>
public DataSet getDataSet(string strSQLQuery)
{
System.Data.DataSet ds;
using (OracleConnection conn = new OracleConnection(strConnection))
{
OracleDataAdapter dA;
ds = new System.Data.DataSet();
dA = new OracleDataAdapter(strSQLQuery, conn);
dA.Fill(ds);
}
return ds;
}
}


In the service code we will then have some properties to hold the parameters, (I’ve use our Election database for testing here). There’s a static string holding the database name, because I need to be able to switch to an alternative database. Bear in mind while consuming the service that it you put in a routine to change this value, it will be reset on a failover situation and would not be consistent if load balancing across several servers.

private FootballServices.OracleData db;
private Int32 intCounter;
private static string strDB = "ActiveDB";
private string strConnection = "Data Source=" + strDB + ";" +
"Pooling=True;" +
"User ID=xxxxx;" +
"Password=yyyyy";

Then we have a routine to call the SQL command,

/// <summary>
/// Return a list of elections available as xml.
/// This uses a SELECT statement in the program, not a procedure call.
/// </summary>
/// <returns></returns>
[WebMethod(Description = "Get Elections (SELECT)")]
public XmlDocument Elections()
{
string strSelect;
XmlDocument xmlDoc = new XmlDocument();
DataSet ds;
try
{
db = new FootballServices.OracleData(strConnection);
strSelect = "SELECT * FROM election";
// Return a dataset as XML, using a SELECT statement
ds = db.getDataSet(strSelect);
// Set these names to put the same named tags around the XML data
ds.DataSetName = "ELECTIONS";
ds.Tables[0].TableName = "ELECTION";
xmlDoc = GetXml(ds.Tables[0]);
}
catch (Exception ex)
{
System.Web.HttpContext.Current.Response.Write(ex.Message);
return null;
}
return xmlDoc;
}

I have called a getXML routine to convert dataset to XML

/// <summary>
/// This simply takes a data table and converts to xml format.
/// </summary>
/// <param name="dt">data table</param>
/// <returns>xml data</returns>
public XmlDocument GetXml(DataTable dt)
{
StringWriter sw = new StringWriter();
dt.WriteXml(sw);
sw.Close();
XmlDocument xd = new XmlDocument();
xd.LoadXml(sw.ToString());
return xd;
}

That’s it. Build>Publish to the web site; Invoke the GetElections to get an XML listing. The calling application just uses this url to get the data. Simple.

We could just duplicate this routine to get all the other SQL statements that we need, but a better way is to use stored procedures. This is somewhat more complicated. Each procedure call needs to be used with the exact data type for each parameter. This means that if procedures use different data types, they will need a different procedure call. We need to write a procedure call for each combination (or order) of parameter data types. I shall give the example of a procedure with parameters to solve that problem as well.

The routine in the main service is quite similar, but has the two parameters in the interface – electionID and regionID, which are then used in a call to runProcedure to fetch the data. (For some reason I allowed for a string on the electionID, which I convert to an integer. The data is converted to XML in the previous way.

/// <summary>
/// Return a list of all vZones in this election, region.
/// </summary>
/// <param name="electionID"></param>
/// <param name="regionID"></param>
/// <returns></returns>
[WebMethod(Description = "Get VZones in Region (PKG_ER)")]
public XmlDocument ElectionVZones(string electionID, int regionID)
{
Int32 intElection = Convert.ToInt32(electionID);
if (intElection < 100) intElection = 603;
XmlDocument xmlDoc = new XmlDocument();
DataSet ds;
try
{
db = new electionService.ElectionDB(strConnection);
// Return a dataset as XML, using a stored procedure call
ds = db.runProcedure("PKG_ELECTION_RESULTS.proc_ListVZone ",
"pElectionID", intElection,
"pRegionID", regionID);
ds.DataSetName = "ELECTION";
ds.Tables[0].TableName = "VZONE";
xmlDoc = GetXml(ds.Tables[0]);
}
catch (Exception ex)
{
System.Web.HttpContext.Current.Response.Write(ex.Message);
return null;
}
return xmlDoc;
}

The new addition here is the runProcedure method in the OracleData class,

public DataSet runProcedure(string strProcName, string param1, long value1,
string param2, long value2)
{
// This is an method to return a dataset as XML, using a stored procedure
System.Data.DataSet ds;
//
using (OracleConnection conn = new OracleConnection(strConnection))
{
OracleCommand cmd = new OracleCommand(strProcName, conn);
cmd.CommandType = CommandType.StoredProcedure;
OracleParameter prm1 = new OracleParameter(param1, OracleType.Number);
prm1.Direction = ParameterDirection.Input;
prm1.Value = value1;
cmd.Parameters.Add(prm1);
//
OracleParameter prm2 = new OracleParameter(param2, OracleType.Number);
prm2.Direction = ParameterDirection.Input;
prm2.Value = value2;
cmd.Parameters.Add(prm2);
//
OracleParameter prm3 = new OracleParameter("rsresults", OracleType.Cursor);
prm3.Direction = ParameterDirection.Output;
cmd.Parameters.Add(prm3);
//
OracleDataAdapter da = new OracleDataAdapter(cmd);
ds = new System.Data.DataSet();
//
da.Fill(ds, "rsresults");
}
return ds;
}


This works OK but is quite verbose. I decided to add a few routines to add the parameters. They don’t save much but it reads a little better, to me.

public DataSet runProcedure(string strProcName, string param1, long value1,
string param2, long value2)
{
// This is a method to return a dataset as XML, using a stored procedure
System.Data.DataSet ds;
using (OracleConnection conn = new OracleConnection(strConnection))
{
OracleCommand cmd = new OracleCommand(strProcName, conn);
cmd.CommandType = CommandType.StoredProcedure;
//
addNumberParameter(cmd, param1, value1);
addNumberParameter(cmd, param2, value2);
//
OracleParameter prm_rs = new OracleParameter("rsresults", OracleType.Cursor);
prm_rs.Direction = ParameterDirection.Output;
cmd.Parameters.Add(prm_rs);
//
OracleDataAdapter da = new OracleDataAdapter(cmd);
ds = new System.Data.DataSet();
da.Fill(ds, "rsresults");
}
return ds;
}

I have three types of parameter, you may have more, but the routines I use are,

internal void addNumberParameter(OracleCommand cmd, string param, long pvalue)
{
OracleParameter prm = new OracleParameter(param, OracleType.Number);
prm.Direction = ParameterDirection.Input;
prm.Value = pvalue;
cmd.Parameters.Add(prm);
}
//
internal void addStringParameter(OracleCommand cmd, string param, string pvalue)
{
OracleParameter prm = new OracleParameter(param, OracleType.VarChar);
prm.Direction = ParameterDirection.Input;
prm.Value = pvalue;
cmd.Parameters.Add(prm);
}
//
internal void addDateParameter(OracleCommand cmd, string param, DateTime pvalue)
{
OracleParameter prm = new OracleParameter(param, OracleType.DateTime);
prm.Direction = ParameterDirection.Input;
prm.Value = pvalue;
cmd.Parameters.Add(prm);
}


It all seems a bit awkward, so if you find a better way, let me know. Hope it helps.

Second day (First day here) warm up was given to Britt Selvitelle (@bs) from Twitter. A tough task given that there was a late PayPal party the previous evening. Twitter are now thinking of the next step; they want more developer involvement so they announced the twitter labs site for this. They are producing their own javascript library. They will be advertising apps on their web site and developers may be able to integrate more closely to the twitter website. At some point they will open source the software stack, so that your twitter pages will be more flexible. Not too many details on the labs site or the API, but they promised to email details of the beta to the FOWA list.

Simon Wardley gave a talk at the Cloud Expo a month or two back and it was just as enjoyable second time round. Simon, from Canonical, is involved with pushing the Amazon EC2 standard into Eucalyptus on Ubuntu servers. An in-house cloud if you like and open source. Hard to write down the humourous way that he talked around the ubiquity of computing and the way that cloud computing will become commoditised. As demand increases and improvements in facilities occur, cloud computing will be everywhere. The transition will move from the current confusion, through management, trust, security to transparency of the services. What concerns him is the need to have an easy way to switch between services, data transfer etc. By moving to the standard for the EC2 API he says that this will help form de facto standards, which will make these problems easier. Componentisation will (vastly) increase the speed of development.

Yehua Katz (@wykatz) from the EngineYard talked on Merb, Rails3 and the future of Agile. He’s a proponent of pair programming (with @carlhuda) and emphasised the agile aspect of deferring any decision to the latest possible time. Merb helps this; they use the couchDB which is easy to use and grow with, providing a RESTful JSON API. (Uses Lucene which I talked to some other users about for text storage and search) (Also mentioned the multi language mongo database and the Cucumber testing system) Rails3 brings background tasks and more separation for the Controller to allow other Model layers.

Joel Moss (@joelmoss) from Codaset and Sanj Matharu came on to talk about developing for Vodafone devices. It all sounded very straight forward. He suggested testing with Opera, as it is the most common browser on mobiles. The apps need to be zipped to a wgt file before uploading, but beware of Macs which zip into 64bit format. Joel showed a quick “hello” app. They suggest using the eclipse editor, but any text editor will do. Sanj talked about the app store at www.jil.org. It has lots of stats available and don’t forget the AppStar competition.

Looked briefly at the Ordnance Survey stand where they were showing off their maps API. Just for the UK, but it gives their traditional display of the map, with all the features that you’d see on the paper versions. Surprisingly, paper maps figure for less than 8% of their turnover now. Digital is important to them and they are running the Geovation innovations scheme for their OpenSpace API. (note the mis-spelling on their business card at the show). Have a look at bikehike.co.uk/mapview.php to see an example

Robin Christopherson of AbilityNet came on to ask everyone to design for easy access. He went through some truly awful examples of what a blind person may hear when using a web page reader. Facebook is one of the worst. Users find it easier to read the mobile version, but they don’t have the same facilities to edit their pages etc. Remember that accessibility will give better search rankings. Have a look at blog.gingertech.net for advice. There are some problems with video in HTML5 but it looked promising. Google’s Chrome seemed to have some problems and showed nothing in some areas. He mentioned the work of Steve Faulkener at the Paciello group.

Alex Hunter (@cubedweller) came on to talk about branding. He’s ex-Virgin and talked about the need for passion. Define your values at an early stage. Everyone in the company should have the vision; everyone must be an evangelist. You need people that care and that are prepared to risk their reputation. You must create the passion and be aware that the conversation is two way. Listen to the users; watch what they do. He tlked about Qype, a micro meetup site, and amazingtunes where unsigned bands can push their own music.

Lynne Johnson – ex Fast company, talked about the future of newspapers. Print ad sales went down 30% in Q1 2009. Journalists need to find a web presence but perhaps feel undervalued on the web where everything is free. Newspaper functions have been eroded by sites like CraigsList (ad listings), eHarmony (personals), Google (news) email (for advertising/events) etc We are in a new era of social eg sodahead and the huffington post. Look at the CNN mobile app. The NewYork Times now also has several developer APIs.

SixApart did a Uni session as well. Ed was there with Mark Atkins who built the API. They have built a stack in python to connect to the TypePad API. They give full access to the data (whereas Facebook control the access). They use OAuth for the user login, can then do server to server functions or caching. Motion is built on this platform. It runs on your own webserver, similar to FireEagle, it just gives the API. It is built around Django, as they thought this was the easiest and fastest development system; Django also has good documentation. Component apps can be added. The python mapper gives a REST API, similar to a database, giving objects back. They also have a batch http library to combine several http actions together. The limit on the free service is around 3600 per hour. There is also a JSON REST API coming for TypePad.

Dave McClure gave a positive talk about building the business, on the basis that most won’t succeed more than 6 to 12 months. Most sites are building too much and have no idea what is being used. You need to build in real time metrics to allow decisions to be made. Try search Google for “Startup metrics” There’s plenty to read. Recommended “To the smartest person in the room” by Chris McDonough. Concentrate on User experience and distribution; Move users from low to higher value; Have a fast iteration with feedback; Keep it simple. You need to Aquire users, get them Activated, Retain them, get their Referrals, get the Revenue (AARRR – was for his pirates analogy!). Target users are high volume, low cost, high conversion. His slides are on slideshare.

Chris Lea of Virb/MediaTemple talked about Efficiency and Scalability. Efficiency means that scaling will be lower cost; Scalable is true if you can express it in financial terms. If you can do this, you can balance cost with expansion. He rated Steve Souders‘ limit of having a maximum 3 sec page load time, and his 14 things to check. He also recommended Cal Henderson’s “Scalable Web Sites”

The end of the day was re-jigged a little after some audience feedback and twittering. Bruce Lawson came back for another coding session on HTML5 which all went well after finding a laptop that worked. He’s enthusiastic to say the least. Then Francisco came back for a further demo of the Cappuccino framework. Not available yet, so he showed how to use nib2cib to create an app from Apple’s Interface Builder output. There are samples online. He uses Safari for it’s debugging and profiling tools. They just want to make objects that work together by default and two Cappuccino apps should be able to drag images between them.

The end of the afternoon gave us the impressive Gary Vaynerchuk (@garyvee). Loud, brash and knows what he’s talking about. He’s been around a while and the confidence shows. 95% of people are talking rubbish. Cable is not the future, it’s like going to MacDonalds and needing to pay for the whole menu. Business success means customer service and hard work. You can build a business at zero cost, just by doing all the work. (Cash is neutralised by sweat equity!) Care about the people; care about the brand. Marketing is the queen in control of the house. He’s just about to start corkd – a wine social site, and gourmetlibrary.

I came away from the two days in my usual state; full of inspiration and new ideas. Talking to people around the event allows ideas to bounce around and adapt, gaining some momentum on the way. Are they still in that 95% of the rubbish or will they be forgotten in the mad rush of normal life. Who knows. I know that I will have plenty of things to look into on Monday. Plenty of new projects to think about. Plenty of energy for the next month or two. Thankyou Carsonified. There are lots of links here, but search slideshare for FOWA09, you’ll find a few presentations there.

Another year rolls around to one of my favourite conferences, Future of Web Apps organised by Carsonified. It’s a little smaller this year and returns to the previous venue at the Kensington Town Hall. This is a comfortable size but previous problems with wifi were repeated on the first day. Intermittent though so I didn’t hear too many complaints. There is only one stream this year so we didn’t have to read through all the summaries to decide which to attend. Nice and simple was what I needed as I had been quaffing cocktails til the early hours with a few of the Microsoft web guys. They appeared at the show as well, so it was good to see that they’d survived. (Second day is here)


Fowa09 was kicked off by the ever enthusiastic Kevin Rose. I feel he has more direction this year, but maybe he has regained more of a focus and found his own niche. 10 rules to follow in order to move up to a million customers, sounded a bit simplistic, but all good advice.

Mike McDermot from Freshbooks, the online accounting/bookkeeping service gave us some of his “totally tubular” ideas. His Freemium accounts allowed users to get into the action easily and quickly, with few restrictions other than numbers and branding. His advice was to not build anything that you didn’t need to, apart from tracking systems. You need to be able to tell where your users are landing, the keywords that they used to get there and their path through your pages while they stay. He didn’t think that Google Analytics was good enough, but I’ve use Google to track paths quite successfully. Main point was to build the reporting systems well, so that your programmers don’t have to constantly work on management reports.

Ryan had developed a “hello” app (using some help from RedBus and Microsoft) It was an experiment in crowd twittering and I though it intriguing but it may not give the expected results; perhaps there were no expected results. It was built around using tweets to show what type of people were sitting where in the auditorium (each chair had a unique code!), and to meet to discuss topics helped by the requirement to exchange tokens. In scoring points, the users would mix more and be collecting the points for prizes on the second day. (Interesting idea and could this be used for corporate?) We shall see. They had a small panel later with Scott Guthrie pushing Microsoft’s “spark” initiative which allows small companies free licences to all the tools for three years. Matt Lee from RedGate helped develop the app using ASP/MVC. It was like a sponsors message for Microsoft but done in a casual way. Interesting ideas as usual from Carsonified. The app will be open source after the conference. Websitespark.com for the Microsoft tools. If you’re a student, you get all the tools free anyway – search for dreamspark. Microsoft are being very friendly, friendly and even have an installation wizard for setting up all their server and development software. Surprisingly though it will also give you the option to install php under the IIS system along with a selection of open source software such as Drupal, WordPress etc. Looks good; it says it can handle updates as well, but not sure about the third party software. Expression 3 looked impressive. Definitely worth a try for the SketchFlow features and state control.

Dustin Diaz of twitter (@ded) talked about the beauty of Javascript frameworks. He’s been around several of the corporations in the valley – google, yahoo but is now with twitter. He didn’t pick between the libraries, (jQuery, Dojo, YahooUI, Mochikit, Prototype, Mootools, Sproutcore ) but was trying to tell us to roll our own. You’ll know the library better, and can keep the error checking and validation down to limits. His main advice – keep it small, separate the business and the look, use proper classes and avoid over abstraction. Pointed out Dean Edward’s Base, and Dan Webb’s LowPro, neither of which I had heard of before. I’ve been using jQuery with some success and I asked Yahoo about the size of their tools to compare. Their answer is that they have stored their libraries on their edge servers (and Google’s). This allows them to serve the library at top speed for any web site using them; probably faster than storing even a smaller library on your own servers. Interesting thought – more speed tests to do here.

Addison Berry (@add1sun) gave us a talk about the need for passionate people. She finds hers in the open source community, especially with Drupal – a lot of effort can be found for very little monetary return. If you can find some passionate people, treat them with passion and there will be great returns.

Francisco Tomalsky form 280North was next. He’s ex-Apple, from the Safari team and has moved on to bring Objective-J from the Objective-C background, and then ported a version of Coco to be the Cappuccino framework. Really impressive. He was brought back late on the second day because there was such a tweet around this first demo. I’d seen the demo before, but it still felt extra quick. They have moved from producing their 280slides application, to the full development environment with 280atlas.com. Original plan was to produce web apps, running in the browser; now everyone is asking for desktop apps so they’ll be competing with the likes of Air and Titanium. It will be based on a local webdav Cappuccino server, with html5 and Google Gears. Look out for the Beta on November 15, (priced at $20)

David Prager (@dlprager) from Revision3 next up with more passion. His advice was to that you can find a niche where there are lots of passionate people. Use this passion to find evangelists. They are the group that will spread the word and build your business. Another person advising the importance of having good reporting.systems; they allow you to monitor the effects of changes.

At lunchtime I went to one of the Uni sessions, this one with Gerry Gale (@vicchi) now taken over by Yahoo geo team. He set up PlaceEarth, a system of identifying everywhere in the world and being able to find the places from a huge variety of local and international contexts. 85% of the data on the net is unstructured and it is doubling every 3 months. As most of this information contains geo references, this system can be used to find an exact location from a variety of text phrases automatically. Yahoo are promoting their WOEIDs (where on earth…) as the index to the location, which could be a place or an area. They are building these from their own sources at the moment, but will bring user input sometime next year, to allow user authentication and editing. The developer API looks good; it even allows a call to scrape a remote url to get the information to pinpoint the location. It will then fix the html and give structured data to use with its YQL query language. No JSON yet and only POST but early days for the API and they will be looking at the developer response. Go to developer.apps.yahoo.com/wsregapp to sign up and to get a key. ygeoblog.com for the blog. Demo at Isithackday.com/hacks/placeearth

Paypal, another sponsor of the event, were pushing their developer API, Paypal-X. Find out about it on the x.com website (is that name allowed!) They have been through the various permutations of payments and seem to have most variations coverd – split payments to several people, chained payment through middlemen, commission payments, approvals. It looked good to cover anything that I would want. Still seemed a bit expensive for micropayments tho’, 5cents + 5%. They leave some room for competition. Their iPhone app has been popular. 4million downloads in 9 months and lots of cash passing through it. The Android version is coming soon. Paypal were predicting that the value of digital goods will exceed eBusiness revenue with the next year. They have their first developer conference in San Francisco in November. Use the FOWA99 code for a discount.

After lunch, Chris Abad (@chrisabad) talked us through his success with the Spymaster game. Why did Irata Labs have such success? They started with a great product, had some passionate fans and the scoring in the game was based around spreading the word and recruiting people. It used twitter to run the game, with points for followers and transactions, so the popularity blossomed as the hash tag became a leader in the trending topics. They also seemed to have some influential people invited to the initial game play, which meant the publicity arrived on the news sites pretty quickly along with strategy guides from the fans. It needed to be a good game to get the fans whipped up and features were added after listening to their feedback. Chris’ marketing slides are at iratalabs.com/spymaster_slides.pdf

Cat Lee came on to promote the use of Facebook Connect. There are interfaces to get Identity, Connections and Activities for users. The push is to allow web builders to add Facebook type functionality within their own sites; the Livestream box used on the German elections had 9,000 messages. Have a look at all the widgets that are available, http://www.facebook.com/facebook-widgets/ There’s a lot of functionality from Facebook that you can put on your own web pages. Facebook has also allowed users to translate the various phrases on the site. By doing this, they had the French version done within 24 hours! Many other languages followed. Now they’ve opened up the service to allow people to use it on their own sites, with voting, monitoring and moderation services. Looks great if you’re doing a multi language site.

Ed Anuff, Mike Malone talked through the announcement of Motion from TypePad. It’s an API for developers to interface to a data store in the cloud. Initially for blogs and connections for users. Ed was at Kevin Rose’s Pownce before the takeover and a lot of the ideas have been rewritten into the new system. It’s Django/python based, storing all the data in the cloud. They have objects for all the normal user, connection, follower, blog type objects and could build a twitter or micro-blog type site fairly easily. I might give this one a try. The open source software is at developer.typepad.com. The example is at motion.typepad.com.

Vodafone were showing off the latest phones and looking for developers to produce some widgets for them. There’s a one million euro competition which should be some help. The sdk is all javascript, webkit based so it should be relatively straightforward for most developers. There are openSocial and micropayment interfaces, libraries for hooking into the hardware etc. Geo location is there now, accelerometer, compass coming later. Looks easy. Give it a go. The Appstar competition page is at widget.developer.vodafone.com/appstar .

Bruce Lawson gave another popular talk about HTML5. Canvas tag looks great but has accessibility problems and needs plugins for Internet Explorer. (excanvas.sourceforge.net ) Video without plugins is another winner. It will compete with Flash and Silverlight in my book. I have been moving back to jQuery and similar libraries as I don’t need my whole page being created by Adobe or Microsoft. Having used Thermo and Expression Blend, I find myself creating whole pages of application that need the latest version of a browser plugin to get the most out of. For day to day this seems over the top. If they can sort out the problems with html5 life could be far simpler. Javascript libraries such as modernizr will help the progress.

Dr Chris Thorpe (@jaggeree) of The Guardian then gave a talk about the future of Guardian services. They seem to be progressive in their search for new media possibilities. They are very aware of the fall of print media and are trying to be part of that disruption and the move towards what he called “mutualism”, or reaching out to get audience input and opinion. They now have an API to all their back content, with output in xml, json and atom formats; free developer access. He pointed out that data from http://data.hmg.gov.uk is now available on Google Groups. Over a 1000 data sets. They are pushing a green ad network , helping novel tweeting in Westminster politics, they have an app in the iPhone app store, their datablog and a flickr group. They’re trying to create a monetising ad network where there can be shared proceeds. The django app that they put together to allow the public to notate MP’s expense was very popular, only took a week to produce and cost less than £100 of the Amazon EC2 cloud.

Aza Raskin (@azaaza) finished the day with a talk about Ubiquity from the mozilla team. They are trying to smooth out some of the users workload, trying to take on some of the tasks within the browser. The work should centre around you. The browser knows your identity, your data, your social connections and it could deal with more of the interfacing that needs to be done. It allows you to search with more natural language, to cut and paste maps with a click or two. You keep your train of thought because you don’t have to switch to thinking about how to do something else. Also mentioned the jetpack plugin for Firefox which I hadn’t seen before.

Everyone seems to be talking social this year, but with a more combined effort. The openID movement a couple of years ago has moved to a position of not wanting to remember any of your personal details. Perhaps you could log in at the beginning of the day, but after that your movement around the web should be aware of your contacts, your tastes and your history. Different systems may start to help this, but Kevin’s thoughts were that perhaps the browser will do all this. The browser will control how your information is put onto the web. Many more browser apps will hold information, presumably in the Cloud somewhere so that the data is accessible from where ever you are. There will be more sharing of data between secure, approved connections.

Link to the second day blog.

Our company had a hack day last week and I thought that I’d have a look at the Google App engine. I was getting used to the management reply of “do you have a budget code?” when asking for a server in the racks, so I thought that I’d experiment with some data in the cloud. I had taken in the story about the Guardian knocking up a quick python web app using Django to notate the MP’s expenses information. I heard tell it took a week so I thought I might get something simple done in a day.

What I hadn’t realised is that Simon Willison, who wrote the Guardian app, had been a major contributor to the Django framework and so knew it backwards. Sigh. I did have a look at the framework but in the midst of various problems with wifi, there was just too much for the first half day. In the end I just cut some simple python code together to see what response times were like and to get a flavour of the database side in the Google App engine. It was a good experience and convinced me to give it another go after learning more about Django. I’ve put some notes here about what I needed for development and a few demo screens about the app that I created.

I needed python on the laptop, so I went for the latest version, v3. That was my first mistake. Google doesn’t work too well with this version; it has some idiosyncracies that require 2.6. I had to uninstall the new version and set up the older version. I would advise over riding the default directories, as some parts of the operation (patchng for django?) seem to falter over spaces in directory names. In the end I installed to the C:/python26 directory and all seemed to work. I then installed the app-engine-patch that is needed to run Django on the Google App engine. I used version 1.1. It was interesting to start looking at Django, but I found that I needed serious learning time. In the end I decided just to set up some simple REST service to input some records and return some XML.

Once python is on your development machine, you need to add the Google app engine tools. These give a simple gui to allow you to control the loading and running of several services, each with their own socket. Write the app using any favourite editor (htmlkit is a simple, free one that I can recommend – although I’m normally on eclipse), then compile and run with this gui. It will run the app on a local server, which is booted automatically. Browse to the server with eg http://localhost:8080 and the app will be run. A few seconds delay the first time, as it is being compiled. You choose the port number when loading the app, so you can have several apps running at one time. Pause them, continue etc.

What happens in the app and what sub pages exist, are defined in the application. It effectively links a routine to a page url. When you’ve tested your application locally, just click the Deploy button and it will be sent up to Google’s cloud and it will then be available across the net. It really is simple.

Two main files are required, app.yaml and main.py

An example of app.yaml is,

application: data-form
version: 1
runtime: python
api_version: 1
handlers:
- url: .*
script: main.py


This names the application as data-form and defines the action for all the pages in the application as main.py. There are only a limited number of application names allowed per developer (10, I think).

Main.py is where the logic is stored and has the definitions of the processing, the classes and the urls.

First we have the normal includes for the libraries,

import cgi
from google.appengine.api import users
from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
from google.appengine.ext import db

The class definition for the objects in the database, in this case a football fixture,

class Fixture(db.Model):
user = db.UserProperty()
league = db.StringProperty()
status = db.StringProperty()
home = db.StringProperty()
hscore = db.StringProperty()
ascore = db.StringProperty()
away = db.StringProperty()
date = db.DateTimeProperty(auto_now_add=True)


The following class creates the display page. It reads from the fixtures database, using the gql querylanguage. Then it writes out the fixtures, followed by a form to input a new fixture.


class MainPage(webapp.RequestHandler):
def get(self):
self.response.out.write('')
fixtures = db.GqlQuery("SELECT * FROM Fixture ORDER BY home ASC LIMIT 10")
#
for fixture in fixtures:
if fixture.status:
self.response.out.write('%s ' % fixture.league )
self.response.out.write('%s ' % fixture.home )
self.response.out.write('%s-' % fixture.hscore )
self.response.out.write('%s ' % fixture.ascore )
self.response.out.write('%s ' % fixture.away )
self.response.out.write('
' )
else:
self.response.out.write('%s v
' % fixture.home)
#
# Write the submission form and the footer of the page
self.response.out.write("""
<div>
Fixture
Started
Finished
<br />
Prem
Championship
Second
<br />
Home
Away
<br />
</div>
<div></div>
""")


Which gives a screen like this,

The following class is used to add the fixture from the form data.

class AddFixture(webapp.RequestHandler):
def post(self):
fixture = Fixture()
#
if users.get_current_user():
fixture.author = users.get_current_user()
#
fixture.league = self.request.get('league')
fixture.status = self.request.get('status')
fixture.home = self.request.get('home')
fixture.hscore = self.request.get('hscore')
fixture.ascore = self.request.get('ascore')
fixture.away = self.request.get('away')
#
fixture.put()
self.redirect('/')


This class will simply list the matches,

class ListFixtures(webapp.RequestHandler):
def get(self):
self.response.out.write('List fixtures')
#
fixtures = db.GqlQuery("SELECT * FROM Fixture ORDER BY home ASC LIMIT 10")
#
for fixture in fixtures:
if fixture.status:
self.response.out.write('%s ' % fixture.home )
self.response.out.write('%s-' % fixture.hscore )
self.response.out.write('%s ' % fixture.ascore )
self.response.out.write('%s ' % fixture.away )
self.response.out.write('
' )
else:
self.response.out.write('%s v
' % fixture.home)
#
self.response.out.write("""
""")


This class lists the fixtures as XML.

class ListFixturesXML(webapp.RequestHandler):
def get(self):
self.response.out.write('')
#
fixtures = db.GqlQuery("SELECT * FROM Fixture ORDER BY league, home ASC LIMIT 10")
#
for fixture in fixtures:
self.response.out.write('%s' % fixture.league )
self.response.out.write('')
self.response.out.write('%s' % fixture.home )
self.response.out.write('%s' % fixture.hscore )
self.response.out.write('%s' % fixture.ascore )
self.response.out.write('%s' % fixture.away )
self.response.out.write('')


Finally a section that defines which page urls are associated with which procedure. If the address localhost:8080/xml is used, the ListFixturesXML routine will be called.

application = webapp.WSGIApplication(
[('/', MainPage),
('/sign', AddFixture),
('/xml', ListFixturesXML),
('/list', ListFixtures)],
debug=True)
def main():
run_wsgi_app(application)
if __name__ == "__main__":
main()


All relatively painless, once you get the overall idea of the layout. It becomes more complex as the operations require more processing, further classes and interaction, which is where having a framework like Django will bring benefits. I shall take the time to look more into Django, as the value of running this type of service on the cloud are that it is largely free for moderate usage and free of the overheads of setting up any hardware and web server software. Javascript could have been used in the same way; I just wanted to have a look at python, as I may need it in other systems.

We had a few people from Google to talk about the latest developements and tools, so I thought that I’d just put down a few of the links as a memory aid. I looked at the impressive O3D after the conference and will return to it later, no doubt, but this session was more to do with flights of fancy around Google Earth and the customisation of Google maps.

Stefan Kuhne gave a demo of the Timeline Editor for Google Earth and how it can be used to generate videos of flights around the world. It has come a long way and has options to customize the flight and the view to give styles that fit with the company branding. Rather than just a quick trip between cities, you can now create a whole information video by adding buildings, adding text with banners etc. You can even add sound tracks and a voiceover so that the video becomes a complete presentation. There are features there now to output to a variety of different video formats. The text and keyframe data is embedded within the generated kml file in XML format, so I’m sure people will be putting together apps that will read and write the format as the kml is read from the web site, giving the ability to make these trip files on the fly or to make them for the language of the website visitor. The ability to look at older views of the same city makes quite interesting viewing. Make sure that you sign up for their Sightseer newsletter for all the latest news. See this section for more info on making the videos.

In the 3D world, SketchUp seems to be producing a whole host of people that are prepared to model their city for next to nothing. It’s so easy to put the models up there in Google Earth and some have obviously had a huge amount of time spent on them, Collada seems to be a growing open format now that Google have given it their backing; it’s certainly popular with the Flash contingent where it is used by default with Away3D and Papervision.

Google maps is very easy to use now. It’s just a cut and paste job to put maps in your blog or on your web site. There are also facilities for map makers. Maps of places in the News such as Iran, are being built by thousands of volunteers using Google facilities. It makes maps almost live entertainment. For some inspiration have a look at the MapsMania blog which looks at the latest sites using Google maps. Other great examples from from the Washington Post with their timespace Flash app and the kmlfactbook site showing CIA data. If you need Flash maps, try the uMapper site which helps you make them.

Google are such a huge company now, they are building systems that require support and marketing and so need to get some return for all their efforts. In practice this means that anyone who puts effort into adding content to Google sites in the way of 3D models or street map data, is giving Google a licence to make a profit from it. Although the use of the models and maps is free for normal use, if you start to make any money then Google would like their part, even if only by adding their attribution. It seems a bit strange to Open source advocates that people who add models and streets to their system effectively sign away the rights to their data. We need more facilities like these in the OpenStreetMap and other similar projects. Google makes it so easy though, it’s sometimes hard to complain.

Spent a day and a half looking at the new release of Eyeon Fusion with Matt Leonard of SphereVFX. Nigel Richards of the distributor FocusFX arranged some tuition and Framestore donated their training room. Matt has been looking at Fusion betas for a while and has good experience of the Nuke package, so he was able to give a balanced answer to most questions that came up. He doesn’t know the scripting side of things that well, but showed everything else I wanted to see. The new 3D and GPU render effects are fantastic with multi layer rendering, normal map handling and the stereo facilities look interesting.

The new version of Fusion gives a lot more information in many areas, the meta data from images, information about the tool settings etc Doing a click/drag from the colour picker button shows not just the colour info while dragging across the screen but the alpha channel values. If you hold the Control key down while connecting the output from one tool to another, all the possible inputs to the tool are shown. It all makes the software easier to use.

A major part of this upgrade is to the 3D tools and they have many more facilities than can be covered in a short blog. The system is able to read in fbx files from any of a number of 3D packages. It can texture, light and reflection map these models and even write them out again for processing in other compositors. There are a number of shading models; the usual Phong and Blinn with the addition of Cook-Torrance and Ward shaders give a wide range of finishes. With the ability of being able to mix shaders, the system is able to give complex shaders from simple plastics and metal through to car paint, skin and wetness. The 3D also applies to the various types of stereo tool available. Stereo can be produced from a single camera by adjusting the eye distance and focal length, or more complex situations can be created by using two cameras and combining their viewpoints. It looks quite comprehensive, but I’d need to get a real project in to see where the practical benefits are. The 3D upgrade is really impressive and Matt showed us some good examples but it needed more time or again a real job to show its power. Features of note include the fog, openGL rendering, fbx exports, texture (uvw) transforms, normal mapping 3D tracking etc etc. Really impressive.

Two phrases have been brought in with this release, “Domain of Definition” and “Region of Interest”. The Region of Interest is a way of just processing and displaying the part of the final image that is important. Only this area of the screen is updated through the whole composition, so it makes the render much quicker. It’s as quick to do as clicking and dragging a rectangle around the area and so should be really useful. The Domain of Definition on the other hand, is a cropping of the area being processed by a pipe, so that no rendering is done outside of that area at all. Material outside the area is discarded. This can be done at multiple places through the pipe and again, will improve the rendering times proportionally to the area involved. Effects can be limited to just a small part of the image. Where these are quite subtle to see, a tint can be put onto the video to show the area without the effect. Useful.

Splines have changed a little in the way that they work. Matt talked about the use of beta-Spline rather than b-Splines, giving more control. I seem to remember that changing points and tangents with bezier spline functions used to affect the curve as a whole, whereas beta spline functions only affect the curves connected to that control point. They seem to work well; they have a few extra keys to create the double splines for smooth masks, move groups of points together etc. They also have a useful mode to affect all keyframes. An extra smoothing point can be added to all key frames at once, rather than having to go back and repeat the action to all the keyframes already made.

I haven’t really looked at Generation, but I’ve seen that the two packages can be used in conjunction to give more editing and versioning features. If you don’t want to bring in an Avid, it can perform most of the basic editing and colour processing. It also deals with versioning of a composition. If a comp is double clicked in Generation, it will open for editing in Fusion and will save as a new version, but it doesn’t destroy the old version. The user could revert if they prefer, to one of several prior versions of the comp. Fusion audio hasn’t changed much. It is still limited to just a simple scratch track. It could do with some extra audio processing facilities, even just some simple sound mixing would be useful. Chroma keying is much the same. Keylight is probably worth buying if you need that extra quality.

All in all, the two day SWAT course was really useful. Matt’s experience with other packages gave an insight into where Fusion was ahead of the competition and there were a few hints on where it might catch up in other areas over the next release or two. If you need to get up to speed in this version, I can throroughly recommend his DVD which has several hours of tutorials on the latest changes. Even after being on the course, I found the videos showed yet more of the detail of the new features and I’m sure I’ll replay them several times over. Another really good version 6 update descripton is on Matt’s entry on fxguide.

Had a look at the new Aston 7 machine. It has created a useful interface and is being used for some real work now. The Aston team have wrapped the Brainstorm 3D engine with an interface that reflects the older Aston interface which was quick and simple for operators. It doesn’t expose all the functionality in Brainstorm, but tries to give a regular interface that previous Aston operators will find comfortable. These are just a few comments that I took down during the demo and it doesn’t claim to be comprehensive.

The interface is a click and drag interface with a toolbox of elements that can be brought into a graphic. Materials, colours and resolution can then be adjusted in the interface with a context sensitive properties window. Single objects or groups can then be dragged back into the pallete area to save a standard item or a template for use in other pages. The view is a locked off camera and the animation is done by moving the models in the scene. Lighting looked good with point and spotlights, with and without attenuation. The lights are all global at the moment but selective lights are being added. There are no shadows yet and no physics which are in Brainstorm. Primitive objects such as spheres, rounded cubes have adjustable complexity so the operator may balance performance with quality. It is easy to texture cubes on a per side basis, a global selection may be over ridden by selections for particular sides. There are some blending optiopns but I’m not sure that all those allowed for in Brainstorm come through. Not as obvious as the Photoshop blends that we are used to. This may well be a later addition.

All their pages and data are XML files. There is no database involved. Assets are held in folder structures and there are tools to make sure that the on-air boxes are refreshed with any new images as they are needed. The fonts on a page are logical fonts; they can be defined as part of a project along with colours etc. Shared assets in a set of pages can be updated and they will update the next time the page is loaded. The pages are reference as a four digit number adn can be recalled quickly using their interface. This will suit the Aston operators of old and people used to vizRT Trio systems. The keyboard interface is very reminiscent of the older Astons and has some quick text handling that operators like, character kerning, movement of selected bits of text; the scale to fit option can have a combination of X scaling or XY scaling as the operator chooses.

Being Brainstorm driven, the graphics are state based, meaning that the system can move from one state to any other at any time. There is no fixed timeline. This can be a benefit for flexibility but it can be difficult to produce some types of graphics where the path of the animation is fixed and can be previewed. The designers are used to timelines, so they may have difficulty here. There was talk about some type of timeline being brought in, but it would be based around a series of events rather than a fixed animation timeline. The cool facility in Brainstorm, to create image buttons by dragging and dropping states to a window is not available in Aston, although they thought that it might be possible to open up. They don’t really have the content pilot type functionality without this. The file formats for 3D objects didn’t seem to be as full as Brainstorm, but this is just a mater of letting it through the Aston interface.

The operator had a few problems when trying to use masks and opacity with textured items. This might be a lack of functionality from the Brainstorm interface, or a bug; it is available in Brainstorm underneath. There is no scripting at the moment. There are some actions that might be triggered when data changes but these are relatively simple value comparisons. Any more complicated logic has to go into an external control application. It would do the logic and then provide the Aston with data in a simple table. Strangely, the Aston needs external apps to act as a data server. (??) When the graphic changes it polls the app for the latest data. I’m not sure how this would work in an app that drives the machine completely as in the sport controller case. We would need to tell the machine to load a page and then the page would ask for the data. We shall look at the API docs in more detail.

Tickers seemed to be easy to make, with multiple fonts and could have 3D objects placed in a font for use between normal text items. Looked quite smooth although we only saw 2D onjects. The data form that fed the ticker is read as it takes each line on screen, so a change to an item in the list will be updated on screen as early as possible.

A number of pages may be on screen at the same time, allowing graphics to be mixed anywhere on the screen or even overlapping. The system has a series of events that can be generated that will fire a state change in other graphics. This allows a strap coming on to fire an event to squeeze up a full page graphic to make room for it. I’ll be interested to see how effective this is and how complicated it gets as the graphics interact. It compares to transition logic in the vizRT machines. Video clips are usually Quicktime or AVi but the system uses ffmpeg internally so any codec to suit that should be possible. The performance of the system looked OK, but Aston are still working on a numeric display to show render time per frame which will help to judge the complexity of the page being built.

The screen layout can be configured for different operators; the windows are just moved around and resized even over two monitors which is welcome. The playout operator is able to get thumbnails of the pages in this wider layout with large page numbers and text. The assets folders can then also be made larger with search facilities that might not be used in designer mode.

We haven’t seen the automation interfaces, but Aston and Softel the parent company are well used to these. They would probably be using the Brainstorm versions which we’ve seen previously, but it would be good to see it in action. Hardware wise, the system is based around a PC with nVidia quaddro cards and an AJA card for video in/out. This card gives a couple of SD inputs; maybe only one in HD as there was a question of what the performance hit would be. It would be a box (4U) per channel, but design stations could sit on a normal machine and link to the main boxes remotely. This could give a cheaper overall feel to the system. The system is definitely getting useful, but has room for improvement. I like the engine within it, the ideas in the interface look useful but I need to look more at the detail to see the quality and speed of use.

Spent a sunny day going on a train trip up to Birmingham for the Flash Camp. I decided that I’d like to listen to Mike Jones talk about components again, with a Flex 4 flavour this time. It was well worth the trip, not just for Mike but there was an interesting bunch of speakers there; a reminder on Away3d and the best demo I’ve seen of the Catalyst workflow. Friendly group up there; I recommend you get to some of the future meetings.

Enrique Duvos gave us the warm up by showing us some of the latest sites using Flash. Automated reality with the General Electric wind vanes (lee brimelow?), the Morgan Stanley finance app which I think is a brilliant looking design. He showed SpreadTweet which hides your twittering in a spreadsheet to fool the boss. The Flex framework has now added more facilities and apparently Tour de Flex has had 6m views now. Enrique also reminded people that there is another E4 GrandMaster Flash challenge open now. Get an Air game app in now and it could win £5k.

Simon Bailey came on with a good description of pureMVC. I have looked at the docs, but I think I may try Swiz first as I prefer to do my own events/value objects. The talk was similar to Clive Hall’s documentation so it gets hard for simple folk like us to follow. Someone needs to give some simple examples of what this means at on object/message level without going into the details. People can always get the detail later from the web site. Good to see it progressing though and Simon could always help out on the freelance side if you’re near Leicester (?).

Mike Jones was next up. I saw his presentation at the London Flash camp and have got on quite well with the Flex3 component kit, so I was happy to hear him talk through how easy it now appears to do the same thing with Gumbo. Let’s see if I can remember how later! Where there was a single base class before, there are now five base classes from UIComponent. To use theme, we now have the event model of Spark rather than the old Halo model with FLex3. It sounds as though I have more learning to do….but it will be easier later….promises, promises. There were some good slides to show the relationships, but have a look at Mike blog for more. I’ll try and get a link to his slides later. THere’s a lot of changes in the skinning department. The look is much more separated from the actions in the Gumbo model. Spark skins can now have states and transitions between states, so maybe we are going to have to use Catalyst to do more of this stuff rather than coding all those hex codes. It’s getting more like Expression Blend every day! Mike also has a new version of his components book at Amazon.

Some relief from the technical detail as James Whittaker talked about graphics using the Degrafa library. The fxg format will have quite an effect on this, so keep an eye on developments. He mentioned Birdeye as another open surce library. I’ve also been looking at the Axiis extensions as well. They look good. If your site has plenty of charts and diagrams these libraries are well worth the effort. Fxg may change things in Flash 10, these are what you can use now in Flash 9.

Rob then gave an up to date view of Away3D. It was useful for me as I wanted to know where the differences and advantages are between Away and its Papervision root. It has been a while since it first branched. Rob and the team have concentrated on stability and ease of use, but they added many features,

• Perspective correction
• Z-sorting
• Object intraction
• Normals shaders
• Tiling and projected textures
• Dynamic geometry

More recent additions add to this long list,

• automatic triangle cacheing
• mesh animations with the quake md2 files
• advance culling to handle more complex scenes
• new tools – path extrusion, skin extrusion (height map to model)
• bezier patches – the usual utah teapot
• normal map generation
• export of models to dae
• augmented reality
• physics with the active jiglib library

Papervision hasn’t stayed still but Away3D has had some brilliant collaborations. Rob showed some demos of the wiiFlash library, Flint particles, then some examples with the BBC F1 circuit guides, Dragonfly for Autodesk, ITManager for Intel and the lovely Morgan Stanley site.

What’s coming next? Flash 10 texturing will be much better. Reflections using pixel bender combinations, text and vector shapes, pre baked lighting, inverse kinematics, sphere texture optimisation. Looking very healthy.

Anthony and Jerome Ribot from ribot then gave what I thought would be a bit dry, just user interface design, but it was really interesting. They’ve obviously been doing some interesting studies in how people approach a web site. If it’s a negative experience, then more than 60% of users will never return. Makes sense to listen to some of this. They used the term ‘data snacking’ which I thought was quite cute. Hadn’t heard that before, but it fits the actions of a lot of users, me included. Ribot have some impressive clients and are winning awards, so they must be doing something right. THey had lots of interesting things to say about how they are designing their mobile apps – simple, intuitive movements and lookig at gestural systems, touch displays. They try and sketch the design/ui on paper first and then re-use as many similar behaviours as they can. They’re based in Brighton, if you need them, but they’re likely to be busy.

The sessions were then rounded off by Enrique again, with his demo of the Flash Builder 4, Catalyst workflow. As good a demo as I’ve seen. It started with a button in Adobe Illustrator, and a Photoshop file. These were brought in to Catalyst for some simple object building. When the button was exported to Illusttrator again, it had metamorphsised into a multi state button that was then easy to add states to. I thought that I might not like the Catalyst code generation (typical programmer) but it does so much that I can’t now see myself doing without it. It was easy to make a scrollable data grid; components can be moved between packages; data service components can be set up and then taking them into Flash Builder will create so much of the code and event handling for you. It now has transitions and quite a few finished, skinnable components. Look for more as they get towards a release version. Flash builder hasn’t yet got all the wizards in for various types of services. They’ve started with the ColdFusion systems and have changed the PHP wizard from Flex 3. It used to generate a simple (? with classes – not trivial) PHP web service interface for a database. Now it automatically uploads a set of Zend libraries to generate an AMF web service. I haven’t looked at how useful that is, which is a testament to not needing to look. It just works. Have a look at the roadmap and for more details on fxg, skinning etc on the opensource.adobe.com site. Download the betas from the labs site and do it now. THere was mention of the built in FlexUnit testing. I suppose I should look at that as well!

Final part of the evening was a panel discussing how to set up a business and whether you should be independently freelance or work through an agency. Lots of experience came through. I wonder if it was recorded; it would make a good podcast. General thought was to get some experience in a business first. Then balance the guaranteed but lower weekly rates of the agencies with the possible higher rates where you have to sort out the jobs yourself. Negotiating fixed price contracts is an art form that will burn your fingers from time to time. You need to be able to handle customers really well in this area. Make sure you have some indemnity insurance; it’s not expensive.

All in all, a great day out. Small but reasonable venue; everyone was very welcoming and friendly. Make sure you look at the furture meetings. It’s a good place to make friends, learn a few things and maybe do some business at the same time.