So far I’ve written a couple of posts about information gleaned from the XDC keynote address last week. One session that revealed some additional information was Joe Ranieri’s Compiler session.
Joe started off by talking about what’s happened to the compiler in the past year. The list is pretty impressive since that includes iOS (32 bit AND 64 bit), 64 bit for Mac, Windows, and Linux, as well as adding the new framework, and adding better compiler error messages.
He spent some time explaining why the Using and Global keywords came about and how they are used. It’s interesting that you can mix and match the two frameworks and how that might be desirable.
Iterators were next up in the presentation. Iterators allow our classes to be used with For Each loops and Joe said that iterators are generally more efficient than alternate approaches. Two interfaces are available Xojo.Core.Iterator and Xojo.Core.Iterable. A good example of the new interfaces are in the Xojo.Core.Dictionary class.
The new Text datatype is the attempt to solve the String datatype deficiencies. Strings could be text or a bucket of bytes which led to issues with encoding. Text is always a valid textual representation and is a series of Unicode code points (a way to think of this is an array of characters that might be ASCII or a valid Unicode character- either way you, the developer, don’t need to care). When converting to Text you always give it the Encoding you want so it’s never in question. One nice feature of Text is that you can convert to and from a String with no penalty.
The New Auto datatype is the replacement for Variant. Auto’s perform NO conversion of data which led to sometimes subtle issues with Variant as it would gladly convert from datatype to datatype regardless if it made sense or not. Auto will only do conversions that the compiler would (such as doubles and integers) but raise exceptions when it comes across something it can’t do (like strings to integer and visa versa). Auto preserves type information exactly so you can use Introspection to determine the type.
New for 2015 R3 is more 64 bit targets. This includes GUI projects on Windows and Mac OS X, console and web projects on Linux, Windows, and Mac OS X. Porting, for most of us, should be straightforward. However, there are a number of problems we’ll face. Among them are Declares, Integer size assumptions, and Plugins.
A new 64 bit aware plugin SDK is due out soon and Christian Schmitz from Monkeybread was showing off his plugins running in 64 bit apps with no issues (it’s my understanding it was NOT using the new SDK so I’m sure he’s got some work to). The new SDK is entirely C based and the overloaded C++ functions are going away. Most of the long deprecated functions are doing away too.
Declares will be a problem, though. Of particular note is the Windows Functionality Suite. It won’t work in 64 bit and you’ll have to find replacements for those things you use. Mac OS Lib is in better shape but needs some updating too.
Structures need to be updated for 64 bit apps to. The default structure alignment of 1 means it puts each field right after each other and this is wrong for 64 bit apps. If you use the structure alignment of 0 it will align the structure ‘naturally’ which matches was C does. I’ll be honest, this was interesting news but way above my pay grade in understanding. Talk to Joe if you have questions on the implications of this change.
Also new in R3 is customizable array sorting. Currently we can do this using SortWith but now we’ll be able to pass in a delegate. Joe really seemed pleased about this addition but I think the implications won’t be immediately noticed by the community. I for one don’t remember the last time I had to sort an array since we generally load arrays sorted in the order we want later. You might find this useful.
Joe wrapped up his talk with some roadmap items. For R3 the IDE debugger is still 32 bit. Obviously it needs to be 64 bit and that will happen. The better compiler error messages initiative will continue as well as Xojo-specific compiler optimizations.
Perhaps the biggest bombshell that came out of the roadmap portion was exception line number information! This means that we should be able to get information on which line of code caused the exception. I believe at this point several people clapped as determining which line of cause caused an exception can be difficult to determine.
I followed up with Joe after the session and while it’s not finalized, here are the plans. The compiler will spit out two files on the build. The first is the application and the second debug information. When an exception is called there will be a binary blob that can be saved and sent to the developer. There will be a tool included with the IDE that takes that blob and can show you the original line of code that caused the issue. AND it will show you the stack like the debugger does now. It will not have any variable or argument information.
Regardless, this is a feature that people have been requesting for years. This should lead to better error reporting and hopefully better programs!
The compiler session was the only Xojo led session, that I attended, that had any sort of roadmap information presented (with the exception of the Keynote). It was informative and was a wealth of information. This session gets a five start review (except for the purple code against the black background – sorry Joe).
See anything that gives you hope? Anything makes you want to mope?