Real Software

Hello from Paul Lefebvre

2012-02-01T14:48:00.000-06:00

Hello fellow Real Studio developers! My name is Paul Lefebvre and I am the newest member of the Real Software team, taking on the role of Developer Evangelist.

In this position I will be responsible for many things that relate to educating prospective and existing customers about the best ways to get the most out of Real Studio. In particular, I will be focusing on documentation, tutorials, example projects, webinars, blogging, training and social web coverage.

I've been using Real Studio for over 10 years and have been programming professionally for nearly 20 years using other tools such as PowerBuilder, C#, VB.NET and Java.

I am extremely excited to be joining the Real Software team!

I love hearing from fellow Real Studio developers, so if you have any suggestions on how I can help you make better use of Real Studio, send me an email: paul@realsoftware.com

Debugger 101

2012-01-30T07:30:00.000-06:00

There are a lot of users that don't realize that Real Studio has a debugger- and it's very easy to use!

Let's say that you want to track down a bug in your code and you know that the problem occurs when you push the Show Me button on a window. In your project you would go to the action event of the Show Me button and set a breakpoint next to one of the lines of code as shown below by the red dot (click on the hash mark to set the breakpoint):

Then, to debug the code:

1. Press the Run button

2. Enter any necessary values into the UI

3. Press the Show Me button

You will see debugger pane on the right (this shows the result after pressing the Step button several times):

That's all there is to it. Using the debugger you will have a much easier time locating and fixing problems in your code. For more details on how to use the Real Studio debugger visit "Debugging Your Code" in our Documentation Wiki.

Leveling the playing field

2012-01-24T07:23:00.000-06:00

Anyone reading this blog knows that one of the most valuable features of Real Studio is its ability to create cross-platform applications. So it goes without saying that the more level the desktop OS playing field is, the more important cross-platform becomes. As the Mac market share has increased, we get more and more Windows developers coming to Real Studio because their customers want them to support the Mac.

Last week, research firm Gartner released a report on PC shipments for the fourth quarter of 2011. It showed that while all the major Windows PC makers saw a drop in market share, the market share for the Mac increased substantially. And this week, the Wall Street Journal reported that big companies like GE are allowing employees to choose the Mac as the computer they will use at work.

As the market share for the Mac increases, the OS playing field becomes more level and that's great for cross-platform software. It's good news for those of you that create cross-platform, commercial software with Real Studio and it's great for us. In the ideal world, the market share for the three major desktop OSs would be split evenly. But anything that makes it more even is a good thing.

Is it time to redesign?

2012-01-20T09:18:00.000-06:00

A huge part of what makes any application intuitive is its interface. If it's well thought out, a user interface can make the difference between an app that is fun and easy to use and one that makes water boarding seem like a nice alternative. If the developer has taken the time to make sure the interface is not only self-consistent but consistent with other applications that provide similar functionality (when appropriate), it can add beauty to an application.

User interfaces don't age like fine wine. If an application's user interface is not updated from time to time, it's going to start making the app look old and out-dated. Additionally, if the application has a lot of features, its developers are likely to have learned quite a bit over the years about how people use the app. It's important to continually advance the usability of an application, this improves the productivity of its users and, in the case of commercial software, keeps the app competitive.

In some cases, incremental improvements can be made to a user interface. But sometimes the entire user interface needs to be redesigned. If you could do it over again, would you create the same user interface you have today? Though it may be a lot of work up front, a much improved user interface should be seriously considered throughout an application's life. Real Studio has gone through several user interface changes since version 1 and we are working on another big one right now.

Let's take a look at how the Real Studio user interface has evolved. Real Studio was first released on July 4, 1998 as REALbasic. The original release of Real Studio back in 1998, looked like this:

REALbasic 1.0

When Mac OS X was released, we updated the user interface to have an appropriate, native look and feel:

REALbasic 5.5 for Mac OS X

And when we brought it to Windows, we took care to make sure the UI felt native:

REALbasic 5.5 for Windows

Over the years we began to recognize that there were areas where we could really improve the user interface. One of the downsides to the original interface was that a user could easily end up with a lot of windows open. At the time, browsers also suffered from this same problem and to solve it the idea of using tabs to separate documents rather than windows was adopted. We also recognized that users spend a lot of their time navigating their projects, so anything to make navigation easier would be helpful. Lastly, we decided we should be eating our own dog food. The IDE was written in C++ and it really should be written in Real Studio itself. So in 2004 we began redesigning the user interface, rewriting in it Realbasic, to solve these and other problems. In mid-2005 we introduced the current Real Studio user interface:

Real Studio 2011

This current interface uses a single window rather than multiple windows. This makes it easier for the user to concentrate on the item they are editing, rather than spending time rearranging and scanning through windows that are layered on top of each other. This concept started on Windows and Linux but has been adopted more and more by Mac OS X applications as well.

The user interface you see above has served Real Studio users well for the past six years. In that time, however, we have learned a lot about how people use and learn to use Real Studio and we have taken note as interfaces have changed in the last six years. As a result, we are applying all of this to a significant redesign of Real Studio's user interface. Our goals are a cleaner user interface, easier navigation, better interactivity, a more intuitive user interface and a more modern look and feel. I'll be more specific about these goals for Real Studio:

Cleaner user interface - Every piece of text, control, line, and icon you present in a window is something the user believes they have to understand to use the product. Determining which items are infrequently used and removing them (possibly moving them to menus if they still do provide a needed function) can help make the interface cleaner. For example, the current user interface relies too much on text.
Easier to navigate - Real Studio users spend a lot of time moving from one part of a project to another. While the tabs help, they can also get in the way. The user has to constantly return to the project tab and double-click on a project item which then opens in its own tab. All of these tabs start to take up a lot of room in the tab bar and before long the user is spending time closing tabs to make room for new tabs! Search results only add to this issue because double-clicking on result opens another tab. And while there's one way to navigate a project, there's a different way to navigate the code for the project. All of these ways of navigating present opportunities for improvement.
Better interactivity - A project can be filled with many different project items that need to interact with each other. The current user interface does not make this as easy as it could be. For example, to create a custom canvas subclass and use it on a window requires as many as six steps:

Click Add Class in the Project Editor.
Change the Super property of the new class to Canvas.
Write your code.
Switch to the Window Editor.
Choose Project Controls from the Controls Selector popupmenu above the Controls list in the Window Editor.
Drag your custom canvas subclass to the window.

That's a lot of steps. It's also not easy for a new user to figure out these steps. Making basic tasks like this more simple and intuitive helps create better interactivity. And this not only makes it easier for a new user to learn; it makes the experienced user more productive.

More intuitive - An intuitive interface is one where the user can use the software, for the most part, without consulting the documentation. The key is to think of all the different ways users will try to use the software and anticipate them. The more often a user is successful when attempting a task, the more intuitive the software is. In the current version of Real Studio, there is usually only one way to do a particular task. In the new user interface, we are adding more ways to accomplish tasks to create a more intuitive design for more users.
Modern look and feel - Modern user interfaces are using higher resolution graphics, shadows, textures, animation and more. We are using many of these elements in the new user interface to modernize the look and feel.

It's been 2 years since we first began designing and implementing a greatly improved user interface to reach these goals. Because Real Studio has many editors, this has been an enormous task but we are very pleased with the results and I'm sure you will be too.

Some people just don't like change and any significant change to a user interface will result in some of the existing users balking at these changes. There's just no getting around that. Though most of our users really appreciated the changes in the 2005 user interface refresh, there were a small number of users that just hated it. Apple changed the direction of gesture for scrolling in Mac OS X Lion; though it seemed like a huge change at first, it quickly became more intuitive to users. Technology moves fast and user interfaces need to keep pace. People will adjust quickly to well-thought-out changes and designers have to consider what the best user interface will be for the application moving forward.

iOS Meta Tags

2012-01-19T13:08:00.001-06:00

Over the last few months, there have been several requests for the ability to override the tags that are used for determining how a website scales on iOS devices. Before Real Studio 2011r4, you were locked into using our defaults.

Viewport

The default tag looks like this:

<meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0">

This says:
1. The page width should be the same as the device width
2. Users are NOT allowed to pinch or zoom the page to change the scale
3. The initial scale is 100%
4. The minimum scale is 100%
5. The maximum scale is 100%

While this works out great for web applications (most of the time anyway), it's not so hot for other uses.

Take our Orders example – the minimum width of the main screen is 1012. Not so much a constraint of the browser, but of the content on the page. When viewed on an iPad in portrait mode, you have to slide the page left and right to access all of the elements. To accommodate this, you can now override this tag with your own by simply adding a replacement in App.HTMLHeader. For the Orders example, the code looks like this:

This tag tells the browser that the width of the content is 1012 and not to restrict page scale. In doing so, the page will scale to fit the device. Note: Using this dimension does not work for smaller devices like the iPhone. With a smaller screen, it tries to fit the content into 320px (portrait mode) or 480px (landscape mode), which means the content will be drawn at ¼ or ⅓ of the original size, respectively.

Web App Capable

On iOS devices, when looking at a web page in Safari, you can add the current page to your Home screen where it will get an icon and be available directly with a single touch. Our defaults make it so Safari does not display the URL and Search fields, nor the Safari toolbar across the bottom of the page. The result is that there is a greater amount of vertical space for your application to run.

If you want to turn off this capability, thereby making your application always work more like a website, you can add a line to App.HTMLHeader:

<meta name="apple-mobile-web-app-capable" content="no">

Web App Icons

By default, we compose your application icon for you so that it fits nicely within a white rounded rectangle background. While this is the style that Apple recommends for icons, you have very little control of how big your icon will be. Moreover, as Apple has started offering devices with higher resolution screens, they've suggested different resolutions for different devices.

You can override the default icon by adding a line like this:

<link rel="apple-touch-icon-precomposed" href="touch-icon-iphone.png">

if you want iOS to add the nice "shine" effect to your icon, leave out "precomposed" like this:

<link rel="apple-touch-icon" href="touch-icon-iphone.png">

For more information on the options for configuring Web Applications for iOS, see Apple's Safari Web Content PDF.

Remember: setting these values affects every page that is loaded. If you set the width to 1024, every page will render as if it needs 1024 pixels to appear properly. If your page is only 320 pixels wide it will only take up ⅓ of the device width, regardless of the resolution.

What got you interested in programming?

2011-12-20T13:19:00.000-06:00

When I was a kid, I would race home after school to watch M*A*S*H reruns on TV. One of my older brothers watched Star Trek reruns so I would sit through Star Trek waiting for M*A*S*H to start. It didn't take long before I became a Star Trek fan. Star Trek provided me with a view of the future. In that future all things were better. No one was poor, getting around was easy and just about any sickness seemed curable all in a 60 minute episode. Computers were an important element in Star Trek so for me, they became a way to touch the future.

I grew up near the University of California at Irvine. I would ride my bike there and hang out in the computer science lab. I bought punch cards, put them in a punch card machine and typed on them. I had no idea how to write programming code. I just mimicked what I saw others doing. I was probably 13 at the time and why no one chased me out of there still surprises me to this day.

My father spent his career as an electrical engineer mostly creating communications equipment for the military. One day he brought home a Texas Instruments portable terminal. It had no screen, just acoustic couplers that held the telephone handset for communication with the VAX mainframe at his work. A thermal printer was the only output device and of course when we would run out of the special thermal paper, that was a problem. My dad taught me to program in the original BASIC and we played the original text adventure game (called "Adventure") as well.

When the Apple II came along I wanted one but being in high school at the time, I certainly couldn't afford it. My dad was unwilling to pay extra for the Apple brand so instead purchased a Franklin ACE 1000, which was an Apple II Clone. The Franklin's motherboard failed several times, and I'll bet my dad ended up paying far more for it than he would have paid for an Apple II to begin with! He bought me a book that taught Applesoft BASIC and 6502 assembler. One look at the pages about assembler and I knew right away that I was going to stick with BASIC.

Programming for me became a terrific outlet where I could create anything I could imagine. That's what got me interested in programming.

What got you interested in programming? Share your story.

How to create a Dylib on Mac OS X and create declares in Realbasic to use it.

2011-12-12T09:00:00.000-06:00

This tutorial explains how to use Xcode to create a dylib, and then use Realbasic to declare into it. Dylib is short for Dynamic Library, which is a file that contains code that can be linked against at runtime. This means that it isn't built directly into your application, like a static library is, but you can still load it up and call methods in it.

This is mainly useful for C/C++ or Objective-C programmers to create a library that may do something not possible from Realbasic.

Creating the dylib

Launch Xcode
This tutorial assumes that you are using Xcode 3.1.4 from Apple.
Choose "File->New Project", or type Command-Shift-N.
Select BSD Dynamic Library, and click "Choose".
Choose a project name. For this example, we'll call it "SampleDylib".
Choose "File->New File..."
Choose "C File", from within the "Mac OS" section
Name the file. For this example, we'll call it "SampleDylib.c". The default settings are generally correct, but if you have multiple projects open with multiple targets, make sure the proper project and target is selected. When done, click "Finish".
Open the SampleDylib.c source file.

Add the code below:

#include <string.h>

int addFunction( int a, int b ) {
 return a + b;
}

int stringLength( char *str ) {
 return strlen(str);
}

Save the file, then click the Build button, or press Command-B.
If there were build errors, ensure that the code you entered looks exactly like it does above. Once the build is successful, continue to step 12.
Find where the build was saved. If the builds folder location hasn't been changed, it will be located in a "build" folder, next to your project file. It will be named libSampleDylib.dylib. (This is bceuase we've not altered the default install name in the build target.)
Another way to locate the file is to locate the target by going to the project window, expanding libSampleDylib, then expanding Products. Select libSampleDylib.dylib, and control-click (or right-click, for those with two-button mice), and choose Reveal in Finder
You will need to access this location later.

Creating the Realbasic project

Launch Real Studio. Create a new project, and choose "Desktop"
Save the project to your Documents folder (so that it is next to the dylib file). For this example, we'll name it, "Test Dylib.rb"
Double click on "App" in the project window.
Expand the "Events" section, and select "Open"

Add the code below:

CONST dylibLocation = "@executable_path/../Frameworks/libSampleDylib.dylib"

Declare Function addFunction lib dylibLocation (a as integer, b as Integer) as Integer
Declare Function stringLength lib dylibLocation (s as CString) as Integer

msgBox "5 + 2 = " + str(AddFunction(5,2))

msgBox "The length of ""asdf"" is " + str(stringLength("asdf"))

Run your application using the "Run Paused" feature of the IDE.
Copy the dylib from the Xcode build into the application bundle. You can do this by right clicking on the debug app & selecting "Show Package Contents".
Navigate to Contents > Mac OS & copy the dynamic library created by Xcode into the Frameworks directory in the bundle. (If the edition of Real Studio you use supports this you could use a Build Automation Step to do this for you on every compile)
Now launch the debug application by double clicking it in the Finder. It should then connect to the debugger in the IDE.
Notice that it correctly adds, and also correctly computes the length of the string.

What is it doing?

The loader (aka Dynamic Linker) doesn't search for a dynamic library very well. It relies on either having a full path to the library, or having it relative to the executable path. Since we want the dylib to be installed in the bundle, we use "@executable_path/../Frameworks/libSampleDylib.dylib" as the path for non-debug builds. This means that when you build your application you will need to copy the SampleDylib.dylib file into your Contents/Frameworks directory next to your actual executable file.
However, since the application is regenerated every time Realbasic builds it, the same path won't work for debug builds. (Suggestions about how to deal with this are included later)

What about the native types in Realbasic?

Using Realbasic, you can do almost anything through declares. Here are a few tips on how to handle different types in Realbasic:

Passing a float into your dylib, or returning a float: In Realbasic, use "Single" as the data type. Singles are the exact same as a float -- a single precision floating point, to be specific.

Passing a double into your dylib, or returning a double: Doubles are the exact same in both languages.

Passing a c-string (null-terminated string) into your dylib: In Realbasic, declare the type for the parameter as CString.

Passing a pascal-string (one byte length specifier) into your dylib: In Realbasic declare the type for the parameter as PString.

Passing a void* (arbitrary data) into your dylib, or returning it: In Realbasic, declare the type for the parameter as Ptr, and pass in a MemoryBlock. Also declare the return type as Ptr, and it will automatically be converted to a MemoryBlock on return.

Passing a pointer to a struct into your dylib: The same as above. Set up the memoryblock to contain the different fields, and pass it in as a Ptr.

Limitation: It isn't currently possible to pass in a struct inline.

Known issues

By default all symbols (functions & subroutines in C) are exported. This is usually what you want.
If you happen to preface one with the C keyword "static" then it won't be exported & so it will not be usable directly in Real Studio code like we've shown.
If you name your file with a ".cpp" extension then Xcode assumes that it is a C++ file & names will get mangled by the Xcode compiler. This means they would not be directly usable in Real Studio.
You will need to preface them with an "extern "C"" declaration to make sure the names get exported unmangled.

Because Real Studio recompiles your application every time you run it under the debugger you can't use the same path for the dylib while debugging as you can in the final build. You can deal with this by using an absolute path to the dylib when debugging. In my case this would be:

CONST dylibLocation = "/Users/npalardy/Documents/libSampleDylib.dylib"

Another way to deal with this is to put the dylib next to the application bundle where Real Studio builds the application (right next to the project file on OS X). Then you can use a relative path like:

CONST dylibLocation = "@executable_path/../../../libSampleDylib.dylib"

And you could make the code in your Real Studio project look like:

#if debugBuild
   CONST dylibLocation = "@executable_path/../../../libSampleDylib.dylib" // next to the app bundle
#else
   CONST dylibLocation = "@executable_path/../Frameworks/libSampleDylib.dylib" // inside the app frameworks in the bundle
#endif

Declare Function addFunction lib dylibLocation (a as integer, b as Integer) as Integer
Declare Function stringLength lib dylibLocation (s as CString) as Integer

Document Updated by:Norman Palardy norman@realsoftware.com

Real Software, Inc.
based on a previous article by Jonathan Johnson
Real Software, Inc.

Search Engine Indexing of Web Edition Apps

2011-12-09T09:22:00.001-06:00

We've been getting some questions about how the search engines treat Web Edition apps and what, if anything, you can do about it.

First of all, it's worth noting that most search engine "bots" do not support Javascript. This means that neither the Web Edition framework nor the initial WebPage of your app will ever be delivered. You can't even use a Javascript command to redirect to another page.

In fact, there are some good arguments for why you wouldn't want a search engine to index your application content. Think of a membership list, or a company calendar or an email client. Having that content indexed by a search engine could be catastrophic, and probably part of the reason that most search engines don't index dynamic content like that, unless specifically told to do so.

We're investigating ways to make this a little easier to do, but there is something you can do about this now... META Tags. There are two HTML header tags that you can add that help a search engine to figure out what your site/app is all about. They are:

Description: A brief description of that your page or product is about. It is not uncommon for search engines to display this text as is when showing a listing for your page.
Keywords: A list of key words and phrases under which a search engine should index your page.

To use these tags, add code that looks like this to the app.HTMLHeader property in the IDE:

How much is too much?

2011-12-07T11:38:00.001-06:00

This week, Microsoft provided more information about the app marketplace being built into Windows 8. They are doing some things differently than Apple which is a good because healthy competition is always a good thing for consumers.

In one of the videos, Microsoft Web Services VP Antoine Leblond says that prices for apps can be between $1.49 and $999.99. He went on to say that "a thousand bucks is too much for an app." Who exactly is he to say how much is too much for an app? Microsoft's store currently sells two editions of Visual Studio for over $1000 each. Will these not be offered in the app marketplace?

The price a developer charges for their product should not be dictated by any online store. That's a decision the developer should make.

Static Variables in Web Edition

2011-12-07T10:00:00.000-06:00

Static variables can be a valuable thing, but there is a downside that you should be aware of when using them in Web Edition.

The Real Studio documentation for Static says:

"A variable declared with the Static statement and assigned a value retains its value from one invocation of the method to the next." (Click Here)

Static variables persist across subclasses as well, so if you have a method in a class that uses a Static variable, all of the subclasses will share that variable's value.

So what's so special about Real Studio Web Edition? Well, each end-user session is technically a subclass of the individual Webpages and other items you created in the IDE. Using Static variables may have unintended results.

For example: If you use a variable as Static in the WebPage1.Resized() event like this:

Event Resized()
//Initialize the Static Variables
Static LastWidth as Integer = Self.Width
Static LastHeight as Integer = Self.Height

//Show a message if the window got smaller
If Self.Width < LastWidth and Self.Height < LastHeight then
MsgBox "The browser window just got smaller!"
End If

//Update the Static Variables
LastWidth = Self.Width
LastHeight = Self.Height
End Event

This will work fine as long as there's only one Session (like if you're testing in debug mode). Once there's more than one, they will all share the LastWidth and LastHeight properties and every time a one user's browser window is resized, LastWidth and LastHeight will be updated for all connected users.

Here's what happens: If User1 makes their browser smaller and gets the MsgBox and then User2 makes their browser window smaller they will only get the MsgBox if the window is smaller than that of User1. Whichever user resized last, the dimensions of their browser is what is left in LastWidth and LastHeight.

While this could lead to a hard to track down bug, imagine what would happen if you used a Static variable for a Password!

To avoid this problem, you should use properties of the class you are using (in this case WebPage1.LastWidth) or as a property of the Session itself.

When writing code for Web Edition, always remember that all of the Sessions are technically running the same exact program. Properties on Modules and the App class, Shared Class Properties and Static Variables will all be available to all Sessions.

Linux & Cairo

2011-12-06T10:00:00.001-06:00

In Real Studio 2011 Release 4 we upgraded our Graphics drawing on Linux to use Cairo instead of the antiquated GDK drawing system. For those unfamiliar with Linux, Cairo is akin to GDI+ on Windows, or CoreGraphics on OS X.

The main benefits to switching to Cairo include: smoother drawing because of anti-aliasing, translucency support and hardware accelerated drawing. See figure below for a comparison of Cairo drawing (top) and GDK drawing (bottom)

Another important reason for switching to Cairo is because 2011 Release 4 introduces alpha channel support for Pictures. This would have been excruciatingly painful to do in GDK (and GDI on Windows for that matter), so the upgrade to Cairo was a necessity.

An additional gain from this upgrade is improved printing support on Linux. Although we resolved the issue with only being able to print at 72 DPI in a previous release, the fact that we created an offscreen picture and scaled the text was a show stopper for many. Now that our printing API uses Cairo and our Graphics drawing is also using Cairo, this transitory picture we had to keep around before is essentially out of the picture now, pardon the pun.

The demise of HyperCard

2011-12-02T08:48:00.001-06:00

John Gruber, the blogger behind Daring Fireball, has a podcast called The Talk Show. Right at the end of this week's episode, he and his co-host Dan Benjamin discussed the demise of HyperCard.

If you're not a Mac user or are too young to remember it, let me give you a little background. HyperCard was a simple development tool provided with the Mac prior to Mac OS X. It had a drag and drop interface builder and a simple programming language similar to AppleScript. I saw the appeal of an English-like programming language but also quickly discovered the concept's Achilles' heal. In English, you can say the same thing many different ways. In HyperTalk (the programming language of HyperCard) there was usually just one way to write the code for a particular function. AppleScript suffers from this same problem which can make it quite frustrating at times. One of our engineers once called AppleScript "a read-only language" which is a great description. It's easy to read AppleScript code, but very frustrating to write. HyperCard also suffered in that it did not support color and could not be used to build standalone applications. If you sent a HyperCard file (called a "stack") to another person, they needed to have HyperCard installed to run it.

Despite these limitations, there was an attractive simplicity to HyperCard.

So, despite its simplicity and popularity why did HyperCard die? On the show, the hosts suggested that Steve Jobs killed it. One of the things that Jobs did when he returned to Apple was simplify. He very correctly and intuitively understood that Apple needed to focus on a smaller number of projects if they were going to produce great stuff. Also, one of the features of NeXT that Jobs was most proud of was its advanced (at the time) visual development tools and object-oriented language. He believed (correctly as it turned out) that object-oriented programming was the future. So if you consider how important Jobs felt it was to focus and how he felt about the development tools brought to Apple with the acquisition of NeXT, it's easy to see how Jobs would feel that two development tools was one too many.

But I think the real reason is far simpler. Bill Atkinson was the main developer behind HyperCard. He left Apple in 1990. Without Atkinson pushing HyperCard, it was quickly abandoned inside of Apple. There were probably few who knew the code or who had anything like the passion that Atkinson had for it. As a result, updates were released with decreasing frequency and in 2004 Apple finally killed it.

In their podcast, John Gruber and Dan Benjamin discussed what development tools exist today that fill HyperCard's void. I was quite happy to hear John mention Realbasic. It won't shock you to hear that I think Realbasic/Real Studio fills this gap nicely. One of the big problems John felt HyperCard had was that it couldn't build stand alone apps. Even if it could, Hypercard didn't use native controls so the apps would not have felt like true, native applications. Real Studio of course builds native apps and uses over 40 native interface controls.

It has always been my vision for Real Studio to be an easy-to-learn and easy-to-use development tool that is powerful enough to build almost any kind of app while supporting all the important platforms. The only platform Real Studio is missing at this point is mobile and that's something we are working towards. It's just never made sense to me that a developer should have to learn lots of different languages and development tools to build different types of applications.

HyperCard was one of the first visual, integrated development tools. That was a significant innovation. While HyperCard and Real Studio are very different in many ways, they have the same goal: to make programming accessible. I think that Real Studio has done a good job of taking over where HyperCard left off.

Embossing Effects On-The-Fly

2011-11-30T11:00:00.008-06:00

Embossing is an effect used to give an object the appearance of being sunk into or raised above a background. They are very easy to create in Photoshop, but today I'm going to show you how you can start with nothing but a shape and build the effect in code. This has the advantage of allowing you to adjust the effect on-they-fly based on parameters you choose.

We've done exactly this in our new IDE. In fact, I've been given permission to show a very small glimpse of the tray area of our new layout editor. The same object in our current IDE is on the left, the new version is on the right.

That version on the right is produced in code, starting only with an 8-bit mask to describe the shape:

The embossing effect is created using 3 layers. The bottom layer is the drop shadow, the middle layer is the fill, and the top layer is the inner shadow. I created this simple animation to demonstrate how the individual layers build together to create the effect:

Now, let's get to some actual code. First, you need an image to use as the shape. This image should have no color, only shades of grey. The background can be either white or translucent. We first need to create a method used to draw this shape at any color. For simplicity's sake, we'll call this method IconAtColor:

Private Function IconAtColor(Icon As Picture, Fill As Color) As Picture
  Dim P As New Picture(Icon.Width,Icon.Height,32)
  P.Graphics.ForeColor = Fill
  P.Graphics.FillRect(0,0,P.Width,P.Height)
  P.Mask.Graphics.ClearRect(0,0,P.Width,P.Height)
  P.Mask.Graphics.DrawPicture(Icon,0,0)
  Return P
End Function

Next, the actual embossing. We'll start with the bottom layer, the drop shadow. In our effect, the drop shadow will be used to create a bottom-edge highlight. So we're going to create a picture and fill its contents with white. Purists will argue that a new picture starts white, and they'd be right, but I like to be explicit. By filling it with white, there is no doubt you have a white picture. Next, we're going to clear the mask. A mask defaults to filled black, but we want the opposite, so a simple ClearRect call will handle that. Into the mask, we're going to draw the icon twice. First, we're going to draw the icon using some shade of grey between black (opaque) and white (transparent). This creates the opacity of the shadow. In the example code, we're going to use 75% white (25% opaque, &cBFBFBF). The shadow must be drawn 1 pixel from the top. Then we draw the icon a second time at 100% white (&cFFFFFF) at 0 pixels from the top. This "cuts" the shadow away from where we will actually fill. We do this because the fill may be translucent, and we don't want the shadow to show through. Here's the code to what we just did:

Dim DropShadow As New Picture(Icon.Width,Icon.Height,32)
DropShadow.Graphics.ForeColor = &cFFFFFF
DropShadow.Graphics.FillRect(0,0,DropShadow.Width,DropShadow.Height)
DropShadow.Mask.Graphics.ClearRect(0,0,DropShadow.Width,DropShadow.Height)
DropShadow.Mask.Graphics.DrawPicture(Self.IconAtColor(Icon,&cBFBFBF),0,1)
DropShadow.Mask.Graphics.DrawPicture(Self.IconAtColor(Icon,&cFFFFFF),0,0)

Now we're going to create the fill layer. Because we want the fill to darken the background, we're going to fill a new picture with black, and once again, clear the mask. Then all we have to do is draw the icon into the mask, again at some color between black and white to describe the opacity. In our example, the fill will be 50% opaque (&c7F7F7F):

Dim Fill As New Picture(Icon.Width,Icon.Height,32)
Fill.Graphics.ForeColor = &c000000
Fill.Graphics.FillRect(0,0,Fill.Width,Fill.Height)
Fill.Mask.Graphics.ClearRect(0,0,Fill.Width,Fill.Height)
Fill.Mask.Graphics.DrawPicture(Self.IconAtColor(Icon,&c7F7F7F),0,0)

And of course, the final layer is the inner shadow. Like the fill, we want this layer to darken, so we fill a new picture with black, and like the other two layers, we clear the mask. Like the drop shadow, we need to draw the icon twice. Once for the opacity, and once to "cut" the shape away. In this example, the shadow is 75% opaque (&c7F7F7F). This time, the first drawing should be 0 pixels from the top, and the second drawing should be 1 pixel from the top.

Dim InnerShadow As New Picture(Icon.Width,Icon.Height,32)
InnerShadow.Graphics.ForeColor = &c000000
InnerShadow.Graphics.FillRect(0,0,InnerShadow.Width,InnerShadow.Height)
InnerShadow.Mask.Graphics.ClearRect(0,0,InnerShadow.Width,InnerShadow.Height)
InnerShadow.Mask.Graphics.DrawPicture(Self.IconAtColor(Icon,&c3F3F3F),0,0)
InnerShadow.Mask.Graphics.DrawPicture(Self.IconAtColor(Icon,&cFFFFFF),0,1)

And there we have it, the three layers needed to create the effect. Draw them all directly on top of each other, starting with the drop shadow, then the fill, and finishing with the inner shadow. You can adjust some of the numbers, such as the distances from the top to draw the icon on the drop shadow and inner shadow layers, and choose different colors to create different opacities. Your fill color does not need to be black. You can reverse the inner and drop shadows to create a raised effect. Experiment with this code to achieve new effects.

A sample project can be downloaded here which includes the artwork and code ready to run.

More than an Introduction to Programming

2011-11-15T10:11:00.001-06:00

Last week Peter Wayner wrote a nice piece in the New York Times titled "Programming for Children, Minus the Cryptic Syntax". Anything that gets kids interested in programming is a good thing and the article discusses a few software products designed specifically to teach kids programing logic in a fun and intuitive way.

Real Studio would have a made a great addition to this list. Though most of the software tools Wayner mentions are great for introducing programming to kids, they can't realistically be used for much more than that. On the other hand, Real Studio can be used to introduce programming to kids without limiting what they can do to simplistic programming. Real Studio is really accessible to children and is already used in many schools around the world to teach programming.

Many people feel that you have to choose between something being easy and intuitive or difficult and powerful. I think that choice is a copout- you can have it both ways, though it may require more design and thought to achieve. We add features that make Real Studio easier and we add features that make it more powerful. We work to make it intuitive for those learning programming for the first time and at the same time, make it powerful for experienced developers.

You can have it both ways if you take the time to design your products with this in mind and the result can be a far superior product, one that students would be lucky to get their hands on early.

The Winner: HTML5

2011-11-10T12:07:00.000-06:00

Developers have tried for years to deliver applications with desktop-like features and quality through a web browser. In the early days HTML was simply not up to the task. The original solution was to use Java to run an app inside the browser but that, unsurprisingly, resulted in a horrible user experience. Later Flash appeared. Flash provided a much higher quality experience because the Flash browser plugin could do just about anything in terms of the user interface while still providing the benefit of deploying the app through a browser. Java and Flash are similar in concept but one was developed by a company that primarily made servers while the other was developed by a company that exclusively made desktop software. It's not a shock that Flash has a better user experience.

But Flash is not without downsides. First, the user has to have the Flash plugin installed. Second, the plugin has to load some or all of the application from the server to the user's browser. This often results in the user waiting through an annoying loading progress thermometer. Flash also crashes too often. Over the years, some people have told me that they don't install Flash because their entire system becomes unstable if they do. In addition, Flash and similar technologies like Microsoft's Silverlight are not efficient on mobile devices which are sensitive to battery life. Apple famously chose to not support Flash on iOS because it was felt that Flash was just not efficient enough.

Here at Real Software, long before there was an iPhone, we considered giving Real Studio users the ability to build applications that could be deployed in a browser via a special plugin we would develop. After much consideration, we decided not to pursue this for many reasons- one of which being we believe that depending on an installed plugin greatly reduces the value of the technology.

Later, AJAX and HTML5 came along making it more possible to build desktop-like applications for the web. This made Adobe Flash and Microsoft Sliverlight less necessary and provided an excellent solution for power-sipping mobile devices. At Real Software, when we decided to investigate building web applications again, the native web technology had caught up with what we wanted to accomplish allowing us to develop our web framework for Real Studio. Real Studio Web Edition has never relied on plugins and instead creates native HTML/HTML5, CSS, JavaScript, etc., on the fly and sends it to the browser.

Now Adobe has announced that it's discontinuing the Flash plugin for mobile devices. It also appears that Microsoft may be putting Silverlight out to pasture as well. Adobe is going to refocus on HTML5. If Microsoft is going to end development of Sliverlight, perhaps they plan to do the same. This will likely be the beginning of the end for Flash as a plugin for desktop browsers as well. If Flash is going to support HTML5 for mobile, where all relevant browsers support HTML5, it's only a matter of time before the majority of desktop users are using an HTML5-compatible browser. At that point, it would not make sense for Adobe to continue to support a Flash browser plugin at all.

HTML5 has won this fight but it's not a total win for users. Flash is a complete end-to-end solution developed by one company. That allowed Adobe to provide a very consistent user experience. HTML5 (along with CSS, JavaScript, etc.,) is a standard that is then interpreted by the developers of Internet Explorer, Firefox, Chrome and Safari. That's a lot of different people and the result is that these native technologies don't work exactly the same on all browsers, creating extra work for web application developers that have to test and tweak their web apps for each browser. Adobe will have to deal with these inconsistencies.

The Real Studio web framework already abstracts the developer from these browser differences and from the assembly language of the web (HTML, CSS, JavaScript, AJAX and PHP/Java) as well. This is what web development technologies need to do to make web application development efficient for and accessible to everyone.

What we are seeing today with this announcement from Adobe and the rumors about Silverlight is technological equivalent of survival of the fittest and this time the winner is HTML5.

Safely connecting to a MySQL Database

2011-10-27T15:41:00.002-05:00

You can connect to a MySQL database in a Real Studio web or desktop application using the MySQLCommunityServer class. If you have built a web application you need to consider SQL injection which is a way for someone to get data out of your database that you didn't want them to have or change data that you didn't want changed. The goal is to make sure that user input (such as SQL commands or delimiters) doesn't contain anything to manipulate a database in an unwanted way.

So, before you upload your web app, take a look at using prepared statements to protect your data. Although it uses the Real SQL Database there is example code for this in the Order example project. You can download that project from the about box in the Orders example.

Here's some example code from the Real Studio Language Reference:

// We'll assume "db" is the MySQL Database object added to your project

Dim stmt As MySQLPreparedStatement

stmt = MySQLPreparedStatement(db.Prepare("SELECT * FROM Persons WHERE Name = ? AND Age >= ?"))

stmt.Bind(0, "John")

stmt.BindType(0, MySQLPreparedStatement.MYSQL_TYPE_STRING)

stmt.Bind(1, 20)

stmt.BindType(1, MySQLPreparedStatement.MYSQL_TYPE_SHORT)

Dim rs As RecordSet = stmt.SQLSelect

Siri: The killer app for the iPhone 4S

2011-10-17T08:51:00.000-05:00

I freely admit that I'm a gadget guy. I often buy new technology when it's first available and I'll admit that has not always worked out. I remember having several "Newton moments" waiting for the Apple Newton to attempt to turn my chicken-scratch handwriting into text. It routinely misunderstood- often to the delight of whomever was watching my demonstration.

Whenever I want to buy a new gadget, the first step is rationalization. How can I rationalize spending the money on this thing? Well, I don't have any other expensive habits. I don't play golf or gamble. But the real rationalization for buying the new iPhone 4S was my kids. The 8 megapixel camera can shoot 1080p HD video with image stabilization. After all, I can't go back in time and reshoot today’s pictures with a higher quality camera tomorrow. Basically 100% of the photos and video I take of my kids (heck, of anything) are taken with my iPhone; after all they say the best camera in the world is the one you have with you! So I convinced myself (and my wife since we make purchasing decision above $100 together) that the better camera alone was worth it. And it really is.

But there's another new feature of the iPhone 4S called Siri that I was interested in. For those of you that have somehow managed to still not have heard about Siri, it's a built-in personal assistant that recognizes your voice and can take actions for you. But as much as I attempted to rationalize Siri as a reason to buy the new iPhone 4S, somewhere in the deep recesses of my mind, I couldn't help but think it was going to be more cool than practical. That was, until I tried it.

Siri can be activated simply by holding your iPhone 4S up to your ear as if you are about to make a call. The very first thing I asked Siri to do was "Tell my wife I'm thinking about her." That is word for word what I said. Siri then sent my wife a text message that read “I’m thinking about her”. Apparently, I should have said, "Tell my wife I'm thinking about you" so that the text message would have been "I'm thinking about you", but that's close enough for me. Next, I asked Siri to call my mom. Siri asked, "What is your mother's name?" and I replied, "JoAnn". "Is your mother JoAnn Perlman?", asked Siri. "Yes", I replied. Siri then asked, "Do you want me to remember that JoAnn Perlman is your mother?" and again I replied, "Yes". Siri then told me it was calling my mom and the call went through. Pretty cool.

Testing Siri further I asked, "What is the capital of Texas?" Siri responded with a document that had several details about Texas including the fact that the capital is Austin, Texas. On my way home from lunch, I heard a text message come in. I put my iPhone to my ear and asked Siri to read my last message. It read it and asked me if I'd like to reply. I told it what I wanted my reply to say and Siri sent it. Next, I asked it what time my marketing meeting was today. It looked at my calendar and responded correctly. I asked it what I had on my calendar for tomorrow. It read my tasks. I even composed an email message and sent it while driving, though I'm not sure how you tell it which email account to use.

This is pretty amazing and useful technology and I'm sure Apple will take this much, much further. Siri seems to be the killer feature of the new iPhone 4S. Someone pointed out to me that technology like this has existed for Android for sometime. Well, in fact Siri has existed for iPhone for some time as well. What Apple did in iOS5 is buy it and deeply integrate it. But it’s interesting that I had never heard of it until now for either platform. Everyone is talking about Siri now but I don’t remember anyone ever mentioning it before for either platform.

For an app or feature to be considered “killer” to me, it must be very useful but I also have to know about it. It does no good for a great product or feature to exist if no one ever hears about it.

So long, Steve.

2011-10-05T20:26:00.001-05:00

When I heard this evening about the death of Steve Jobs, I immediately thought about the huge influence he has had on my life over the last 30 years.

I started learning programming on an Apple II. Actually it was a clone because my dad wouldn't "pay extra for a brand." He paid dearly when we replaced the motherboard three times.

I earned my first computer, a Macintosh 512K, doing custom programming for my brother's company.

I made my living working at an Apple dealer and later writing custom Mac software until I went to work for a Mac development tools company in Silicon Valley. In 1994 I left for Austin, Texas where I founded Real Software because there were no good rapid application development tools for the Mac.

My kids have been growing up watching Pixar movies. And when I saw the trailer for Finding Nemo, I knew Pixar was something special so I bought Pixar stock and held it until they were bought by Disney.

I watched Steve Jobs bring Apple back from the brink to amazing success. Apple is certainly the greatest corporate turn around in history. From the iMac to the iPod, to the iPhone and the iPad, he has left his mark on the world of technology.

Steve Jobs truly was a visionary. He was often way ahead of his time and never allowed the limits of what others thought possible to stop him. He was a relentless taskmaster (based on what the people I know that worked for him) but that was just what came with the package.

What I learned from Steve Jobs was to not be afraid to dream big, to be passionate about what you do for a living and to never accept "just good enough."

I had never really realized until tonight that my entire adult life has been so impacted by the vision of Steve Jobs. This might make me sound like an Apple fanboy, but really, I'm just a fan of great products that enable people to do things they couldn't have done without them. Steve Jobs was always great at making great things.

Whether you liked him or hated him, he was a genius. Only a fool would deny that.

But now he's gone, far too early and the world is diminished.

So long, Steve. We'll miss you.

Real Studio, Cocoa and LLVM

2011-10-05T10:24:00.000-05:00

Our new Cocoa-based framework for Mac OS X made some big leaps forward in Real Studio 2011 Release 3. And we continue to hear good results from our beta testers that their projects are running fine under Cocoa. We have set up a way for beta testers to alert us to any showstoppers that may prevent them from shipping their apps. Needless to say, we are prioritizing these to maximize the number of Real Studio developers that will be able to ship Cocoa-based Mac apps using our next release. This is important because starting in November Apple is placing additional restrictions that will require apps submitted to the Mac App Store to be built with Cocoa. To be clear, it's not that they are requiring Cocoa; it's that Carbon apps don't seem to be stable when built with the new restrictions Apple is requiring. To further our efforts to get Cocoa into the best shape we can for our next release, we are adding additional engineering resources.

Real Studio 2011 Release 4 will ship in November. Our Cocoa support will still be considered beta for that release. Our criteria for it to no longer be beta is that we are comfortable making Cocoa the default option for building for Mac OS X. However, although it's beta, there's a very good chance that your projects will work perfectly using the Cocoa build option so give it a try and give us feedback.

There will be more Cocoa bugs to fix for 2012 Release 1 and there are two additional features that need to be implemented for that release as well: the movie player and drawers. However, we are quite confident that 2012 Release 1, scheduled to ship in February, will bring our Cocoa support to the point where we can remove the beta label. That will be a real milestone for us (no pun intended) as the transition to Cocoa has been a long one.

Once Cocoa is no longer beta, we will return to working on our transition to LLVM for our compiler backend. While we have been focused on Cocoa, the LLVM team has been improving LLVM - and this is great news for us and you! Hooking up the Real Studio debugger was estimated to take us at least a month, due to a significant amount of work required to parse the LLVM metadata. Fortunately, the LLVM team has done this work for us which means LLVM for Real Studio that much closer.

Finally, I'd like to thank all the beta testers who take their time to help us improve Real Studio. Thank you! We really appreciate your efforts and we look forward to putting out the new releases you need.

What is "App"?

2011-09-30T08:00:00.003-05:00

The question what is "App" comes about from a recent Feedback case. This case does report a bug - which we've fixed - but it also points out a limitation in peoples' understanding of the Real Studio runtimes.

So what does App actually refer to? If you change your app class name why does App. still refer to the right method that you wrote on your class called "TestApp"?

This is a long standing area of confusion. When the runtime starts your program, it creates 1 instance of your app class. But, at runtime how do you access that instance? You can't use TestApp as that's the name of the class and not a reference to the one instance. So how do you, the end user, get access to this one instance?

When the IDE compiles your program it actually inserts a function called App that, if you wrote it, would look something like:

Function App() As TestApp

return mAppSingleton

When the runtime starts, it creates an instance of your app class and saves that reference so it can return it later when needed.

So the App function always returns an instance of your app class - regardless of what it's called.

And you can always use App.whatever to refer to methods, properties, constants etc. that you put on your app class.

Using SSL with the ServerSocket Class

2011-09-29T14:42:00.000-05:00

Using ServerSockets to serve SSLSockets has been problematic at best for anyone wanting to create an application that serves secure TCP sockets. It was recently brought to my attention that even though a critical framework bug was fixed this spring, we still lacked instructions on how to set it up properly.

The instructions here are for Linux and Mac OS X, and we are actively trying to figure out the right configuration for Windows. As soon as we have that information, it will be added to the SSLSocket page in the Documentation Wiki.

The Secure Part of Secure Sockets Layer (SSL)
The first thing you'll need is to get an SSL Certificate. If you'll be testing internally or only connecting to your own apps, a self-signed certificate will do the trick. For simplicity and ease of understanding, open a Terminal window and follow steps 1-4 on this site.

The second thing you'll need to do is to combine the private and public keys (server.key and server.csr) into a single file. Use your favorite text editor to copy the contents of server.key into server.csr and save. The resulting file should look something like this:

-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQCgdz6vtxQcENpusUzL+aReKYRQv9lYoxYT4l7yK4ylLw
PE/qOVx3puQDYZb80WzvDq2Z4t5KyYEEru3f+s4OfMhdUnDEkkOMLrBE1
…Edited for content...
-----END RSA PRIVATE KEY-----

-----BEGIN CERTIFICATE-----
MIICUTCCAboCCQCaEmvwajGn1DANBgkqhkiG9w0BAQUFADBtMQswCQYDV
UzETMBEGA1UECBMKU29tZS1TdGF0ZTESMBAGA1UEBxMJU29tZS1DaXR5
…Edited for content...
-----END CERTIFICATE-----

The Hookup

Now that you've got the certificate, you will need to create an app that can listen securely. If you've done any work using ServerSockets with TCPSockets, you know that ServerSocket has an AddSocket event that fires every time the ServerSocket thinks it needs to make more connections available.

Traditionally, you would create a subclass of ServerSocket and then do something like this:

Function AddSocket() As TCPSocket
Dim ssl As New SSLSocket
ssl.ConnectionType = ssl.TLSv1
//If your certificate has a password you'd enter it here
ssl.CertificatePassword = ""
ssl.CertificateFile = getfolderitem("certificatefile.crt")
ssl.Secure = True

Return ssl
End Function

Let's say your ServerSocket subclass is called "MyServer". When you call MyServer.Listen (assuming everything else is set up), you're all ready to go!

Two Steps Backward, One Step Forward

2011-09-27T18:36:00.000-05:00

In August, Mozilla introduced WebAPI, a standard API for web applications to communicate with various parts of smartphones such as contacts, dialing, the clock, etc. This would of course be with the user's permission or some other form of security. They want this API to be the same across all browsers, operating systems and devices. I think this is a great idea and it's really needed to make web-based apps "first class citizens" on mobile devices. Of course most apps may not need this level of access but if yours does, then greatly improving access to a mobile device's hardware, especially in a cross-browser way, would be great. We could certainly use it in Real Studio Web Edition.

But why stop there? Web apps running on browsers on desktop/laptop computers need similar levels of access. These types of devices may not be as sexy as mobile devices but I'd guess that more web apps are accessed from desktop/laptop computers than mobile devices. These apps could benefit from many of the same capabilities that are being suggested by Mozilla for WebAPI.

Web Apps are great because they are easy to access, require no installation and are easy to maintain for the end user. But while this is a step forward in application development, it's also two steps backward because of the limitations browsers impose in the name of security. I'm all for security but the browser can, as mobile browsers do for things like GeoLocation, ask the user's permission so insure security and enable more powerful web applications.

OS X & Fonts

2011-09-27T16:00:00.000-05:00

One thing that surprises people in OS X is that unlike Classic Mac OS, text drawing OS X can't always draw text in italic or bold.

There's been some discussion on this in the lists & the forums and the reasons seem to all boil down to OS X drawing routines work differently than Classic Mac OS and require the specific variation of a font be installed so it can be used. There may be more technical underpinnings but the upshot is if you want italic or bold, the font has to have that variant or it won't work.

You can see this effect for yourself in a tool like TextEdit.

* Create a document and make it rich text.

* Type a bunch of text then select it all and open the Font panel.

* Select a font like Lucida Grande and try making the text italic.

In 10.5.8 this font has no italic variant and so you cannot select the Italic style for the text. It's not even enabled.

As you might guess, this affects Real Studio as well since we use system level text rendering routines. But there are options. You can always use the "standard fonts" installed with OS X that have the variants you need. Or, if you need a custom font or need to guarantee that the font you use has the variants, you can set up an Application specific font quite easily.

The following is from this great tutorial posted by by paulg on the forums:

1. Download a custom font file from one of the many font sites on the internet. Many are available for free with no restrictions. For example here is a freebie I will use in this tutorial: http://spacefonts.8m.com/fonts/stargate.zip

2. In a new RS Desktop Application drag a StaticText Field to the window.

3. Change the TextFont property to "Stargate" or the exact Full Name of the font, not the filename. You can get the Full Name of the font by using the finder to Get Info on the font File and you will see the Full Name. It is Case Sensitive. Note that you will not see the custom font in the IDE as it will only be visible at runtime, instead the default system font will be used. You can get around this by installing the font on your system. But this defeats the test we are trying to run.

4. Change the text to something other then Untitled. I also increased the size to 16 in my example and used all Caps for this particular font.

5. Build the application.

6. Open the built app's contents folder by right-clicking and choosing "Show Package Contents".

7. Navigate to the "Resources" folder and create a new folder to hold your font(s). In my example, I created a folder called "AppFonts".

8. Copy your font file(s) to this new directory.

9. In the Contents folder of the package, open the info.plist file in your favorite editor. If you are using the Plist editor add a new Child and add the key ATSApplicationFontsPath. Plist editor will display it as "Application fonts resource path" and set the value to the name of the folder you created in step 7. In my example I called it "AppFonts" so that is what I put as the Value.

Run the app and you will see the StaticText in the font you specified. In 10.6 you may get a warning that your app wants to use a font that is not installed on the system and asks if you wish to continue.

Of course this could use some automation and there may be a security concern if people get a message that your app wants to use a font that is not installed. I have a few other Non-RB apps that use fonts in this manner and I do not get that warning so not sure what that is about, maybe code signing?

You can use more then one font in your app, just include them all in the folder you created in step 7 and refer to them by name.

Saying Goodbye to Mac OS X 10.4 Tiger

2011-09-20T13:02:00.000-05:00

We generally support a particular version of an OS for about 5 years. Mac OS X 10.4 is more than 6 years old now. Apple no longer updates 10.4 even for security issues and most of the sites that report version statistics indicate that usage of 10.4 is at about 5% to 10%. The longer we support older versions of any operating system, the fewer resources we have to support the newer, more modern releases.

With that in mind, Real Studio 2011 R4, due in November, will be the last release to officially support Mac OS X 10.4. We wanted to make sure you knew this ahead of time so you could plan accordingly.

Windows 8, Metro and Real Studio

2011-09-20T08:38:00.002-05:00

Last week Microsoft released the first developer preview of Windows 8. At Real Software, we have done some preliminary testing of Real Studio on it and so far, so good.

There are a dozen or more reviews of the Windows 8 developer preview along with the new Metro user interface so I'm not going to write another one. But I will give you my overall view of it and where Microsoft stands at this point.

Metro shows that Microsoft understands the problem of taking the current Windows UI and putting it on tablet. Though Metro is a step in the right direction, Microsoft continues to display a no longer deserved arrogance. When it comes to smartphones and tablets, Microsoft is in a distant 3rd place yet they act as if they are the clear frontrunner. When they shipped Windows Phone 7, the team at Microsoft had a mock funeral for the iPhone. We all know how that turned out. I watched one of the Metro presentations. The presenter talked as if iOS, arguably the premier smartphone OS, had not already done most everything he was showing. And he talked about iOS and Android without mentioning them by name as if they were not worthy competitors. Professionally, that sounds silly.

Like I said, Metro is a good start and there are minor improvements here and there over iOS as it is today. For example, they have made moving an app from one page to another much simpler by allowing you to hold the app and flip though screens with a second finger. The thing is, Metro is not competing with iOS 4 or even the soon to be released iOS 5. It will be competing with iOS 6 which will be shipping when Windows 8 and Metro, which Microsoft has spent the last two years developing, start shipping. There aren't even rumors about iOS 6 yet. And there are large areas of Metro where it's clear that Microsoft just doesn't get it. The simplicity and clean lines are great. But the animation on the Start screen, while it might make for a good demo, is REALLY distracting. The screen has a dozen visible tiles, each representing an app, some of which are changing their content every few seconds. I was instantly reminded of the scene in the movie Idiocracy where this guy in the future is sitting in his living room watching nine TV screens all at the same time. Don't get me wrong. I LOVE animation. But it should be used sparingly in a user interface or it can become counterproductive.

Microsoft is really behind the eight-ball. They probably felt they needed to show Windows 8, what is likely to be more than a year before its release, to keep Windows developers focused on Windows development. I get that. But what Microsoft needs more than anything is a change of attitude. They continue to act with arrogance when they have been humbled by Apple and Google in the smartphone and tablet market. Microsoft's stock price hasn't really changed in almost ten years!

Microsoft is still the dominate player on the desktop. But even there, PC sales are flat or in decline (while Mac sales are on the rise) because a portion of the market is shifting to smartphones and tablets. Microsoft is not at all positioned to keep customers, let alone gain new ones in this market shift. Of course, they are keeping customers to some degree because the cost of switching is high but if Microsoft is going to have any chance of beating the competition, they need to feel hungry and they need to act humble. Shouting "We're number one!" should be reserved for those that actually are number one.

The Rough Edges of HTML5

2011-09-14T17:09:00.003-05:00

In his post last month, "The 11 hard truths about HTML5", Peter Wayner points out that HTML5 has some rough edges that prevent it from unseating native apps. I think he's right.

Wayner begins with the inherent security issues of JavaScript, that if you know what you are doing, you can change variables since they are exposed to you. The solution is to code defensively. The example he cites is a user changing their longitude and latitude to make it appear they are somewhere they are not. Developers should request this data any time they need it rather than store it in variables that could be manipulated by the user. However, this does place the burden on the developer.

Further, there are security issues with web apps built with traditional tools like JavaScript that Wayner doesn't mention. In the vast majority of cases, web apps are a bunch of text files on a server somewhere. Larry Nedry, a friend of mine and an internet security expert, says, "The only way to make a server totally secure is to unplug it." He's right. If a hacker really wants to get on your server, they will. Since the source code is all exposed, it can be manipulated in ways that can easily go undetected by many developers. We solve this problem in Real Studio by compiling web apps to native machine code. While it's still possible to hack, it's significantly more difficult and most hackers are likely to move on to an easier target.

Wayner also mentions how local data storage is not as useful as many had hoped because the user can switch browsers or computers. And since it's just a SQLite database, it can be easily changed, which means it's no good for storing sensitive data. He points out that local storage is used for creating applications that work off-line but syncing to a server-side database is problematic as well. Heck, if the user can change the data, syncing could get really screwed up.

He's right that one of the huge benefits of web apps--that the user doesn't have to install and upgrade them--can also be a detriment. Users aren't always ready to upgrade when the developer is. This is another area where the developer has to be extra careful because he or she is upgrading everybody at the same time. Native apps don't suffer from this problem but this is just one of those things developers have to accept about web applications.

Finally, Wayner discusses the fact that there are incompatibilities between browsers with tag formats, varying levels of feature implementation and hardware idiosyncrasies. He says, "...why have I wasted two weeks trying to get basic audio files to play in all of the major browsers?" Good point. In the end, he summarizes it all when he says that many JavaScript developers have left it up to libraries like JQuery to abstract the developer from these differences.

As developers, heck as humans, we long for a silver bullet solution. Those rarely occur and when they do, they are narrow in focus rather than something as broad as HTML. HTML5 is a great step forward in making web applications more desktop-like. But it's just one of many steps toward this end and as a result, native applications will be with us for a long, long time.

Having said that, one of the ways in which we as developers can make use of the increasingly faster processors available today is by having more abstraction from platform details. The details I'm talking about are not just the ones that Wayner mentions but also from HTML, JavaScript, CSS, PHP, and AJAX or what I call the assembly language of the web.

Developers should be able to build their UI via drag and drop like they do on the desktop. And they should be able to use the same language and frameworks they use for the desktop as well. The browser should be nothing more than the delivery system for the app. Why should a developer have to start over from scratch just to build an app for a new platform? Why should they have to abandon so many of the skills they have mastered?

Our goal for Real Studio as always been to abstract developers from all of this. Real Studio provides developers with a single IDE, language and framework with which to build applications for Mac OS X, Windows, Linux and the web. Yes, there are some differences between these platforms and we can't abstract 100% of them but we abstract enough to let the developer focus on what makes their application unique. This level of abstraction does require developers to give up some control. However, most developers don't need 100% control and will gladly give some of it up for far greater productivity and security.

The long term solution is for development tools to shield developers from platform differences. Computers and mobile devices have the processing power to allow for this. It is the development tool that can provide the layer of abstraction that smooths out the rough edges of both native and web application development.

When a WebLink is not a web link

2011-09-13T20:07:00.000-05:00

Every once in a while, a situation comes along where you want the appearance of one control, but the behavior of another. A user recently asked me if they could use a WebLink control just to execute some Realbasic code in the MouseUp event, and you can, but there's a trick!

If you add a WebLink to a page and then add a Msgbox command to the MouseUp event like this:

Sub MouseUp()

MsgBox "Hello World!"

End Sub

The problem is that the WebLink is expecting to have a URL associated with it. Leaving it blank and clicking anywhere on the text of the link causes the page to refresh, clicking outside of the text (but still on the control) will execute the code in the MouseUp event.

So how do you get the whole control to behave? In the URL field, type this:

javascript:;

This tells the browser that instead of going to a page, you want it to execute a command (in Javascript). Immediately following with a semicolon sends an empty command, so it does nothing, and the MouseUp event fires the way you want it to.

Presto!

The Cost of Using a Slow Computer

2011-09-06T08:55:00.000-05:00

This is an interesting article about the cost to a company of having developers using less than optimal computers for their work. At Real Software, I learned this a long time ago. Replacing developer computers every two years or less is better for the developer and doesn't cost as much as you'd think. You can get more for the computer if you sell it sooner or pass it on to another person in the company.

Vote for the Real Software Panels at SXSW 2012!

2011-08-29T16:35:00.000-05:00

South By Southwest (SXSW) is an annual event held in Real Software's hometown of Austin, Texas that celebrates what's new and what's next in Music, Film and Technology. For SXSW 2012, Real Software has offered two panels for the Interactive conference.

Here is Geoff Perlman in a short video of what he's proposing for his panel Navigating the Sea of Programming Languages.

Not one to shy away from a challenge, the newest member of Real Software's Engineering team, Greg O'Lone offers his panel Web App Evolution - From Mainframe chat to Web 3.0.

Open voting for panels ends Friday...this Friday, September 2nd! Check out the Real Software panels and vote for your favorite. Full disclosure: You will have to create an account to vote and comment but it only takes a moment!

Steve Jobs

2011-08-25T11:50:00.000-05:00

Steve Jobs was born of educated parents then adopted by a working class family. While this wasn't by design, it couldn't have been a more perfect beginning. Intelligence and a strong work ethic make for a good shot at success.

He has always been ahead of his time. Apple didn't invent the first computer small enough and inexpensive enough to have at home. But the two Steves did recognize that every home should have a computer and effectively invented the notion of the personal computer. Jobs has never been short on vision- from the original Apple computer to the Macintosh to NeXT to Pixar to the iMac, iPod, iTunes, iPhone and iPad. But his vision is even greater than that. Every thread of the fabric of Apple is scrutinized by Jobs. I heard that when the first Apple stores were opening, Jobs personally chose the songs that would be playing in the store.

Jobs has always been a man of great vision and focus. The vision part, in some ways, is the easy part. You either have it or you don't. I think Job's vision is to make things as easy as possible for the customer and not let the current limitations of technology and others' lack of imagination get in the way. If you ever find yourself interviewing for the job of CEO somewhere, you'd better walk into that interview with your well-thoughtout vision of the future of the company. The board will either love it or thank you for your time but you'd better have it.

Focus, on the other hand, is much more difficult. When you are in the role of CEO and you have lots of great ideas for growing the business, it's easy to want to try just about everything you can think of. Having the discipline to focus very intentionally and directly on your value proposition is rare. I remember Jobs once saying, after being praised for the work Apple had done on some product, "I'm more proud of what we have not put into our products than what we have." Jobs believes that you should only put in features that 80% of your customers will use. Anything else distracts the user, making the product harder to understand and less elegant.

At All Things Digital Jobs was asked what it felt like now that Apple was bigger (in market value) than Microsoft. Jobs responded (and I'm paraphrasing here), "It's sort of surreal. But it's not what gets me up in the morning." That really says it all. Jobs doesn't spend much time thinking about Apple's competitors. His focus, and the focus on Apple, is on what is best for their consumer, their customer. Jobs believes that if you focus on your customer, you will win. I think he's right.

I have been guilty in years past of wanting to put every feature I could think of into Real Studio. But I have learned by careful study that that's a mistake. I've grown more focused over the years. That's something I have learned from watching Jobs: focus is an extraordinarily valuable thing. And of course that technology can be beautiful.

Jobs has made his share of mistakes. He's an extraordinary demanding CEO which is a nice way of saying that he's not an easy person to work for. He has very high expectations and if you don't see things the way he does, he will tell you, bluntly, rudely and in no uncertain terms. I think he has mellowed over the years a bit, but still, this is who he is. I think perhaps this comes, hand in hand, with his vision, focus and work ethic.

You probably already know the reason for this post today. Steve Jobs has resigned as Apple's CEO. He has formalized what has been the case for the last few years. How will this affect Apple? In the short term, not much. Jobs is going to continue to be as involved as he can at Apple. It's his baby after all. If he has imprinted himself on Apple (and I believe he has) then Apple will continue to be the great company that Jobs always knew it would be.

I hope Jobs is with us for many more years because I believe he still has a lot to contribute. But if that's not the case, he will certainly be going out at the top of this game.

Can a programming language be completely visual?

2011-08-23T11:07:00.011-05:00

Google recently abandoned their App Inventor for Android development tool. To be totally accurate they open-sourced it, but it's clear they won't be investing it in any longer. App Inventor was designed to make it possible to build apps (though certainly not every kind of app) for Android without having any background in programming. It didn't take off to the degree that would be required for it to stay within Google's focus, so they dumped it. It might not be a popular move (especially with App Inventor users) but it's still likely the correct one.

There have been many attempts to make a programming language that is completely visual. The idea is that rather than type in lines of code, you would drag and drop icons that each represent an object or function and then chain them together to create your application's logic. It sounds great in theory and it demos very well. But does it work in reality?

If you are as old as I am, you've seen visual programming a few times before. There was a database development tool for the Mac back in the 1980's called Double Helix. Its programming language was completely visual and it was very easy to get started. However, as your functions became larger and more complex, the code became unwieldy. I remember visiting a friend who was building an application in Double Helix for his company. He had printed out some of his functions but they were so large (because icons simply consume more space than the equivalent text-based code) that he had literally covered an entire wall of his office. It was quickly becoming impractical.

There was also a series of products called VIP (Visual Interactive Programming) that attempted visual programming. And there was AppWare as well, which eventually failed. I looked at another one called Prograph which used a wiring diagram model which I'm sure made a lot of sense if you were an electrician or electrical engineer. The database development tool I used back in the 1980's through the mid-1990's, 4D, had a flowchart-based option (as opposed to the more popular text-based option) for writing methods but it wasn't very popular and I believe they eventually abandoned it.

There's an interesting Wikipedia article about visual programming languages. As I looked down the list of languages, I was surprised to see so many of them but I didn't recognize many names.

Why aren't visual programming languages more popular? Probably for the same reasons that visual instructions aren't always used in daily life. They can and do work just fine for simple things but the more complex and intricate the instructions need to be, the more difficult it becomes to describe them visually. We spend so much time reading and writing that it's really the only way we receive and communicate complex instructions. Of course there are times where visual instructions make sense but they are usually for dealing with physical things like Legos or building Ikea furniture.

I will continue to investigate future attempts at visual programming because I think it's an interesting area to research but I don't hold out much hope for a solution that can really be scaled to solve large, complex problems.

Ok who did it?

2011-08-17T16:25:00.000-05:00

Like solving a tough mystery, debugging software can be challenging too, especially if you plan on targeting multiple platforms and even then you have multiple versions of multiple platforms (i.e. XP, Vista, Snow Leopard, Lion, Ubuntu, KUbuntu, etc.). Real Studio makes this task easier as you can run your app and debug it locally on each platform or with our remote debugger. However, there comes a time when you release your app to the masses, and you are faced with the possibility of some users who do things that you don't expect and crash your app. For simplicity sake we'll consider these two types of crashes:

a RealBasic exception (stack overflow, accessing a Nil Object, etc.)
an OS exception (memory corruption, buffer overflows, invalid operations, etc.)

Luckily a RealBasic exception is something that we generate and can be caught easily. An OS exception however, is more fatal and can usually be attributed to poorly written declares, invalid pointer manipulation, plug-ins, performing GUI operations in a separate thread, or something in our framework.

In most cases when a user encounters a RealBasic exception you can catch this and continue with your program execution. However, if the user encounters a RealBasic exception that you're not expecting, you can create a stack trace (also referred to as the call stack) to help you narrow this down. I'm not going to go into details about catching exceptions as Geoff's blog post explains it very well, but being able to receive a stack trace from your user(s) can help you locate the problem.

So what is a stack trace? In short, it's a stack of method calls. All apps begin at a main entry point and starting from there it calls other methods.

[   etc.  ]

[ Method2 ]

[ Method1 ]

[   Main  ]

Knowing in which method the exception occurred will help you narrow down the issue. Great, so how do I get this stack information? Those familiar with compilers and using debug symbols know that this information must be stored in the built app. Consider that a method call is really just a pointer to some executable memory location, we need a way to map that address to a human readable method name. To be able to generate a readable stack trace you will need to enable App.IncludeFunctionNames, which defaults to off. With this enabled, RuntimeException.Stack will now contain a readable stack trace.

Since the exception isn't handled by your app, you'll probably want to record the stack information in App.UnhandledException. Consider this less than real world example:

Sub Window.Open()

Call Test

End Sub



Sub Test()

// This will cause a NilObjectException

Dim f As FolderItem

f.Visible = True

End Sub



Function App.UnhandledException(error As RuntimeException) As Boolean

MsgBox Join( error.Stack, EndofLine )

End Function

When you build and run this app, assuming you enabled App.IncludeFunctionNames, you should see something like this appear:

Window1.Window1.test%%o<Window1.Window1>

Window1.Window1.Event_Open%%o<Window1.Window1>

:

[additional stack trace snipped for brevity]

:

%main

As you can see, the output is a bit mangled, but being able to record the stack trace can help you track down the issue when debugging isn't possible.

A Breath Of Fresh Air

2011-08-02T08:00:00.003-05:00

Being a Real Studio developer can be lonely work, especially if you work on your own like many of us do. We often go to client sites, but the project work we do is usually done at home on our own. We are all used to having to work problems out ourselves using the forums, or occasionally by asking questions on the NUG.

In May, a client using several of my bespoke Real Studio databases asked me to recommend someone who could support them should I become unable in future. I found another experienced developer and we met a couple of times. It went so well we decided to form a user group in the midlands, UK. We planned to hold an event in Leicester on July 28th to get some UK-based developers together.

After getting the word out through Real Software and Christian Schmitz from MonkeyBread Software, and on the NUG, we hoped to get ten people from England to attend our event. The response was overwhelming and the event quickly sold out. One guy even asked if we had plans to stream the event live so he could watch from the USA! There is clearly a demand for Real Studio developer events and networking meetings.

The event was last Thursday. About ten of us socialized together in the hotel the evening before, which was a nice icebreaker. The event went very well. Seventeen developers from England, Germany and Belgium came for the day. The three guys from Belgium found they worked about two miles from each other and lived about seven miles apart!

The main reason people wanted to come was to meet other Real Studio developers, to socialize, to discuss technical issues and get help, and meet people who could maybe help in future projects.

The presentations were well received. We also had a video chat with Geoff Perlman, who demonstrated the latest Web Edition and also answered our technical questions and talked about the future direction of the IDE.

The benefits for me have been great. I discovered lots of simple but very useful things I didn’t know. I’ve also made useful contacts and have new development and training opportunities to explore. I learned how to make some of my coding quicker and easier, and got fresh ideas for my own projects. I now know how to get around some technical issues I had been struggling with and I helped a few other developers get over a technical problem too.

It’s been a breath of fresh air. I have new contacts and feel energized.

You don’t have to be alone if you work for yourself. You can get involved with a user group, and go to meetings. You can work out answers to your issues with others, find out how to do things better, and help others with their issues. You never know where it could lead.

Eric Gibbon (eric@mactasks.com)

MacTasks Limited

Co-Founder, RSDevsUK

@RSDevsUK and http://rsdevs.org.uk

Announcing Real World 2012!

2011-08-01T06:30:00.002-05:00

We are very pleased to announce Real World 2012, the biggest Real Studio event of the year!

At Real World 2012 you can attend informative, educational sessions, network with other Real Studio users, meet the Real Software team and gain industry insight...Oh, and since it's in Orlando you will certainly have a bit of fun too!

The conference will be held May 24-25, 2012 in Orlando, Florida, at the Royal Plaza Hotel! Save the date, registration will open soon.

Just think, "I'm going to Real World 2012...and Disneyworld!"

For details visit the Real World website.

Setting up Control Arrays in Real Studio Web Apps

2011-07-28T13:31:00.003-05:00

The way that you set up a control array in a web app is a little different than the way you create one in a desktop app.

Let's say that you have put a Label control named Label1 on a window and you want to make a copy of it. First you set the Index property of Label1 to 0 in the properties pane.

I put this code in the Action event of a push button but it could go a number of different places.

dim myLabel as Label1 = self.AddLabel1

myLabel.top = 160 //now move the new label so that we can see it

That's it! Now you have a copy of the Label. If you want to set the text in both labels the code looks like this:

Label1(0).text = "Real Studio"

Label1(1).text = "Web App"

Of course, you have more than one copy of this Label and other controls in Real Studio.

Real Studio, Sandboxing, and the Mac App Store

2011-07-25T13:54:00.004-05:00

As some of you have heard, Apple is going to require all applications submitted to the Mac App Store to be sandboxed starting in November.

Sandboxing is a security feature that limits the amount of damage your application can do if it was to be exploited. The way this works is that an application, by default, is unable to see or manipulate any of the world around it. Not only does this mean that there are fewer attack vectors to compromise your application, but also that it would be unable to harm the user if it was.

However, applications running in complete isolation would not be very useful. What Apple has done is added controlled holes in the sandbox called entitlements. These entitlements let your application access only the bits of the outside world that it absolutely has to. For example, there are entitlements that allow you access the computer's video camera, access the user's address book, or make outgoing network connections.

One entitlement in particular is interesting: the ability to use open and save dialogs. Since the application does not have access to the entire file system, normal open and save dialogs would be completely useless. So what Apple has done is design a system they call Powerbox that seamlessly shows the open box in another process. When the user selects a file from the dialog, it then pokes a hole in your application's sandbox and then you can use that file.

Unfortunately Powerbox is very broken in Carbon applications. We've filed all of the appropriate bug reports with Apple (rdar://9695639, rdar://9695604, rdar://9695574) but it is unclear if they will ever be fixed. It is our opinion that Apple is moving Carbon into a maintenance mode and is only doing updates to keep applications fitting the look and feel of Mac OS X as it changes.

What does this mean for your application built with Real Studio? Basically, it means that the Real Studio Carbon framework cannot be used for applications targeting the Mac App Store. By November, you must switch to using the Real Studio Cocoa framework to submit applications to the Mac App Store.

We realize that our Cocoa framework, in its current state, may not be stable or complete enough for some of your applications. However, we have not stopped working on it and it is improving with each release.

We hope to have addressed all of your important Cocoa framework issues by November. In order to do that we need your feedback. So please test your projects under Cocoa and report issues in Feedback so we can ensure a seamless release.

Real Studio July Upgrade Sale

2011-07-21T07:00:00.002-05:00

Good news everyone! Now through July 31st you can get 20% off any Real Studio upgrade to Pro or Enterprise editions. Just use Promo Code UPSALE and get access to more powerful Real Studio features & functionality!

Working in Personal but want to cross compile? Using Pro but want Web Edition or the Profiler? This is your opportunity to upgrade at a 20% discount!

For a comparison of Real Studio editions visit this chart.

Now Forming! Real Studio User Groups

2011-07-20T10:09:00.000-05:00

If you get the Real Software newsletter or follow us on Facebook or Twitter, you know that Real Studio User Groups are really taking off - we now have user groups in four countries and on three continents! User groups can be great resources for new and long-time Real Studio users; they offer unique networking opportunities, training and technical assistance. In June the San Fransisco Bay Area user group held a virtual Web Edition demo + question & answer session with Geoff Perlman. On July 28th, the UK group (RSDevUK) will host a sold out event in Leicester, UK and the Auckland, New Zealand group is preparing for their first meeting!

These groups are further proof of the extensive and active user community surrounding Real Studio. Our community is easily one of Real Studio's greatest resources. If you are interested in starting or just participating in a user group in your area, please let us know.

For a full list of Real Studio User Groups visit our updated Community page.

An update on Mac App Store compatibility

2011-07-07T07:00:00.002-05:00

We have gotten some reports that people can't submit their applications to the Mac App Store with Application Loader 1.4.1. Specifically, it would give an error about missing required architectures. It is possible to work around this by using Application Loader 1.4. However, it is likely that Application Loader 1.4 will stop working in the near future.

At WWDC we spoke with an Apple engineer about this and we are pleased to announce that this issue has been fixed in Real Studio 2011r2. We highly encourage all users who are currently submitting or intend to submit their applications to the Mac App Store to upgrade to the most recent release.

In terms of technical details, the problem was that the Real Studio linker was not emitting the LC_UUID load command in generated Mach-O binaries. This load command is essentially a unique identifier for your program and allows Apple to group together crash logs (and other information we don't even know about). We now generate the proper information, which can be verified by running 'otool -l', like so:

[joe@Mac-Pro.local ~] otool -l "/FancyApp.app/Contents/MacOS/FancyApp"
...
Load command 11
cmd LC_UUID
cmdsize 24
uuid 15416171-690E-4D46-B15F-AD456B1EA572

The multi-platform era

2011-07-06T15:29:00.001-05:00

In a blog post today, Horace Dediu explains that the Post-PC era will be a multi-platform era:

"So the very reasons which are driving developers to spread their bets across all and any new platforms should indicate the potential for new platforms and the sustainability of small platforms. The thesis that one dominant platform wins the mobile “war” is naive. The post-PC era will be a multi-platform era. Developers already understand this. Platform vendors know this. It’s time to unlearn the lessons of the PC era."

I agree with him and our vision for Real Studio has always been to allow developers to learn one set of tools to leverage as many platforms as possible. We started with the three major desktop platforms (Mac, Windows and Linux) then added the web in 2010, mobile platforms will be next.

Providing platform abstraction is how we maximize the value of Real Studio- letting Real Studio developers focus on what makes their solutions unique rather than the details of so many diverse platforms.

The challenges of HTML5

2011-06-29T12:40:00.000-05:00

Ed Silverstein of the HTML5 Report published an interesting article yesterday about the benefits of HTML5 to developers. He mentioned Real Studio's new HTML5 features as well. It's great to see people outside of the Real Studio community recognizing Real Studio as alternative to traditional tools for building web applications.

The Future of PowerPC and Carbon Support

2011-06-27T10:56:00.008-05:00

Next month, Apple will ship OS X Lion (10.7). In order for our engineers to be able to develop and test on Lion, we must upgrade to the latest version of Apple's development tools. The new version does not support PowerPC. Therefore we will have to drop PowerPC support entirely for Real Studio 2011 Release 4 due this Fall. Less than 5% of Mac users are still using PowerPC-based Macs and by the time we ship R4 it will have been five years since Apple switched to the x86 Intel processor. I know for some of you this will cause some grief but you can still use 2011 Release 3 and earlier builds to support PowerPC.

As you know, we are moving our Mac framework from Carbon to Cocoa. Real Studio 2011 R2 includes greatly improved support for Cocoa. Many users are telling us they can ship their apps built with our current Cocoa-based framework. We believe that our Cocoa support will be complete enough to no longer be considered beta starting with Real Studio 2011 R4. At that time, Carbon will be deprecated. That means we will not be fixing any Carbon-specific bugs except for the most egregious. We will continue to support Carbon as a build option until we ship a release of Real Studio that includes a LLVM-based compiler as the default build option. In that release, Carbon will no longer be available as a build option.

Transitions are not always easy, but sometimes they are necessary in order for us to move forward. I know that for some of you these transitions will cause some grief but I think you can see that they are necessary if we are to keep making Real Studio better.

Key events of web browser KeyEvents

2011-06-24T08:55:00.000-05:00

One area of Web Edition which has been confusing to our users has been the data that is returned from a user's browser with the two keyboard events — KeyDown and KeyUp. In Real Studio 2011r2, we've changed some things around to make the data more consistent from browser to browser and simpler to implement.

First of all, instead of two events, there is now only one, KeyPressed. This event fires after a key has been pressed and the Details parameter now includes several more pieces of information:

4 Booleans that indicate the state of the different meta keys — AltKey, CtrlKey, MetaKey and ShiftKey.
Character contains the character that the user typed, assuming the key that was pressed has a glyph associated with it.
CharCode contains the ascii character code associated with the key.
KeyCode contains the keyboard code associated with the key (note: this may be different than CharCode, but not always). 28 KeyCode Constants to help you figure out which non-character key has been pressed.

Note: Some browsers even include the key names in the Character property. For instance, if you pressed the down arrow key, Character might be set to "Down". Don't rely on this functionality, it's not consistent from browser to browser.

Real Studio 2011 Release 2 has arrived!

2011-06-21T06:00:00.000-05:00

Real Studio 2011 Release 2 is available for download today. Here is a quick video demonstrating some of the key new features in this release.

With new HTML5 features like WebSockets, GeoLocation and WebMoviePlayer, as well as JSON support, Real Studio 2011r2 gives you the essential tools to communicate with online services like Google, Flickr and Twitter. The new release contains 42 new features and 184 improvements, you can read the full release notes here.

JSON: A New Kid on the Block

2011-06-20T12:30:00.000-05:00

With Web Edition coming along and more and more feature requests coming in, one of the essentials to making external services work was to add JSON support (http://www.json.org). This nifty protocol written by Douglas Crockford is a way to represent objects as a string so they can be transmitted across the internet. As it turned out, interfacing with Google's Geocoding engine was the perfect opportunity to add JSON to the upcoming Real Studio 2011 Release 2.

Building on an open-source library from Charcoal Design, we created a new class named JSONItem. For those of you that don't already know, JSON objects can either contain named items (like a dictionary) or indexed items (like an array). To make these objects a little easier to create, we've added methods so you can manipulate them either way. Values can be Strings, Numbers, Booleans, Nil or another JSONItem.

For instance:

//Like a Dictionary

Dim Person as new JSONItem

Person.Value("Name") = "John Doe"

Person.Value("Married") = True

Person.Value("Age") = 35

Person.Value("Spouse") = "Jane Doe"

//Like an array

Dim Kids as new JSONItem

Kids.Append "James"

Kids.Append "Julie"

Kids.Append "Joe"

Kids.Append "Jessica"

//Add the Kids JSONItem to the parent JSONItem

Person.Value("Kids") = Kids

//Create a JSON string from the defined object

Dim JSONString as String = Person.ToString()

JSONString = {"Name":"John Doe","Married":true,"Age":35,"Spouse":"Jane Doe","Kids":["James","Julie","Joe","Jessica"]}

In addition to creating JSON Strings, JSONItem can parse them. Once loaded, you can walk through the object as if you were traversing a folderitem tree. Using the example above:

Person = new JSONItem(JSONString) //From the example above

Dim MyKids as JSONItem = Person.Child("Kids")

For i As Integer = 0 to MyKids.Count-1

MsgBox MyKids.Value(i)

Next i

Services that you can communicate with using JSON include Google, WordPress, Twitter, YouTube and Flickr.

Avoid the "default" language

2011-06-16T07:49:00.001-05:00

Avoid the "default" language, at least as far as the language a project is built in.

Why should you avoid "default"?

When you compile a project "default" means "whatever language the current user is running in". On some OSes this is not a problem as you only have one available language. But on something like OS X where it's dead easy to switch between English, French, or any other installed language, it can be horribly confusing.

You might work in English and your partner might work in French, for example.

Now when you compile the "default" language for dynamic constants it's considered to be English, and when your partner compiles it's considered to be French. What this means is that depending on who builds the project, you or your French partner may be surprised by the results.

Ideally, if a user has their preferences set to list German, French or English, then that user would see the application in French. And if someone else has them set to German, English, French they'd see it in English.

So far so good.

But now when you edit the "default" value for a constant what language do you write them in?

If you write in English and your partner writes in French, you'll have problems. Our first German example above will see some default values in French and some in English and so will the second. Why?

It works this way because "default" is ambiguous for each developer. For the English developer it's English and for the French developer it's French. So which is it for the entire project? The answer is that "it depends".

When "default" is the selected language the created plist for the application requires an entry for the "development region" - what the OS should consider the "default language". And since the project is set to "default" the value used has to be derived from somewhere - and that is the language that the OS is currently using.

You can avoid this in one of two ways.

always explicitly set the language that a project is built in (see Build Settings > Language)
always put in values for each localization in the listing for each localized constant

Ideally you should do both.

No more Mac?

2011-06-09T12:47:00.002-05:00

Since 1984, the operating system for the Mac has always begun with the "Mac" prefix. First it was Mac OS and later, Mac OS X. Apple has been very consistent about that. They never called is "OS 9" or "OS X". Apple always used the "Mac" prefix. But if you look at Apple's page for the next version of the Mac operating system, for the first time, that's no longer the case. Lion is called "OS X Lion" all over their website.

Why? I think Apple is trying to transition to a single brand for their mobile and desktop operating systems. Certainly, many of the features in Lion were inspired by features in iOS. And it would make sense for Apple to want their users have a common user experience between their iPhone, iPad and iMac or MacBook. Steve Jobs said that the Mac and PC have been "demoted" by iCloud to being "just another device." Apple is not content for the desktop to be the digital hub because the desktop digital hub is not always available. The cloud is, so by keeping all of your devices in sync via iCloud, they make it easier for you to own more devices. At least, they make it easier to own more Apple devices. And that only makes sense because Apple is a hardware company.

So the rebranding of Mac OS X to simply OS X is Apple's first step towards a single name for their two operating systems. One day you will see all the devices they sell as being so similar in user experience that there will be few barriers to stop you from buying more of them. And that's the point, removing the barriers that prevent prospects from becoming customers.

What do you think? Why would Apple remove the "Mac" prefix from Mac OS X?

On a related note, in this blog post, Bob Cringely stated that the iCloud's real purpose is to kill Windows. iCloud might indeed be the final missing ingredient that makes the iPad a realistic option for Windows users looking to replace their current PC. After all, when considering a new Windows PC versus an iPad, price is no longer an issue. However, I don't think Apple spends time thinking about killing Windows. I think Apple spends its time thinking about creating great products. Anything else that happens is nothing more than a byproduct of that thinking.

This all may make me sound like an Apple fanboy. I'm certainly a fan of theirs. However, I'm a fan because they have consistently made great products. There are plenty of companies for which I'm a fan for the same reason.

Pushing Pixels

2011-06-06T11:53:00.005-05:00

At some point, many of us end up writing routines that will make changes to a picture. You might need to rotate the image, change the color scheme, etc. You can use the Graphics.Pixel property but Real Studio offers another, faster way: the RGBSurface class. This class has a Pixel method that works just like Graphics.Pixel, but RGBSurface is significantly faster than using Graphics.Pixel! In my test, RGBSurface averaged 14 times faster on the Mac and about 70 times faster on Windows. That means of course that Graphics.Pixel is pretty slow on Windows since RGBSurface on the Mac and on Windows are roughly the same.

You can change pixels using the RGBSurface class using almost identical code to what you'd write when using Graphics.Pixel. For example, my test code simply copies an entire picture pixel by pixel.

Here's the code using Graphics.Pixel:

dim copy as new Picture(beach.width, beach.height, 32)
dim beachGraphics as Graphics = beach.Graphics
dim copyGraphics as Graphics = copy.Graphics
dim lastX as Integer = g.Width - 1
dim lastY as Integer = g.Height - 1
for x as Integer = 0 to lastX
for y = 0 to lastY
copyGraphics.Pixel(x, y) = beachGraphics.pixel(x, y)
next
next

And here's the same code using the RGBSurface class:

dim copy as new Picture(beach.width, beach.height, 32)
dim sr as RGBSurface = beach.RGBSurface
dim cr as RGBSurface = copy.RGBSurface
dim lastX as Integer = beach.Width - 1
dim lastY as Integer = beach.Height - 1
for x as Integer = 0 to lastX
for y as Integer = 0 to lastY
cr.Pixel(x, y) = sr.pixel(x, y)
next
next

The only big difference is that you just need to get an RGBSurface object for the source and the destination and then copy pixels between them.

So when you need to do pixel-level changes, make sure you are using RGBSurface!

EDIT: Charles Yeomans found an optimization for both examples. It didn't speed up the first example but it made a big difference for the RGBSurface example making it even faster.

Hello World: An update on LLVM

2011-06-01T17:22:00.001-05:00

When learning programming, the most common first program one writes is "Hello World" which basically just displays that message. It's a small but significant milestone to be able to produce this simple message. When we were working on adding support for Windows to Real Studio, it was exciting to see "Hello World" on Windows 98! We experienced the same excitement during the development of support for Mac OS X, Linux and the web.

We reached a similar milestone today with our work to replace the backend of our compiler with LLVM. First, a quick summary of how our compiler works and how LLVM will be an important part of the future of our compiler:

When your choose Run or Build in Real Studio, all of the code you wrote is passed to the Real Studio compiler which is represented by the items in grey in this diagram. The front end is the part of the compiler that understands the Realbasic syntax. It converts your code to a sort of meta-assembly language. That meta-code is then passed to the compiler backend which turns it into x86 assembler which your computer can understand. All this compiled code is then passed to the linker which puts it all together and produces the actual application you can distribute. Of course all of this is hidden behind the scenes but it's helpful (or at least mildly interesting) to understand how it works.

We have written two different backends for the compiler: one that produces x86 assembler and the other that produces PowerPC assembler. The latter is no longer supported since Apple has stopped making Macs using PowerPC processors.

LLVM is an open-source compiler backend that has a lot of advantages over the ones we have written:

It's an optimizing compiler which means it can make your code run faster.
It does dead-code stripping which means it can leave out the parts of the Realbasic framework that your project isn't using resulting in a smaller application.
It may enable us to return to a single-file executable on Windows.
It supports the ARM processor used in mobile devices such as iPhone/iPad.

Last year we took the first step of making RBScript compile with LLVM. The next step is to replace it for building entire applications. We have spent a bit of time on this next step recently. Today we were able to compile and run a "Hello World" console app and a desktop app as well. This is a significant milestone but it's only the first of many.

There is still a lot of work to do before you will be building your projects with LLVM but reaching this important "Hello World" milestone is an important one.

EDIT: For the sake of clarity, it's possible that some issue might prevent us from achieving single-file executables for Windows. So I have changed "will" to "may" in item #3 above. Also, I have removed mention of Android from item #4 because LLVM doesn't help (or hinder) us when it comes to supporting Android.

Digital Evolution

2011-05-20T09:27:00.004-05:00

65 million years ago, environmental conditions on Earth changed radically when an asteroid collision made it impossible for the dinosaurs to survive. They couldn't adapt and natural evolution is too slow a process to even have given them a chance. In contrast, transitions in technology can change the landscape just as dramatically as an asteroid though they usually give us more time in which to adapt and evolve.

In the mid 1980's I bought a compact disc player along with about 10 discs. I never bought another vinyl record again. Movies went digital about a decade later and after buying a DVD player, I never bought another VHS movie. Last year I bought a Blu-Ray player and I only buy Blu-Ray DVDs now. And of course I already know that eventually I won't even be buying physical media at all. I certainly don't buy music on CD anymore. Print however, has been much slower to go digital but it appears that it's finally reached a tipping point.

Yesterday, Amazon announced that they are now selling more ebooks than printed books. Amazon is a very smart company. They knew this transition was going to happen and if they weren't prepared for it, they would be left behind. They went a step further and even decided to help make it happen by creating the Kindle.

Barnes & Noble is trying to make this same transition and offer their own ebook reader, the Nook. However, I think it really only appeals to the hardcore Barnes & Noble fans and they are almost certainly more interested in printed books since Barnes & Noble has such a big retail presence. Of course Barnes & Noble is also going through a transition as they have recently received an offer to by acquired for a $1 billion. For a chain that has over 1300 stores, that doesn't seem like a lot of money. Barnes & Noble has about $4 billion in assets and $3 billion in liabilities. Subtract one from the other and you get $1 billion, so they are being bought for their book value. That looks like a fire sale to me and could mean the beginning of the end for Barnes & Noble. It feels to me that their effort to transition to ebooks (if they even looked at it as a transition rather than just some additional way to sell books) was half-hearted at best. Don't get me wrong. I like Barnes & Noble and if they go away I will miss browsing the bookshelves. But books and magazines are transitioning to digital and it's looking more and more like digital is the asteroid that will take out Barnes & Noble. An article on the Huffington Post from April suggests that Barnes and Noble should go all digital and close their stores.

Borders was too late and filed for bankruptcy last February.

Blockbuster Video should have seen the transition coming for video and bought Netflix when they had the chance years ago. By the time they realized their mistake and tried to create their own online copy of Netflix, it was too late. That mistake has cost them everything.

These types of transitions happen in every business but they happen most and quickest in the information business and that's what music, video, books and magazines are: information. Here at Real Software we are constantly looking at what we need to do to transition as well. We have recently added the ability to build web applications and are making preparations to support mobile platform as well. You have to be constantly on the lookout for how things are changing so you can adapt and evolve.

What changes are going on in your environment? How are you evolving and adapting? Share your thoughts.

Another way to enter a property declaration

2011-05-18T11:10:00.006-05:00

You probably add new properties to a class, module, window or webpage by typing the name, pressing the tab key, typing the property type, etc. But did you know that you can do all of that in the name field? Just type the entire declaration ("Status as Boolean" for example) into the field where you type the property name and the IDE will parse out the declaration and put everything in the right fields for you.

So you can type:

And then get this after you press tab:

Inline IFs

2011-05-16T15:53:00.000-05:00

Have you ever wanted to be able to conditionally add something to the middle of a statement without lots of if-then or select statements? Here's a trick that I've used in many of my own projects.

In a module, define a method (IIF = Inline IF):

Name: IIF

Parameters: Condition as Boolean, TrueValue as Variant, FalseValue as Variant

Returns: Variant

If Condition Then

Return TrueValue

Else

Return FalseValue

End If

Here's a quick example of how you might use this in your code. Imagine you wanted to display a different confirmation message based on how many records the program was about to delete:

Dim msg as String = "Are you sure you want to delete " + IIF(n=1,"this record","these records") + "?"

If MsgBox(msg,4) = 6 Then

//…Delete Record(s) here…

End If

If n=1, the message displayed will be:

"Are you sure you want to delete this record?"

Otherwise, it will read:

"Are you sure you want to delete these records?"

So why did Microsoft buy Skype?

2011-05-13T16:33:00.001-05:00

Since we create cross-platform development tools and our customers build cross-platform software, I tend to closely follow other cross-platform software products. Here at Real Software, we use Skype daily so when it was announced that Microsoft is buying Skype, my interest was piqued.

I think Bob Cringely got it right. Microsoft needs to transform itself and buying Skype is one of many ways it can do this. It's not clear if there is a specific strategy at Microsoft however. In this particular case, the strategy may very well be to simply keep Google from buying Skype. There's never only one prospective buyer and the reason Microsoft paid such a high price is no doubt related to Google's interest in Skype. The fact that the Microsoft antitrust decree ended on Wednesday with little fanfare is more evidence that Microsoft just isn't what it used to be.

But since we use Skype daily, my biggest concern is what will become of Skype. Microsoft has not had great successes with purchasing a product and then improving upon it. If you're were a FoxPro user, you know what I'm talking about.

Are web apps the key to cross-device access?

2011-05-11T17:03:00.000-05:00

This is an interesting article by Tim Bajarin on the idea of apps running on multiple devices. If you need an app to run on multiple devices, a web app is a really good solution in many cases. There are certainly times when a native app is a better solution but for a lot of apps, especially business applications, a web-based application saves development time and money.

Shell Differences on Windows

2011-05-02T11:58:00.000-05:00

I ran across a bug report a while back which claimed that the Shell class on Windows was broken. Thankfully, the reporter was nice enough to enter what client app he was running which made him think the Shell class was broken on Windows. The culprit in this case was Microsoft's ftp app. The issue was that no output could be read from the app, even though it appeared that sending input to it worked just fine. The short answer to this issue is Microsoft's ftp app uses Console Input/Output. The technical details are...

On Windows there are two approaches to console I/O. In Microsoft's terms, there's the high-level approach which enables simple character stream I/O, or the low-level approach which gives the app more flexibility and access to the console's input and screen buffers. Microsoft's ftp app uses low-level console I/O which means it is directly poking the characters to the console instead of streaming it through the standard I/O mechanism. There is no way for our Shell class to pick up the low-level console output that the ftp app is sending so what you get back is nothing, which is what this particular user was encountering. Notice that Microsoft's telnet app also uses low-level console I/O.

So what's the solution? Well for those adventurous enough to explore this further you could spawn the ftp app in a hidden console window and read its input using the low-level console I/O functions as described here: http://msdn.microsoft.com/en-us/library/ms684965(VS.85).aspx
However, for most people I'd suggest finding some good REALbasic ftp classes or adjust the way you're using the ftp client (maybe you don't need it to be interactive. Microsoft's ftp app can be scripted quite easily). You could also try to find a different ftp app that doesn't use low-level console I/O.

CSS in a Web Application

2011-04-29T10:40:00.000-05:00

With Real Studio Web Edition you can use the WebPageSource class to insert CSS, HTML or JavaScript into a Web Application in a couple of easy steps. For example, to use CSS to add a red square to the lower right corner of your web page add a WebPageSource class to the window. Next, set the Location property to 3- After Content. Then, enter this code for the Source property:

<style type="text/css">

#redrect {
position: absolute;
width: 100px;
height: 100px;
right: 20px;
bottom: 20px;
background-color: #FF0000;
}

</style>
<div id="redrect"> </div>

Now Run the project and you should see a red square in the lower right corner or your page. Quick and easy customization of your web application is just one of the powerful features of Web Edition.

Optional Parameters

2011-04-25T08:21:00.000-05:00

Did you know that the parameters you create for methods can be optional? There are two easy ways to do this and they can even be combined. The simplest way to make a parameter optional is to add the Optional keyword:

MyMethod(x as integer, Optional y as integer)

In the above example, the keyword Optional makes the "y" parameter optional. If only one parameter is passed, y will have the default value for an integer which is zero. You can also include the default value if you want it to be different that the default value for the data type you are using:

MyMethod(x as integer, Optional y as integer = 5)

When you provide a default value, the Optional keyword is, well, optional. But it's good to use it because it makes your code a bit more explicit.

You can even have the same parameter use two different data types by making two methods with the same name but with different parameters. For example:

Foo(x as integer)

Foo(x as boolean)

Both methods can have their own code or you could have one call the other. So as you can see, there's a lot you can do with parameters.

Real Studio Release 1.1 now available

2011-04-20T11:12:00.000-05:00

Real Studio Release 1.1 is now available. This release includes 10 improvements, you can read the full release notes in the product download. Download Real Studio 2011r1.1 at our downloads page here.

Why does it take a crisis?

2011-04-17T12:00:00.000-05:00

The organization that hands out IP addresses to ISPs in Asia just ran out of IPv4 addresses. You can read more about it here. That means that soon, perhaps very soon, some Internet users in Asia are going to start having problems getting on the Internet. That's because the current scheme (IPv4) wasn't designed for as many IP addresses as it turns out we need. Why not? For the same reason that back in the 1940's the CEO of IBM said the total world market for computers was six. Sometimes even people with vision lack vision.

Thankfully, the answer to the IP address shortage doesn't involve waiting in long lines. In fact, the answer was developed years ago: IPv6. It uses much longer IP addresses along with some hexidecimal to provide more IP addresses than we will ever need. No, really. I think it's totally safe to say that this time. In fact, the number of IP addresses available under IPv6 is so big, I had actually never heard of the number before. It sounds like one of those numbers my kids make up when they want something to sound really big. "Dad, there are like a bazillion frogs in the backyard." I think that long before we run out of IPv6 addresses, we will have replaced the Internet with whatever it will be replaced with. Will you take the red pill or the blue pill?

Unfortunately, switching to IPv6 isn't as simple as typing in a new IP address. Behind your Internet connection is a lot of hardware that needs to be replaced in order to support IPv6. This is great news for companies like Cisco (who make such equipment) in the same way that the meltdown of nuclear reactors in Japan is great news for Toshiba who makes very safe 4S reactors that will no doubt now see speedy approval. As other continents start running out of IP addresses as Asia has, ISPs and the upstream backbone providers will finally switch to IPv6 and once again all will be right in the world.

If you are reading this, you are likely a Real Studio user. If that's the case, you will be happy to know that supporting IPv6 is relatively easy for us and you will, for the most part, be abstracted from it. Abstracting you from the gory details is, after all, our job.

But why does it always take a crisis for us ("us" being society in this case) to act? These problems are not like the asteroid in the movie, Armageddon, where we get just a few months notice that we are all going to die unless Bruce Willis can save us. These problems are ones we have years and years of warning about and have known solutions that don't involve sending oil workers into space.

I hope that the appropriate organizations that provide Internet access to the rest of the world will learn from Asia's cautionary tale.

As an unrelated note, for the very first time, I wrote this entire blog post on my iPad.

Building demo apps using in-memory databases

2011-04-15T16:30:00.006-05:00

A lot of web applications access a database as a primary function. If the user can make changes to that database, it can complicate your ability to provide a demonstration mode for your web app. You probably want the demo user to be able to make changes but since they are not official users yet, you don't want them altering real data. You could duplicate records and give them a demo status of some kind or have a separate demo database, but you still end up having to track the user to undo changes that they made. Fortunately, there's an easier way.

As you probably know, RealSQLDatabase is based on SQLite. SQLite has the ability to create a database, on disk of course, but it also has the ability to create a database that is in-memory only. An in-memory database can be modified but it can't be saved to disk. Using an in-memory database is a great way to allow a demo user to try all the features of your app without giving them the ability to make permanent changes.

To create an in-memory database you simply create a new database object without creating a database file or attaching an existing database file:

Dim Orders as RealSQLDatabase

Orders = New RealSQLDatabase

if Orders.Connect then

//continue

else

//Check Orders.Error

end if

Presto! You've got an in-memory database. You can create tables, add records, perform queries and basically do anything you can do with an on-disk database. If you want to pre-populate the database with tables and records, it's really quite easy to copy the tables and records from an existing RealSQLDatabase into the in-memory database. First, you attach the source database to your in-memory database using the Database.AttachDatabase method:

Dim source as Folderitem = GetFolderItem("Orders.sdb")

If Orders.AttachDatabase(source,"Source") Then

Then, you use SQLExecute to create a table and use a SELECT statement to specify the table and records from the source database. For example, the following code copies a table called “Invoices” and all of its records from the source database into the in-memory database (which in his case is the Orders property):

Orders.SQLExecute("CREATE TABLE Invoices As SELECT * FROM Source.Invoices")

Now you’ve got an in-memory database with a table and data copied from your source database! Pretty sweet huh? When using this with a web project, if you create the Orders property on the Session class, each user can have their own in-memory database that they can change as much as you allow without affecting other users. As soon as the user leaves the application and the session ends, the in-memory database will vanish. Of course, you can use this technique with desktop applications as well.

In-memory databases, along with the ease with which you can copy tables and records into them from another source database, make for a really powerful and easy way to provide demo apps for the web and the desktop.

Feedback Tips

2011-04-08T12:10:00.001-05:00

Back in September of 2009 we introduced Feedback, our tool for reporting bugs and requesting features that is built in Real Studio. Since then we have updated and improved Feedback significantly, tailoring it to our users' and our engineers' needs. Though there are many features we look forward to adding in the future, there are probably a few really handy ones you may not know are already there.

Search by Creator: You can search for reports by the creator's email address using syntax like "email:test@123.com" where "test@123.com" is the creator's email address.

Search Using old Fogbugz ID's: Use "fb:xxxx" where xxxx is the original Fogbugz ID number.

Removing yourself from emails: To stop getting emails about a specific bug simply remove that report from your favorites list.

Read-Only Mode: Read-only mode allows users with expired license keys to search and check the status of exisiting reports. To exit Read-Only mode, simply go to Preferences, click on the Applications tab, then click the "Change" button in the Editions group.

Creating New Bug Reports: And last but certainly not least...can't create a new bug report? Just a reminder that before you can enter a new bug report you must first do a search to see if the report has been entered already. Feedback will not let you enter a new report until you have first searched. This feature was designed to save both you and our engineers time.

Hopefully this helps you to use Feedback to its fullest. If you have a tip on improving Feedback please enter a feature request. And don't forget about the Feedback Help on the start page or the Documentation Wiki.

Web Site or Web Application?

2011-04-02T15:53:00.004-05:00

When we announced Real Studio was going to support building web applications, many of you started asking if Real Studio could be also used to build web sites. Our initial response was no; Our web framework was designed for building web applications, not web sites. But as the discussions on our forums and email lists continued, it became obvious that the answer is not that clear...and you were going to use it to build whatever you wanted anyway!

Web sites are generally, mostly static content without a whole lot of user interaction whereas web applications are usually designed to create content dynamically and are highly interactive. But there is a ever changing gray area in between. So is our new web framework meant for building web sites?

If your web site (or a part of your web site) is very dynamic then it might actually behave more like an application than a web site. If that's the case, then Real Studio might be appropriate. If, on the other hand, your web site is very static, then Real Studio is almost certainly not appropriate.

Is Real Studio designed for building web sites? No, it's not. But your web site might function more like a web application than a website, in which case perhaps Real Studio's web application support is a good solution for you.

Memory Management in REALbasic

2011-03-30T10:39:00.000-05:00

Many times we see the question asked "when does REALbasic's garbage collector run" or something to this effect.

REAlbasic does NOT use a garbage collector like Java's VM does.(see Garbage collection on wikipedia) It uses reference counting (also mentioned on this same wikipedia page) and when the reference count drops to 0 the object is destroyed immediately. Not some time later but right then and there.

Note that this has certain implications. If you have circular references where one object has a reference to another and that object has a reference back to the first then the reference counts may never drop to zero. And, if for some reason you lose your original references to these objects then you can "leak" - or have objects that will never be destroyed but that you can no longer access or reference (well not easily at least).

There are some excellent resources that cover this in plain language and that give you some excellent tips on how to avoid common pitfalls.

The recent Atlanta conference had a session on Advanced Language features and Charles Yeomans covered this fairly well in his talk. I'd suggest that you find the video from this session when they are available on the ARBP site.

Web Edition Updates

2011-03-29T09:09:00.000-05:00

Today we're introducing a new update mechanism for Web Edition that allows us to provide patches to the Web Framework without having to release a whole new version of the IDE.

It works like this:

1. Download a PageSource object from the Extras section of the Downloads page.

2. Drag it into the project that needs the bug fix.

3. Add it to any pages that need the bug fix.

If we release another Web Edition Update, you can just delete the old class from your project and add the new one. All of the subclasses on each page will automatically be updated.

When the next major version of the Real Studio IDE is released, all of this code will be included in the Web Edition framework and the patches are automatically disabled.

Today's update includes two bug fixes:

1. GotFocus and LostFocus events have been fixed for Firefox

2. Touch events have been greatly improved for iOS devices

3. Fixed a bug in WebPopupMenu where changing the menu using the List(index) method caused a Javascript error.

The file is available in the Extras section of our Downloads page or you can download it directly by clicking here.

The Real Studio Atlanta Summit

2011-03-25T16:11:00.006-05:00

This past weekend was the Real Studio Atlanta Summit hosted by the Association of Realbasic Professionals. Four of us from Real Software, Thom, Greg, Norman and myself attended, and Thom and I presented sessions. The conference lasted two days with lots of sessions aimed at various levels of Real Studio proficiency.

Getting so many Real Studio users together in one place is always a great thing. Those of us at Real Software who attended really enjoyed talking to long-time users and meeting new ones as well. The speakers all did a great job. The wide range of experiences both speakers and attendees had was amazing.

I'm sure there will be Real Studio conferences in the future and I highly recommend attending. You will learn from the sessions and the hallway conversation with other users, as well as gain valuable networking opportunities. It's a lot of fun too!

Attack of the Clones

2011-03-24T09:20:00.000-05:00

For a long time now (perhaps since the very beginning) the Realbasic framework has allowed you to have a menu item appear in multiple locations. For example, you might have a menu that appears in your menubar but also appears in a contextual menu somewhere else in your project. In order for the Realbasic framework to allow this, the entire menubar is rebuilt every time you open it or type a keyboard shortcut.

This has led to problems in the past. For example, plug-ins cannot modify menus nor can declares. These limitations have been around for quite some time and we have all grown accustomed to them, even if we prefer they didn't exist. It also has a considerable runtime cost to continually rebuild the menubar during typing. In our transition to Cocoa we would like to take the opportunity to move to a system where the menubar is stable and does not have to be dynamically updated.

While the end result is much nicer, there is a downside: backwards compatibility. If you are using a menu item object in multiple locations once we make this change your code will break. Specifically, it will raise a MenuHasParentException.

Fortunately, updating your code will be pretty straightforward. Rather than having the menu item be in two or more places at once, you will instead clone the menu item using the newly added Clone() method.

To make this transition less painful, this behavior will be required only for the Cocoa framework starting with Real Studio 2011 R2. All desktop frameworks (Mac OS X Carbon, Windows and Linux) will support it but the others will initially continue to support the old behavior as well. Beginning with Real Studio 2011 R4 it will be required for all desktop frameworks so that there is a single, standard technique (cloning) for dealing with menu items that appears in multiple
locations.

We don't make changes that will break code without a lot of thought. But a little bit of pain now will save a lot of it down the road. It's really better that we allow the OS to handle as much as possible so that when OS changes occur, they have minimal impact on your projects. And in this case, you will even gain some functionality because plugins and declares will be able to modify menus.

If you are not using menu items in multiple locations, this will have no impact on you. If you are, I think you can see that the gain will be well worth the effort.

Using links in your comments

2011-03-23T15:44:00.000-05:00

Ever find that you had to read a set of online documentation or specifications in order to implement something and thought it would be really nice to put a reference to that material in your code just in case you or someone who maintained the code might need it later?

One handy feature in the IDE is that if you put a full URL in a comment the IDE will actually recognize it as a URL and highlight it so it's clickable.

And it works with several URL schemes

In a code editor, if you put in code like:

// this came from code at http://developer.apple.com/

the URL for developer.apple.com highlights and appears as a clickable URL

Or you can use mailto if you've sent source code to others so they can easily mail you back

// mailto:blah@example.com

And yes, you can add subject lines as follows:

// mailto:blah@example.com?subject=Hey%20there

If you click on a mailto link, like above that is in your RB code, it starts your email client & addresses it to "blah@example.com" with a subject if you had one.

This is really handy when you need to refer to documentation from Apple, GTK, MSDN, etc. so you or the person who comes along later can see where you got the reference material from.

Plugging IDE Memory Leaks

2011-03-22T09:48:00.005-05:00

During the development of Real Studio 2011r1, we spent some time analyzing the compiler's memory usage. What we noticed was that the compiler was leaking memory. A memory leak occurs when code uses memory but then does not release this memory when it’s finished with it. The result is that the amount of memory the application uses continues to increase until the user quits the application or the application uses up all available memory and crashes.

During the development of 2011r1 we fixed every memory leak in the compiler. In fact, we went beyond that and fixed every leak we could find in the IDE. We fixed leaks in some framework classes as well such as:

Shell
RealSQLDatabase
TabPanel
VirtualVolumes
PopupMenus
MemoryBlocks

As you may know, the Real Studio IDE is created with Real Studio and the Realbasic language. We create it in the same way you create your projects. The chart below compares running the Real Studio IDE project in 2010r5.1 (blue) versus 2011r1(green). All tests were performed by running the project in the debugger and then closing the project. Incremental compilation was disabled.

You can see that after five runs of the project, Real Studio 2010r5.1 leaked over 45 megabytes of memory. Compare that to Real Studio 2011r1 (green) where after five runs, not a single extra byte of memory was leaked.

This is a huge improvement in the performance of the IDE. Before 2011r1, if you were using the IDE for long periods of time, you probably found that it would slow down to the point where you had to restart it. By doing this you were releasing the memory that had not been released by the IDE. This is no longer an issue in 2011r1 which means you can now run the IDE for very long periods of time without having to restart due to memory leaks.

While we believe we have found every leak in the IDE, it is possible there are others and there are certainly leaks that remain in some framework classes. Should you believe you have found a memory leak, create a simple sample project and include it with a new case in our Feedback system.

5% of Next Week's Sales will be Donated to Japan’s Relief Efforts

2011-03-17T14:00:00.000-05:00

Real Software will donate 5% of our total sales for the week of March 20-26 to the American Red Cross’ earthquake and tsunami relief fund for Japan. All products including new Real Studio licenses, renewals, upgrades and support plans will be applicable. This is one small way we can help our friends in Japan after this devastating disaster.

I want my iPadTV!

2011-03-16T09:38:00.004-05:00

When my daughter was eight, she started asking if she could have a computer in her room. When she turned nine, I decided that an iPad would be a nice compromise and she loves it. She's about to turn 10 years old and lately has been asking if she can have a TV in her room. That's not going to happen.

Yesterday, Time Warner Cable released a free application for the iPad that lets TWC customers watch 30 channels of TV on the iPad. It's a very nice app that works very well. I was happy to see that at least for the moment, the Disney Channel is not among the available iPad channels. However, Food Network is and my daughter loves that. So it looks like she's going to get a TV in her room (and in fact, anywhere in the house she takes her iPad) after all. You might think that watching TV on a iPad-sized screen wouldn't be all that great. But considering that you quite literally watch TV at an arm's length on the iPad, the viewing size actually works very well. Rather than spend money on another TV, you can now just use your iPad.

This was a very smart move on the part of Time Warner Cable. People are spending more and more time in front of their iPads (and computers) and less and less time watching TV. So what they have done is put themselves in front of those iPad users with an app. It will likely increase viewing and give their customers another reason to keep their cable and internet service with TWC.

It's great for Apple as well because at least some people will decide to spend their money on an iPad instead of buying yet another TV. Why buy a TV when you can have an iPad that does so much more for about the same price?

This is yet another sign of how important the iPad (and tablets in general) will be to the future of computing. We are committed to supporting these and are working on the prerequisite steps needed to do so. The most important of those is completing our support for LLVM. We already have support for LLVM in RBScript. Next, we need to support it for stand-alone applications. Once this is done, we will have the ARM processor support we need to begin building an iOS framework and possibly support other mobile devices.

Mobile devices are going to be critical to the future of computing and to the future of Real Studio.

Using Mac OS X tools to manipulate the Info.Plist

2011-03-09T09:34:00.002-06:00

There are several tools and ways to edit the property list, or plist, that's part of every Mac OS X bundle.

You might need to do this as part of getting your application ready for the Mac Application Store or because your application requires a newer version of Mac OS X than the default required by most Real Studio applications. Real Studio will, by default, set the entry for LSMinimumSystemVersion to 10.4 for Carbon apps or 10.5 for Cocoa applications.

If you have the Apple developer tools installed you can, as part of any build or run, use the Property List Editor in Developer > Applications > Utilities > Property List Editor to edit your plist. This is a nice GUI tool that Apple supplies that makes editing an applications plist very easy.

You can use this tool whether you are debugging or not by making use of Run Paused.

When you use Run Paused you can then locate the application, open the bundle and use the Apple Property List Editor to change/update whatever you need and then, when done, run the debug application and it will connect to the IDE that is waiting.

If you have an edition that supports Build Automation, you could script the change as a post build step using Apple's included Mac OS X tool called PlistBuddy located in /usr/libexec/PlistBuddy. (see http://developer.apple.com/library/mac/#documentation/Darwin/Reference/ManPages/man8/PlistBuddy.8.html)

As part of a post build step you could run a command like the following to set the minimum OS X version to 10.6.6. (This is only a sample to show you how it can be done.)

dim dbg as String

if debugBuild then dbg = ".debug"

dim appNameForShell as string

appNameForShell = PropertyValue("App.MacOSXAppName")+ dbg +".app" + "/Contents/Info.plist"

// there are several other special characters that you might need to escape

appNameForShell = replaceall(appNameForShell, " ", "\ ")

dim s as string

s = DoShellCommand("/usr/libexec/PlistBuddy -c ""Set :LSMinimumSystemVersion \""10.6.6\"" "" " + CurrentBuildLocation + "/" + appNameForShell )

print s

This saves you having to do this change in the Property List Editor manually every time.

Making it easier to adjust the plist is frequently requested but in the meantime you can use either of these mechanisms to update the property list generated by Real Studio.

Real Studio 2011 Release 1 is now available

2011-03-08T08:40:00.000-06:00

Real Studio 2011 Release 1 is now shipping. Adding 35 new features and 114 improvements, this release features easier deployment of web applications, improved HTMLViewer support and major advancements in Cocoa support.

* Web application deployment with Real Studio is now just as easy as creating the app itself! We are now offering a new CGI build option that outputs a Perl script. This script is placed in the cgi-bin folder, allowing for easier web deployment and more hosting service options.

* RealSQLDatabase now has a new MultiUser property that lets web applications allow multiple users to access a RealSQLDatabase file at the same time. This may eliminate the need for some web applications to require a database server.

* A new, native Microsoft SQL Server plugin has been added. This plugin supports Windows only.

* This release includes a huge number of improvements to Real Studio’s Cocoa framework.

* Improved HTMLViewer support offers the options to get/set custom user agent strings and increase/decrease the font size.

* The WebListBox now has a CellClick event (just like the desktop Listbox). It also now has Cell and Column Style properties allowing or greater control over the look and behavior of cells.
The new DragPicture property lets you use an image for dragging.

Real Studio 2011 Release 1 is now available for download at, our Downloads page. For full details about what’s in this release view the product Release Notes.

Issue for Web Edition Projects Going From 2011 R1 back to 2010 R5

2011-03-08T07:54:00.004-06:00

If you are creating web applications and are going back and forth between Real Studio 2010 R5 (or R5.1) and 2011 R1, there is the potential for project corruption but there is also a solution.

If you save a project in 2011 R1 then reopen it in 2010 R5, the project will open but it will not run. When you run the project, you will get a fatal error:

Just as Real Studio warns when you opened the project, there is the potential for data loss. In this case, the likelihood is very high. In R1 there is now a TargetWeb constant which you can use to write code in classes and modules you share between your web and desktop projects. This constant can be used to include code in shared classes and modules that should only be compiled into your web projects. Unfortunately in order to support this, the project format is no longer backwards compatible. Again, this is only for web projects. Desktop and console projects are not affected. Once you save a project in R1 it will no longer run in R5.

The good news is that there's a relatively easy way to fix your project should this happen. To fix your project:

1. Using R1, save your project in XML format by choosing Save As from the File menu and then choosing the XML Project option from the Format popup menu.

2. Quit Real Studio and open the XML version of the project in a text editor.

3. Search for 3 and then change the 3 to a 1.

4. Search for True and delete this line.

5. Search for -1 and change the -1 to 9000.

6. Save your project. Now you can reopen it in 2010 R5 and it will run. You will still get the warning when you open it but this will go away once you save the project in R5.

If you are using the Version Control Format for your project, do the following:

1. Open your project in a text editor.

2. Change Type=Web to Type=Console.

3. Change WebLivePort=-1 to WebLivePort=9000.

4. Save your project. It will now open and run in 2010 R5.

Again this particular issue only affects web projects that were saved in R1 and need to be opened and run in R5.

We apologize for this inconvenience. We really try to keep the project format as compatible as possible when you move back and forth between versions but that's not always possible. However, we are going to add something in a future release of Real Studio so that you don't accidentally find yourself in situations like this one.

Detecting Modifier Keys

2011-03-02T08:56:00.000-06:00

Sometimes it is necessary, or at least user-friendly, to adjust your interface when the user holds down modifier keys. For example, iTunes changes its "Create Playlist" button from a plus icon to a gear icon when the option key is held down. The goal is to inform the user that option-clicking the button will perform a different task.

At first glance you might think that simply looking for the option key in a KeyDown event will do the trick. The problem is KeyDown/KeyUp does not fire for modifier keys. The solution is to use a Timer, which I'll show you how to setup. In this tutorial we'll be creating a timer to detect the option/alt key, though this class could be adapted to read any of the modifiers.

First of all, we need to decide whether to create a timer embedded on a Window, or to create a subclass. Either technique will work, but the subclass creates reusable code which I always recommend. Also, the subclass will allow us to trigger events which will come in handy.

Start by creating a new class called "OptionTimer" whose super is "Timer". Next, add a property "Pressed As Boolean", an event "KeyDown", and a second event "KeyUp" to OptionTimer. In the Action event insert the following code:

If Keyboard.AsyncAltKey = True And Pressed = False Then
Pressed = True
RaiseEvent KeyDown
Else If KeyBoard.AsyncAltKey = False And Pressed = True Then
Pressed = False
RaiseEvent KeyUp
End If

That's it, nothing more the class needs to do. So go to your Window and place a Timer on it. Set the super to "OptionTimer" and now you can insert code into the events for that timer. You'll also want to adjust the period of the timer to something small such as 250 to make sure the events are responsive.

To test it we could use a MsgBox in each event but MsgBoxes are blocking and require user interaction. Since this test is about user interaction, we should avoid the MsgBox. So instead, in the KeyDown event insert a single "Beep" command. And in the KeyUp event insert two "Beep" commands. When you run your project, you should hear a beep when you press the option key and two beeps when you release it.