ctodx

DXTREME Mobile for C# developers–the Design

Julian Bucknall (DevExpress) — Tue, 14 May 2013 00:06:01 GMT

I must add a caveat to that title: “Such as it is”.

(See the Introduction to this series here.)

In essence, I want to keep the work flow of the Citizenship Test app pretty simple to suit the main devices it’ll run on.

When you run the app, I envisage a plain home screen: the title, and a couple of options. The first option allows the user to review all hundred questions and their answers. I see this as a straightforward list of Q&A items and the user would flick to scroll the list up and down. An alternative would be to just list the questions in a scrollable list, and then have the user touch a question to navigate to another screen to see the answer. Although uncomplicated, I feel that this could be cumbersome since the user would then have to navigate back to the question list. A user experience that is not overly onerous, but the back-and-forth is still a little inelegant I think.

The second option from the start or home screen would be the testing option: display a question and accept input from the user. What I’d like is a text box and some natural language processing to analyze the answer and check it against the actual answer. I’m not too sure about that just yet (NLP is not my forte), but we’ll see. Somewhere on the screen will be a button to navigate to the next screen with the next question. Since the actual naturalization test consists of ten questions of which you have to answer at least six correctly, this will also be the format of the testing option. There’ll also be a final screen (not shown) that would grade your answers.

The back button on this screen would not go back to the previous question, but to the home screen. Pressing it would cancel the current test.

As you can see, the way I’ve designed this app is to break it up into several steps (that is, screens), going from the simple to the more complex. That way, as we build it, you’ll get a flavor of how to develop these kinds of applications with DXTREME Mobile.

Next time: the Home Screen.

DXTREME Mobile for C# developers – Foundations

Julian Bucknall (DevExpress) — Thu, 02 May 2013 23:46:02 GMT

We have just published a Release Candidate for DXTREME Mobile 13.1. There have been many changes for this particular release – even better Visual Studio integration, greater performance, better “native” look-and-feel, new Windows Phone 8 support, and so on – and I thought it would be a good idea to introduce how to write multi-device apps for this new version, especially as they’re written with HTML5 markup and JavaScript. I’ll do this introduction and tutorial over several blog posts, which may in turn become an official part of the documentation.

First things first, let me lay down some ground rules. I shall assume you are a C# developer (or at least familiar with its syntax and grammar) and are using and are very familiar with Visual Studio 2012. Perhaps you know some HTML5 – or at least are familiar with basic HTML markup – and perhaps you know some JavaScript. That’s great if so, but I won’t assume you know too much in that area.

What I’ll do in this series of posts is to create a simple app for iPhone 5, iPad 3, and for the Kindle Fire HD tablet, all of which I have at hand and can test on. The app is going to be designed to help me in a momentous event later this year: I’m going to take the USCIS Naturalization Test to become a US Citizen. As part of this overall test, there is a sub-test on US civics, especially history, law, and government. The nice thing about this particular test is that all of the 100 possible questions are published and you have to answer 6 or more correctly of ten random ones that the USCIS Officer will ask you in order to pass. My goal is 100%. What we’ll do with this app is to load all 100 questions into some kind of database, and then ask the questions of the user one at a time, randomly. We’ll also explore how to process the answers: maybe by using multiple choice, or analyzing the reply for keywords, or whatever. I’ll also go through the process of compiling the app with PhoneGap and getting it into the relevant app stores.

Without further ado, let me provide a quick introduction to some basic JavaScript.

Introduction to JavaScript

JavaScript is a simple interpreted language designed explicitly for web pages. Nowadays, scripts are even compiled for even faster execution, but this need not worry you too much: just assume that the interpreter in your browser knows how to parse and execute JavaScript files.

JavaScript Types

JavaScript’s simplicity starts off with the type system – yes, no matter what you have heard, JavaScript does have types. Not many, but they’re there. There are six: number, string, boolean, object, null, and undefined. For now, just concentrate on the first four; we’ll introduce the others later on.

Number: in C# terms, this is the same as double. There is no equivalent to int unfortunately, so beware of issues with rounding errors during calculations. You enter constant values just the way you're used to in C#: 1, 2.3, etc. The typeof operator called on a variable containing a number will return "number".

String: for all intents and purposes, this is equivalent to C#'s string type, but do note that JavaScript's strings support 16-bit characters only; you cannot access characters on Unicode's higher planes. You enter constant values in the normal manner, however you can use either single or double quotes to do so: 'hello', "world". The typeof operator called on a variable containing a string will return "string".

Boolean: just like C#'s bool, a type that has just two values: true and false. The typeof operator called on a variable containing a boolean will return "boolean".

object: anything else, including arrays, dates, functions (yes, functions are objects too) and objects you create yourself. There is a special syntax to defining objects, which we'll get to in a moment.

Since JavaScript is a C-type language, you should easily understand the declarations of the following variables:

var e = 2.718281828;             // a number
console.log(typeof e);           // outputs "number" 
var name = "John O'Doe";         // a string
console.log(typeof name);        // outputs "string" 
var anotherName = 'Jane Doe';    // another string
console.log(typeof anotherName); // outputs "string" 
var isFamiliar = true;           // a boolean
console.log(typeof isFamiliar);  // outputs "boolean"

One major difference to note: you do not declare anywhere the type of a variable. At the time a variable is used, JavaScript will work out what type the value has. Until then, it doesn't care. This means you can reuse variables as different types (please, don’t do this):

name = 42;            
console.log(typeof name); // outputs "number"

Objects

There is no class system in JavaScript. Objects are rather more fluid than C#’s class model allows, and the inheritance scheme JavaScript uses is known as “prototypal inheritance”. Since it is so different from class inheritance, many people will implement a proto-class inheritance system. We’ll see some of this later. For now, just be aware that objects do not have a class definition behind them that describes what they look like.

An object in JavaScript is a container for named properties and methods. They are most often declared using an abbreviated syntax:

var ball = {
    color: red,
    bounce: function () {
        // code to make it bounce
    }
};

That is, ball is an object with two members: a color property with value red, and a method (a function) called bounce. In short, you declare an object with braces. Inside the braces, you can declare a set of comma-separated members of the object (if you don’t, the object is empty), where each member comprises a name followed by its value, separated by a colon.

The above code is equivalent to:

var ball = {};
ball.color = red;
ball.bounce = function () {
    // code to make it bounce
};

Notice that you can just add members to an object as we did here, or remove them or replace them. Objects are endlessly flexible in JavaScript.

Sometimes, objects are newed up, just like in C#. It’s not a constructor as we understand it in C#, just a special function with some built-in members. We’ll come across examples of this later, but for now here’s a simple example:

var startTime = new Date(); // get an object representing now
console.log(startTime.toTimeString()); // use built-in method

Functions

Functions are encapsulations of code. They’re objects and so can be passed around and manipulated in a functional manner, but they can also be called. We’ve seen a couple of them in use so far (console.log() is an example: log() is a function declared as a member of the console object, which is created by the browser under certain development/debugging scenarios).

Here’s an example that shows how you can create and pass around new functions on the fly:

var makeBracketedLogger = function (log) {
    return function (value) {
        log('[' + value + ']');
    };
};

var logAlert = makeBracketedLogger(alert);
logAlert(true); // displays [true] as an alert

var logConsole = makeBracketedLogger(console.log);
logConsole(42); // displays [42] on the console

Here we implement a function that creates logging functions. The functions it creates display the value they’re passed in between square brackets. I create two functions: one that uses the alert() function to display the value in an alert dialog box, and the other to display the value to the debugging console. This easily shows that functions can be created at run-time.

Scope and closures

This is one of the biggest differences between C# and JavaScript. In JavaScript the scope boundary for local variables is the nearest enclosing function, not just the nearest enclosing braces. Locals declared in an outer function are visible to inner functions within, too. Take a look at makeBracketedLogger() above. The log parameter is visible inside the function being returned as well (which is why the returned function works). However, note something else as well: the returned function forms a closure over the outer function so that it can still “get at” the log parameter, even after the outer function has completed execution. Closures are extremely important in JavaScript, so make sure you refresh your memory on what they are and how they work in C#. It’s the same in JavaScript, just with a simpler syntax.

Statements, expressions, and so on

…Are pretty much as they are in C#. There are a few wrinkles that you’ll need to understand, the main one being that the JavaScript interpreter will go to great lengths to coerce one variable to the type of another when you mix them, but we’ll cover those as we get to them.

There is one operator in JavaScript that is not known in C#, the identity operator, or triple-equals (===). This operator performs a comparison between two values, much like the equality operator (==) does in C#. JavaScript’s equality operator is a coercion operator: if the two sides are not of the same type, JavaScript will go through some gymnastics to coerce one value to the type of the other. Sometimes this can be convenient (for example: 1 == '1' evaluates as true), but sometimes it can seem downright capricious in its results. Best practices say, always use === (or, negated: !==), since the person reading the code after you will not get caught out by some coercion assumption you’ve made.

Onwards!

Anyway, that’s enough foundation for now. Let’s jump in next time with some DXTREME Mobile.

(If you want to explore more JavaScript syntax and grammar, please see my series on JavaScript for C# developers.)

DevExpress Roadmap 2013

Julian Bucknall (DevExpress) — Fri, 22 Mar 2013 22:52:06 GMT

Finally the last discussion was debated, the last long email thread was terminated, the last agreement made, and the last document collected. It was then all up to me to collate all those bullet points and write the DevExpress roadmap for 2013.

This year, perhaps more than the previous ones, there was much uncertainty about what path we should take. Perhaps uncertainty is the wrong word, ambiguity might be a better one. And path implies there’s just one road to take, whereas in reality there were several directions to follow. Despite what you may believe, DevExpress is not a vast enterprise with resources out the wazoo: we do have to pick and choose what we do; and carefully at that.

The first decision was possibly the easiest. I’ve talked about this at length before, but it bears repeating: the web is this giant juggernaut of a train. You miss it at your peril. It’s not just “web sites” anymore. It’s “single page applications”, it’s “responsiveness”, it’s “mobile” in all its wild wonderful forms, it’s the “cloud”, it’s all of these separately and together. So, first of all we are concentrating on our ASP.NET story, and our HTML5/CSS3/JavaScript story in DXTREME.

The second was perhaps equally as important and equally as straightforward: improve our “thick client” offerings, especially WinForms, WPF and VCL. Not all of our customers are writing the next killer web app (someone do Google Reader 2.0, please?) but are heads down in implementing awesome Windows applications. The rich data-fed Windows app is not going away, despite the maturity of each particular run-time. Hence we are spending some resources this year on polishing and enhancing these libraries (the new smooth scrolling is awesome, just as one example), and cementing our pole position as provider of Windows app components, no matter which technology you prefer.

The third decision was to continue to enhance our dashboard, reporting, charting, and data analysis products, at an aggressive pace. We have many innovative ideas for these products, some of which you’ll see this year and some in 2014 or later.

Anyway, for more details, please peruse the roadmap here. Note that it does not and cannot cover every single suggestion or feature that we’ll be implementing, for then it would be tens of pages long and I’d never have finished it. And as I say every year on one way or another, use it for guidance, but don’t make solid plans based on it.

It does promise to be a banner year though; let’s see what develops.

Seven…

Julian Bucknall (DevExpress) — Fri, 15 Mar 2013 19:50:12 GMT

So today is special. For a start it’s the Ides of March, which, history has it, was a particularly rough day for Julius Caesar from which he didn’t really recover. But more importantly for me, it’s the seventh anniversary of my starting as CTO at DevExpress. I’d thought I’d take a moment to riff off the number seven.

First a bit of fun personal math: 7 in binary (base 2) is 111, which taken as a number base 7 is 57, which in turn is two years more than my age. Numerology is not dead!

Second: DevExpress has UI controls/extensions/widgets for seven different platforms: VCL, WinForms, ASP.NET (MVC), WPF, Silverlight, HTML5/JS, and Windows 8 Modern UI. When I started here, we had but three, which is kind of amazing when you think about it: the rate of change in this industry is scary fast.

Third: some trivia. 7 is a Mersenne prime; there are seven hills in Rome; there are seven continents; 7 is the most probable score when rolling two dice; there are seven wonders of the ancient world (and, no, I’m not one of them); there are seven musical notes (do, re, mi, fa, so, la, te); seven days in a week; seven colors of the rainbow (whose names I remember using “Richard Of York Going Back Into Venice”, which makes no sense at all); September used to be the seventh month of the year, hence the name; there are seven deadly sins. Finally, if you remember old style calculators, each digit position had seven segments.

Now playing:
Enigma - Seven Lives
(from Seven Lives Many Faces)

The Bestselling Publisher and several Bestselling Product awards from ComponentSource

Julian Bucknall (DevExpress) — Fri, 01 Mar 2013 00:00:00 GMT

ComponentSource® is the world's largest marketplace and community for reusable software components and development tools. Every year they tot up the sales of each product they sell globally and work out who is the bestselling software publisher and which products sold the most during that year. I’m happy to say that we won a couple of these awards (he says modestly).

First up is the big one: DevExpress was the top software publisher with ComponentSource in 2012. Not just in the top five, you understand, but Number One.

Although this is certainly an impressive award, we have further good news: DXperience Enterprise was the top selling product for 2012 at ComponentSource. Another number one! Indeed, since DXperience WinForms is also at number 3, it means that, of the top five bestselling products, two were from DevExpress. Three other DevExpress products were also placed, this time in the Top 25: DXperience ASP.NET at 11, VCL Subscription at 13, and DXperience WPF at 15. These are striking results and just goes to show the high regard our products are held in the marketplace.

So a big thank you is in order to all our customers who purchased through ComponentSource. You made us number one! Thank you!

Is HTML5 the UI platform to rule them all?

Julian Bucknall (DevExpress) — Mon, 21 Jan 2013 08:01:00 GMT

Right before the Christmas season at the end of last year, a little snippet of news flew by which you may have missed: the World Wide Web Consortium (W3C) announced that it had completed (and published) the full definition of both the HTML5 and Canvas 2D specifications. “Wait, what?” I hear you say, “but my phone already supports HTML5!”

Well, strictly speaking your phone and my desktop and Joe’s tablet all support their own flavors of HTML5. The latest version of the markup language has been in development over a few years and browser manufacturers have been keeping up to a certain extent. But, before you start complaining that your browser of choice doesn’t support the full HTML5 spec, consider the moving target that the browser manufacturers have had to aspire to. To a certain extent, it makes sense that the browsers would lag behind the spec: after all, you don’t want to have to discard code when the spec changes (I’ll stop for a moment right there as every programmer who’s ever made a living at this job howls with cynical laughter at that scenario).

But now the spec is finalized, the browsers can catch up and everyone’s happy. Right?

I wish. The problem is that modern web apps like Single Page Apps (SPA) rely on a lot more than just HTML5. In fact, you might think of HTML5 as an overall moniker for a system that looks more like a triangle, with HTML5 relegated to just a single corner. The other two corners of this UI platform triangle are CSS3 and JavaScript (or some flavor of ECMAScript 5) – and if you think HTML5’s spec took some time and tracking to implement, just wait until you see the morass that is CSS3 support (vendor-specific prefixes anyone?) and ECMAScript 5 support. Nevertheless, the rigid steel triangle that is HTML5/CSS3/JS is well understood by pretty much everyone who uses it to provide app functionality: HTML5 is the content, CSS3 the presentation of that content, and JavaScript the code glue that binds the others to provide interactivity, richness, and a proper user experience.

And that is another cue for some laughter among my readers: “proper user experience”. The issue here is that no longer do we just look at a website in a 960px-wide window as in days of yore. My desktop is 1920px across, my iPad is 2048px or 1536px depending on whether I hold it portrait or landscape, my Kindle Fire HD is 1280px × 800px, and my iPhone 5 is…whatever it is. With just that little lot on my desk (let alone my Surface RT) how can we talk about “proper user experience”? I must admit to being a little biased perhaps, but I kind of expect my web apps to look like they are native iOS apps on my iOS devices and like native Android apps on my Fire. And it would be great if the website had a “responsive” design as well for my desktop browser. (A responsive design for a web app is a UI that can change its rendering depending on the size of the browser window. For a discussion on why this is becoming more and more important in 2013 and beyond, see this Mashable article.) In other words, a proper user experience no matter which device is being used.

That of course leads me to our just-released DXTREME product line. Part of the HTML side of the DXTREME subscription is a client-side library that understands devices. It will switch (that’s the JavaScript part) the presentation of the app (that would be the CSS part) according to the device you are running on. The markup of the content (that’s the HTML5 part) does not have to change to support these different devices. Now, agreed, this is all in the early stages – DXTREME does an excellent job for phone-sized devices – but that doesn’t translate brilliantly yet to tablet-sized devices with their extra screen real-estate, so you have to design your tablet interface separately for the best UX. But we have big plans for the next major release to support more devices and to support more widely-varying resolutions. Nevertheless, for creating a multi-platform single-page web app that looks native on whichever devices your users have, DXTREME today is the way to go.

So, in answer to my somewhat flippant question above: if you view HTML5 as the markup language, then, no, of course not. If however you view it as the overall name for the HTML5/CSS3/JS UX triangle, then it’s close, but gets even closer with DXTREME.

Musings on “mobile”

Julian Bucknall (DevExpress) — Mon, 21 Jan 2013 03:08:40 GMT

I look at my desk. There’s my laptop, driving not only its own screen but two external ones. There’s an iPad, third generation, affixed to a third-party keyboard. As I mentioned on my own blog, there’s a Kindle Fire HD propped in the stand on a foldable Bluetooth keyboard. To my left is a cheapo docking station slash speaker pair that is charging my iPhone. Behind me on the floor, propped against the bookcase (why do I still have physical books when I have three Kindles?) is my Surface RT that I hardly use. Next to it is my old Kindle Fire, now relegated to my tech junk pile of history along with my previous laptop which I use for my Windows 8 testing. The only reason I can’t chuck my still-perfectly-functional yet-I-no-longer-use-it desktop on the same pile is that it’s the base for my old CD player – yes, I’ve been known to play the odd CD.

Sure, I’m a geek. I have a gazillion devices. This isn’t about that. It’s more about the variety of devices, the variety of provenances, the variety of OSes.

A few more data points on my curve before I get to my thesis:

My wife’s best friend has just bought (as a Christmas present from Santa) a Nabi tablet for her daughter, a feisty three year old, because she was fed up with the little darling monopolizing her iPad playing with paint apps.
Although Amazon don’t release Kindle sales data, all indications seem to point to the Kindle Fire HD being a big seller. Perhaps even better than Google’s Nexus 7? The iPad mini seems to be a bestseller.
Project Glass by Google. Yeah, it’s a concept device, but how close is it to release? This year? 2014?
I’m not a TV person (I don’t own one) but all I see at the moment is companies jostling with their TV devices (Apple, Google, Microsoft, etc, etc). And why should there be a TV device anyway? Can’t a tablet/laptop do the work?
In-car infotainment systems were all the rage at CES, how long before they’re in every car we can buy? General Motors and Ford seem to be leading the pack since they allow the linking of a smartphone to the device (and therefore the downloading of traffic data, say, for the device), but how soon before the car’s system is itself a “phone” and has its own Internet connection? Yeah, we can laugh now about the notion of downloading apps for the car, but it’s going to happen.

My point then is this: in this world of a gazillion different devices with different screen sizes and resolutions and input methods (keyboard, touch, speech), how are you going to target the consumer? By writing iOS apps and assuming that the mobile market is just the iPhone and iPad? Or maybe that Android is the answer? Good luck with that; that’s not a plan of action for understanding the future, it’s painting yourself into a corner.

My thought here is that it’s way too late to just concentrate on one OS, on one device. We had that possibility in the past but it’s now gone, dumped with my old computing devices on my tech junk pile of history. Our customers are using god-only-knows-what devices to access information about the world, about us. They may be mobile as we currently understand “mobile” but they may be something else. The only way we can easily reach (for some reasonable value of “easy”) our customers in the future is to target the devices they are using, that they are thinking of using, that they will use. And that means HTML5/CSS3/JavaScript. It’s the only pan-device user interface technology we have.

Not only that – that was the engineering view, if you like – it also means that we have to get better at responsive web design. Our pages of data and information and content have to reflow automatically to suit the device; what looks good on an iPad will look disgustingly awful on those future Google glasses. We have to get better at data visualizations: a small screen needs different visualizations than a large one. Touch requires different scenarios and technologies than speech.

I feel we’re at the top of a cliff with a hang glider strapped to our back, with a wonderful countryside vista spread out in front of us. There’s a single simple step to make but – oh, the possibilities – how long will we fly, where will we land?

[A quick note: this is me pondering the future, and does not necessarily jell with DevExpress’ future direction. Or maybe this is more of a curve in 11-dimensional space, and several dimension dot products coincide with DevExpress’ 11-dimensional future plans. Who knows? I’m only the CTO here.]

Visual Studio Magazine Readers Choice Awards for the win!

Julian Bucknall (DevExpress) — Mon, 12 Nov 2012 21:10:20 GMT

Visual Studio Magazine has just announced its 2012 Readers Choice Awards and DevExpress is well represented among the winners with eight Gold awards and three Silvers:

Chart, Gauge & Graph Components – GOLD

XtraCharts Suite

Component Suite: Desktop – GOLD

DXperience Enterprise

Component Suite: Web – SILVER

DXperience ASP.NET Edition

Databases, Data Development & Modeling – SILVER

eXpress Persistent Objects (XPO)

General Development Tools (Includes IDEs) – SILVER

CodeRush

Grid & Spreadsheet Components – GOLD

XtraGrid Suite

PDF & Print/Preview – GOLD

XtraPrinting Library

Reporting, Data Analysis & Visualization – GOLD

XtraReports Suite

Software Design, Frameworks & Modeling Tools – GOLD

eXpressApp Framework (XAF)

Text, OCR, Scanning & Barcode Components – GOLD

DevExpress Rich Text Editor

UI, Toolbar, Menu & Ribbon Components – GOLD

XtraBars Suite

Now winning such awards always evoke good feelings, of that there is no doubt. But in this case, these awards were the results of votes by the readers of the magazine, which magnifies the sentiment. In other words it was our customers, people like yourself, who took the time to mark the ballot in our favor. Thank you to everyone who did so, you are the best customers a company could wish for!

Not only that, but I notice that some of the products that gained awards have done so last year too, And the year before that. Wow, we must be really on the right track if these products keep on winning awards year after year. Rest assured though that we shall not rest on these particular laurels: we are frantically (er, nimbly, or perhaps agilely) preparing version 12.2 of DXperience. Remember we’ve already announced the release date – December 3, 2012 – so our feet are becoming toasty from being so close to the fire!

Let’s see what develops…

The first batch of Surfaces arrive for DevExpress

Julian Bucknall (DevExpress) — Fri, 26 Oct 2012 21:36:48 GMT

Our favorite delivery guy of the day turned up this morning with some boxes: our first batch of Microsoft Surface tablets. We sat him down and fed him cookies to thank him for being so quick, while we opened up the boxes and stacked the Surfaces for the Photo of the Day:

It’s still too soon for an in-depth review, but we have been trying it out. The screen is very responsive to touch and everything is very fluid. We’ve played around a bit with the included apps, including the Office RT Preview that’s pre-loaded, and we’re impressed so far. The Touch Cover keyboard is great (and keeps up for at least my typing skills) and it’s certainly possible to hold the Surface upside down by the selfsame cover (it doesn’t come off). The power connection is not very “magnetic” and will pop out if you are not careful though. The kickstand is genius.

Seth and I both have one and we’ll will be happy to show off DXTREME on it at our booth at //build/ next week. Here’s an initial image showing one of our demos running on the device (and, yes, I wish I had a better camera):

If you are at //build/ do come on over to the booth and say hi and see the demo for real.

Now to watch the others fight over the remaining Surfaces…

Presenting the Windows 8 XAML controls in DXTREME

Julian Bucknall (DevExpress) — Tue, 09 Oct 2012 11:01:00 GMT

It’s a funny old world. It seems only like yesterday we had a WinForms suite of controls and an ASP.NET suite of controls for .NET and that was about it. (My first commercial use of DevExpress controls was led by the old original version 1 ASPxGrid mumblety-mumble years ago, when men were men, women were women, and developers hand-crafted data access layers before lunch.) I then joined DevExpress and it seems we suddenly had a veritable Big Bang of controls and platforms (not all my doing by any means!).

There was WPF and Silverlight – quickly realizing how much they had in common, so we did some refactorings and created a common XAML library – and of course ASP.NET MVC.

We’ve now entered another phase of platforms, a secondary Big Bang if you like: the mobile platforms, led of course by iOS and Android, with Windows 8 and Windows Phone 8 playing catch-up. Way back in November 2010, I wrote a blog post about silos and about how it made sense to me to target the browser for these mobile devices rather than locking ourselves into writing controls for a particular operating system. Fast forward almost two years and we announced DXTREME, a multichannel, multi-platform suite that provides an innovative solution to developers being asked to create applications that span a multitude of devices and platforms, from Windows 8 tablets to the iPad and to smartphones like the iPhone and Android devices. It’s in preview mode at the moment, with a publish date of December 3.

We’ve been talking an awful lot about the HTML5/CSS3/JavaScript aspects of DXTREME (the ability, if you like, to expand beyond the silo of a single OS), but there’s another important part: the WinRT XAML support. Yes, I’ll agree this is a silo, but this particular silo makes a lot of sense. Go back a moment: remember we did a ton of refactoring work to produce a common XAML library for WPF and Silverlight? Well it turns out that, with very little work, we can make this a common library for a set of WinRT XAML controls as well.

And that is what we have done in DXTREME. Let me cover what we have.

Free Download

First important thing to realize is that we’ve provided the DXTREME Preview for everyone. You can download the free trial here. You will be presented with a registration page:

On this page you’ll enter your DevExpress site credentials, soon after which you'll get an e-mail with a link for downloading your trial copy of DXTREME. (If you have any questions on this stage, write to eval@devexpress.com and we'll be happy to help you.)

Once you have downloaded the DXTREME-ENTERPRISE-(Preview)-12.2.0.zip file, you'll note that it comprises two setup programs:

DXTREME ENTERPRISE (Preview)-12.2.0.exe – this installs the DXTREME HTML5 support, and

Windows 8 XAML (Preview)-12.2.0.exe – this installs the DXTREME Windows 8 XAML controls

Note: In order to install the Windows 8 controls, you must be running Visual Studio 2012 on Windows 8. WinRT applications can only be created on Windows 8 using Visual Studio 2012.

What's included?

And now the meat of the preview and this post. The DXTREME Windows 8 XAML suite includes a set of user interface (UI) controls and an MVVM framework.

Data Visualization Controls

Given the primary role Windows 8 is going to take with tablets, it makes sense to talk about data visualization first; possibly the more important set of controls for such mobile devices.

Chart Controls

We have re-designed our chart controls to take full advantage of the Windows 8 XAML platform. The new controls support 18 chart types and use Direct2D for blazing fast drawing.

Gauge Controls

Whether you need to build a digital dashboard or animate your application's Live Tile with a circular indicator - we have the gauge controls for you. Written natively for Windows 8, they support touch, animation and interactivity.

Map Control

The DevExpress Map Control can deliver either raster maps from Microsoft Bing Maps and OpenStreetMap services, or vector maps in Shapefile and KML formats.

Grid and Data Editor Controls

And now for the basic controls for creating business applications.

Data Grid Control

Although not part of the preview, we are in the process of building a very fast and lightweight grid control – after all we are well known for our grids. The initial release will provide the essential data shaping and analysis features (sorting, totals, etc), together with an intuitive and smooth touch-enabled UI.

Data Editors Library

In developing our Editors library, our primary focus was usability in data entry. Validation support also plays an important role here too. We are delivering full support for numeric, date-time and regular expression masks. In addition to the standard keyboard entry, we are also leveraging touch capabilities by including editors like Date Picker which allows you to easily select dates using a touch-enabled UI.

Application Layout

Without a doubt one of the more important aspects of a tablet experience is a good, open, visually relaxing layout that helps get the user’s work done.

Application-Level Layout and Navigation

For DXTREME we are building a set of controls allowing you to manage application layout and navigation at a higher level. You can easily specify what kinds of pages are to be displayed and how users navigate them. In addition to building your application's navigation structure, our controls automatically preserve application state when the application is suspended and restored, fully integrate with our own MVVM Framework, and much more.

Page-Level Layout Management

This lower-level layout control helps you easily create data entry forms of any complexity. The control automatically arranges controls per Windows UI Guidelines and makes sure that proper adjustments are applied when changing your device orientation.

DevExpress MVVM Framework

In addition to the controls library in DXTREME I just described, we will also ship a new MVVM framework that helps you build typical business applications much faster. In order to be accepted by the Windows 8 Store, applications have a very standard UI. We have therefore implemented all of the frequently needed Windows 8 features in our framework in order that you can focus on your business requirements. The framework natively integrates with our controls, such as the Layout Management controls mentioned above, so that your application can automatically respond to application state changes.

And for the more advanced developer, the DevExpress MVVM Framework for WinRT will include a number of essential features, from Value Converters and an ICommand implementation to a standard means of application navigation using keyboard, mouse, and touch.

Getting Started

Of course, all this would be for naught if we didn’t provide some help in getting you started in writing Windows 8 XAML applications. Firstly we have some preliminary documentation online. In this help documentation, you can find several topics that will assist you in trying out our controls as well as the description of the APIs for those controls. Code samples to further assist you are being added regularly.

Since the vast majority of our customers will be using Visual Studio to develop WinRT applications, we’ve added some templates to smooth the way. The first couple are project-level File|New templates that help you in getting started with a new Windows 8 application:

The two are:

DXTREME Blank App, which creates an app with an empty DevExpress page. This template is built on top of our MVVM application framework and radically reduces the amount of code behind in your application.
DXTREME Grid App, which provides Windows UI Style navigation for a two-level object hierarchy. A hub page, section page and detail page are generated. This template natively supports MVVM and is built on top of our application framework.

Then we have four new page-level templates to assist you in solving common tasks:

The four are:

DXTREME Blank Page, which creates an empty DevExpress page with the use of our MVVM application framework;
DXTREME Login Page, which creates a typical login page;
DXTREME Horizontal Tabbed View and DXTREME Vertical Tabbed View, which create pages with tabs for different layout views and which automatically support layout management (for example, Filled, Snapped, etc.).

Summary

With the DXTREME Preview, we’ve shown what we’re working on in the mobile space well before we launch. It’s all about a multiplatform, multi-channel experience, and a large part of that is our controls for Windows 8. We’ve made a solid start and you can expect rapid additions to the DXTREME package throughout 2013. Until then, download the Preview and try things out. Let’s see what develops.