ctodx

We’ve just published version 12.1.5 of our VCL subscription. This version adds full support for Delphi XE3 (both 32-bit and 64-bit) and C++Builder XE3 (32-bit). Log in to your account on devexpress.com and you’ll be able to download it providing your subscription is active.

A couple of links to help you understand the changes in this new version:

• What’s New in DevExpress VCL 12.1.5
• Breaking Changes
• Known Issues

With regard to the latter, I’d just like issue a warning if you are still using the BDE. Some late testing revealed that there was a change to the BDE support code in the VCL that meant that calculated fields and lookup fields do not work with XE3 (they still work just fine in XE2 or earlier). We’ve reported the issues we’ve found to Embarcadero’s QualityCentral.

So, if you’ve been waiting for the official support for RAD Studio XE3, download away! Let’s see what develops…

Today is the final day at BASTA, here in Mainz, Germany. Seth and I have had a ball meeting existing customers and people who haven’t heard about us yet. Needless to say there was a lot of interest about our new multi-channel DXTREME product, and we’ve been demoing it on our laptops, Windows 8 touch-capable ThinkPad, our iPad, and iPhones. Attendees were here not only from Germany, but also the Netherlands and Switzerland. It was great chatting to everyone.

Of course, being the last day, there was a giveaway presentation, where attendees could win prizes from the exhibitors. We gave away a copy of DXperience Universal (meaning the winner will also get DXTREME) and a copy of CodeRush. Here are our winners. First off, Thorsten Engels of Meyer Werft won DXperience Universal (click to expand):

And Holger Klaussner of gradient won CodeRush:

Congratulations to them both!

On September 12, Microsoft released the latest version of our favorite IDE: Visual Studio 2012 at what might be termed a rather purple launch event. The photo at right is the lobby of the event and the purple theme was propagated everywhere (seats, restrooms, visuals).

Considering that VS2012 has been in a pretty public beta for a while, I’m sure you have some idea about what it contains and what the changes are from Visual Studio 2010 (our previous favorite version), but I’d just like to take a look at the product from a high-level vantage point.

Let’s approach this from the world of the consumer—after all it is the end-user, the consumer of our software, who is dictating more and more what our software should do. Consumers are increasingly looking to having their digital world with them at all times: they have smartphones of various brands and OSes, they use tablets at home and at work, they want their data to travel with them and not a particular device. Retail consumer applications are getting more sophisticated, and at the same time sporting a simpler interface and experience. We developers have to follow these trends or fall by the wayside, and VS2012 is a great leap forward, especially when mated with great UI controls from DevExpress.

Since VS2012 has been available for a while in various beta incarnations, I’m sure you know about the changes to its look and feel. Rather than hash another tired argument about whether this new UX (user experience) is good or bad, I’d like to approach it from an angle I’ve been using for a while: letting the UX inspire and influence the visual aspects of your apps. Consider the typography and the spacing of visual elements in VS2012 and the interactions needed to get your work done. How can you apply those aspects and techniques to your own designs?

From my viewpoint, I’d say there are possibly two overriding goals for VS2012: creating applications that target a variety of devices, from smartphones to tablets (including the up-coming Microsoft Surface), to ultrabooks and laptops, to desktops and servers; and creating the cloud infrastructure using Azure (or maybe the new ASP.NET Web API) to store and serve data to these applications. Clients can be native (which for touch devices implies Windows 8) or browser-based. Although it’s plainly evident that VS2012 would have thorough support for designing and creating apps for the Windows Store as well as desktop apps for Windows 8, it also has some impressive new tooling and features to help in creating web apps: better JavaScript Intellisense, debugging, HTML5 support, and a DOM explorer, as well as push-button deployment to Azure.

C# and Visual Basic have changed as well, with possibly the most important and exciting feature being simplified asynchronous programming using async and await. These new keywords and the patterns they encapsulate are possibly the most significant aspect to creating responsive applications for phones and tablets, where it is paramount that the user remains in charge of their own device, no matter what may be happening in the background.

All in all, VS2012 is a significant step forward in the art of creating connected client applications for a multitude of different devices, that store their data somewhere in the cloud. And, these days, that is where the action is. Let’s see what develops…

Based upon some excellent feedback from our customers using our Coded UI support, we’ve created a separate installation of our Coded UI Test Extension for WinForms controls. Why? Well, it’s because Coded UI is about testing, and it’s a little silly to make you install the full DXperience Universal just so you can run tests in your testing environment.

This new install includes a pre-compiled (and signed) Coded UI Test Extension binary, as well as the source files for it. The install does not contain assemblies for the DevExpress WinForms controls. When run, it deploys only the Coded UI Test Extension assembly and does not affect other assemblies. This makes it a neat package for deploying to your testing environment.

If you manually build our WinForms controls and sign the resulting assemblies with a custom Public Key Token, you will also need to manually build the Coded UI Test Extension (and sign it with the same key) in order to test them.

The installer for the Coded UI Test Extension for WinForms Controls will be available shortly for all subscribers of DXperience Universal Edition.

It seems that Nate Woolls is a smidgeon happy about the new Server Mode we added to the ExpressQuantumGrid in VCL Subscription 12.1. So much so, he’s on a tear describing it and how to use it on his blog.

He has two posts that are well worth looking at (and I’ll note it’s only been 24 hours since we released 12.1):

1. “Blazing-Fast” Data Binding for Large VCL Datasets Here Nate checks out the speed increases you can expect when you switch over to using Server Mode in your grids, especially with very large datasets.
2. Getting Started with Server Mode for ExpressQuantumGrid In this post, Nate takes a look at how to implement a grid that uses Server Mode. It’s a great how-to with lots of images to help understand the flow.

Thanks, Nate!

Look it’s ridiculously simple. DevExpress started out with VCL user interface controls and, despite everything that has happened in the thirteen-and-a-bit years since, we are still very much in that market: the biggest vendor, with the widest breadth of controls and functionality. Not only that, but we’re just about to publish possibly the best release in years: VCL Subscription 12.1.

Let’s start off with the highly visual. We’ve added a tile control that is inspired by the new Metro look-and-feel of Windows 8. What we’ve found with our WinForms version is that a tiled front page to your application produces a very versatile dashboard-type view. Some of the tiles contain static content and some are “live”, where the content automatically changes through several frames of animation. As a user, your instinct is to “touch” the tile you are interested in, either with a traditional mouse cursor, or, if you have a touch-enabled screen, touching the screen itself. You can rearrange the tiles by dragging and dropping the tiles on the screen. The user experience is very fluid and graceful.

As a developer, you can reinforce the dashboard metaphor by wiring up the click events of the tiles to “drill down” and show more information that is relevant to each particular tile. So, for example, if you are showing total sales in a tile, touching the tile will show a different screen (preferably by sliding it in from the side) that shows more information about the total sales, say using a grid with some charts. The ability for the user to rearrange the tiles into an order that is more relevant to their work empowers them, they become more invested in the application.

Another point I want to emphasize about the tile control is that it is a pure VCL control, written in Delphi. There’s no magic, just the traditional DevExpress pixie dust. That’s why we say the control is “inspired” by Metro’s UI. It’s a chance for you to bridge tomorrow’s inevitable move to Windows 8 and Metro by introducing your users today to the concepts of tiles and how they work. We think they will be delighted.

We realize that a lot of this is brand new, so please check out the Realtor World demo application we provide with VCL Subscription 12.1. You can see the functionality I’m describing and, because it is a demo app, you have the full source code. Open up the project in RAD Studio and browse the source. Better still, use the demo app as a template for your own app: go ahead and delight your users.

On to the next big feature we’ve added to VCL Subscription 12.1. This time it’s not a visual feature, nevertheless it can improve the user experience of your application significantly. I’m talking about Server Mode for the ExpressQuantumGrid.

Given the feedback from some of our customers, an explanation may not be needed but allow me to expand a little on what Server Mode is. Traditionally, the grid has operated like this: when the grid is first displayed, the grid engine fetches all the records from the database. It stores this data in memory and uses it to provide the various user manipulations needed, including paging, sorting and grouping. As you can imagine this initial data fetching can take some appreciable time if there are thousands or millions of records and the memory requirements are massive.

With Server Mode, the grid has been enhanced through the use of some helper classes to fetch only the data needed for the current view. Conceptually (actually, our Server Mode is optimized even more than this basic description illustrates), the grid only fetches the number of records required for the current view. If the user pages down to see the next rows, the grid fetches another set of records right there and then. If the user sorts on a particular column by clicking on it, the grid merely fetches the first few records of the new sort order: the database engine is solely responsible for doing the ordering. In essence, the grid and its new helper classes are crafting SQL statements on the fly to fetch just what is needed for the current grid view.

This then is Server Mode: the initial display of the grid is much faster but each subsequent page display may be slightly slower (since it could require a round-trip to the server), and the memory usage is reduced. Overall though, your users will perceive a much smoother experience.

For 12.1, we are providing support for the big database engines: Microsoft SQL Server, MySQL, Firebird, Interbase, and Oracle. Other databases will be supported in future releases. The current support is for read-only data; read-write capabilities will be forthcoming.

Of course, there are many other new features and changes in 12.1. There’s the new high-speed paint mode for the skins that doubles the speed of painting elements and is more compatible with terminal systems and low-color modes. We’ve improved the performance of the layout control for complex layouts. We’ve added color galleries that can also be used as color editors. We’ve improved the Ribbon control with several new much-requested features. And so much more. You can view the whole What’s New in 12.1 here.

Crystal Ball time

Having produced this new release, let me reveal a little about what we’re planning (or not) for 12.2. Remember, we are resource-constrained with regard to supporting Delphi and C++Builder, and so we have to pick and choose what we want to – and are able to – implement.

First of all, as everyone who uses RAD Studio knows, Embarcadero usually follow an annual cycle for major releases. If this year is no exception, that means XE3 is some three months away. Nothing official has been said about this release yet (apart from JT’s blog post about C++Builder, of which more in a moment), but we can imagine that there’s going to be a lot of news about FireMonkey and support for various platforms. I doubt there will be much about VCL.

If we assume that XE3 is due this half, we’ll need to trim the supported IDEs again: 12.1 will be the last version to support Delphi and C++Builder 2010. I will sound a further note of caution: it’s likely that in 2013 we shall drop support for Delphi 7 and Delphi 2007 (what you might call the “ASCII IDEs”), so that we can concentrate on the latest run-times and environments.

I’ll be the first to admit that FireMonkey has come on by leaps and bounds since its not-very-complete release last September, so I dare say it’ll be that much better in XE3. Consequently, we shall be doing some investigations creating controls for it, especially for iOS. At this point in time though, it’s unlikely we shall invest in replicating what we have in VCL for FireMonkey to target, say, the Mac.

With regard to a 64-bit C++Builder that is to be built with Clang/LVVM, I’m going to say we shall treat it with kid gloves. Re-engineering a compiler so fundamentally says “breaking changes” to me, especially given the necessary extensions that are present in the current C++Builder to interface with Delphi. So, fair warning: if the changes are too severe, we shall not support 64-bit C++Builder in 12.2. It took us long enough to support 64-bit Delphi across our entire product line, and this year we don’t have the resources. That doesn’t mean we won’t ever do this (after all, Embarcadero are saying that they’ll switch completely to Clang/LVVM at some point), just that we won’t this year.

For VCL, expect more enhancements to Server Mode, including read/write capabilities. Expect more touch enhancements. Expect some larger scale features. We are of the strong belief that VCL has a lot of life yet, and we shall continue to bridge your current expertise to fit the future. Let’s see what develops!

For fun, here’s a panorama of our booth on the Exhibitors’ floor at Tech·Ed:

Click to enlarge.

We’re here all week, so, if you are attending, make sure to come along and visit – we’ve got lots to show you.

Every time we release a new version of our flagship DXperience product, I’m reminded of how far we’ve come in the .NET world and, paradoxically, how much further we have to go. I feel as if we’re in a station on the Tube in London, the train has just come in, the speakers are blaring “mind the gap, mind the gap”, and we have watch out for the gap between platform and carriage or we may have an accident.

By now, we’re all pretty familiar with what we may call the traditional platforms: WinForms, ASP.NET, WPF, and Silverlight. Some of us can develop apps for these platforms in our sleep almost, we’re so well versed in them. And yet, there are technologies out there that we can’t easily reach and use without help. Sure, Windows 8 is just around the corner (but, being Windows 8, the corner is fairly sweeping and will take a long time to get round) and it will help with some of these technologies, but we are in the here and now. We need something to bridge that gap between the platform we’re on and that Metro train.

I’ve talked about this before, but we’re moving away from developer-centric UI design (dragging controls one by one onto the surface) to a more designer-oriented process. Your existing applications now must be extended to run on an array of mobile devices, like iPads, slates and mobile phones. Building such applications requires more focus than ever on great design principles. With 12.1, you can use elegant Office-inspired or Metro-inspired templates to incorporate new projects to your solutions so your users can view, manipulate, and analyze data in more insightful and compelling ways. For ASP.NET solutions, we’ve created a sophisticated project wizard to help you configure your application more easily (authentication, compression, resource merging, and localization, to name a few), a much better themeing engine, and, for the tablet world, 12.1 includes a new tablet project template with a built-in iOS theme. And of course our sample applications, created in partnership with the DevExpress team of professional designers, are like having your own design agency in the box.

It goes without saying that we’re fully on board with touch-enabled applications. But we don’t want you to wait until Windows 8 and Metro tablets reach a critical mass, we want you to be able to use touch right now in your applications you’re writing at this very moment, on the platforms you are so thoroughly experienced in. Of course we have improved the tile controls we introduced in 11.2, including headers, extra animations, and larger tiles, as well as a template for creating a Metro-inspired UI, but with 12.1 we’ve added some new touch-supported docking panels. With these sophisticated touch-enabled controls, you can build solutions that will, quite honestly, delight your users.

Reading between the lines, you can see that productivity is not taking a back seat in 12.1. New templates, beautiful themes (and better theme control), project wizards, all these enhancements improve your ability to get your job done and get it done quickly. In talking about productivity, though, I should mention CodeRush, the most productive of IDE productivity tools. Last time we incorporated Code Duplication Detection and Consolidation (aka, finding and fixing copy/paste code issues) into CodeRush. We’re cementing our lead on this by improving the detection algorithms and making it much easier to consolidate the code into the class you need. There’s a new FrictionFree mode that gives you the benefits of CodeRush under the hood without altering your Visual Studio environment too much, as well as a myriad other enhancements that will help you write, navigate and test your code more efficiently than ever before. Talking of testing, 12.1 includes complete Microsoft CodedUI testing support across our entire WinForms line (with aggregated action support): you can now incorporate automated user interface testing of complex forms more easily than ever before.

As is usual, there are many other enhancements across the board in 12.1: a rewritten charting engine for even speedier chart drawing, a WPF report designer, floating objects in the rich text editor, a scheduler for ASP.NET MVC, to name but a very few. I would check out our complete What’s New list for a full run down.

All in all, DXperience 12.1 is a solid release aimed at helping you produce beautiful and functional applications on the platforms you know and are experienced in, incorporating the latest technologies easily, and bridging the gap between today and tomorrow. Let’s see what develops!

I’m sure you read that Facebook bought Instagram recently for little more than the change Zuckerberg found in between his couch cushions. No, I’m not going to talk about that acquisition, but about Instagram.

If you haven’t used it, Instagram is a camera app for the iPhone (and now Android, to rather bitter commentary from a few Apple fanbois) that, unlike the camera app that comes with the phone, allows you to digitally manipulate the photos you take on the device itself. To that end you can apply artistic filters with whimsical names like Lo-Fi, Toaster, Hefe, 1977, Kelvin. Once manipulated, Instagram provides means to share your images across your social spectrum.

In effect, what Instagram did was to be inspired by all those rather lo-res, easily-faded polaroid pictures people used to take and create digital image manipulations that imitated those photos. The aforementioned 1977 filter, for example, produces an effect that looks like your photo has just spent the last thirty years in a box in the attic.

And that’s the main theme for this post: using something that already exists as inspiration for something new. Instagram did it for photos (“get that retro look and share your photos”), but what do we as developers of software in our daily jobs have? Just to warn you though, I’m talking about inspiration, not plagiarism: I’m certainly not condoning ripping off another application for your own.

The main inspiration for our new applications is obviously existing ones. Indeed, I’d say imitating Outlook in its various versions – no matter what you may think of it – has been the inspiration for many applications. Of course, some of our own WinForms controls have been inspired by Outlook. I would also say that existing applications also provide “anti-inspiration” in the sense of you know what to avoid doing by looking at such-and-such a program (“I can do much better than that!”).

Another source of inspiration, I find, is well-designed web sites and web applications. These are probably the best source of inspiration for me in my non-DevExpress work (say, messing with my personal blog): I see something cool or neat at some website and I long to learn from it and replicate it myself. As an example, one site I’m particularly enamoured of is ThinkGeek. Take a look at its main page on a wide screen (so that the robots/UFO background is visible) and then scroll the page until you reach the bottom. That is an awesome effect; totally inspiring, even though I’m not sure how or where I could imitate it.

The final source of inspiration for you is to use our full-featured demo applications. Here it’s even easier: you get the source code and the images/icons and our developer license allows you to take the demo and fix it so that it solves your business problem. I can’t tell you how many people have come up to me at conferences, looked at the Realtor World demo on my laptop’s screen (here’s the Silverlight version), and say wistfully, “I wish my app looked like that”. And I say, it’s just a demo with the product. Rip out our data source and plug in your own and make your app look like this. We’ve paid our designers to think about the hard stuff so that you can be inspired and imitate what we have.

(Of course, it almost goes without saying that our Realtor World app was inspired by the Metro look-and-feel from Windows 8, and that, in turn, was inspired by the so-called Swiss-style Graphic Design, which in turn owes much to the Bauhaus movement in the 1920s and 30s.)

And that is the crux of the whole post: make something great by building on top of something that’s already great. Imitation really is the sincerest form of inspiration.

This week we were at DevConnections in Las Vegas. It was an ideal opportunity to chat to customers past, future, and present, to participate in the official launch of Visual Studio 11 beta, to meet with partners, and to hear the news.

One item of news that I’m sure you’ve already heard of is that Microsoft have decided to open source ASP.NET, or, to be more precise, ASP.NET MVC (which, admittedly, has been open source since v1), the ASP.NET Web API, ASP.NET Web Pages (aka, Razor), and the System.Json assembly. What’s also new is that they are now taking contributions and patches to the source, something they haven’t done before. (Blog post from ScottGu.) This effort doesn’t alter what you are doing now with ASP.NET (it will continue to be part and parcel of Visual Studio, for example), but it will mean that ASP.NET will broaden its appeal to non-Microsoft projects. (Blog post from Miguel De Icaza, CTO of Xamarin, the vendor for the Mono products.)

We also had the opportunity to have a one-on-one chat with Jason Zander (Corporate VP for Visual Studio) about this announcement and about what’s coming up with regard to Visual Studio 11 and beyond. Whereas a lot of what we talked about is private, there was one thread that came up again and again in our discussion: tooling. You see, with the announcement of the open sourcing of ASP.NET, Microsoft are essentially saying that it’s the development tools that are significant and not necessarily the run-time code. They’d rather give away the run-times and emphasize the market for the Visual Studio ecosystem, than try and sell the whole kit and caboodle. Even more important, I would say, is the fact that ALM-type tools (Application Lifecycle Management) are already the major market in development tools.

With Visual Studio, that means TFS (Team Foundation Service). Or more properly, taking into account the other big Microsoft announcement of this week, Team Foundation Service on Windows Azure. (Blog post from Brian Harry, PUM for Team Foundation.) This new service, currently in preview mode, is fascinating since it moves a lot of development build processes to the Cloud. In essence, think of TFS as a bunch of build servers in Windows Azure, ready to compile, to unit test, or to run any type of other process as part of the build (let’s say, as a wild, er, rushed example, some kind of code issues analysis program). The service allocates a build VM from a pool, runs the build script, and once the build is done and the results copied, releases the VM back to the pool.

In other words, the developer tooling market is growing in importance and reach. Not only for these “big iron” tools, but for smaller, more focused tools as well. The “code” you buy will get less important, but the tooling and development aids you get with it will evolve to be much more significant and relevant. (See my fourth point in a previous blog post of mine.) If you like, developers aren’t going to want to choose from a buffet of vendors for pieces and parts as they’ve perhaps done in the past, they’ll want the whole enchilada from one, and the tooling needed to get the most from it.