- Instant File Initialization – Killer Feature for SQL Server
- RAD Studio 10 Seattle Update 1 Available
- Bug fix list for RAD Studio 10 Seattle Update 1
- Delphi Blogs of the Week/Month #35
- More on ARC, Weak References, and Unsafe References in Delphi Mobile Compilers
- SQL Server Index Fragmentation In-depth
- A Look Back at PASS Summit 2015
- FireMonkey Paint Canvases
- IDE Fix Pack 5.94 released – RAD Studio 10 Seattle support
- October 2015 XE6 Hotfix Available
- Speaking at EKON 19 Next Week
- Running Delphi Applications on Android Intel
The update is now available for download. This update consists of over 250 bug fixes, including fixes to 70+ customer-reported issues -- see the list at edn.embarcadero.com/article/44619. Almost all of these 70+ customer reported bugs come from Quality Portal, http://quality.embarcadero.com, and include the 5 top voted issues specifically opened for 10 Seattle (and among the most voted overall). Here are the download links:
The update includes the following notable fixes (some of which are specific to Delphi or C++):
- Win64 compiler bug causing indeterministic behavior (RSP-12512, this issue was also previously addressed with a beta hot fix available to all registered users)
- DataSnap REST client call issues due to the switch to the HTTP client library (RSP-12685)
- DBGrid columns sizing bugs (like RSP-12433, RSP-11797)
- High-resolution monitor and tabbed dialog handling (RSP-12332)
- C++ 32bit CLANG compiler issues (like RSP-12250 and RSP-11883)
- Themed common dialogs (RS-11814)
- TPushEvents Android exception (RSP-12347)
Notice that these bugs will be marked as closed in QP in a few days, along with all other bugs that are closed as fixed or as duplicate of other bugs that have been fixed. The process is automated but requires manual overview...Re-Install, Only For Subscription Customers
Two more tidbits. First, this update is a full uninstall/re-install. As usual the reason is this update touches such a large number of files, that individually updating those files won't really save any time (it will be much slower, in fact), but facing more risk of errors. You might have seen the size of the recent 64bit compiler hotfix.
Second, as the name implies and as already happened for XE8 and part of Embarcadero policy since the beginning of 2015, the Update is available only to active Update Subscription customers. If you own a 10 Seattle license without Update Subscription don't try to install it: you'll have to re-install the original version. What you can do is add the Update Subscription to your current license, contacting sales or a reseller partner. The standard limitations for buying Subscription only with or immediately after the product have been waived, so any 10 Seattle customer can now buy the Subscription for the next couple of weeks.The Most Stable RAD Studio RAD Studio 10 Seattle was a very stable release, and with this further Update is really becomes a version that's hard to miss for any C++Builder or Delphi developer! And if you still haven't bought 10 Seattle, you can take advantage of the current, incredible offers that provide you free high-quality components (RAD Solution Pack, Konopka Controls or CodeSite, depending on the SKU) with your license. Read more at www.embarcadero.com/radoffer. Update: ISO Link
The ISO download is now at cc.embarcadero.com/item/30446
I just realized it has been almost two months since my last collection of links, but I did blog quite a bit with the most important ones anyway. Still, welcome back to this collection of links, blogs, and other information you might have missed. here is the list, with no specific order:
- Changes in Quality Portal component's list and some hints at community.embarcadero.com/blogs/entry/changes-in-quality-portal-component-s-list (by Juan Antonio)
- Important Note about using the Google Maps API from Desktop Apps at theroadtodelphi.wordpress.com/2015/10/19/important-note-about-using-the-google-maps-api-from-desktop-apps/ (by Rodrigo)
- Using the Network List Manager (NLM) API from Delphi at theroadtodelphi.wordpress.com/2015/10/28/using-the-network-list-manager-nlm-api-from-delphi/ (also by Rodrigo)
- TRichEdit behaves differently under Unicode at chapmanworld.com/2015/11/04/trichedit-behaves-differently-under-unicode/ (by Craig)
- Using QueryLines to filter your BaaS data at community.embarcadero.com/blogs/entry/using-querylines-to-filter-your-baas-data (by Sarina)
- (even if not strictly Delphi, still related) Migrating legacy C++ Builder Apps to C++ Builder 10 Seattle at community.embarcadero.com/blogs/entry/migrating-legacy-c-builder-apps-to-c-builder-10-seattle (by Al)
- Android Services Presentations and Workarounds at delphi.org/2015/10/android-services-presentations-and-workarounds/ (by Jim)
That is all for this round. Maybe I should get back to my old model of sharing my Twitter retweets and Favorites on the blog... and do it more timely. But I'll probably just try to get back to a monthly list.
This blog post delves into some technical information about ARC and the available types of references in the Delphi mobile compilers for iOS and Android. The reason for this blog post is that there has been very little technical information about this topic and I've personally only recently come to realize -- in conversations with Embarcadero developers, particularly Allen Bauer -- some of the implications (so that my Object Pascal Handbook, while correct, can be considered incomplete).
Here I'm not going to repeat all of in the information already in my book and other sources, but provide a short overview and focus on the latest part, unsafe references, which is the most neglected one so far.What is ARC?
Automatic Reference Counting is a memory management model based on tracking the references to a single object in memory and disposing the object in a fairly deterministic way when all references go out of scope. Unlike garbage collection, ARC happens in the thread of execution and in synch with the program flow, even if the flow can be fairly complex to easily understand when each given object will get deleted. (Not that here I want to delve into the merits of ARC vs. GC, this could be a whole different blog post). ARC is the standard memory model for Apple programming languages on both OS X and iOS.
Delphi mobile compilers all embrace ARC as the primary model, with ways to mitigate the transition from the traditional memory model thanks to extra methods built into the TObject class. When all references to a Delphi object go out of scope, the object is deleted and its destructor called. You can set a reference to nil in advance, to make this happen sooner, and even force the execution of the destructor in advance (calling DisposeOf).
Again, a lot has been written about ARC and ARC in Delphi, and I don't really have too much to add here.What is a Weak Reference?
Weak references are a fundamental element of the ARC model. With ARC, unlike a GC, there is no loop detection so you need to "break" any loop using a weak references. This is something I cover in my book, I wrote about in white papers, and that is documented in several other sources. The implication of weak references is that these are managed. The system tracks all pending weak references, and if an object is destroyed and there is a weak references pending, this is automatically set to nil. This way you can check if a weak reference is nil to verify the object the weak reference is pointing to is still in memory -- something not available with the traditional memory model. The management of weak references has a runtime cost (although this cost is lower in Delphi than in Apple's implementation), as the system need to store them and track them. A large number of weak references might become expensive at runtime.
Can we skip using weak references altogether and use a manual, traditional approach? This is certainly a possibility, as explained below, however if you need to set up another complex object destruction notification system of your own, you might end up with a system that implies writing more code and have a larger runtime penalty compared to weak references.What is an Unsafe Reference?
The last element, and the main point of this entire blog post, is the existence of unsafe references. There are a few documented examples of their use (including in my book) mostly focused around the scenario of handling temporary objects. A classic example is that of a function creating and returning an instance. At the point the function returns and before the object is assigned to another variable (for example as the result of an expression) the instance might end up with exactly zero references, and could be subject to (unwanted) disposal.
However, unsafe references can be useful in other scenarios. You declare one with the unsafe keyword, or (even better) the [unsafe] attribute. You can use this attribute to decorate a local variable or a field in a class or record.
What is in essence an unsafe reference under ARC compilers? It behaves basically as a traditional non-reference-counted reference of the Delphi world. No increase or decrease of the reference count happens when an unsafe reference is assigned an object or goes out of scope. No check for zero references is performed. Just like with a "good old" Delphi reference. (Along the same line mixing unsafe and ARC references can get you in some tricky scenarios, more or less like mixing interface and object references on the Windows compilers).
Does this mean developers should scrap ARC and go for the traditional model? To me this does make sense in some very specific scenarios, in which another memory management model is already in action. In general, ARC is a very powerful and complete model I recommend understanding and embracing, rather than fighting. Make sure you learn your options, and than make an decision, rather than taking a shortcut to the scenario you know from the past.
Consider also that our entire library uses ARC and weak references (although some of those might end up moving to unsafe references in the future).A Roundup Micro Demo
To round up the blog post, let me finish with a very simple code demo, to highlight in less than 10 lines of code the differences between regular ARC references, weak references, and unsafe references. Consider this code snippet:var myObj: TMyClass; myObj2: TMyClass; [weak] myObjW: TMyClass; [unsafe] myObjU: TMyClass; begin myObj := TMyClass.Create; Show(myObj.RefCount.ToString); myObj2 := myObj; Show(myObj.RefCount.ToString); myObjW := myObj; Show(myObj.RefCount.ToString); myObjU := myObj; Show(myObj.RefCount.ToString); myObj2 := nil; myObj := nil; // frees the object // are references still (apparently) valid? Show(Integer(Pointer (myObjW)).ToString); Show(Integer(Pointer (myObjU)).ToString); end;
The program creates an object with two regular (ARC) references plus a weak and an unsafe one. The reference count is displayed each time. Later the two main references are set to nil (effectively freeing the object), and we look at the raw pointer value of the two "pending" references, the weak and the unsafe one. Can you guess the output without looking to the image below?
As you can see, the weak reference is automatically set to zero (so you can do an if Assigned test before using it), while the unsafe reference becomes in all effects a dangling reference, a reference to the memory location where the object used to be (before being destroyed). Using that reference is bound to incur in errors and it is very difficult to determine at run time if that reference is indeed valid. Which is the main reason for using a weak reference in the first place.
Of course, the point of using weak and unsafe references is in managing very complex data structures, but this small snippet should convey the key technical differences among these three reference types, underlying the fact that they behave in a significantly different way. I hope this blog post helps shed some light.
While giving a session on FireMonkey architecture yesterday at EKON, we got to the subject of alternative configuration for the direct paint operations, using the GPU in different ways. To demonstrate that on different platforms the Canvas object you use for painting is different, I added to an empty FireMonkey form the following OnPaint event handler:procedure TFormFMtoGPU.FormPaint(Sender: TObject; Canvas: TCanvas; const ARect: TRectF); begin Canvas.Fill.Color := TAlphaColorRec.Blue; Canvas.Font.Size := Height div 3; Canvas.FillText ( ARect, Canvas.ClassName, True, 1, , TTextAlign.taCenter); end;
If you run this FireMonkey applications on different platforms, you'll see different Canvas objects are going to be used:
- on Windows, by default, you get TCanvas2D2 (for Direct2D support)
- on the Mac, you get TCanvasQuartz (Quartz is the OS X GPU library)
- on mobile platforms, both iOS and Android, you get a TCanvasGpu
This "GPU Canvas" is a way to send graphic commands to the GPU directly, bypassing an operating system stack which is not always very efficient. Now what it less know is that you can use the same GPU Canvas also on Windows, by forcing it with the global setting FMX.Types.GlobalUseGPUCanvas to True in the project source code before the application object is initialized. On Windows there is also the option of disabling DirectX and using the GDI+ fallback, generally a slower solution with much worse anti-aliasing effects. This is achieved by setting to False the global setting FMX.Types.GlobalUseDirect2D . In other words, on Windows you have 3 separate options.
For more information, you can read the following:
The session at EKON was mostly focused on styles in FireMonkey, however a developer in the audience was able to tweak the canvas and get an application working on a rather old PC, so I though it was worth sharing the tip.
Following the XE7 counterpart, there is now a hotfix available for RAD Studio XE6, called "October 2015 XE6 Update Subscription Update". This includes a subset of the issues fixed in the recent XE7 hotfix. Again, this hotfix is available only to Update Subscription customers, as an extra bonus for our most loyal customers.
As we covered a few times, Update Subscription is your way to stay current with the products and also have fixes for recent past versions. We understand that even if you have the latest version available you cannot migrate immediately and cannot migrate all of your applications. While newer versions offers many significant enhancements in many areas of the product, and we certainly want to encourage everyone to move to RAD Studio 10 Seattle, having project on older versions with a few issues fixes can be beneficial.
So if you bought XE8 with Update Subscription you can head to
download and install. If you started update subscription with 10 Seattle, you can also download the package, but you might have to refresh your license in License Manager (at least over the next few days) before you can apply the fix. The installer, in fact, checks for a specific update subscription + license combination. By the way, the same applies to the XE7 fix: we are doing some final testing and will explain the actual steps as soon as possible.
Finally, the team is also working on an XE8 Update including some of the fixes introduced in 10 Seattle. And also working on the first main Update for 10 Seattle itself. These updates will also be limited to Update Subscription customers: If you bought 10 Seattle recently you might still have time to add the Update Subscription to it!
Next week I'll be speaking at the 19th EKON conference in Germany, a rather large Delphi-focused event with tracks in German and in English, and many top quality speakers.
EKON, entwickler-konferenz.de/2015/en, is one of the longest standing Delphi events, now in its 19th edition (even if originally it was a multi-technology developer conference). The conference runs November 2nd (Monday) to 4th (Wednesday) in Koeln (or Cologne), Germany. The location is a minute from the main train station, very easy to reach.
There are two speakers coming from the US (Cary Jensen and Nick Hodges), many well known German and European speakers, an Embarcadero presence with myself and Matthias Eissing. I'll give a keynote on Delphi 10 Seattle and the product status in general, and also two technical sessions on VCL/Windows 10 and on FireMonkey.
EKON is generally a very nice event for networking with other developers, chat over a beer, and have some fun. If you are coming, I'll be available for a chat, for a meeting with your team, or anything else. I can also bring printed copies of my latest Object Pascal Handbook, if you want one signed -- but let me know in advance.
As I mentioned in my last blog post about my CodeRage product address, it is technically possible to run Delphi Android applications on Intel devices. For the conference, Jim McKeeth had an Android Intel device he used, but I don't have one at hand. It was good someone suggested me to look into this blog post by Magno Lima, magnumlabs.wordpress.com/2015/10/09/android-using-bluestacks-as-emulator-delphi/, focused on using Bluestacks Android Intel emulator.
This emulator (unlike others) runs a full Android and it does support libHoudini, the emulation layer for ARM binaries. So armed with a little time today I installed Bluestacks, fiddled a little with the adb tool to make it visible to the Android SDK (and RAD Studio), and started some experiments. If you take a plan FireMonkey application and deploy it, this is what you get:
This happens because FireMonkey, by default, injects platform test code into the application. Originally an ARM binary would just crash on Intel, so better show an error message than an exception. You can read about this at docwiki.embarcadero.com/RADStudio/XE8/en/Running_Your_Android_Application_on_an_Android_Device (and the case is similar to the Amazon table one). So what you have to do in practice (and Magno explains very well), you have to remove the x86 check by removing the library from your project in the deployment options:
In the background you can also see the Bluestacks target (with a rather random name) in the Project pane of RAD Studio. Now run the application again, and it should work:
Of course, you can run also some fairly more complex applications, like the one below (in this case notice the issue with the title bar, explained again by Magno at magnumlabs.wordpress.com/2015/10/10/delphiandroid-misalignment-status-bar-on-intel-based-devices/ -- along with a workaround). Something to work on for our dev team. Anyway, this is the output of the actual demo:
I ended up with some "fire" apps on Bluestacks... but again, the same should work on a physical Android Intel device, with a recent version of Android (Lollipop preferred) equipped with libHoudini:
In my CodeRage X Product Address for the Delphi/Object Pascal track last week I covered the status of the product with Luis Navarro and highlighted the "broadening" of FireMonkey Android target platform. In particular I showed two short demos covering:
- How the current beta version of the Microsoft Astoria UWP (Universal Windows Platform) bridge can be used to execute FireMonkey applications build for Android on a beta version of the Windows 10 Phone operating system. To test this you need a compatible phone, with a beta of Windows 10, to sign up for project Astoria, configure the Android SDK with specific Microsoft add-ons, and the RAD Studio IDE will be able to target the Lumia devices directly. Not everything we have tested works, but this is still in beta.
- How the most recent Android Intel tablets can run FireMonkey applications build for ARM targets using the pre-installed libHoudini library Intel is offering. From some recent internal tests on the libHuodini that comes with Intel Android Lollipop, the compatibility is very high, and in the session Jim demonstrated running InterBase IBLite, FireDAC, and FireMonkey smoothly. It is important to notice you need to disable the Intel platform check in the deployment options, or that code will display an error message and stop the application. That check was originally added to avoid an odd crash of the application on earlier Android Intel devices.
Now the real question becomes, with these solutions working is RAD Studio going to provide also a native solution for Windows Phone and Android Intel?
In the case of Windows Phone the apps you are building in RAD Studio are binaries that can run on the phone CPU as they are, with a mapping layer for APIs only. Astoria offers extra Java APIs and an Astoria app is a UWP app that you should be able to distribute via Windows Store. While we do plan improving our support for Windows 10 Phone via Astoria once this is released, we consider this native platform support.
In the case of Android Intel, the solution works like a virtual machine, remapping assembly instructions to a different CPU, while the APIs are already compatible. This is not the ideal solution, as performance is affected, although the applications still seem quite responsive. We plan keeping this platform under scrutiny, collecting feedback on the libHoudini layer, evaluating the market share (which remains quite modest), and determining the priority for a potential Intel Android compiler and toolchain.
Getting back to the overall Product Address, including the mentioned demos, you can find it on YouTube or linked below:
The 10th edition of the online CodeRage developer conference is starting next week, Tuesday to Thursday. The theme for this year’s CodeRage conference is " Develop Anything, Anytime, Anywhere ".
Most of you have probably attended past edition, and it is great if you have a chance to reserve a little time next week for training... better understanding Delphi and C++ Builder product features (not limited to the 10 Seattle release) and exploring solutions and third party components. The online conference has two parallel tracks devoted to the two programming languages used by RAD Studio developers.
The conference goes from 5am to 5pm US Pacific time, which is 8am to 8pm US eastern time, 2pm to 2am for those in central Europe, and so on. More technical information, the webinar software downlaod and so on at www.embarcadero.com/coderage/coderage-logistics.Object Pascal / Delphi Sessions
Among the Delphi sessions, I'll give the introductory Product Address, and there will sessions on Windows 10, IoT, Parse, AWS, DataSnap, VCL styling, core RTL, InterBase, VCL components, WinRT integration, security, parallel programming and multi-threading, MongoDB, Android services and Intents, mobile sensors.
R&D team member sessions including those FireMonkey, BeaconFence, EMS, and PAServer. Third party and Embarcadero components include FastReports, Gnostice, AppAnalytics, CodeSite, FastReport, FrameStand, and Arduino. Plus other sessions I've probably missed.
The complete list is at www.embarcadero.com/coderage/coderage-x-op-sessionsC++ / C++Builder Sessions
Many C++ sessions have the same content of those above, so the list is similar, and that should not come as a surprise. After a C++ Product address, the C++ specific sessions include a special "Meet the C++ team event", some component session like OpenWire, some FireDAC sessions, and more. As you can see in the list, some of the sessions are not strictly product specific but are only in one of the tracks, other are duplicated as the code demos will be specific to the track.
The complete list is at: www.embarcadero.com/coderage/coderage-x-cpp-sessionsRegister Now!
If you still haven't done so, sign up now at:
and don't miss the online sessions and live Q&A. We are expecting a packed house... good that we'll have enough room (ehm, bandwidth) for you all.See You Online
And see you online next week! I'm heading to Scott Valley, California over the weekend to help host the event, be there for live Q&A, and have my regular visit to the office, as well. We'll be online in the Embarcadero Community, Facebook, Twitter, Google+ and more, to engage with all online conference attendees and have also a bit of fun.
Called " Summer 2015 XE7 Update Subscription Update ", a new hotfix for XE7 is available on CodeCentral. As you can guess from the name, we planned to release it a couple of weeks ago (well, they say October is part of Indian Summer in California). Anyway, the idea is to use a "season" name, rather than a number, to make it is easier to refer to different fixes released over a longer time period.
It is important to notice that this hotfix is available only for Update Subscription customers. This is part of the new model introduced by the company since earlier this year and you can read more about at www.embarcadero.com/products/rad-studio/update-subscription.
What is the rationale of this approach? Many of our customers told us that even if they are on Update Subscription they don't plan migrating all developers, and even less all existing projects, to the latest release, which is why offering fixes for some of the most critical bugs in older releases is relevant. Notice we don't plan to update target operating systems support in older releases, although some exceptions might happen. If you need to target the latest operating systems, particularly the mobile ones, staying current with RAD Studio will be an advantage.
However, if you have projects based on XE7, this hotfix can help with a few quite core issues, mostly in the RTL. The list of actual fixes (a dozen, all customer reported issues either on QP or QC), along with the download -- a whopping 670MB, please ignore the "Download 0 bytes reference" -- is available at:
We are currently working on fixes for XE6 (very similar to the XE7 set) and XE8 (mostly focusing on regressions already fixed in 10 Seattle). This work is done as part of the new Update Subscription model promise to offer fixes for past versions for up to 2 years, which is a significant change from the past approach.
A new version of OS X was release yesterday, and we have provided a fix to PAServer for 10 Seattle to offer full support for El Capitan.
The downlaod is at cc.embarcadero.com/item/30398 and is offers also some improvements in iOS 9 support (you can now use the latest SDK to target older versions of iOS). Read more on Sarina's blog at community.embarcadero.com/blogs/entry/paserver-hotfix-for-rad-studio-10-seattle-ios-9-and-os-x-el-capitan.
For iOS 9 support you can also read community.embarcadero.com/blogs/entry/how-to-use-custom-info-plist-xml-to-support-ios-9-s-new-app-transport-security-feature and (if you are not using 10 Seattle) community.embarcadero.com/blogs/entry/workaround-steps-for-building-ios-32-bit-applications-for-ios-9-with-xe7-and-xe8.
Using the Microsoft Astoria Bridge (currently in beta) for Windows 10 phone (also in beta) you can run Delphi FireMonkey applications on a Lumia phone. This is certainly great news for the Delphi (and C++Builder) developers who want to target the Windows phone platform (beside the Android and iOS ones) with a single source code. Here are some of the steps, information, links to get you started.A Windows 10 Phone
First of all you need a Microsoft phone (Lumia) capable of running the Windows 10 insider preview. Not many phones satisfy this requirement (and there are further restriction for the Astoria bridge). I bought a cheap (80 Eur/90 USD) Lumia 435 phone. Basic, but good enough for some tests.
Once you have the phone, and installed a ton of useless updates (I found no way to cancel them, and having to replace the operating system wan't really much interested). Anyway, I was already signed up for the Windows 10 Insider preview and so I got to windows.microsoft.com/en-us/windows/preview-download-phone and installed on my phone the "preview app", which in turns can update the operating system. Took a while, but it was a very smooth process. Here is the phone with Windows 10 preview:
Get The Astoria Bridge
The second step is to sign up for the Astoria bridge, get approved by Microsoft (time might vary, but it is not immediate -- from few days to a few weeks, form past experience). The entry page for the bridge is at: dev.windows.com/en-us/bridges/android. Once you get approved, you'll be able to see all of the information. In short, you'll have to open the Android SDK manager, download some additional tools and Java interfaces from an external source, and install the wconnect utility from Microsoft. This can be configured as a bridge between Android adb command and the actual phone, so that the phone is seem by Android as an actual device -- and responds to any command as expected. Once the "adb/wconnect" bridge is configured (took me less than 10 minutes) the device will show up in the RAD Studio IDE:
Ready to Go
At this point you are ready to go. Take an existing FireMonkey application or build a new one, and just target the phone. At start up, the application have a little delay (there is some validation and API mapping taking place), but at runtime they seems to respond without any lag. Not everything works, as this is really a beta bridge, and some of the device sensors seem to be ignored. The only app I could not start is one with advertising, not a surprise.
Here are a few apps I installed and one actually running on the device:
Over the next few weeks (or months), as the Astoria bridge and the Windows 10 Phone OS emerge from beta and become more stable, we plan doing more testing and fully "certifying" the platform as one we support, providing eventual suggestions for migration, and possibly supporting specific Microsoft APIs. But the fact you can run Delphi and C++Builder Android applications almost unchanged on a Windows Phone, beside the other mobile platforms, is certainly a very good news. Single source compiled apps for iOS, Android, and now even Windows Phone is really a unique capability RAD Studio brings to developers.
Also, the applications that use the Astoria bridge are first class UWP (Universal Windows Platform) apps, so it should be possible to distribute and sell them via the Windows App Store. Stay tuned for more information, and let us know if you experience any obstacle (or any success) using the Astoria bridge.
There is only one more day to take advantage of the current offers for Delphi 10 Seattle, C++Builder 10 Seattle, and RAD Studio 10 Seattle.
Current offers include introductory 10% discount, upgrade from any older version, and BOGO (buy one, get one free), plus the free Bonus pack. All of the details are at:
Act now, offers are expiring tomorrow, September 30th. Upgrade to a great version of Delphi and C++Builder (see what customers are saying) while these great prices are available... and don't forget to add Update Subscription to your order, to receive updates, support, future releases, and access to special content.
I was looking into Quality Portal customer reports for the RAD Studio Project (RSP) and noticed that with Delphi and C++Builder 10 Seattle we closed many customer reported bugs, including most of the top voted. This is part of a continuos push for improved quality, performance, and stability that is part of our ongoing development effort. While the flow between the internal and the public bug system will be further improved (with easier categories and more options; and also making sure all internally closed bugs are matched in the public system), it is nice to see that transition to Quality Portal is helping us move in the right direction.
Below is a image with a snapshot (because data will change over time) of the bugs in the system with 15 or more votes, filtered by date (only bugs reported before RAD Studio 10 Seattle was released). You can see the Jira query at the top. There are 17 issues in this group, most of them are closed... and those closed as duplicates refer to a similar report that has been closed (so the issue has indeed been handled).
Of course, large memory address support has been part of the effort in closing the most voted one and a few more. What is still open? The "Smart ARC" (9946) is clearly a feature request, and so are the changes to project sort order (11311), inconsistency of projects sort order (11308), and run icons (9367). Two of the issues (9679 and 10417) have been partially addressed, but the issues are remaining open as we don't think work is complete. IDE high-DPI awareness (9678) is a top priority at this point, along with further work in the VCL in the same area. The other bug is the FMX 3D issue.
The much higher rate of fixes in the most voted bugs, along with the high number of overall bugs closed in 10 Seattle (including 331 user reported bugs, as you can see in the list at edn.embarcadero.com/article/44561), is a good sign or the product direction and I really hope it is appreciated.
I'll be presenting the keynote at the Delphi Tage event next Saturday in Fuerth, near Nuernberg. The Delphi Tage is a very large gathering of German Delphi developers, organized by user groups with the help of the local Embarcadero office. I've been to half of dozen of these events in the past few years, and they've always been great. The speakers are very knowledgeable and include international guests and third party vendors. The only drawback is that many sessions are in German.
For all information visit www.delphitage.de/ and don't forget to join for the Friday evening community dinner (and beer). See you there.C++ Events
Over the following week, I'll be back to Germany for two C++ focused events, in Hannover and Stuttgart. I'll be joined by C++ experts to cover all of the new C++ 11 language features and a general overview of C++Builder. More information at forms.embarcadero.com/EM15Q3DACHCBuilderSeminar.EKON
Finally, I'll go back to Germany for EKON 19, entwickler-konferenz.de/2015/en , a more international conference with sessions both in German and in English, in early November in Koln (or Cologne). Several speakers coming from the US, many well known German and European speakers, and lot of time for networking. This is one of the longest running Delphi-related events, this year in its 19th edition.
I'll be avaialble for a chat at any of these events, for a meeting with your team, or anything else. Can also bring printed copies of my latest Object Pascal book, if you want one signed -- but let me know in advance.
Here are 3 different news about components for Delphi, all very recent.RAD Solution Pack
This is a brand new collection of existing and popular components sold by Embarcadero. It is an easy to way have components covering the most relevant areas (grids, reports, charting, and more) in a single package. While some of the components are owned and produced by Embarcadero, many others come from third parties like Steema, Woll2Woll, and FastReport. Even if you don't need everything in the package, the single RAD Solution Pack provides significant saving compared to buying individual ones. And you get a higher traffic license of AppAnalytics and other features included as a bonus.
Notice that the price you can find on the store, or by asking sales and partners, does automatically include 1 year update subscription, covering new releases of the components (with new features) and updates of the components for new versions of Delphi and RAD Studio. Also, most components can be used both with 10 Seattle and with previous releases.
Information at www.embarcadero.com/products/rad-solution-packTorry's Delphi Page
The very popular Torry's Delphi components portal, one of the early sites for the products, has changed owner, with the new company behind it (Yamaco Software, from the Czech republic) moving to new servers and working on different improvements. Great to know this site has found a new home, after Maxim decided to step out (although he's still currently involved). More information in the announcement on the "old" Embarcadero forum (which got a new database and became much more stable recently, by the way): https://forums.embarcadero.com/thread.jspa?threadID=117553. Thanks again to Maxim for all of these years of support and to Yamaco Software for taking over the work.JCL and JVCL on GetIt
Finally, just a short notice about the availability of both JCL and JVCL (some pretty large and popular open source components collections, of JEDI fame) on the GetIt package manager for both XE8 and 10 Seattle. GetIt is rounding up some of the best and most popular open source components. And makes installing and updating these components a nicer experience. More information at community.embarcadero.com/blogs/entry/jedi-libraries-now-in-getit-package-manager.
Stay tuned for more component announcements by Embarcadero, the great third party vendors who partner with us ,and our lively open source community.
I've pushed a very large update of the demos coming with my latest book, Object Pascal Handbook, there are now 116 demos in the repository. Some of the demos use VCL, and while the ultimate goal was to migrate everything to FireMonkey, that would have taken too much time.
Direct browsing of the code repository is possible at code.marcocantu.com/trac/marcocantu_objectpascalhandbook/browser while the SVN link for working on the repository is code.marcocantu.com/svn_public/marcocantu_objectpascalhandbook/. If you already did a checkout, update the repository and you'll get almost twice as many demos!
The book is available in electronic format to any registered user of XE8 and 10 Seattle, and in print on CreateSpace, Amazon (US and European outlets), and other online book retailers.
Another round of blogs posts, articles and information mostly focused on the just released Delphi 10 Seattle.General Feedback on 10 Seattle
What developers are saying... community.embarcadero.com/write-blog-post/entry/delphi-c-builder-rad-studio-10-seattle-what-developers-are-saying (from David I)
Nick's latest installment:Blog Posts on 10 Seattle Features
Luis writes about per-monitor DPI awareness for VCL applications in the new release, including a nice video of the changes when you move a form between monitors and comparison with the reference Microsoft demo: community.embarcadero.com/blogs/entry/new-per-dpi-awareness-in-vcl-applications. Very relevant feature for VCL developers, and nice blog post.
In a different blog post Luis covers using Android services (a feature now supported directly from the IDE, with no need to low level work) to download an image in the background, even while the app has been stopped. iOS has a similar feature we support, but it not exactly the same underlying model. Read the article and get the code at community.embarcadero.com/blogs/entry/download-an-image-in-background-with-android-services
If you are interested in RAD Studio MongoDB support, make sure you check docs.mongodb.org/manual/tutorial/install-mongodb-on-windows/. Installing the server takes very little time, if you know where to find the right information. You can also see the MongoDB snippet of the launch video at https://www.youtube.com/watch?v=J01gerMDANA&list=PLwUPJvR9mZHgRPPsXQs9CSd-yoXRZsG5L&index=23.
Sarina blogged about new FMX component styling options in the new release at community.embarcadero.com/blogs/entry/creating-a-custom-button-style-with-rad-studio-10-seattle. Sho also covered customizing TMultiView for Windows 10 at community.embarcadero.com/blogs/entry/using-tmultiview-in-your-windows-10-firemonkey-applicationsA Hotfix and a Hackfix
There is a rather simple hotfix available, an update to the DUnitX source code that was shipped in RAD Studio 10 Seattle, Delphi 10 Seattle, and C++ Builder 10 Seattle. Download for all registered users at cc.embarcadero.com/Item/30368
There is also an unofficial fix (more of a temporary stop gap or hack) if you need to use 125% or bigger font scaling in Windows 10 and see IDE tabbed dialogs with very large fonts. A full solution is being finalized and will be made available with an update, but for now you can lessen the problem by getting this temporary "imperfect" fix: cc.embarcadero.com/Item/30367 (and thanks to the author).More 10 Seattle Events Coming
You can tune in next Saturday for a very long and in-depth deep-dive webinar, coordinated by David I. See community.embarcadero.com/blogs/entry/rad-studio-10-seattle-deep-dive-saturday-sept-19-9am-to-2pm-pdt for more information. This webinar will go way beyond the shorter launch webinar. Highly recommended. I'll have some contributions.
The following Saturday, instead, I'll be giving a keynote at the German Delphi Tage www.delphitage.de/ in Fuerth. And I won't miss the beer the previous night. Lots of great speakers from Germany and other countries to this classic community event.
This will be my second live keynote, after the event in Manchester last week.
A new release of RAD Studio, Delphi, and C++Builder, called "10 Seattle" is available since Monday, and you are probably already aware of the news. If not head to:
to learn about the new great features, from the 2x IDE memory to the incredible Windows 10 support, from the new Android services to the MongoDB FireDAC integration... and much much more, as you can see even in more technical details at docwiki.embarcadero.com/RADStudio/Seattle/en/What%27s_New.A Few More Links
I think it is still worth pointing out to a few additional links and resources:
Eweek article introducing the product: www.eweek.com/developer/embarcadero-rad-studio-10-seattle-targets-windows-10.html
The Register article focused on C++Builder's new Win32 compiler: www.theregister.co.uk/2015/09/01/borland_c_now_legacy_as_embarcadero_releases_delphi_and_c_builder_10/
The team fixed 331 user reported bugs in 10 Seattle (274 from Quality Portal, 57 form the old Quality Central). See the list at edn.embarcadero.com/article/44561. It is likely the number is much higher, as many of the out-of-memory related issues are still open, pending feedback from the original submitters. We'll look forward to re-test and close a few more.Launch Webinar
Launch webinar taking place later today (and tomorrow, for Australia and Asia/Pacific time zones). Looks like we'll have a great crowd, but there is still room to register at forms.embarcadero.com/RADFirstLookWebinar-2015-09-02 . I'll be there presenting RAD Studio 10 Seattle with the other two product managers, Sarina and Luis. The idea is to introduce all of the main new features, as a technical and detailed coverage could take many hours. There will be plenty of demos, though.
If all goes smoothly, the webinar in itself will be just slightly over one hour, with live Q&A following it.
The yearly RAD Studio developers survey is closing in 2 days. If you can find the time to participate, we'd appreciate. And here are a couple of tidbits from it.
But first of all (and before you continue reading) if you haven't already done so, take the survey at www.surveymonkey.com/r/FGCCYNY . We know it is time long and time consuming and really appreciate your input. If you don't have the time, we understand.
Now, if you have taken the survey and had the patience to go to the end, you might have noticed a fun, trivia question asking for your favorite RAD Studio variable or type name. These are the answers so far:
- Global variable ReportMemoryLeaksOnShutdown is winning with 41% of the votes
- The exception type EProgrammerNotFound is close second with 37% of the votes
I'm really disappointed that the enumerated values Elf, Dwarf, and Wizard in TDeviceClass got less than 8%. I like those and the way they are documented in the help file.More seriously, we generally don't share survey data but there are a couple of (temporary) results worth mentioning, considering these are not absolute facts but depend on those who responded, of course, who are mostly "active" customers even if often using versions released years ago)
- FireDAC is now the most used database access library
- Microsoft SQL server and Mongo DB are the preferred relational and NoSQL databases
- Parallel programming library is the favorite RTL extensions done in recent years
Overall, we had a good response rate, but, again, we'd appreciate having even more. And a few extra votes for the elves ;-)