Are You Still Using Real Studio?

Xojo has been out for about a year and half now.  Based on comments in the forums and on this blog I’ve come to the conclusion that a fair number of people are still using Real Studio.

For some it might be the Navigator.  For some it might be supporting older operating systems that Xojo doesn’t support.  I am curious on what your reasons are for sticking with Real Studio and not going with Xojo.

Thanks for the comments!


I ran across an issue with Xojo.Core.Date that I talked about on the forums

The issue is that the new Date class does not have SQLDateTime.  Well, technically it does with a generic ToText function.  However, there is no way to get just the SQLDate portion without having to write your own method.

The ToText method has a LOT of power to do and it is considerably more powerful than the old Date class.  The ability to work with Locale is very cool and should simplify some things.  However, I have some issues with the ‘replacement’ for SQLDateTime.

First, SQLDateTime is very explicit in what it does.  ToText (with no parameters) doesn’t tell me jack and the fact that I missed it in the documentation tells me the name absolutely 100% fails the ‘name explicitly tells you what it does’ test.

Second, there’s no option to just get the Date in SQL format.  Sure, you can create your own method to get that but that’s one more thing to create, test, and maintain.  There are times when you need just the SQLdate portion.  It doesn’t matter why we need it – we need it.

The new Date class is full of wonderful things.  However, removing functionality that many of us use every day should be avoided.  I think this is one of those times where the Xojo engineers got too clever in the new framework.  I’d much rather have the SQLDateTime and SQLDate methods back.  They are much more explicit than ToText.  If you agree, you can sign on to <feedback://showreport?report_id=37521>

Of course, like with the Numeric.FromText methods, I’m willing to be convinced that the Date.ToText method to get SQLDateTime is better.  What say you?



Later I realized that we could accomplish everything by adding the SQL option to the DateFormat and Locale enumerations.  Then the code would be something like this:

dim d as Xojo.Core.Date = Xojo.Core.Date.Now

dim t as text = d.ToText(Locale.None, Date.FormatStyles.SQL, Date.FormatStyles.SQL)

That would solve all of the issues, no?  They get to keep ToText and we get the ability to format the date in whatever form we want.  Then there is no ToText without Parameters.

New Navigator Preferences in Xojo 2014 R3

Without reigniting some of the flamewars of the past I think we can all agree that the Xojo Navigator is less superior to Real Studio in some ways. The old Real Studio IDE project list and method list showed you a lot more information at a glance without having to dive into the details. With all of the attention on iOS in release 3 I forgot to mention two new preferences for the Navigator that might make life easier for some.

Under the General Tab in Preferences there are two new checkboxes that affect how the Navigator shows some information. The first is the Default Values checkbox. This option changes how Properties and Constants are displayed.Xojo Preferences

Don’t Show Default Values:Don't Show DefaultShow Default Values:

Show Default Values

The other option is the Show Types in navigator checkbox. That option allows you to see the Property and Constant data types in the Navigator.

Don’t Show Types in Navigator:Show NothingShow Types in Navigator:Show Types
While certainly useful, it does make the the Navigator more cluttered, in my opinion. Cluttered makes things harder/more complex so I’m on the fence if this is a good option or not. I think what would be far more useful is to show the Super and Interface(s) of objects in the Navigator like how Real Studio did. What it did was put that information in separate columns so you could resize them as needed. In Xojo you have to hover the mouse over the object to get a help tag of the super and interfaces, or you look into the Inspector for the Super and go into a stupid dialog to get the list of Interfaces.

Real Studio:

Real Studio

Xojo Help Tag
My beef with the Navigator hasn’t really changed much since the initial version. It shows me too little information when I want more, and too much when I don’t. There are times when I’m okay with the Navigator but to work with it on a regular basis I find myself right clicking on objects to open it in a new tab – which is what Real Studio did. If the goal was to reduce ‘tab management’ Xojo is an abject failure in how I work.

I’ve been using Xojo on an every day basis since the new IDE was still in alpha so I don’t think it’s just a matter of ‘getting used to it’.  It has clearly affected how I manage my projects and there are still significant bugs, a year and a half later, that still affect us.  Yes, the list of bugs if getting whittled down but it’s obvious, to me at least, that the Navigator is an incredibly complex piece of code and starting with complexity is never a good start for a project.

Let’s hope that with iOS finally out the door, Cocoa working well, LLVM and 64 bit seemingly ‘close’ after several years worth of work some time can be spent on the IDE interface, the Windows framework, and some other long standing issues that drives us Xojo developers insane.

What do you think?  What’s on your wish list for the new year?

iOS For Xojo Notes #1

After doing about five hours of training video for iOS for Xojo I’ve discovered a few things.  First, the new framework will take some getting used to.  It’s not that it’s difficult to figure out, it’s just different.  Each little difference requires that I analyze what it’s doing and evaluate if I need to change my coding practices.

We’ve already talked about one of those differences with the FromText methods.  In the old framework using string.val does a lot of assumptions (not all of them good ones as we’ve come to find out) and those assumptions will either result in a valid number or a zero.  Blank strings also convert to a zero as well.

We’ve all been used to those assumptions for so long that we didn’t even realize the assumptions.  Or we ignored them.  Either way, we depended upon them.  The new framework uses much more stringent rules and if the text is outside of those rules it will throw an exception.

We can argue all day long whether it’s really an exception but that’s an argument for a different day.  Xojo has decided that errors shall not be silent (am I the only one that just said in a Gandolf voice, “Thou shall not pass (errors)!”?).  Errors causing excpetions will change the way we code and I’m still not entirely sure that I’m comfortable with those changes yet.  I’m sure it’s really a matter of getting used to them.

The other thing I’ve discovered is that events on iOS controls are different than their desktop and web counterparts.  In desktop and web if you set the value of a control it fires their relevant change events.  In iOS it does not.

In desktop and web apps we’ve actually relied upon this behavior.  Rightly or wrongly, it was there so we did.  This also meant, however, that we’ve had to somehow make a distinction of whether or not the user or the developer set the value (and caused the event).  Usually it was a matter of setting the control enabled = false while loading the data and then setting enabled = true when we were done.

Since iOS does not have this behavior I suspect we’ll start putting less code in the events of controls and instead use a method that does the work.  This is probably a good thing.  Being dependent upon the events to do something will make us better programmers in the long run (hopefully).  It’s not really a huge change but it’s a somewhat important one given the background Xojo developers have in desktop and web.

At first I thought this might be a bug but after cornering a Xojo engineer this was by design.  I can live this change now that I’m aware of it.  Do you have different thoughts on this?

What significant changes have you found in iOS that were a surprise?

Xojo 2014 Release 3.1

Xojo 2014 Release 3.1 hit the internet today. This release is a minor maintenance release and is recommended for everyone.

Web received a number of fixes. Checkboxes now work properly on touch devices. Label offsets are calculated correctly when the initial text is an empty string. Labels that had been on a container that had been set invisible in the IDE and visible via code now appear properly.

It’s a shame that these bugs made it into release.  Beta testers were so enamored with iOS that desktop and web didn’t get much attention.  But then again I was using the beta’s for production web apps and didn’t spot these bugs either so my bad too.  They’re kind of obscure in how to set them up and I generally don’t do either of those.  Hopefully with 2015 R1 we’ll get some better testing for targets other than iOS.

iOS received a few critical fixes. The first is that SQLSelect and SQLExecute now work properly (it was randomizing the data). The second fixed soft declares.

If you have not played around with the iOS SQLiteDatabase class the SQLExecute and SQLSelect methods now have built in prepared statements so there’s no need to through the steps of creating the prepared statement and then binding the values.

The IDE received a few minor bug fixes.  So did the compiler.

I reported a bug with the new Xojo.Core.Timer.CallLater in Windows yesterday. It generates an exception in a compiled application but in the debugger it generates an exception in the IDE! Too weird to be anything bug true. :)

I am looking forward to 2015 (seems weird to be typing that) Release 1. It looks like iOS builds will be 64 bit in that release. That means that Xojo is creating 64 bit builds for standard and debug builds in the iOS Simulator (Intel) and, at a minimum, standard builds for device deployments (ARM).

Presumably, this means that the IDE can already understand 64 bit debugger instructions, right? Is 64 bit for other targets far behind? Let’s hope not!

We already know the fiasco over the FromText methods in the new framework are being addressed in 2015 R1. In addition to FromText Xojo will offer a much less stringent Parse method that should satisfy most developers.

Any bugs that you’ve seen in Release 3? Anything you’re really looking forward to in the next release?

New Xojo Framework Thoughts

I don’t think application development is very hard. It is however complex and this, I think more than anything else, makes it appear hard because people equate complexity with being hard. Xojo does a pretty good job of making things less complex for us and I honestly truly appreciate that.

The new framework that we’re really seeing for the first time in iOS has some good things in it. Database errors throw an exception. I like that that because that’s what we (BKeeney Software) does with our own SQLSelect and SQLExecute extends methods (name SQLSelectRaiseOnError and SQLExecuteRaiseOnError). Not everything I agree with though.

In the existing framework we would do something like this to get the integer value of the aTextField.

dim i as integer

i = TextField1.text.val

We’ve been using this for close to 15 years. Works great. Now, in the new framework we have to use different converters and use code like this:

dim i as integer

i = Integer.FromText( TextField1.Text)

Seems pretty straightforward, no? Well, no, because in their infinite wisdom, if there is no text (i.e. a blank string) an “InvalidArgumentException” is thrown. WTF?!

Instead, you will have to do this instead.

Dim i As Integer

If Not TextField1.Text.Empty Then
   i = Integer.FromText(TextField1.Text)
End If

But even then, if there text there that can’t be converted to an integer it throws the exception. I sort of agree with that change.  But, I don’t see this change as being ‘better’ or even simpler. If anything it’s more complex and it’s getting away from the strengths of BASIC that made many us use it over other languages in the first place.

So really what you’ll need to do is something like this:

Dim i As Integer

   If Not TextField1.Text.Empty Then
      i = Integer.FromText(TextField1.Text)
   End If
catch e as InvalidArgumentException
   i = 0 //if that’s what you really want.

You really want to do that several thousand times in a big accounting application?  When I suggested that I’ll just create my own extends methods to match current functionality the response was “Not doing so is a great opportunity for silently doing something really wrong.” Well, I guess at that point it’s MY problem, no?  If something goes wrong, and I did my own method, it really *is* my problem.  Or are the Xojo Programming Police going to take away my license?

Xojo is trying to make a complex process idiot proof. I appreciate the effort, I really do, because Lord know I can be an idiot at time. All they did, in my opinion, was make this simple process more complex. I think they may hinder adoption of the new framework. My guess, though, is that they’ll force it down our throats for console, desktop, and web when the time comes.

What do you think, my friends? Is the new framework helping us or hurting us or is this just a “this is different so I hate it” reaction?

iOS Development on Xojo

Xojo 2014 Release 3 was a big one for Xojo.  R3 allows the average person to create iOS applications in Xojo, in a RAD language, in an easy to use IDE.  I think most people will find developing iOS apps easy in Xojo.

The iOS applications that Xojo creates uses native controls.  This is huge because when iOS 9 comes around and Apple changes the native controls (because you know they will) Xojo iOS applications will most likely just work.  Some other iOS development environments use images for their controls which means they will have to update their tool set to work with the updated look.

For a first release, Xojo for iOS is pretty solid but it is definitely lacking in some areas.  Some of the controls are not fleshed out completely.  An example is the table.  What it does, it does well, but it is lacking in options that many developers will want.  Views aren’t scrollable yet and there are no UI pickers yet.  There is a Date and Time picker example that was done via declares but it’s not built-in to the control palette yet.

Another area that I’m sure the community will rally around is converting the iOS frameworks over to Xojo.  There is a similar project on the Mac OS side called MacOSLib and I’m sure some of the same developers will be active on both (they share some similar libraries after all).

Currently Xojo allows you to debug your application while it’s running in the iOS Simulator.  It would be awesome if Xojo could get it working so that we could debug while it’s running on the device.  Given the provisioning profile and the ability to manually add apps to the iOS device this might be possible but, to be honest, I don’t know what the sandboxing rules would be for that.  I also don’t know if that means Xojo developers in Window or Linux could deploy directly to the device or not (don’t hold your breath on this one, by the way, but one can always wish).

I am impressed with iOS in the first release.  Xojo has managed to take something that’s complex and made it easier.  If you already have some Xojo experience the transition will be a piece of cake (although there are framework differences between iOS and Desktop/Console/Web).  I think anyone with iOS development aspirations should take a look at Xojo.

We’ve been busy doing training videos!  We currently have over 4 1/2 hours (and growing) of iOS specific training videos available to subscribers over at  Come check it out!

[Update] I forgot to mention that the first couple of iOS apps developed with Xojo mad it through the approval process on Thursday.  Excellent news!

Xojo 2014 Release 3

Xojo 2014 Release 3 hit the public today.  It is, without a doubt, the most ambitious release we’ve seen in quite a while.  This release brings the much anticipated iOS target and while it’s a first release it seems pretty solid.  There are new licensing and pricing options and a new framework that is ambitious in scope and has long-term implications to all developers.  And, as with every Xojo release, there are bug fixes, changes, and additions to the IDE and all of the targets.  So let’s dig in!

New Licensing and Pricing

Xojo has changed the pricing structure to make it simpler.  Purchasing Xojo has moved to a single purchase price and upgrade pricing is gone.  The single-platform desktop license is $99 a year.  Console is $149, Desktop (with all 3 platforms) is $299, Web is $299, iOS is $299, the Pro license is $699, and Enterprise is $1999.    A new Pro license iOS but existing Pro licenses will have to be upgraded to get iOS.

Licenses are set to auto renew every 12 months.  You can turn this off in your Account settings page.  I can see this as a convenience and also a bummer for some folks.  The licenses, for some, are pricey enough that you probably want to turn off the automatic update.  For those corporate accounts it’s probably not a big deal.  I’m sure this will generate some controversy.

My opinion (since you asked):  When Xojo announced iOS they never promised that it would be in the Pro license.  With the amount of work they put into it, and that it’s essentially a new SKU, I would expect the Pro license to be more expensive.

Am I happy with the no upgrade pricing?  I’m ambivalent, at best.  Yes, it costs more for me, but it’s a lower cost for people new to Xojo.  More potential customers means more demand for my products and services.  I think the goal for Xojo is to grow as much as they can so hire more engineers and do ambitious things.  For us, we’re kind of a captive audience since we use Xojo for 99% of our business so for me it’s the price of business.  Frankly, coming from the VB world we were used to paying tens of thousands of dollars a year to stay current so the relatively minor price increase doesn’t phase us much.

iOS Target

R3 is the first release for iOS.  This is a huge undertaking and represents the culmination of many man years of work.  iOS is a completely different beast.  It required a completely new compiler (LLVM), new editors, new frameworks, and new ways of doing things.  I must give the engineers at Xojo major kudos for getting it done (yeah, I wanted it last year too but some things just take time).  As a first release, Xojo iOS is pretty solid.

Xojo has always been about hiding the ugly implementation details from users and iOS is a great example of that.  If you’ve done any iOS development you know that Apple really likes the MVC (model – view – controller) pattern.  Xojo does not necessarily fit that pattern (though it can).  So for the engineers to have it ‘just work’ like we we’re used to in console, desktop, and web applications is impressive.

Xojo for iOS uses the iOS Simulator that comes with Xcode so your are required to installed Xcode 6.1 and agree to its licensing terms to pretty much do anything.  After that when you run an iOS application in the debugger it creates a package that can run in the iOS Simulator, loads it, and starts it in the simulator.  For Xojo developers this is not a huge departure from what we already do (though the cycle time in the debug cycle is longer).

To deploy on your own device you have to join the Apple iOS Developer Program ($99/year) so you can create a Provision Profile and install the app via Xcode.  Joining the program also allows you to submit your app to the App Store for sale.  During the beta process several developers submitted apps to the app store but I’ve not heard if they have been approved yet (not that this was recommended during the beta process by Xojo, by the way).

Developing for iOS will require some new thinking for existing Xojo developers.  You’ll have to figure out the relationship between the application object, screens, and views – especially how screens and views interact given that screens can have single views, tabbed views, and split views and each of those content views are independent (one of the videos I added to our training library today goes into this).  Developing for iOS also uses the new framework so some things are different.

Screen Shot 2014-12-09 at 10.07.16 AMThe new framework has a namespace that might be confusing for a while.  For example, a timer is really Xojo.Core.Timer.  In the shared build settings if the Simple References is set to true, you can reference a timer as Timer and it can figure it out on its own that it’s using the new framework (mainly because that’s the only one it can use).  There is a new Using keyword that lets you choose which framework to use in a module or even in a method.  Another example of how the Simple References is convenient is RandomInt is really part of the Xojo.Math framework but with Simple References on you can simply use RandomInt rather than the full Xojo.Math.RandomInt.

Another thing that’s new for iOS is Auto Layout.  In the View Editor we no longer have the Top/Left/Right/Bottom lock properties.  It’s been replaced with Auto Layout and it can be confusing to use.  I promise you that it gets easier with use.  Auto Layout is not perfect in this release as it seems rather finicky.  I have no doubt it will improve with time.

Screen Shot 2014-12-09 at 10.07.35 AMPerhaps that hardest part of Auto Layout is coding the position of the controls since you can’t just say control.left = 10.  You have to add or change the Constraint of the control.  To understand the complexity of this, take a look at the UI in the Inspector.  Now translate that into code.   To say that this is going to take some adjustment by everyone is to be an understatement.  But, in the long run this will make complex UI easier and eventually it will be coming to the web and desktop targets.

For a first release, iOS is pretty solid.  To say that it’s 100% complete would be an incorrect.  There are a number of things missing in the first release that might make life hard for a while.  There are no built-in Date/Time pickers though you can add them via declares (there is an example of this in the iOS examples folder).  There is no picker control (the equivalent of popup menus) and there is no scrollable view yet.  No camera support.  No Location support, There is also not a Style Editor that allows you create an overall look and feel of your application though you can certainly set Fonts, colors, sizes, etc. via the Inspector and code.

Overall there is a lack of depth in supporting libraries.  During the beta process users figured out the declares to get the Date/Time pickers working via declares as well as several other useful things (check out the iOS declare examples that ship with Xojo).  I’m sure the community will come together to fill the needs we come up with and I expect the iOSLib project be birthed soon (if it’s not already in the works).  Check the iOS forum for news on this if and when it appears.

The New Framework

iOS requires the new framework, but you can start using the new, non-iOS, framework in the console, desktop, and web applications.  You are not required to use it in R3 or even in the near future.  I’ve heard that the existing framework will be around for a minimum of five years (forever in computer terms) so there’s no imperative to start using it this instant.

The new framework is very cool, though, because it adds some much desired consistency to the framework.  You’ll never have to remember if an index is 1 based or 0 based.  Everything is zero based.  Method and property names try to be explicit in what they do, and, in general, the new framework helps eliminate common mistakes in code.  One example of this is the Date class and with the current framework it’s often used incorrectly which leads to code that fails subtly (I know because I’ve  been the victim of this).  The new Xojo.Core.Date class is very explicit how it’s used and eliminates the most common mistakes.

There are two major data type changes to the new framework.  The first is the Text data type.  Really, it’s still just a string to us, but it makes a distinction about encodings and characters.  No longer is it byte-based but a character is now a ‘user-perceived character’.  This means that a user-perceived character in Japanese is one character but it’s multiple bytes in length and the various string methods will be able to work properly with them (there are no byte string operations now).

The major implication of this change is that sockets that used to bring things back as a string now bring things back in a MemoryBlock and you’ll have to extract the data from it.  This one change eliminates various issues that many people have had over the years with string data that has no encoding information and being able to decode the data properly.

The other major data type is the new Auto type.  This is the replacement for Variants.  Variants have always been weird because they implicitly convert data from one type to another.  This led to some subtle data errors (think double to integer and back again) that were hard to find.  The new Auto does zero implicit conversions.  It’s up to you to figure out what’s in the Auto variable (using Introspection this is pretty easy) and then you have to covert it yourself.  If you stick an integer into an Auto variable it will come out as an integer and if you want to convert it you’ll have to do it on your own.

Before you freak out about the Auto data type I spent 30 minutes coming up with my own Auto extends module that did a number of things.  First, it checked to see what was in the variable so if I wanted to convert it to an Integer I’d check to see if it already was an integer.  If it was the conversion is easy.  If it’s not, I then used the various conversion routines to convert it to an integer.  Example, if the Auto variable is set to “Bob”, the type check will come back as Text.  Then I can assign the integer value using the Integer.FromText shared method that’s in the Integer datatype.

So will this cause some heartache?  Yes, yes it will.  Will it cause a lot?  Nope.  Our ActiveRecord classes used a bunch of variants to hold data of any type.  I spent maybe 30 minutes converting it over to use Auto and Text and another 30 minutes or so testing.  The more complex your classes the more complex this conversion but I don’t expect it to be as awful as you think it is.

As a reminder, I did say that you don’t have to start using the framework immediately.  I highly recommend that you start working with it because I think you’ll find some gems that you’ll want to start using.  The drawback, of course, is that your code will not be backwards compatible with older versions of Xojo.

Web Apps

WebLabels had some work done on them to improve IE 9+ compatibility.  Unfortunately, this may have caused some other issues with WebLabels in dynamically embedded WebContainers.  Look in the forums for a temporary fix if you have this problem.

Web apps on Windows can now use Windows Service events.

Web apps now have a HandleURL event for handling any request that would normally results in a 404 Not Found error.  This should allow you to use almost any URL within your web app for whatever purpose you want.

Miscellaneous Stuff

The R3 compiler is now much pickier about some things.  Properties and structures that are defined in multiple modules will get flagged as being duplicates.  In one of my projects I found that I had two global db as SQLiteDatabase variables.  How did the compiler know which one to use and could some odd user bug reports point to this type of bug?  I don’t know but I’m glad the compiler is smart enough to figure this out now.  Users of MacOSLib will want to update to the latest version since it is a major offender of this particular issue.

The IDE has a slew of changes.  Obviously the addition of iOS is the biggest change but a lot of cleanup in the editors and Inspector has occurred.

The debugger received some love this release too.  No longer do you have to have over variables to get them to refresh.  Variants now display and behave the same as the data stored in them.

Yosemite is now fully supported in the IDE and in compiled applications.

Be aware of a possible behavior change if you use HTTPSocket or HTTPSecureSocket.  It no longer strips off user specified content-length or content-type headers if no post content was specified.

The desktop hierarchical listbox has two new methods.  The RowDepth returns the nesting level of a row.  The RowIsFolder allows the user to get or set the ‘folder’ status.

The SSLSocket class now has TLS v1.1 and v1.2 support.  This means that HTTPSecureSocket, Pop3SecureSocket, and SMTPSecureSocket support it as well.

The Currency data type received some love and should be more accurate in both Xojo and in XojoScript.


As always, check the release notes to see the complete list.  This release has more than normal list of new and changed things.

The addition of iOS is a huge deal.  For a first release it’s pretty solid and I expect that will generate some interest in the product.  The new framework is both exciting and frightening at the same time because it introduces some uncertainty of when to start converting over to it.  But, as I said earlier, you don’t have to start now and it’s advisable to start looking at it and become familiar with it.

What excites you?  What concerns you?  Anything big that I didn’t cover?

[Update] Change ‘upgrade’ to ‘renewal’.  You can upgrade from a lessor license to a better one still but the 50% off renewal pricing has been discontinued.

Change is the Only Constant

No one likes change.  I know I don’t.  It introduces an unknown element and unknown equates to scary.

Back in college (granted, this was decades ago) the language dejour was Pascal and C was an upper level CS course (being an electrical engineering student I never had to take it).  Visual Basic wasn’t heard of and Xojo wasn’t even a wet dream yet.  Since then C++, C#, Java, Javascript and a myriad of other languages have come.  And some have gone too.  Then came the frameworks that made life much easier because no longer did we have to reinvent the wheel on every project.  The only constant in software development is change.

Xojo has been around for over fifteen years.  I think anyone that’s been using the product for any length of time can say it is not a static product.  It supported 68k Mac’s back in the day, then PPC Mac, then Universal Mac apps, then Carbon, and now Cocoa.  For Windows there’s been a bit more stability but things have changed from Windows XP to Windows 8.  Linux, well, it seems that there’s a new Linux distribution every month that are slightly different from each other.

Xojo introduced the ability to create web apps that ran on Mac, Windows, and Linux and introduced a new framework for the controls and for web specific things.  Overall, however, the web framework was exactly the same as the standard framework even when it didn’t make much sense (e.g. web controls having drag events when there’s no way they’d work like the desktop version).

And now Xojo is working on an iOS version (due out soon) which uses an entirely new framework.  iOS is a completely new beast.  It most definitely is not a Mac, Windows, or Linux desktop or console app.  When you think about it, making web apps is really just a console app so it wasn’t a big stretch since Xojo has been doing console apps for a while.

iOS is very different.  It uses a completely different processor which requires new system calls.  Heck, there are no ‘windows’ but has ‘views’ that are sort of, kind of, like windows.  The metaphors between mobile and desktop (and web) are completely different.

For 15 years the Xojo framework has had a lot of new stuff bolted on.  Different Xojo developers did different things but for the most part it’s just worked.  It was wildly inconsistent and every developer, like myself, that has spent a lot of time working with the language still has trouble remembering which framework calls used zero or a one index.  Names weren’t always consistent and some things were simply harder than they needed to be.

So Xojo is making a new framework that eliminates the confusion.  All indexes are zero based – no exceptions.  Methods and properties are consistently named so (theoretically, at least) if you are using an object you’ve never used before you should be able to make reasonable guess at what the method you want is.  Obviously, there will be exceptions to this rule but the goal is to make it easier on us developers in the long run.

In the long run…That’s that key phrase.  What we’re finding out is that it’s generating a bunch of concern amongst Xojo developers.  I get it.  Change is hard and it’s scary.  But it’s not that bad.

Here are the facts:

1.  The existing framework isn’t going away.  It will be around for many years (if not forever).  Xojo has said the existing framework will be 64bit and will be released sometime in 2015.

2.  The new framework is only required with iOS.  There are zero Xojo iOS customers right now.  All desktop, console, and web applications, are okay and need zero modifications in Release 3 to work.  NO CHANGES REQUIRED!

3.  You will be able to intermingle the new and old framework.  Xojo has introduced a Using keyword that allows you to use both at the same time.

Xojo isn’t forcing you to use the new framework in Release 3.  Your apps will still compile and work just like they used to (the compiler does find new types of bugs so don’t be surprised if you have to fix a few things).

Should you start looking at the new framework?  Absolutely!  Should you start converting code over to the new framework soon?  Well, I would hold off a release since the new framework is still in some flux (I think).

Porting code to the new framework isn’t all that difficult.  Is it work?  Yes – especially if you have extensive code libraries that are shared between console, desktop, web, and iOS.  Co-mingling new and old frameworks will be painful for a while but the nice thing is that the new framework (that parts that exist, at least) will work on all platforms in Xojo 2014 Release 3 and beyond.

The new framework is different.  You might have to looking at every line of code.  I personally won’t do this with existing code but certainly all new code will probably use the new framework.  It is the future and I hate coding things twice.  The biggest problem is legacy code and that the new framework is not backwards compatible.  As a 3rd party controls and library developer this has the potential to mess up development for a while.

The new framework is coming and it’s not all that scary – really.  iOS users will bear the brunt of the changes, at first, but everyone can start using it now and I encourage you to start looking at it.

Styled HTML Field 2.0.10

picAppIconWe updated Styled HTML Field today to version 2.0.10.  The StyledHTMLField is a set of classes for Xojo that allow you to export HTML from StyledText in a native TextArea control.  The classes also allow you to create HTML emails.

This maintenance release has the following changes:

  • Added ConnectionType for secure connections with ability to choose SSL2, SSL23, SSL3, TLSv1 and TLSv11, TLSV12 for R3 when it’s released.
  • Added Paragraph Alignment to the demo application
  • Removed PWEmbedImageSMTP. Now uses TCPSecureSocket but secure set to false for non-secure connections.
  • Fixed deprecated items with current Xojo replacements.
  • Fixed items found in project check
  • Fixed old BKeeney URL’s in the demo app

Demo, pricing, downloads, and other details at