Over the last week or so Embarcadero has started publicly disclosing more information about the next major release of RAD Studio, Delphi and C++Builder, 10.3.
This is usually a pretty good sign that the release is not far away, so we thought we’d create a single post with links to all the public information that we have, and keep it updated as more is released.
Back in August, Embarcadero updated their Public Roadmap. (Of course, something appearing on the roadmap is not a guarantee it’ll be released when they planned, but it was the best we had to go on, until recently). Here’s what they said about 10.3 at the time:
Since then, we’ve had more detailed blog posts from Embarcadero staff:
I guess this comes under the “Language Enhancements…additional syntax improvements” item in the slide above, but is potentially a much bigger deal than that simple bullet point suggests. You should read Marco’s post, but in brief, this will allow you to declare a variable anywhere inside your method, not just in the var block at the beginning. Further, the variable will have true block scope, meaning the compiler will catch any references to it outside the block it is declared in (for example, the enclosing begin..end block). They can also be declared and initialised in a single line, and also declared within a for statement.
But the big one for me is Type Inference. What this basically means is that the compiler will figure out what the type of the variable should be, based on the type of the item you assign into it. For example, if you do:
var lCount := 30;
lCount will be of type Integer.
Now, let’s be clear, this is the compiler doing this. This is not done at runtime. Further, this is still strongly typed. lCount is not some dynamic type that can take all sorts of things. If on the next line you went to try and assign a string to it, you’d get the same compiler error you would have got if you’d explicitly declared it as an Integer.
Now, in this example there possibly isn’t that much value, but immediately I can think of two places I want to use this: Generics and JSON. It has always bugged me that I’ve had to be so verbose when using Generics. Now I can turn something like this:
var lCustomerLookups : TDictionary<string, TCustomer>; lCurrentCustomer : TCustomer; begin ... lCustomerLookups := TDictionary<string, TCustomer>.Create; ... lCurrentCustomer := lCustomerLookups.Item[aCustomerID];
begin ... var lCustomerLookups := TDictionary<string, TCustomer>.Create; ... var lCurrentCustomer := lCustomerLookups.Item[aCustomerID];
Same end result but I haven’t had to repeat myself multiple times on what all the types are.
Now, I understand some of you won’t like this, and of course it can be abused to make code less clear. It’s totally optional, the existing way still works. But there are definitely places I’ll be using it to make my code more readable.
If you haven’t done much on Mobile or Linux in RAD Studio, you may not realise this, but those platforms have a different approach to memory management than Windows and Mac. The article goes into much more detail, but essentially those platforms allowed you to create objects in Delphi and not explicitly call Free. They would be reference counted much like Interfaces in Delphi. Now, just like Interfaces, there were a bunch of corner cases you need to be wary of, in addition to a runtime performance cost, and as a result, I generally found myself still writing explicit Create..Try..Finally..Free blocks on those platforms anyway. You also needed to do this in order to share code between platforms, so this change won’t break any of that code.
So the short version of Marco’s article is that ARC is being removed from the Linux compiler in 10.3, and from the mobile compilers in a future release.
Personally I think the benefits of simplification and consistency across platforms makes this worth the cost of this breaking change. However, it is a breaking change, so it’s worth changing your habits now for new code you write if you are currently not using create..try…finally..free blocks.
David Millington has just posted some details on the UI improvements made to the IDE. Some of this work started in the 10.2 timeframe, but this release brings in some of the most visible changes.
It’s easy to dismiss these changes as just decoration. I have to admit I was a little dismissive of them at first. They were nice, but I didn’t put too much value in them. However after working with the beta for awhile I realised I was enjoying it more. It was a much nicer, more consistent experience. I can’t point at any one thing that made the difference, but I definitely found myself liking it more. There’s less unnecessary clutter to distract you, more space dedicated to the working areas of the screen. A bit like cleaning your desk, it was just a more pleasant place to be afterwards.
David has also posted further about the reorganisation of the Options Dialog.
If you do Android Development in RAD Studio, there’s a very good chance you’ve hit the issue that Jim writes about in this article. We’ve struck it in a customer project when using the TMapView control and wanting to float a toolbar of controls over it (kind of like the way the Search bar floats over the map in the Android Google Maps application). We got it there in the end, but it required a lot of spelunking through the way that FireMonkey interfaces with the Android windowing system and was frankly not work that we really planned on doing.
Thankfully there’s a solution out of the box now, and further, it’s not a specific TMapView solution but rather a general solution that leverages the Native Control support in Android, as well as a bunch of the refactoring to the FMX Android support that has been done over recent releases. The end result is that FireMonkey controls on Android now mesh much more nicely with the underlying platform, and things like TMapView and TWebBrowser behave how you’d expect when FMX controls are in front of them in the z-order.
One of the areas I’m quite excited to see is the attention being given to C++Builder. David goes into more details here, but it covers:
- C++17 support for Win32
- Latest Dinkumware STL support
- Asynchronous C++ Code Completion
- Error Insight for C++
My first job out of Uni was as a C++ developer, and despite the years that have passed since then, I can’t believe I’m excited to play with these new features.
In this post Marco goes into much detail about the enhancements to the VCL’s Multimonitor support, including default usage of Per Monitor V2. He goes into much more details, but these changesshould make your VCL applications much better citizens when run on systems with multiple monitors, including dynamically updating when moving between monitors with different DPI’s.
RAD Server Enhancements
Rad Server has also received some very cool new features. I haven’t seen anyone post about them yet, but I’ve been playing with it lately and it promises to massively simplify building secure, scalable REST API’s with RAD Studio. If nobody writes something up in the next few days I think I’ll do it.
RAD Studio 10.3 Released
As we announced here, RAD Studio 10.3 is now released, so you can grab it and try out the new features for yourself.