TenXer is a tool for measuring employee performance, and is now available as a plugin for Atlassian’s bug-tracking tool JIRA via the relaunched Atlassian Marketplace. Atlassian makes a variety of tracking, collaboration and software development products.

Using the JIRA plugin, development teams can track their metrics and see a performance dashboard. This appears to be the first public release of TenXer, and it doesn’t seem to be accessible outside of JIRA yet.

Ma and his fellow MIT students earned big bucks with their card counting system in the 1990s, but were eventually banned from just about every blackjack table in the country. Since then, Ma has occupied his time founding companies like PROTRADE and Citizen Sports, which sold to Yahoo in 2010. He’s also been giving talks on teamwork at various conferences.

In his keynote at Atlassian Summit, Ma explained that he noticed that successful individuals and teams, from athletes to businesses, quantify their performance and measure progress toward specific goals. That led him to found TenXer to create a system tracking employee performance. To this end, the TenXer plugin for JIRA measures metrics - such as bugs closed, bugs fixed and work logged - to help quantify developer performance. The name TenXer comes from the idea that “great employees are 10x better than the average.”

According to Business Insider, Niel Robertson, co-founder of Trada, is also a co-founder of TenXer. AngelList cites David Jeske as an investor.

The Atlassian Marketplace is an app-store style service for purchasing and installing plugins and integrations for Atlassian products. It was formerly known as Atlassian Plugin Exchange and was relaunched today at the summit.

Email, instant messaging, forums, code forges and other collaboration tools make it possible for distributed teams to get work done - but they're not great tools for making decisions. The team behind Loomio wants to solve that with a new Web-based tool for focused, concise discussions that allow all team members to be heard. 

If you've ever worked with a distributed team, you know how difficult it can be to make decisions as a group. Discussions are unstructured, rambling affairs with dozens of messages flying about and no good way to track consensus. Even worse, requests for feedback can go without comment entirely, or with only a few stakeholders raising a voice.

Agree, Disagree, Abstain, Block

Discussion in Loomio starts with a discussion and specific proposal, and members have the option of voting on the proposal. A group can define the options (defaults are yes/no, abstain and block), and each member can give their view summary. As votes are tallied, everyone can see get a chart that shows how many folks are in agreement, how many aren't, how many have abstained, etc.

This sounds pretty simple, but most of today's collaboration tools don't provide a good way to focus a discussion. The key to Loomio is that it provides a central tool for discussions and (if used properly) narrows things down to decisions that are easy to vote on. Central is key here. It helps a lot to confine activity to one tool rather than making users look all over for information.

A lot of online teams communicate in several ways, including email, IM, IRC, over the phone and face to face. Stakeholders who prefer one medium (like email) lose out if discussions are held in IRC, or vice-versa. Even worse, stakeholders may be totally unaware a decision is being made at all. If a group settles on Loomio, it would enable the group to say "decisions are made here and nowhere else." If something isn't put up in Loomio (or another approved tool), then a decision wouldn't be legitimate.

Settling on a decision tool like Loomio should also help cut down on noise in other communication channels. It's popular to have discussions in email and CC everyone who might have an opinion or might need to vote on something. An active team can inspire email fatigue pretty quickly with discussions that are neverending. Loomio would allow users to visit, vote and get back to work.

Actually, Loomio isn't only for distributed teams. There's no reason it couldn't be used in any organization, but its especially appropriate for situations where team members or stakeholders are far-flung.

Can Loomio Solve the Problem?

Like any tool, Loomio would only be effective if used properly. The early design could probably do with some modification - a more obvious start and end date for votes, for example - but the initial design is solid. The Loomio team says it's already in use by some organizations. New Zealand companies or organizations like Enspiral and BuckyBox are among the first adopters - though no one seems to be providing a public instance that we can point to.

If you want to help, the group is looking for contributions from Ruby on Rails developers, as well as a little extra cash (NZ $5,000) to help the volunteer team devote more time to Loomio development. The project is sort-of open source and already on GitHub. It's "sort-of" open source because the site says it's open source, but if you look at the license text on GitHub it's basically a stump saying: "We need to add the license. GPLv2?" The pledge drive (through the Pledge Me platform) ends on May 18th. The developers have already raised more than their target, but more money might mean more time spent on development.

If adopted a bit more widely, Loomio might help take distributed teams to a new level - much like GitHub has helped with development. It is a simple concept, but bringing order to decision-making could help teams communicate better and make better decisions, no matter where they happen to be located. 

You've heard this from ReadWriteWeb for the past several months: The exodus to the cloud for enterprise services and resources is moving control of everyday work away from the IT department. So what happens with all those displaced IT workers and administrators who are no longer managing applications and services day-to-day?

Well, if you ask the folks producing the next edition of Visual Studio for Microsoft's upcoming Windows 8, they become developers.

"One of the things that we think about is like, hey, there is a world of development and there is a world of operations. In some sense, those worlds have been far apart in the past. [With] Visual Studio 11, we are taking the next big steps in terms of providing a tight workflow between the dev world and the ops world - we call it the 'DevOps loop.'" This from S. Somasegar, Microsoft's corporate vice president for the Developer Division, during the recent rollout of the first public beta of VS 11 - historically its principal developers' suite.

Not Those Two Worlds Over There, But These Two Over Here

Over the last five years, Microsoft has operated under the notion that there are two separate classes of developers, which it once called "Web developers" and "apps developers." The former group has been addressed with a product line called Expression Studio, which was originally geared toward the Web designer that Microsoft described as hailing from the world of graphic design - someone more experienced using Photoshop than Eclipse. Now, with the Windows 8 design motif hinging upon Web apps that it wants its mainline developers to embrace - the workers who know C# and Visual Basic - it can't exactly afford to treat Web apps developers as sous-chefs.

So it did not go unnoticed that the latest VS 11 beta not only has extensive support for JavaScript app developers, but also contains the Expression Blend component - the tool from Expression Studio for devs to design CSS stylesheets. If Microsoft still has two audiences, two worlds, in mind for its developer product lines, their characteristics are evidently both in flux. Coming into focus ever so gradually is a concept called DevOps - essentially, the admin or system operator who either dabbles in development, or has already taken the dive and who Microsoft is only now discovering.

"We're looking very heavily in bringing in another role, as part of the software development team: That's the operations professional," said Corporate VP Jason Zander during the VS 11 rollout event. "DevOps is a good example of that. We have the developer in the operations cycle - sometimes it's the same person, sometimes it's different departments... We recognize especially as we all start going out and building really advanced services and sticking those out in the cloud, it's necessary for us to really get that loop working very tightly."

Windows 8 will ship with two worlds of its own: one which encompasses the new and emerging world of touch-capable apps, and one which most Windows applications will run on today. Microsoft doesn't want these two models to align with separate developer classes - and that's a smart decision. If the "Expression" realm aligned itself with Metro-style Web apps and the "Visual Studio" realm with Desktop-style .NET applications, Windows itself would split into two competing ecosystems.

So think of this latest product cycle as "open-ecosystem surgery" - a route to cross-pollinate Microsoft's existing dev groups, with the result (hopefully) being that a new pair of groups emerges along a different dividing line. Planting some new seeds in this reconfigured garden, Microsoft will be offering an express version of its premium Visual Studio tier. The SKU that used to be marketed to large teams will now get an Express version, hosted within the Windows Azure cloud, for smaller teams.

Worth noting is this new TFS project dashboard, which is supplied by the cloud-based team server. It's not just that it incorporates Microsoft's corporate-wide layout - it borrows its on-screen gadget concept from the upcoming Server Manager tool for the next Windows Server "8."

"The Team Foundation Server Express product uses a lot of the core technologies from the full-fledged [TFS] product that a lot of our developer customers love and use today," remarked Somasegar. "As a result, you get a lot of the core functionality like work item tracking, source control, [issue] management tracking... being able to have task boards that allow you to follow agile practices." Like the developer division's other Express tools, the new TFS Express will be free; but unlike the others, it will support teams of up to five.

In an interview with ReadWriteWeb, Jason Zander tells us to expect some, though not all, DevOps-oriented features from the existing Team Foundation Server to become incorporated into the Express edition. But routing work items between two roles - for example, starting with a developer role and delegating to an operator role - will be enabled within TFS Express.

A Broader Mix of Both Worlds

Microsoft will be taking further steps than we had been told last September to bring the existing .NET developer base into the Metro-style world. Although it's already an accepted fact that Silverlight development is at a dead end, Microsoft is building additions to the .NET Framework that will enable C# and Visual Basic developers to build what Microsoft will officially call "Metro-style apps." This is important because when we were introduced to the Metro concept last September, it was characterized as the style of apps you create using the WinRT runtime library. WinRT is not .NET; and at that time, there were elements of Metro-looking layout that you could incorporate into a .NET app, but it might not be something that runs in a tile on the Start screen.

That has changed: With these new additions to .NET Framework 4.5, including .NET for Metro-style apps, C# and Visual Basic apps can be created using VS 11.

Jason Zander tells us more: "The core subsystems that you want to rely on for a Metro-style application are provided by the Windows Runtime. It's the same one that's sourced up, whether using C++, JavaScript, C#, or VB. There is still the Common Language Runtime [from .NET] in there, and there's still some of the core base class libraries that I need to write code... but one key difference, just to demonstrate this point, is that there's already a communications stack in WinRT, and we just use that one."

For now, Zander says, this will not mean that Metro-style apps will be available to the entire multitude of .NET languages, though he does not discount the possibility that other contributors could change that in the future. The Metro-style additions will be exclusively for C# and Visual Basic.

"To the extent that you're a JavaScript developer and you're writing a Metro-style application, then of course you can just use JavaScript. We do enable the ability for that application... to call out to C++ or .NET assemblies," Zander explains. One example he offers would be a physics library written in C++, which may then be called from JavaScript code in the Metro app. "That's kind of a hybrid application that has both components in it," he says.

"If I'm a Silverlight developer today, and I'd like to author a Metro-style application, probably one of the most direct routes to being able to do that is to target XAML and C#, for example, as a Metro-style app there. And then taking a Silverlight app with the XAML, using some of the code that you have, and being able to retarget that inside of the new Metro project that you write. We do not have tools that will automatically convert those assets over," Zander warns. "And because you are targeting the Windows Runtime, there are some differences." There are new markup items for using XAML with touch and hover gestures, for instance. Windows Phone 7 apps will face a similar transition to Metro and C#, he adds.

But if the developer wants to transition his skill set from Silverlight to JavaScript/HTML, "in that case, you're rebuilding the application. We're not going to try to automatically map anything over. My experience with those types of tools is, they generally have a hard time giving you the fidelity that you'd expect. Sometimes the apps kinda work; and if you're targeting a new medium, like from Silverlight to JavaScript/HTML, those are different enough that I feel you'd actually be more productive as a developer to use [the Silverlight base] more as inspiration than as core assets."

It'll be a difficult set of bridges to build, but in this particular department, Microsoft does have one factor squarely in its favor: It does not have much competition for building Windows apps. Right now, the competition is from the cross-platform development realm, but that realm will not have a leg up on WinRT and the new .NET Framework additions. Microsoft has juggled the order of elements in the universe before. For the converging worlds of apps developers and system operators, don't count it out yet.

A few months later than originally planned, the "RTM" code for version 5 of the open source Umbraco CMS has made its way to CodePlex, Microsoft's open source distribution channel. Now the hard part begins: updating, and in many cases replacing, existing documentation that goes back to version 3.

The various elements of Umbraco's CMS database are referred to as document types. You define how a document type functions and operates by way of macros (not how it looks; that's done with CSS). From version 3 of Umbraco, which was only a few years ago, up until now, there have been unofficially three, and actually four somewhat different methodologies for producing macros. Version 3 relied on XSLT, a W3C standard since the late 1990s. XSLT effectively leverages XML to embed server-side instructions into an HTML page, that translates data from an outside source into content and HTML markup. The client never sees the code, or, to use W3C's term for it, the stylesheet, even though it wasn't being used for style in this context.

XSLT seemed to be the right choice at first, because it was inarguably a world standard, nobody owned it, and it was well documented. It was terribly cumbersome, however. Here's an excerpt from a CMS I created for Umbraco v3 two years ago. It's a code segment that projects the three newest headlines from a blog with my name.

<xsl:param name="currentPage"/>
<xsl:template match="/">
<ul>
<xsl:for-each select="$currentPage/ancestor-or-self::root/descendant-or-self::node [@nodeName='Scott Fulton']/node [string(data [@alias='umbracoNaviHide']) != '1']">
<xsl:sort select="data [@alias = 'DisplayDate']" order="descending" />
<xsl:if test="position() <= 3">
<li>
<a href="{umbraco.library:NiceUrl(@id)}">
<xsl:value-of select="data [@alias='DisplayHeadline']"/>
</a>
</li>
</xsl:if>
</xsl:for-each>
</ul>

It looks far more confusing than it actually is. The easiest part is spotting the pure HTML, such as the UL block where the results are rendered. You can spot certain global variables, or parameters, by the $ prefix, as in $currentPage. Then the whole bit about ancestor-or-self::root and all that is part of another W3C standard called XPath, which is used here to navigate through the database tree. To make sure the articles are sorted by the date of publication as opposed to the date of creation, I invoked the DisplayDate variable as the sort parameter sent to the xsl:sort instruction. (Every single XSLT instruction has an xsl: prefix. I sometimes spent hours wondering why some macros were stuck, only to find I had written "xslt:" as the prefix.)

But the layers of abstraction between the variable name and the XSLT instruction were three-fold, and this was the case all the time. select="data [@alias = 'DisplayDate']" used single quotes to denote the variable separate from the attribution, which was always preceded by @alias (JavaScript devs, imagine always having to write "the name of the variable is" before every variable), which is demarcated by [square brackets] that separate the attribution from the data market ("the following data is data"), which is then set off from the property name using double-quotes. The result looked like the cat had danced on the keyboard, and few XSLT veterans would claim it as legitimate.

With version 4, the Umbraco developers began taking controversial, but necessary, steps to move toward a more sensible approach. As Microsoft began its major push for an architecture called MVC (Model / View / Controller) for ASP.NET, it only made sense that Umbraco adopt it somehow. It fit perfectly with Umbraco's original philosophy of separating the data from the rendering of the data, and separating that from the device that controls it.

But the easiest route to embracing MVC appeared to be the direct one, which with respect to a Microsoft technology meant embracing a Microsoft language: C#. After Microsoft made available a broader array of development tools such as WebMatrix that didn't tie devs down to using the commercial Visual Studio, the skepticism winded down.

Now using Umbraco's third iteration of Microsoft's Razor - its scripting language based on C# - it is entirely feasible for the above monstrosity of an excerpt to be boiled down to a single instruction.

With thanks to long-time Umbraco contributor Warren Buckley, here's a complete example of the change in legibility from XSLT to Umbraco v5 Razor. The following two excerpts do the exact same thing. Here's the Umbraco v3 version:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE xsl:stylesheet [ <!ENTITY nbsp " "> ]>
<xsl:stylesheet
version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:msxml="urn:schemas-microsoft-com:xslt"
xmlns:umbraco.library="urn:umbraco.library" {0}
exclude-result-prefixes="msxml umbraco.library {1}">

<xsl:output method="xml" omit-xml-declaration="yes" />

<xsl:param name="currentPage"/>

<!-- Don't change this, but add a 'contentPicker' element to -->
<!-- your macro with an alias named 'source' -->
<xsl:variable name="source" select="/macro/source"/>

<xsl:template match="/">

<!-- The fun starts here -->
<ul>
<xsl:for-each select="umbraco.library:GetXmlNodeById($source)/node [string(data [@alias='umbracoNaviHide']) != '1']">
<li>
<a href="{umbraco.library:NiceUrl(@id)}">
<xsl:value-of select="@nodeName"/>
</a>
</li>
</xsl:for-each>
</ul>

</xsl:template>

</xsl:stylesheet>

Here is the Umbraco v5 version:

@inherits PartialViewMacroPage
@using Umbraco.Cms.Web
@using Umbraco.Cms.Web.Macros
@using Umbraco.Framework

@{
//Get the macro parameter and check it has a value otherwise set to empty hive Id
var startNodeID = String.IsNullOrEmpty(Model.MacroParameters.startNode) ? HiveId.Empty.ToString() : Model.MacroParameters.startNode;

//Check that we have a HiveId to work with
if (startNodeID != HiveId.Empty.ToString())
{
var startNode = Umbraco.GetDynamicContentById(startNodeID);

//Check that startNode has child pages
if (startNode.Children.Any())
{
<ul>
@foreach (var page in startNode.Children)
{
<li><a href="@page.Url">@page.Name</a></li>
}
</ul>
}
}
else
{
<p>HiveId is empty</p>
}
}


This morning, HP begins a repurposing of the performance testing tools for websites that it gained through the Mercury Interactive acquisition of 2006, for the mobile apps era. It's unveiling what it calls "LoadRunner-in-the-Cloud," complete with hyphens. It will act as an off-premise testing platform for mobile apps that are deployed as services, simulating the activity generated by thousands of users simultaneously to gauge the resilience of servers and resources. This way, you might not have to disappoint three-fourths of them to learn how well your service holds up.

Better Scalability Through Experimentation

"The application architecture itself is the performance bottleneck nine out of ten times," says Matt Morgan, HP Software's global senior director of solutions marketing, in an interview with RWW. "By monitoring these services and knowing how long a transaction spends waiting for a data retrieval or a logic process, or some other storage function to occur, you can pinpoint the modules inside the service that have the most potential to slow an application under load. You can find out which services are not scaling."

When applications are deployed on PaaS platforms such as Heroku and Windows Azure, Morgan says, a great deal of the complexity of how the software interfaces with the hardware is abstracted into obscurity. The architectural concept that I dubbed composite applications in 1991 has expanded to a seemingly unmanageable number of tiers. With the shift to mobile architecture, much of the burden of providing performance has shifted off of the front-end client, and onto the server. And in-between those two tiers are any number of platforms. "So this idea that the software is a composition, gets even more complicated," he remarks.

"We correlate the front-end story to the back-end problem. And if you think about just the complexities of performance monitoring, if you don't do correlation, you can end up with an enormous collection of logs and metrics that don't actually mean anything to the tester," he continues. "The tester really cares about, how many users can the system support, and what will these users experience when they do concurrently hit their system?"

Mobile apps typically break at some point, and Morgan notes, they don't bend very much before they do. Maybe an app performs well with 300 simultaneous users, and then fails completely at 325. So LoadRunner-in-the-Cloud (hereafter LRC) finds the breaking point, which is typically somewhere. Once that's done, it relies upon feedback provided by a vast network of back-end monitors, probing such factors as SQL queries, server metrics, and diagnoses of the method calls being invoked inside the service. "By correlating how much time it takes for a transaction to hit these things, you can actually attain a pretty clear picture, and start to show that the areas of your application that are causing problems have a distinct performance impact."

The protocol HP uses for emulating user activity in AJAX Web applications, called TruClient, is explained in this video. TruClient has been extended for LoadRunner-in-the-Cloud.

Identifying Your App by How and Where It Breaks

The result is a kind of "stress footprint" that characterizes the resilience state of your mobile app. The space in which this footprint appears is the scenario, which is LRC's term for a repeatable test. Each test helps establish a firm baseline, which is then replicated identically for different problem sets - different numbers of users. This way you're testing how the same code scales up, including with each increment - LRC adds test users on an incremental scale, not logarithmic. "You're trying to determine, if the exact same actions take place on the server, do things improve with the change?" says the HP senior director. "Scenarios allow you to digitize that load, creating a one-click re-execution capability, which is very important in an iterative world. You run your load test, you identify your problem, you make your change, and you go back to your scenario and run the exact same test."

Overlaying the results gives you your best metric as to performance, which in a cloud-based scenario is indeed capable of improving with incrementally added users.

Results from previous load tests, including with earlier builds of your apps, are recorded as snapshots. New test results can be overlaid atop these earlier ones, in order to determine what code changes made the biggest impact. "We give you the capability to leverage that information inside of an operational monitoring solution, but if you wanted to monitor a Web or mobile app going forward for functionality, and you want to have visibility to the way it should run, you can use the metrics from LoadRunner to compare against what it's actually doing in production. That gives you the snapshot of the lab world, where everything works, to the production world where everything's real."

LoadRunner-in-the-Cloud is being offered now to HP partners in the U.S. and Canada, and will be rolled out through OEM partners on their own timetables. Pricing will be determined by the party making the sale.

No, no, not that Lode Runner! Somebody get our graphics department off the Apple II and replace this!

Yehuda Katz and Tom Dale had already left SproutCore in October, prior to the rest of the team's acquisition. Katz is a core contributor to a number of major, recognizable projects including Ruby on Rails and jQuery; and Dale confirmed in a tweet last month that he, Katz, and other notables were starting a new venture to be called Tilde. This morning on his personal blog, Katz announced Tilde's first key project: the reworking of SproutCore 2.0 into a new and emerging project called Amber.js.

"We became increasingly convinced that calling what we were building 'SproutCore 2.0' was causing a lot of confusion," Katz wrote, "because SproutCore 1.x was primarily a native-style widget library, while SproutCore 2.0 was a framework for building Web-based applications using HTML and CSS for the presentation layer... To clear things up, we have decided to name the SproutCore-inspired framework we have been building (so far called 'SproutCore 2.0') 'Amber.js.' Amber brings a proven MVC architecture to Web applications, as well as features that eliminate common boilerplate. If you played with SproutCore and liked the concepts but felt like it was too heavy, give Amber a try."

MVC, as SproutCore 1.5 veterans know, refers to model/view/controller architecture - a way of separating the components of an application into the data, the aspect or view of that data, and the device being used to present that view. Keeping these components separate ends up simplifying both the management and presentation processes, and lends itself very well to the different toolsets of Web app development.

Katz' history with SproutCore began in the middle of the product's development; his key contribution was the concept of dynamic templating. This refers to the use of code to specify within a markup page how and where elements of a template may be constructed on the fly. This way, a JavaScript compiler can effectively produce template elements in accordance with the data, and can change the template when the data changes. This was a tremendous breakthrough for SproutCore 1.5, which premiered at a time when CSS stylesheets and HTML documents were being intentionally over-provisioned in order to account for any and all contingencies.

As Katz told InfoQ a year ago, it also allows the runtime to determine the best templating method for the browser at hand, producing different code for Internet Explorer, for example, than it would for Chrome.

Tom Dale announced the first Developer Preview of SproutCore 2.0 last May, with an emphasis on the new Handlebars.js coding system (inspired by Mustache.js) for presenting dynamic template elements. Really more of a syntax than a programming language, Handlebars allows you to insert elements into an HTML page by {{ offsetting it in double-curly brackets }}, and then define those elements as variables using JavaScript.

"Handlebars, unlike other templating solutions like Eco, doesn't tempt you to embed domain logic in your HTML," wrote Dale on his personal blog last October. "Anything other than simple conditionals and loops must be contained in your application's JavaScript, which enforces the separation of concerns and leads to better testability. The language is also extensible with custom helpers, which allows you to effectively write a template DSL for your particular application."

Although SproutCore 2.0's code today remains hosted through the SproutCore organization via GitHub, Katz says it will be relocated to Tilde's namespace within the next few days.

Late yesterday, Microsoft's spokespersons were unable even to confirm that Silverlight 5, whose release candidate remains available now, will make general release in 2011. However, a launch announcement page posted earlier in the year continues to show 2011 as the promised timeframe. One spokesperson would only say that further news would be revealed "in the coming weeks."

The November timeframe came about as a result of a statement attributed to Microsoft Corporate VP Scott Guthrie, who remains recognized in the Microsoft developer community as a champion of the platform. However, that attribution failed to take into account that Guthrie had already moved to the Server and Tools division which is not accountable for Silverlight. (Guthrie replaced Bob Muglia who left for Juniper Networks.) So Guthrie perhaps should not have been treated as the final word on the subject; had the news come from S. Somasegar, it might have carried some weight.

During an RWW interview with Microsoft executives in September, Somasegar - the current CVP of the Developer division - was clear and unambiguous in revealing that the Silverlight effort is being scaled down. So that's not at issue; what does concern developers at this point is how they should plan to implement their own skillset transitions from Silverlight to WinRT.

What Microsoft told us would survive during this transition phase is XAML, the resource description language critical to Silverlight. XAML uses XML-style markup to denote the locations of page elements and controls, and as some developers would argue, is much better suited to the UI of a complex application than HTML. At last September's Build conference in Anaheim, company representatives demonstrated XAML in developing next-generation apps for Windows 8 outside of Silverlight.

But while the structure of XAML may survive the transition, testers of WinRT are finding out that the various controls and elements that XAML would normally reference in Silverlight have yet to make the journey. On the company's development forums, registered partners are already compiling lists of thus-far-unsupported features in WinRT.

"I appreciate that WinRT is still in developer preview phase and it will change by the time Windows 8 beta is released," writes forum member Sameer V. "But the suspense and secrecy is killing me! First we were worrying if XAML will be present in Win8, now that it is there, it's almost unusable (at least for my app)... I hope someone from MSFT is listening, we need some transparency guys."

You can download a free trial of Connect here.

CollabNet got started 12 years ago and developed Subversion before turning it over as open source to the Apache Foundation. It has a series of other open source development tools such as TeamForge as well as new agile courseware that it announced earlier this summer.

Here is a picture of their current universe:

The benefits of Connect include the following:

• New integration framework now available for TeamForge 6.1.1 (and other CollabNet products) on-premises and in the cloud
• Federation and synchronization, orchestration and governance of application delivery processes across commercial and open source ALM and cloud development tools
• Brings Git into an enterprise-grade ALM platform, with consistency of lifecycle and coding practices, governance and security
• Turns TeamForge into an open and flexible software change management hub. Connect incorporates third party tools natively into TeamForge.
• Allows ALM users to search, discover and share artifacts and documents across workgroups and locations, no matter what tools are used.

Earlier this year GitHub Enterprise announced its own integration tool set. It remains to be seen how well Connect will stack up to this.

To make use of all these many features of Connect, you'll need to upgrade to v6.1.1 of TeamForge. There is no additional cost for Connect once you upgrade TeamForge.

Mozilla's latest nightly build of Aurora, the development channel for Firefox, reveals the incorporation of at least one new feature in its growing built-in dev toolkit that, while welcomed, will already look familiar to some who've sneaked into the Chrome camp: a "bread crumbs" toolbar that represents the relationships between page divisions in the active DOM model, and lets you click on a division name to see it isolated in the browser.

Some months back, Mozilla rolled out an addition to its built-in Firefox dev tools that lets you highlight and focus on an element with a bit more animated style. The Inspect function (Ctrl + Shift + I) lets you scoot the mouse over the rendered page to see the location and identity of the element under the pointer. While in Inspect mode, the HTML code for the highlighted elements shows up in a separate window. This seems nice enough until you try to use it for real work. To stop the code window from updating itself for every element under the pointer, you click on the element you want to inspect in order to hold the highlighter in place. Then you can go to the HTML window to scroll through the code, but in the meantime, the page has returned to its regular behavior, albeit with a polarized film over most of it. You can't easily move from element to element without clicking on the white "X" in the upper right corner, which is sometimes easy to miss.

The revision of this feature in the latest Aurora builds is a vast improvement, even if Mozilla had to borrow another feature from Chrome to pull it off. When you press Ctrl + Shift + I, the new bread crumbs toolbar appears along the bottom. The highlight still follows your pointer, but now a flag appears along the top of the highlight bearing the name or type of the highlighted element. You can click any element in the bread crumbs list to see that element highlighted. And to return to the animated selection mode, you just click the Inspect button on the lower left corner.

Now instead of a separate window, the source code is now hidden within retractable panes. The HTML button brings up the source code that you'd find within the separate window of Firefox' current release builds, while the Style button brings up a CSS navigator along the right side. The borders for both panes are easily dragged from side to side to make room.

While Mozilla had been experimenting from time to time with relocating the Web Developer console (where errors are reported, among other things) from the bottom to the top of the active window, in current release builds, Mozilla places it back along the top by default. A Position button lets the developer move the console to the bottom, or detach it into a separate window. Although all these tools are often simultaneously necessary, things may get a bit crowded for Mozilla developers with all these panes competing for real estate.

Until HTML5 can fully implement its standard methodology for capturing browser performance specs, Web developers need alternatives. One candidate, provided by a company RWW spoke with called New Relic, is to have Web apps servers supply performance measurement agents to clients while the apps themselves are being served. These agents communicate not with your server, but with New Relic instead, and the results are made visible as analytics charts through your browser.

"The difference between what we're doing and what our competitors are doing is, we essentially come up with what we call 'curated' metrics," explains Graham Dumpleton, New Relic's principal engineer. "We work out what we think is going to give you the most value quickly, and highlight those metrics. That way, when you install the product... instantly you're getting data. So you don't have a situation where the customer has to fiddle with it, configure it, work out what it is they can actually get out of it that's useful to them. We find out what are the things that are truly important to a majority of people, so as soon as they turn it on, they're instantly getting value from it."

Like many companies in the Web app space, New Relic started out as a tool for Ruby on Rails. It soon expanded into Java, .NET, PHP, and added Python to the mix earlier this month. As Dumpleton explained, the measurement processes for each language and corresponding framework may be entirely different. For example, measuring Java performance may require bytecode manipulation, literally inserting instructions into the interpreter stream. PHP, by stark contrast, is written in C, so measuring PHP performance requires communicating with its internal APIs. For a dynamic scripting language like Ruby, inserting the measurement code may be done using monkey patching - modifying the dynamic classes on the fly.

"That's a big challenge for us, because you can't provide just one solution for each language," explains Dumpleton. "You have to try to instrument the specific frameworks... and target specific implementation problems. It has to be targeted. You can't just blanket-profile everything in the language and what's happening in the code, because there's too much overhead. So we target specific items of interest, and that's how we get the set of curated metrics."

New Relic's new Python agent is designed to work with the language's standard Web Server Gateway Interface (WSGI). As Dumpleton spelled out quite clearly on his Google+ feed earlier this month, "The New Relic Python agent is not just for Apache/mod_wsgi. Any WSGI 1.0 compliant WSGI server should work." That includes cloud-based WSGI deployments. (By the way, mod_wsgi is Dumpleton's own contribution to Apache.)

Once the files are installed on the Web app server, the admin adds the name of the path to New Relic's .INI file as a pair of instructions to the WSGI application script file. Then there is a small but not unimportant matter: the addition of a wrapper function around the entry point of the Python app itself. This is the only addition that needs to be made to the actual code. Python allows the use of so-called decorators to augment the default functionality of an existing function or method without creating a new subclass. In this case, the syntax @newrelic.agent.wsgi_application() may be used for an app whose entry point is a function named application.

New Relic's information collection model is layered, Dumpleton goes on. At the lowest level of its model is what it calls the harvester, where the data is collected and sent off to the core app. Above that is an aggregation layer, followed by another layer that captures data applicable to a specific framework or language, and at the top the hooks for the framework itself. The bottom two layers are the same for all New Relic agents, from Ruby through .NET to Python.

Just after Dumpleton was brought into the company last December, he developed a Python agent on top of the existing C-language core for the company's PHP agent. Later Dumpleton and his colleagues were able to slide the Python agent onto a Python core for New Relic's latest agent for Python apps.

"We've actually optimized our own application at New Relic by monitoring it with New Relic," admits the company's marketing director, John Essex. The company's suite of tools now includes server monitoring as well as client-side, using a so-called "AppMap" that takes account of third-party Web services incorporated into an app. "It maps your environment for you; you can look into any third-party service connected to an application and tell if there's a bottleneck or not.

"We find that in many shops, people wear more than one hat... and developers fulfill many roles, one of them being operations," Essex adds. "We've often called this the operations tool that developers love."

Sisyphus is a jQuery plugin that adds form protection to your site. It's easy to add protection with Sisyphus to your site, it requires just a few lines of code and then Sisyphus does all the work.

It uses local storage to save users' work, and the storage is freed up as soon as they reset or submit the form. It works with text areas, dropdowns, checkboxes, radio buttons and selections. Alexander Kaupanin, the author of Sisyphus has adding fields to exclude from observation on the todo list. That means that, eventually, you'll be able to specify individual fields that won't be stored.

According to the Sisyphus homepage, it's been tested with all recent releases of major browsers (IE, Chrome, Firefox, Safari and Opera). Sorry, Lynx users are still out in the cold. Sisyphus is available under the MIT license, so it should be suitable for pretty much any site. If you're looking to test it out, try the main page with sample form, and then grab the code on GitHub.

So while they tinker with their code, you might want to explore other alternatives that can help you measure your social media effectiveness. We have come up with 17 different services, some free, some fairly expensive. I have tried most of them and will give you my impressions so you can have a head start with your own explorations.

Before I run through the services, let's discuss eight different issues with social media metrics and how the ideal metric should be constructed.

1. There is no single number that can really be universally useful. It isn't like wining the World Series, where you have to score more runs by the end of the game. There are a variety of actions that you want to examine, and you can win in one area and be off elsewhere. My impression is that we place too much emphasis on the final number without really understanding the reasons for its calculation, as the recent changes in Klout have shown.

2. You are also measuring two grossly different activities: giving and taking. This is more than just what you post and what you consume, and there are many subtleties to both. Just because you have tons of followers and friends doesn't mean that you listen to any of them, nor they listen to you. And some of us, such as myself, are more givers (in that we are focused on outbound actions) than takers (collecting information from our networks). Or vice versa. The ideal social media metric should understand both directions and make appropriate adjustments.

3. How transparent is their algorithm, really? By that I mean can you understand how they get the results that you see, and does the scoring make sense to you? Of course, one issue is having something so transparent that the service can be easily gamed or fooled.

4. Can you examine any time-series? Klout has time series data but doesn't label its axes very well, which can be very annoying. The others don't have as much here as I would like. Sometimes you can understand the algorithms better if you can see how they track you over time.

5. How much does the service care if your content is original vs. copied? If you most of your Tweets are retweeted content, is that as good as someone who comes up with original thoughts? The ideal metric should take this into account, and most of them have focused in this area, generally because it is easier to measure than some other things.

6. How many different social networks should be scanned to derive your total score, and how should they be weighed? Klout has done a decent job of expanding their sources beyond Facebook and Twitter, but some of the other services haven't gotten much beyond these two networks yet. Obviously, the wider the reach the better the view into how you are interacting across many networks.

7. Does the tool provide qualitative suggestions in addition to just scores? The ideal metric should provide insight and suggestions for how to improve your engagement and increase your value to your chosen community. Some of them have overly general suggestions that don't really tell you what you really need to do to improve your use of social media.

8. Does your audience really, really like you? Often called sentiment analysis, it isn't enough just to retweet your bon mots but approve of your point of view. There are tools that are beginning to measure this too.
   

Twitter-only metrics

• Twitter Score gives you a single score (I got a 2 out of 10, which seems somewhat low).
• TwitterGrader is another service that gives you a single simple score. I don't think the score is very meaningful: I got 97.5 out of 100, and I know I am not that good.
• Tweetlevel was built by the Edelman PR firm and it gives some good explanations of its assessments and recommendations, although they could be more fine-grained. It tries to provide historical information but there is no way to manipulate the charts timelines.
• Tweetreach shows who retweeted you and some summary stats, and is useful to search across trending topic areas and not just specific Twitter accounts.
• TeraMetric Optimizer for Twitter. This gives you qualitative recommendations on what and how to Tweet. It costs $99/month and has a free trial but requires your credit card info up front.

Facebook-only metrics

Google-owned metrics

• SocialGrapple has paid accounts starting at $6 a month and going up to $125 a month and is used for really deep dives into Twitter.
• Postrank. We have written extensively about them here, which is used to analyze RSS feeds.

Multiple site focus

• PeerIndex is probably the closest competitor to Klout and examines three areas: Activity, Authority, and Audience. They cover multiple sites but are slow to update their scores and don't have much in the way of time-series data.
• Proliphiq which we wrote about earlier in the month has a wide array of measurements and explanations, trending hot topics and more.
• Twitalyzer shows Klout and Peerindex values and costs $5 a month.
• How Sociable is more a general search tool across many sites, and it isn't very accurate since it doesn't tie the search to a particular Twitter username.
• Empire Avenue has lots of games and points for various activities, but underneath all this frilly stuff is some interesting analysis of multiple social network sites.

Sentiment Analysis tools

• We wrote about Viralheat's sentiment analysis for Facebook and Twitter here.
• mBlast mPact can monitor multiple networks and provide some sentiment analysis.
• Kred.ly is still in limited beta but offers some promise in terms of looking at sentiment for Twitter initially.
• Traackr is another sentiment analyzer and at $500 a month is one of the more expensive tools in this list.

Really, all of these tools are somewhat flawed, and we are just beginning to see some consolidation and improvements, such as what Klout is trying to do. And certainly, Google will help here, as they have purchased two companies this year alone in this space. If any of these tools can help improve your social media methods and increase your influence, then stick with what works and what will motivate you to become a better participant in this genre.

MySQL accounts for nearly half of the population to date, but MariaDB is coming on strong.

And when we look at regional differences, MySQL is stronger in Europe, but MongoDB has more concentration in North America.

The SUP system is designed to work with enterprise applications to generate RESTful Web services. Those services are exposed as APIs, and are generated for use by one of the three leading mobile platforms. There's a reason for this: SAP wants its mobile apps to look like they belong on the platforms on which they run, so iPad apps look like iPad users expect.

Part 3 of the video set that begins here (this is Part 1) shows the creation of a Hybrid Web Container.

"SUP allows you to deliver across multiple mobile devices and form factors - iOS, Android, and BlackBerry - and what we've done on top of this platform is provide what we call the Hybrid Web Container," explains Nick Brown, SAP's senior vice president for mobile strategies. "In essence, it's an HTML5-compliant container with native extensions into the device that allows you to access things like camera, video, and voice (which the current HTML5 does not include). This Hybrid Web Container runs on top of WebKit [or] Silverlight for Windows, and allows us to have a secure, encrypted conversation with a native store to our HTML5 container."

The process of mobilizing

The container is essentially a basic Web form with everyday controls for entering, editing, and deleting data. Folks who've been designing on-screen forms since the days of Access (some would say these still are the days of Access) will be immediately familiar with this process. The underlying mechanics of these container forms are in HTML5, Brown tells us, although you can adjust and tailor the CSS to suit your company's style or the general style of your mobile platform.

Sybase calls the act of making its enterprise databases available on mobile devices "mobilizing;" you do this using the SUP development environment. Dragging and dropping table names from the database list into a diagram creates what SUP calls a mobile business object (MBO). That object is used as a kind of prototype for the SUP server to determine how data transactions are to work between the server and mobile clients.

"Let's take something simple like leave request approval - I want to mobilize that," Brown says. In the SUP environment, you define how you generally want forms to appear on your target platform of choice. Then you identify the data that's relevant to the decision making process - for leave request approval, that would include who's making the request, for how long, when, and how much leave time remains. That's pretty obvious, but it would also be helpful if the app could report if anyone else has requested the same holiday.

SUP takes that subset of the data model, and then performs code generation. The code that's generated is specific to individual mobile platforms, either for HTML5 or native apps.

Productivity apps from SAP

The latest mobile productivity apps from SAP itself that use the SUP platform, announced last week for release this quarter, include SAP Manager Insight (shown above), which gives HR managers direct access to key performance indicators (KPIs) for employees. "Productivity to us means we're providing something to an employee user of a company that helps them either perform a role within their responsibility in a corporation, or generally initiate or move a process forward that's part of the overall back office abilities," says Brown.

Another example is Employee Lookup, which gives a mobile user access to not just the general data about contacts, but also the structure of the organization they work for, in a map that can be traversed by finger. "Other things would be simple request creations, like a leave request to go on holiday; capturing and recording my time; and creating expense reports," SAP's Brown adds. "A lot of these users may be non-traditionally targeted users for corporations, who were previously supported via a paper process or a Web portal. Now, with BYOD (bring-your-own-device) policies at work, we see a real opportunity for our customers - even within SAP - to enable people to access this type of functionality in business processes more easily. A much broader audience can be addressed through mobility."

Brown offered this illustration: Suppose a user is fairly high up in an organization, and manages other managers. She wants to obtain metrics across the entire management team, including employee retention rates and satisfaction rates. A tablet-based app could access this user in ways that Web portals couldn't. "So I can look for issues, look for challenges, find managers who need coaching or removal, or managers I want to exemplify in the organization."

One of the problems SAP saw with the Web portal approach is that managers tended to use the goal-setting procedures for those portals perhaps twice per year at best. Performance tracking needed to run six months or more, because that was the period between average uses. And in those organizations, managers didn't institute rewards often enough to keep their employees happy.

So the SUP platform has SAP designate a subset of its Human Capital Management (HCM) functionality, and use that as a prototype to create a mobile interface. "You take that data model, that subset of functionality, and you put it on SUP, and then SUP compiles those databases and those workflows to the targeted devices, so you can just focus on UI - either HTML5, or native UI functionality on the device" the SAP VP says.

"Any Web developer who understands HTML as their primary development platform can take our HTML5 applications, or their portal applications," Brown continues, "and leverage this container to deliver customized [functionality] with their labels, their look-and-feel, as well as support the look-and-feel you would expect on the devices."

Making Dart work will require a new virtual machine, which puts it on a competitive plane with Java, Adobe Flash, and Microsoft Silverlight. But architecturally speaking, Dart will be more dependent on the browser, at least for now.

Google's plan is to implement the Dart virtual machine as a kind of supplement to the browser's existing JavaScript engine. In other words, it will digest Dart code and produce JavaScript. Google is being careful not to mention an eventuality where Dart is embedded in all browsers, though in a blog post this morning, Bak did mention that with respect to integrating the Dart VM in Google Chrome, "we plan to explore this option."

At last, class

The reason for Dart's existence appears to be to improve upon JavaScript, whose viability as the functional backbone for distributed applications in the "open Web" seems shakier as time goes on. Compared to more structured, object-oriented languages like C# and Java, JavaScript often carries with it a lot of duct tape and baling wire. And compared to more clever dynamic languages like Python, Ruby, and D, JavaScript is more verbose, and doesn't get to the point quickly enough.

As the first round of Dart tutorials reveals, Bak and his team of architects started from a JavaScript base and worked from there, adding some critical Java elements and improving the underlying assumptions of the interpreter to enable brevity. True class structures, using the class keyword familiar to Java developers, is the key addition.

With JavaScript, there are a handful of ways to get something object-ish, all of which use the keyword function. You can declare a function which happens to have properties, and whose function is embedded therein as a kind of method. The problem with that is that the method itself doesn't get re-used but rather recreated each time, so the alternative is to add the method back to the function's prototype as a kind of bolt-on. Alternately, you can declare a kind of object using the all-purpose instantiator var, which may use literals to define internal structures. You then assign a function as a method for one of those literals as though it were a variable value. Or, you could declare a var and assign the whole thing the result of a function, assuming that function were to be the only component of the object.

None of these methods is particularly elegant. A great deal of the work performed by the latest generation of JavaScript engines such as V8 and Mozilla's TraceMonkey is actually made up of condensing the "crap code" that inelegant instructions produce, into something less entangled and more precise.

So theoretically, the performance hit incurred by a browser running the Dart VM may be compensated for, by way of code that's easier for the JS interpreter to parse. Theoretically.

Dart reintroduces class in a way that will be familiar to most Java programmers. A few tweaks make the definitions more concise; for example, the reflexive pointer this may be used inside the declarative for a member method (as in Ball.throw (this.distance); instead of Ball.throw (distance); this.distance = distance;). And interface is also supported for creating member properties and methods that may be common to more than one class; a class implements an interface just as you'd expect.

Still unknown: event triggers

One dramatic structural change to which some JS developers might object concerns context. JavaScript functions are often pasted throughout the page, and although somewhere within it is supposed to be a main() function, most functions are triggered by browser events, including window.onload. With Dart, every <script> element is a self-contained context. Class members and variables are considered public by default (there's no "public" keyword in Dart), although "public" for Dart is not a scope that encompasses the entire page - just the script.

"In JavaScript, declarations across multiple script tags are combined together in the same namespace," write Sigmund Cherem and Vijay Menon this morning. "In Dart, code in one script tag cannot directly access code defined in another. If a script wishes to load code from a different URL, it must do so via #import. Each script tag must define its own main() entry point in order to run."

The main() function is the event handler for the DOMContentLoaded event. Otherwise, we're not seeing from the early documentation any indication of how Dart code responds to browser events the way JavaScript code does. If Dart makes no changes at all, then it's foreseeable that, while nothing runs until the DOM is loaded, the main() function could be written as empty while the other functions respond to events - which is about as inelegant as most everything else in JavaScript.

But conceivably, this scheme could facilitate a fairly simple and straightforward approach to multithreading: A page could have multiple scripts, and the VM could run them in parallel... again, theoretically, according to the early documentation. Browsers don't have multithreading interpreters yet, and Dart is not described thus far as something that will include a JS interpreter, so it's difficult to see how Dart would invoke a feature that doesn't actually exist.

Nevertheless, from an architectural standpoint, there's a lot to like about Dart, and there's reason to believe its wealth of opportunity will be spread among multiple browsers, including even Internet Explorer. What remains to be seen is how Dart will impact browser-free HTML5 apps, or "native apps," if at all. We'll be monitoring the news from the developers' conferences as well as from Google itself this week.

When Sun Microsystems produced the first go-round of JavaFX in December 2008, its aim was to build and promote an entirely new declarative language - not Java, not JavaScript - for describing the front-end UI of a distributed app. What developers needed at that time was a simpler, programmatic way to approach the contents of UIs. CSS looked under-developed, and although Microsoft's approach (XAML) was certainly thorough, it lacked the more conservative, procedural approach that veteran programmers were accustomed to.

That was then. Amid a completely different landscape, Oracle yesterday has remade Sun's JavaFX distributed apps platform into a version 2.0 with fundamental differences from its predecessor. The most prominent addition is a new Oracle language called FXML that's very different from JavaFX Script in its handling of UI elements, but whose distinctions against XAML seem almost artificial.

"One of the advantages of FXML is that it is based on XML and is familiar to most developers, especially Web developers and developers using other RIA platforms," reads new JavaFX 2.0 documentation finalized yesterday. "Another advantage is that FXML is not a compiled language; you do not need to recompile the code to see the changes you make. A third advantage is that FXML makes it easy to see the structure of your application's scene graph. This, in turn, makes it easier to collaborate on user interfaces among the members of your development team."

The notable and notational differences

JavaFX, it's very important to note, is not Java. While JavaFX Script maintained the straightforwardness of Java, it also maintained the same context. That meant recompiling the app - or at least, recompiling the script - whenever the front end required changing. In version 2.0, Oracle has cast out the declarative-like portion of JavaFX Script (which lives on in an open source project called Visage), replacing it with FXML and adapting the remaining elements of JavaFX to load that FXML as separate resources.

The difference in methods between JavaFX Script (Visage) and FXML is the difference between procedural and declarative languages. A procedural language gives instructions on how to build something, as if they were being told to someone else - or rather, as if a professor were giving instructions to his math students. "Assume there's an object in space, and we don't know what it is yet, but let's call it 'Frank,'" says the procedural language. "Let's instantiate Frank as a new member of the 'Box' class. Within that class is another new object whose class is inherited, called 'Button.'" By stark contrast, a declarative language states where things are as though they already existed. "Beginning of box," it starts, without having to name it "Frank" or anything else first. "Inside the box, beginning of button. Button says, 'Send.' Reacts to being pressed. End of button."

Now with one less letter!

JavaFX remains a declarative language, and its programs remain constructed using IDEs like NetBeans, which are also used for Java apps. In fact, you build Java apps that utilize JavaFX front ends using the same environment (more on that later). But the FXML-based front end for JavaFX 2.0 apps is described in a separate file, and referenced in the JavaFX code using a handful of interwoven methods. The .getResource method points to the main FXML layout file, and the .getBundle method points to a separate properties file that may contain variations on the main theme. The .getClass method produces the JavaFX 2.0 equivalent of the front end (the "stage," in Sun's original parlance) had it been written directly into the script. All three methods are supplied as arguments for the .load method that instantiates an object from external resources.

The syntax of an FXML file follows the "begins-here/ends-here" logic that typifies XML. Here's an example from Oracle's documentation, which creates an on-screen box that other objects are designed to stack on top of:

<StackPane>
<children>
<ImageView>
<image>
<Image url="@fx_boxback.jpg"/>
</image>
</ImageView>
<Label text="%loginExample" style="-fx-font: NORMAL 20 Tahoma;"/>
</children>
</StackPane>

It's constructions like this one that should have XAML veterans raising an eyebrow. For Silverlight, the class of on-screen box with essentially the same purpose is StackPanel, with an "l". What Silverlight calls a "canvas," JavaFX calls a "stage." And there are plenty more semantics-only differences where that came from.

Another new JavaFX 2.0 feature - which we're told remains forthcoming - is the ability to instantiate JavaFX apps in their entirety (rather than load them separately) through Java, by way of a new API.

That day may be drawing very close. Last week, Michael Mullany, the CEO of Sencha - whose Ext JS library renders spectacular content on multiple browsers regardless of platform - gave an early nod of approval to Internet Explorer 10, the HTML5 rendering engine for Microsoft's forthcoming Windows 8.

"Simply put, (and with the caveat that we were running on the notably overpowered developer preview hardware) the IE10 HTML5 experience is one of the best we've seen on any platform to date. After a decade of Web neglect, Microsoft is back with a vengeance," Mullany wrote for his company blog. Listing the various HTML5 components IE10 will support, he added, "Remarkably, particularly for developers trained to look out for Microsoft platform tie-ins, there are none on this list. Microsoft simply implemented the draft standards with no extensions or gotchas."

At the forthcoming SenchaCon conference in Austin, Texas in late October, Sencha is expected to unveil (or have already unveiled) the first public beta of its Sencha Touch 2 JavaScript library. Its purpose will be to present a normalized set of tablet-oriented functions, enabling the same apps to play on iOS and Android platforms. It's a touch-sensitive version of Ext JS, which normalizes the processes of event handling and layouts, and fills in some of the gaps between what HTML5 is expected to support and what these platforms actually do support.

That public beta was expected to go live sometime this week, but was postponed. We've known for some time Sencha is working toward Windows Phone 7 support. Could the development team be planning an early experimental round of support for the Windows 8 Developers' Preview as well, and could that be behind the delay?

RWW put that question to Sencha's senior director for product management, Aditya Bansod, who gave us this response: "We're excited about Microsoft's focus on HTML5 and touch-based interfaces. We'll be adding support for Windows 8 in the future as a part of our roadmap. In the nearer term, we'll be adding support for Windows Phone 7 in the Sencha Touch 2.x family of products, and then Windows 8 at an appropriate time in the future."

Bansod's careful distinction between version 2.x and Windows 8 support points to the likelihood of Windows 8 being supported in version 3. Since Touch 2 also promises native app packaging - the ability for a cross-platform app to be distributed on native app stores like iTunes App Store and Android Market - outright Windows 8 support will have to wait for Microsoft to construct both the operations and the polices around its Windows 8 distribution outlet, currently called just "Store."

In any event, the probability is now great that a plug-in-free JavaScript library will enable a class of mobile apps that can run on multiple mobile platforms as native apps.

Development of Phabricator is spearheaded by Facebook's Evan Priestley and is being done on (where else?) the Phabricator.org Web site.

What is Phabricator?

Phabricator is Facebook's in-house suite of Web applications for its engineers to write, review and share source code. It includes workflow tools, utilities and more.

Actually, Phabricator does go beyond the Web with a set of command-line tools called Arcanist. Developers can use it to run unit tests, merge changes, check for syntax errors in code and even extend Arcanist to add new commands.

Some of the noteworthy components in Phabricator include Maniphest, Herald and Diffusion. Maniphest is a take on bug tracking that might be a bit more user friendly than entrenched open source tools like Bugzilla. Herald is a tool that allows developers to create filters to notify them when objects are created or updated. For example, if you want to be notified of revisions even if you're not on the CC list. Diffusion is Phabricator's repository browser for exploring Git and SVN repositories, and it may be adding Mercurial support in the future.

One thing that's interesting, however, is that Phabricator has no real-time chat features at all. Instead, developers are directed to IRC to discuss issues with Phabricator.

Phabricator is self-hosting, so if you want to jump into Phabricator development you can just log into Phabricator.org with a GitHub or Facebook account. This also lets interested developers get a look at Phabricator without actually having to install it themselves. But if you really want to dig in and host your own, it's on GitHub now. It is in an early release state, however. Phabricator is under the Apache 2.0 license, so companies should be able to use it for nearly any project without much worry over licensing issues.

The Road Ahead

The big question on my mind about Phabricator is where is it going? The roadmap and status document on Phabricator.org tries to answer that. According to the roadmap, the current focus is feature buildout. This includes things like adding support for Mercurial, and improving Maniphest, Phriction and Projects.

Farther out, there's consideration for building importers to grab information out of other bug trackers and code review tools. While it could make adoption of Phabricator easier, it also could be "a massive timesuck." Why is lowering the barrier to adoption easier? There's some consideration of Phabricator's mission in the roadmap – and whether Facebook might eventually want to develop a revenue model around it. There's not a long-term vision for Phabricator yet, beyond improving the tool, but don't be surprised if you start hearing a lot more about it as it matures.

Microsoft's patterns and practices team had been advocating the use of its Silverlight plug-in for composite applications since 2008, with a project it calls Prism. That project remains ongoing, though the emphasis in recent months has shifted to Project Silk, which focuses on what the company describes as "building cross-browser Web applications with a focus on client-side interactivity. These applications take advantage of the latest Web standards, including HTML5, CSS3 and ECMAScript 5, along with modern Web technologies such as jQuery, Windows Internet Explorer 9, and ASP.NET MVC3."

Microsoft's support for jQuery began three years ago, almost to the day, certainly in earnest though overlapping considerably with the company's Silverlight plug-in project. While Microsoft isn't abandoning Silverlight outright (it touted the forthcoming version 5 just last April), it is certainly de-emphasizing its own plug-in.

Last summer in Microsoft's forums, the company has responded to developers' inquiries about the relative precedence of Silk over Prism by assuring Silverlight developers that there remains a place for Silverlight in line-of-business applications - programs deployed in-house for employees and knowledge workers, rather than public-facing Web sites. But that was before the Build conference two weeks ago, when the spotlight for Silverlight was pretty much turned off.

The two project teams share many of the same members, and thus are not in competition with one another. But in recent days, the two projects have been sharing more than common members, but language as well. For example, a November 2010 description of the "composite application" in the context of Prism, which does involve Silverlight, reads as follows: "Using design patterns that embody important architectural design principles, such as separation of concerns and loose coupling, Prism helps you to design and build applications using loosely coupled components that can evolve independently but which can be easily and seamlessly integrated into the overall application. These types of applications are known as composite applications."

This type of modularization has come to define the composite application in much of Microsoft's training. But now, take a close look at this sample from the latest "drop" of the Silk developers' model app: "Within a browser-based application, a module can add or remove user interface (UI) elements, add or enhance functionality (or behavior) already available in the UI, or enhance the user experience (UX). Modules can be built independently of one another but still communicate with each other in a loosely coupled fashion. Modular applications can make it easier for you to develop, test, deploy, and extend your application. Modular designs also have well-understood benefits that help you unit test your applications and make them easier to maintain over time."

The Silk project team is suggesting that many of the same goals previously attributed to Prism are attainable using JavaScript and libraries such as jQuery, through Silk best practices. One independent developer who definitely perceives this trend is Poland-based Bartek Szafko, who wrote last July, "When you look side by side on new Win8 shots and silk they look quite similar. I believe Silk guidance will be to Windows 8 just like Prism was to WPF and Silverlight."

The September drop of Silk features the latest update to the project team's model app, originally called "Mileage Stats" but which has evolved into an interactive (or, judging from this video, overactive) monitor of all monetary investments in one's vehicle. The idea here is to show how a modular app can generate statistics and update only the statistics that have changed, or only the changes the user has directly requested, without reloading the entire page.

Silk documentation refers to a certain word you'll be hearing a lot from Microsoft in the coming years. Referring to the division of on-screen components into widgets as shown in the above figure, the documentation reads: "Mileage Stats uses the tile widget to animate the position of all boxes horizontally and vertically, because both the vehicle boxes and the Add Vehicle box need that behavior. The vehicle widget expands and collapses the vehicle boxes, because only they need that behavior."
Modularization in the Silk model is accomplished through a concept that the original HTML frame elements tried to achieve, but couldn't: subdividing the screen into regions that can not only be addressed independently, but shifted and resized when necessary without disturbing their contents.

A simpler example of modularization for cross-browser apps from the Silk project (which may be more familiar to jQuery veterans), is this example of a jQuery function that's wrapped around a set of elements bunched together from HTML. In this case, those elements are keywords from a paragraph tagged with <SPAN>, with each element given the name data-tag. A function, triggered whenever the mouse points to one of these tagged spans, looks up the contents of the span on the Delicious Web site, and posts the textual results of that search in an infobox. The jQuery function which does the wrapping appears below:

(function ($) {
$('body').infobox({
dataUrl: 'http://feeds.delicious.com/v2/json/popular/'
});
$('span[data-tag]').tagger();
} (jQuery));

The function attaches the infobox directly to the span. Although that infobox has no instructions for its own appearance in this function, it's given a place in the DOM by the creation function for the infobox element, which in jQuery is called _create. The principle demonstrated here is dynamic tagging. Here, not only can the destinations of old hyperlinks be updated and made more relevant, but the events that are generated as a result of pointing to the tagged span, and the appearance of the box or other gadget displayed on mouse over, are generated entirely on the fly.

This sort of thing has been happening with jQuery-endowed Web pages for the last handful of years, though perhaps not all Web users are appreciating the breadth of the architectural changes embodied here. If you're wondering, what Microsoft technologies does Silk specifically promote, the answer is server-side ASP.NET MVC, whose latest versions make liberal use of jQuery. The Silk philosophy is a relatively new one for Microsoft: an ideal that the purpose for promoting Microsoft-brand technologies on the server side does not have to be the subsequent promotion of Microsoft technology on the client side.

Last week in Anaheim, in amongst the crowd of developers at Microsoft's Build 2011 conference assimilating the news about Windows 8, was a team from a London, U.K.-based company called YoYo Games. In 2000, that company released an interesting entry-level game development and distribution platform called, quite simply, GameMaker. Following in the hallowed footsteps of the great computer game platforms of the 1980s and '90s, it introduced a stand-alone interpreter whose language borrowed a bit from Pascal.

But in the modern era, stand-alone interpreters mean plug-ins; and the handwriting on the wall from Build 2011 was that plug-ins like Silverlight are yesterday's news.

Inspired by what they've seen, YoYo is moving full-ahead today with a public commercial release of a beta of a new version of the GameMaker platform that makes the full transition to HTML5. There's no plug-ins and no interpreter or managed code; instead, there's JavaScript. And the games this IDE produces runs in everyday Web browsers without embellishment... and perhaps most importantly, without Flash.

To a limited extent, it's a move away from the platform that put YoYo in business. But in an interview for PocketGamer.biz published today, YoYo CEO Sandy Duncan said it was time to take advantage of what he perceives as a decline in the popularity of Flash-based games. With competitors such as Zynga having already made fortunes from the Facebook Platform (YoYo has a presence there too with enticing titles such as "They Need to Be Fed"), Duncan said HTML5 could give games that had already been developed for Flash "a new lease on life."

"I expect we'll see a resurgence of existing browser game Web sites such as Miniclip as well as the emergence of new 'stores' which will deliver HTML5 content," Duncan told PocketGamer.biz. "Facebook is the company to watch in this area; we believe it can rival any platform. However, it needs to get its act together providing a much better consumer and developer experience by supporting discovery in a more imaginative way."

By "discovery," Duncan means the ability for the platform on which apps and games are built, to reveal their wares to potential users in an interesting manner. Up until very recently, HTML5's ability to provide discovery was perceived as poor. Game portal sites such as Miniclip remained devoted to Flash, while HTML5 counterparts struggled for recognition on app stores where users have to peruse multiple tiers of menus to find anything at all.

But Microsoft's prototype of the Windows 8 Start Screen has changed that analysis, and quite quickly. However you perceive its implementation (I'm already on record as believing it can and should be reworked), the Start Screen's bright, bold tiles are giving HTML5 developers new cause for hope. Metro tiles can update their own content based on fresh feeds from the Web. Imagine a big tile that scrolls itself to reveal new HTML5 games in the queue. They wouldn't necessarily have to be directly installed on the Start Screen to be seen - or rather, to be discovered by users.

Beta testing for GameMaker:HTML5 is officially closed to new applicants now, although the beta platform is available from YoYo Games for a discounted price of $99.