Beginner Tips – Xojo Programming Blog

Introducing Jade, the Xojo AI Assistant

Paul Lefebvre — Tue, 09 Dec 2025 16:31:26 +0000

With Xojo 2025 Release 3, we are introducing Jade, an AI assistant for Xojo. This initial version is primarily for asking general Xojo-related questions and can be used as an alternative to the documentation.

Getting Started

Jade uses Anthropic Claude as its engine, so before using Jade, you first need to sign up for an Anthropic API key to access Claude. You can do this from the Anthropic Claude Console.

From there you can create your account. After you’ve done that, you will want to get an API key to use with Xojo. Click on the “API keys” tab to see existing keys and create new ones. Click the “Create Key” button to generate a new key. In the dialog, give it a name to indicate its purpose.

When you click Add, the actual key will be shown. Copy it to the clipboard.

Note that you cannot see the key again after closing that dialog, but you can always create a new key at any time.

Now go to Xojo Settings and in the General tab, paste it into the “Anthropic API Key” field.

Go back to the Claude Console and click on the Billing tab to buy credits. Interacting with Jade requires credits. The amount of credits used depends on the complexity of your interactions. Until you get used to Jade and credit usage, you’ll probably want to start with a small amount, like $5, and disable auto-reload.

Using Jade

To use Jade, select Help->Ask Jade or click the Ask Jade button in the toolbar. You’ll get some short introductory text. Note: Using Jade requires an internet connection.

You interact with Jade similarly to a chat app by typing prompts in the conversation area (bottom section) and pressing Send. Jade will think for a moment and then display its response.

If Jade’s response includes Xojo source code you can click one of the buttons above the code block to copy the code to the clipboard or to directly insert it into the active code editor.

When interacting with Jade, keep in mind that although it remembers the context from the current conversation, it has no knowledge of prior conversations. Click the “Start Over” button to clear things and start a new conversation. Starting a new conversation is useful when switching to a different topic as it prevents Jade from relying on information you previously discussed that is no longer relevant.

The Export button saves the current Jade conversation to a JSON file which is a great way to save information you want to retain and refer to later.

Other Tips

Jade currently uses Claude Sonnet 4, but this may change as newer models become available.
The only thing Jade knows about your project is what type it is (Desktop, Web, iOS, etc.). If you want Jade to offer suggestions based on your code, you will need to copy/paste the relevant code into the Jade conversation area.
Your Jade conversation is restored when the IDE restarts. If you get errors, ensure that you have valid internet access, that the API key is valid and you have a positive credit amount.

Wrap

We hope you find Jade helpful with your Xojo development. Remember, Jade in Xojo 2025r3 is the first version of an AI assistant for Xojo and will improve over time. In subsequent releases we expect to add more capabilities and project integration. Read more about Jade in Xojo’s Documentation.

Paul learned to program in BASIC at age 13 and has programmed in more languages than he remembers, with Xojo being an obvious favorite. When not working on Xojo, you can find him talking about retrocomputing at Goto 10 and on Mastodon @lefebvre@hachyderm.io.

Building Blocks for Beginners: Modules, Classes, Interfaces, and Delegates

Gabriel Ludosanu — Wed, 24 Sep 2025 15:50:00 +0000

If terms like “Modules,” “Classes,” “Interfaces,”, “Delegates” feel new or abstract, keep this article as a map. I’ll explain what each one does, why they matter, and how to choose the right one. Think of these features as your toolkit:

Modules: organize shared helpers that don’t store data. They just do a job and return a result.
Classes: represent objects that keep data and have actions.
Interfaces: agreements about what methods exist so parts can work together without caring how they’re built.
Delegates: a way to pass a function around so another part of your app can call it later (a callback).

Modules

Purpose

Provide a namespace for related helpers, constants, and enums.
Offer reusable helpers that don’t remember data between calls.
Add extension methods that make calling code cleaner.

Use when

You need shared helpers (formatting, parsing, conversions).
You want to group constants/enums (error codes, log levels).
You’re adding behavior to existing types via extension methods.

Avoid when

You’re tempted to store changeable global data that creates hidden dependencies.

Benefits

Classes

Purpose

Represent real concepts in your app (e.g., an order, a report, a session).
Keep data and the related rules/actions in one place.
Separate concerns: core logic in classes, screen logic in the UI.

Use when

You have data that changes over time and rules to enforce.
You need services that coordinate steps (for example, “Export report” or “Sync data”).
You want testable units that don’t depend on UI elements.

Avoid when

You only need a simple helper that returns a result (that belongs in a Module).
Platform-specific calls would leak into core logic (hide those behind Interfaces).

Benefits

Clear rules kept close to the data they protect.
Clean boundaries between UI, core logic, and data access.

Interfaces

Purpose

Define the what without the how.
Let you swap implementations (e.g., memory vs. SQLite vs. REST) without changing calling code.
Make testing simple by substituting fakes/mocks.

Use when

A feature may vary by platform or environment (file system, keychain, camera, notifications).
You want to keep app logic separate from the details of databases, files, or network calls.
You’ll have multiple strategies that share the same shape.

Avoid when

There’s only one implementation and you don’t need to test in isolation.

Benefits

Loose coupling and easier future changes.
Cleaner, more stable internal APIs.

Delegates

Purpose

Provide type-safe callbacks by letting you hand a function to another part of your app.
Enable flexible behavior without defining a whole interface and class.
Power progress updates, cancel handlers, filters, or small strategies.

Use when

You need a one-off callback (progress, completion, error reporting).
You want to inject small pieces of behavior (sorting, filtering, formatting).
You’re wiring up dynamic behavior at runtime.

Avoid when

You need a broader contract with multiple related methods (use an Interface instead).
You need lifecycle or semantic grouping (a Class with events may be clearer).

Benefits

Lightweight and expressive.
Less boilerplate than creating full classes for simple callbacks.
Encourages small, composable, testable pieces.

Quick Decision Guide

I need to group common helpers and constants. → Module
I’m modeling an object with data and rules. → Class
I want to depend on behavior, not a specific implementation. → Interface
I need a small callback or injected behavior. → Delegate
I need many subscribers to a lifecycle change. → Event on a class

Quick glossary

Interface: a contract, a named list of methods something promises to have.
Delegate: a variable that holds a function to call later (a callback).
Event: a signal that something happened; other parts can listen for it.

Use Modules to organize shared helpers, Classes to model your world, Interfaces to decouple and swap implementations, and Delegates to pass behavior flexibly. Combined thoughtfully, these features keep Xojo projects easy to change, easy to test, and ready to ship across platforms.

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

How To Create a Custom Button Control in Xojo – Part 4: Adding Focus

Gabriel Ludosanu — Mon, 23 Jun 2025 22:35:31 +0000

In part 3 of this series we made our CanvasButton inspector-friendly by exposing all our colors, corner radius and other properties. Today we’re going to wire up real keyboard focus so that you can:

Tab to the button
See a neat focus ring when it has focus
Grab focus on click

1. Track the Focus State

Add a private property to keep track of whether the button has focus:

  Private IsFocused As Boolean = False

2. Respond to Focus Events

Implement FocusReceived and FocusLost so we can set/clear the flag and force a redraw:

  Sub FocusReceived()
    If Enabled And AllowFocusRing Then
      IsFocused = True
      Refresh(False)
    End If
  End Sub

  Sub FocusLost()
    If Enabled And AllowFocusRing Then
      IsFocused = False
      Refresh(False)
    End If
  End Sub

3. Grab Focus on Mouse Click

Modify your MouseDown to call SetFocus. Now clicking the button also gives it focus immediately:

  Function MouseDown(x As Integer, y As Integer) As Boolean
    #Pragma unused x
    #Pragma unused y

    If Enabled Then
      IsPressed = True
      SetFocus       // ← new
      Refresh(False)
      Return True
    Else
      Return False
    End If
  End Function

4. Draw an Inset Focus Ring

In the Paint event, after drawing the border, add:

// … after the border code …
If IsFocused And AllowFocusRing Then
  g.DrawingColor = Color.HighlightColor
  g.PenSize = 1
  // Inset by 2px so it sits inside the border
  g.DrawRoundRectangle(2, 2, g.Width-4, g.Height-4, CornerRadius-2, CornerRadius-2)
End If

5. Enable Canvas Focus

By default, DesktopCanvas won’t accept focus, so make sure to check AllowFocusRing in the Inspector when you drop CanvasButton onto a window.

Try It Out

Run the app:
- Tab to the button → you’ll see the focus ring

What’s Next?

Stay tuned for more awesome updates!

You can grab the latest source on GitHub: GitHub – CanvasButton

More in this series:

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

How To Create a Custom Button Control in Xojo – Part 3: Make Your Controls Inspector-Friendly

Gabriel Ludosanu — Wed, 28 May 2025 17:54:20 +0000

In Part 1, we built a custom button control in Xojo by subclassing DesktopCanvas. In Part 2, we enhanced it with customizable colors, corner radius, and a disabled state.

Now, let’s make the CanvasButton control even easier to use in the Xojo IDE by leveraging the Inspector Behavior feature. This allows you (and anyone using your control) to configure its appearance and behavior at design time, right in the Properties panel.

Why Inspector Behavior Matters

When you create a custom control, its custom properties will not appear in the Inspector by default. Inspector Behavior lets you choose which properties are shown and how they’re grouped. This makes your control feel polished and professional, and saves users from digging into code to tweak settings.

Step 1: Open Inspector Behavior

To customize Inspector options for your CanvasButton:

In the Xojo IDE, select the CanvasButton class in the Project Navigator.
Right-click it and choose Inspector Behavior…

Step 2: Expose and Organize Properties

In the Inspector Behavior dialog, you’ll see a list of all public properties (inherited and custom).

Make the following properties visible:
- ButtonText
- CornerRadius
- BackgroundColor, HoverColor, HighlightColor, BorderColor, TextColor (all grouped under a custom “Button Colors” section)
Organize properties into logical groups for clarity.

Tip: Defining default values for your properties in the class code means they will be automatically populated in Inspector Behavior. However, Xojo gives you even more flexibility. You can override these default values directly in the Inspector Behavior dialog, so you have full control over what new instances of your control will look like by default.

Step 3: Enjoy Design-Time Customization

With Inspector Behavior set up, you (or other developers) can now:

Change the button text right in the Properties panel.
Pick custom colors for normal, hover, pressed, border, and text states using the color picker.
Adjust the corner radius visually.

Step 4: Best Practices and Tips

Use clear group names (like “Button Colors”) to help users find related properties.
Set sensible defaults for all properties in your code, but remember you can override them in Inspector Behavior.

Conclusion

With Inspector Behavior, your custom controls feel like first-class citizens in Xojo. You and others can now design beautiful, custom buttons by simply dragging, dropping, and tweaking settings in the Inspector. No code required!

Stay tuned for future parts where we’ll explore even more advanced features.

More in this series:

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Build Your First iOS App with Xojo: 10 Practical Steps

Javier Menendez — Fri, 16 May 2025 15:45:00 +0000

Xojo is an extremely useful, fast and fun development environment for building your first (or next) iOS app. In this article, I offer a series of practical steps to guide you from idea to app.

1. Define Your Idea

Start by summarizing your app’s purpose in a single, clear sentence. The more concise it is, the better defined your objective will be. This clarity will help guide your screen designs, navigation structure and code architecture.

This sentence can also double as your app’s short description in App Store Connect.

Focus on the essential features that form your app’s Minimum Viable Product (MVP). It’s easy to get sidetracked by new ideas during development. Resist the urge! Instead, keep a list of potential features for future updates and base priorities on user feedback.

2. Choose The Platform(s)

Xojo supports both iPhone and iPad, but your app doesn’t have to. Choose the device type that best fits your app’s use case.

iPhone apps often support quick, task-based interactions.
iPad apps are better suited to immersive, content-rich experiences.

To target a specific device only, set the unused layout (iPhone or iPad) to “None” in the App item’s Inspector Panel.

You’ll also need to decide the minimum iOS version to support. Xojo currently defaults to iOS 14.0, but as of writing, over 60% of users are on iOS 18 or later.

3. Prototyping

Xojo’s visual layout editor makes it easy to dive in designing your app. But take time to prototype your app first, especially if it has more than basic functionality.

Use tools like Figma or MockUp, or simply sketch your ideas with pencil and paper. Choose whatever helps you plan best and clearly.

Also, review Apple’s Human Interface Guidelines to align your app with native iOS expectations.

When designing in Xojo, you can fine-tune layout behavior using the iOSLayoutConstraint class to adapt to orientation and screen size changes at runtime.

4. Database Design

Most apps use a database. For local storage on iOS, use SQLiteDatabase, and save your database file in SpecialFolder.Documents.

Two key best practices:

Add a Metadata table to track the database schema version.
Create a custom SQLiteDatabase subclass to manage all read/write operations in one place.

This setup allows you to always know which version is installed on the user’s device and to react accordingly as your app evolves.

5. Graphic Resources

For icons, buttons and tab bar images, use Picture.SystemImage with symbols from Apple’s SF Symbols app. These scale beautifully across devices and adapt to light/dark mode. Just ensure compatibility with your minimum iOS version.

When using custom images, add them at multiple resolutions for optimal display across all screen sizes.

Typography also matters. Use system fonts thoughtfully, ideally no more than two font families. Vary sizes and weights to establish content hierarchy. Keep text readable with a minimum font size of 11pt.

Tip: When testing in the Simulator, set the window to physical size (Simulator > Window > Physical Size) to preview real-world readability.

6. Localization and Accessibility

Nothing prevents you from publishing an app in a single language, whether it’s your native language or English; but supporting multiple languages can increase downloads by over 100x.

Start localizing early to avoid design issues later. Add a module to your Xojo project with localized String constants for all app text, and enable the “Localized” option for each one.

Suggested languages (in order of impact):

Core: English

High-impact additions: Chinese, Spanish, German, French, Japanese, Italian, Portuguese, Russian, Korean

Also, localize accessibility labels and App Store listings, including screenshots and descriptions, for each supported language.

7. Testing the App

Xojo provides multiple ways to test your app, both from a design and user experience perspective, as well as from a functionality perspective:

Simulators: Ideal for design, layout and localization testing. You can also use them to take App Store screenshots.
On-device Debugging: Offers realistic input experience and access to hardware-only features.
Build to Device: Lets you run the app outside the debugger, simulating real-world use.

Once you’ve finished fixing bugs in your code and app design, move on to testing in the real world by compiling your app and using Xcode to copy that bundle to a physical device. Testing like this, you’ll likely find some optimizations, especially around design and usability.

TestFlight is your gateway to external beta testers. After uploading a build to App Store Connect, create a public link to invite testers. Remember to increment the version number with each new build.

Tip: Add ITSAppUsesNonExemptEncryption = False in your Property List to streamline build approvals.

8. Publish it!

Publishing with Xojo is straightforward. The most time-consuming step is preparing your App Store Connect listing including text, artwork, screenshots, keywords and possibly localized pages. Read more about this in my earlier post How to Publish macOS and iOS Apps to the App Store Directly from Xojo.

Make sure you select the correct build when submitting your app for review.

9. Marketing

Something you should be doing simultaneously is preparing the related materials to introduce your app to the world. Start your marketing efforts early. A simple website can significantly boost discoverability. Use it to:

Provide tutorials and FAQs
Link to App Store and social media
Highlight features and updates

Consider creating a YouTube channel for app demos and support videos, and maintain active social media profiles to stay visible.

Don’t forget to take advantage of the Marketing tools provided by Apple to help you create badges, assets, links and even QR codes to promote your app.

10. The Next Steps …

After launch, gather user feedback and track any bugs that slipped through. At this stage, it’s common to manage:

A public release (on the App Store)
A development version (next major update)

Save your Xojo iOS project in text format and use a version control system. This helps you manage multiple branches and collaborate efficiently.

To Summarize

Even the simplest iOS apps require a fair amount of time and effort, but thanks to Xojo, both aspects are significantly reduced.

What iOS apps have you created with Xojo? What’s your methodology or any tips you’d like to share? Feel free to comment on the Xojo forum!

Javier Menendez is an engineer at Xojo and has been using Xojo since 1998. He lives in Castellón, Spain and hosts regular Xojo hangouts en español. Ask Javier questions on Twitter at @XojoES or on the Xojo Forum.

How To Create a Custom Button Control in Xojo – Part 2

Gabriel Ludosanu — Wed, 14 May 2025 15:00:00 +0000

In the first part of this tutorial, we built a basic custom button control using the DesktopCanvas class, giving it a custom appearance and handling the basic mouse events to provide visual feedback and raise a Pressed event when clicked.

In this second part, we will enhance our CanvasButton by adding more customization with new properties to:

set the button’s colors for different states (default, hovered, pressed)
adjust the corner radius of the button
implement a disabled state

Let’s get started!

Adding New Properties for Customization

We need to add several properties to our CanvasButton class to store the custom colors for different states, the border color, the text color, the corner radius, and the enabled state.

In the Project Navigator, select your CanvasButton class.
Go to Insert > Property (or right-click the class and select Add to “CanvasButton” > Property).
Add the following properties with the specified names, types, and default values:
- Name: BackgroundColor Type: Color Default Value: &c5e2d8b
- Name: HoverColor Type: Color Default Value: &c729fcf
- Name: HighlightColor Type: Color Default Value: &c628eff
- Name: BorderColor Type: Color Default Value: &c525252
- Name: TextColor Type: Color Default Value: &ceeeeee
- Name: CornerRadius Type: Integer Default Value: 4

These properties will hold the values that determine the button’s appearance and behavior.

Updating Event Handlers for the Enabled State

We need to modify the existing mouse event handlers (MouseDown, MouseEnter, MouseExit, MouseUp) to check if the button is Enabled before processing any mouse actions.

Select each of the following event handlers in the CanvasButton class and update the code as shown:

MouseDown(x As Integer, y As Integer) As Boolean

#Pragma unused x
#Pragma unused y

// Only process if the button is enabled.
If Enabled Then
  // Set internal state to indicate the button is being pressed.
  IsPressed = True
  // Refresh the control to show the pressed state visually.
  Refresh(False)
  // Return True to indicate that this event was handled.
  Return True
Else
  // If disabled, do not handle the event.
  Return False
End If

MouseEnter()

// Only process if the button is enabled.
If Enabled Then
  // Set internal state to indicate the mouse is hovering over the button.
  IsHovered = True
  // Refresh the control to show the hover state visually.
  Refresh(False)
End If

MouseExit()

// Only process if the button is enabled.
If Enabled Then
  // Set internal state to indicate the mouse is no longer hovering.
  IsHovered = False
  // Reset pressed state if mouse leaves while pressed (prevents accidental clicks).
  IsPressed = False
  // Refresh the control to revert from the hover state.
  Refresh(False)
End If

MouseUp(x As Integer, y As Integer) As Boolean

#Pragma unused x
#Pragma unused y

// Only process if the button is enabled.
If Enabled Then
  // Check if the button was pressed down AND the mouse is still hovering over it.
  If IsPressed And IsHovered Then
    // If true, the button was successfully clicked. Raise the custom Pressed event.
    RaiseEvent Pressed
  End If
  // Reset the pressed state regardless of whether the click was successful.
  IsPressed = False
  // Refresh the control to revert from the pressed state.
  Refresh(False)
End If

In these updated event handlers, we added an If Enabled Then check at the beginning. If the button is not enabled, the code inside the If block is skipped, preventing the button from reacting to mouse interactions. We also added #Pragma unused to the parameters x and y in MouseDown and MouseUp as they are not used in the code, which helps avoid compiler warnings. In MouseExit, we added IsPressed = False to ensure the pressed state is reset if the mouse leaves the button while the mouse button is held down.

Updating the Paint Event for Enhanced Appearance

The most significant changes will be in the Paint event where we will use the new properties to draw the button based on its current state (enabled/disabled, hovered, and pressed).

Select the Paint(g As Graphics, areas() As Rect) event handler and replace its content with the following code:

#Pragma unused areas

// Use the custom CornerRadius property.
Var currentCornerRadius As Integer = CornerRadius

// Declare variables for the colors used in drawing.
Var currentBgColor As Color
Var currentBorderColor As Color
Var currentTextColor As Color

// Determine colors based on the button's current state (enabled, pressed, hovered).
If Enabled Then
  If IsPressed Then
    // Use highlight color if pressed.
    currentBgColor = HighlightColor
    currentBorderColor = BorderColor
    currentTextColor = TextColor
  ElseIf IsHovered Then // Check for hover only if not pressed
    // Use hover color if hovered.
    currentBgColor = HoverColor
    currentBorderColor = BorderColor
    currentTextColor = TextColor
  Else
    // Use the custom background color for the default state.
    currentBgColor = BackgroundColor
    currentBorderColor = BorderColor
    currentTextColor = TextColor
  End If
Else
  // Use appropriate system or standard gray colors for the disabled state.
  currentBgColor = Color.LightGray
  currentBorderColor = Color.Gray
  currentTextColor = Color.DisabledTextColor // Use system disabled text color
End If

// Set the drawing color and draw the background shape with rounded corners.
g.DrawingColor = currentBgColor
g.FillRoundRectangle(0, 0, g.Width, g.Height, currentCornerRadius, currentCornerRadius)

// Set the drawing color and pen size for the border.
g.DrawingColor = currentBorderColor
g.PenSize = 2
// Draw the border shape just inside the background rectangle.
g.DrawRoundRectangle(1, 1, g.Width-2, g.Height-2, currentCornerRadius, currentCornerRadius)

// Enable anti-aliasing for smoother text rendering.
g.AntiAliasMode = Graphics.AntiAliasModes.HighQuality
g.AntiAliased = True
// Calculate the width and height of the button text.
Var tw As Double = g.TextWidth(ButtonText)
Var th As Double = g.TextHeight
// Calculate the X position to center the text horizontally.
Var tx As Double = (g.Width - tw) / 2
// Calculate the Y position to center the text vertically, with a small adjustment.
Var ty As Double = (g.Height + th) / 2 - 3
// Set the drawing color for the text.
g.DrawingColor = currentTextColor
// Draw the button text at the calculated centered position.
g.DrawText(ButtonText, tx, ty)

Let’s break down the changes in the Paint event:

We now use the CornerRadius property instead of a static constant for drawing the rounded rectangles.
We introduced an If Enabled Then ... Else block.
Inside the If Enabled Then block, we have a nested If IsPressed Then ... ElseIf IsHovered Then ... Else structure. This determines the currentBgColor:
- If IsPressed is True, currentBgColor is set to HighlightColor.
- If IsPressed is False but IsHovered is True, currentBgColor is set to HoverColor.
- If neither IsPressed nor IsHovered is True, currentBgColor is set to BackgroundColor.
- The currentBorderColor and currentTextColor are set directly from the BorderColor and TextColor properties when the button is enabled.
Inside the Else block (when Enabled is False), we set the colors to standard gray values (Color.LightGray for background, Color.Gray for border, and Color.DisabledTextColor for text) to give the button a disabled appearance.
Finally, the drawing commands use these currentBgColor, currentBorderColor, currentTextColor, and currentCornerRadius variables.

Using the Enhanced Custom Control

Now that our CanvasButton has more customization options and supports a disabled state, let’s see how to use these features.

If you don’t already have an instance, drag the CanvasButton class from the Project Navigator onto a window in the Layout Editor.
You can now access and set the new properties programmatically. For example, in a button’s Opening event, you could add code like this:

// Customize colors
Me.BackgroundColor = Color.RGB(200, 50, 50) // A shade of red
Me.HoverColor = Color.RGB(255, 100, 100) // A lighter red for hover
Me.HighlightColor = Color.RGB(150, 0, 0) // A darker red for pressed
Me.BorderColor = Color.Black
Me.TextColor = Color.White

// Adjust corner radius
Me.CornerRadius = 10

You can experiment with different values to see how they affect the button’s appearance. To test the disabled state, you can set the Enabled property to False.

Conclusion

We’ve now taken our custom button to the next level by adding extensive color customization, adjustable corners, and a disabled state.

This project can be downloaded from GitHub at: https://github.com/xolabsro/CanvasButton

Hope you enjoyed making the button your own! While it’s much more flexible now, there might be other features we could add down the road, so stay tuned!

More in this series:

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Year of Code 2025: May Project, Mobile Apps

Paul Lefebvre — Wed, 07 May 2025 16:00:00 +0000

One of the most common things I love to use my phone for is sharing pictures of my pets with others. We have two cats and a dog: Shawmut, Christofur and Lucy. To be honest, I’m not much a cat person as I find that cats are almost all Richards, constantly causing and getting into trouble. I’m 100% a dog person.

But even though I have my own pets, I do love looking at pet pictures. It’s a simple pleasure, but there’s not much that I find more calming.

Years ago I made a Xojo app (CatsUp) that displayed random cat pictures and it was a lot of fun. And one thing that Xojo excels at is making it fun to create software! That’s what the Year of Code is all about, after all.

Speaking of that, here is the Year of Code topic for May: Mobile Apps.

You can already find CatsUp for iOS and Android included in the Xojo examples, but why stop at just cats? Being a dog guy, I want to see some dogs. All the dogs.

Since I’m not here to start a cats vs. dogs war, I thought, why not both? It turns out I’m not the only one that thinks this as there are actually public web services that serve up pictures of cats and dogs. Web services and mobile apps go together like peanuts butter and chocolate.

The web service for cats that I’ve previously used is called TheCatAPI and is available here: https://thecatapi.com

There is an equivalent dog one called, unsurprisingly, TheDogAPI: https://www.thedogapi.com

For my mobile app this month, I’ve created an all-new app that can show pictures of cats, dogs or both! I call it Pawz.

Pawz app icon

Actually, it’s two apps since I made versions for iOS and Android. Here’s a look:

Pawz on iOS

Pawz on Android

Although they are separate projects, both use basically the same code. In fact there is only about 50 lines of code in each project! The UI itself is just a big ImageViewer that is used to show the picture and several toolbar buttons.

There are three buttons to request a cat picture, dog picture or a surprise picture that could be either. There is also an extra button that lets you share the picture, if you really like it.

You can find the source for the iOS and Android versions of Pawz on GitHub here:

https://github.com/paullefebvre/pawz

Year of Code is all about having some fun making an app. As you can see with Pawz, it doesn’t have to be anything extravagant. Even fun apps can be made quickly with very little code!

I can’t wait to see what great mobile apps you all create this month. Share your creations in the Forum topic.

One More Thing

Although phones and tablets are what we usually think of when talking about Mobile Apps, you know what else is rather mobile? A vehicle! And it just so happens that many vehicle manufacturers, such as Cadillac, Chevy, Ford, Honda, Polestar, Renault and Volvo are now using Android to run their infotainment systems. Technically it’s Android Automotive OS (AAOS), but it is very similar to regular Android.

Because Xojo builds standard Android Runtime (ART) apps, Xojo Android apps also work on Android Automotive OS as a “parked app”. You can test with this by using Android Studio to install an Android Automotive VM for the Emulator. Once you’ve added that you can run your Xojo Android projects on it just like any other device. Pawz works fine in an AAOS Emulator.

Why do I bring this up? No reason, although I believe Xojo 2025 Release 2 pre-release testing might be starting soon…

Year of Code Project

How to Play:

Each month we’ll announce a new theme and share an example project of our own. Share your projects to the Xojo Forum thread for that month via GitHub (all the links you need are posted above ↑ ). Learn how to use Xojo and GitHub.

The Prizes:

Monthly winners get $100 at the Xojo store. Every month you submit a project is another chance to win the grand prize. The grand prize is $250 cash plus a Xojo Pro license and a year of GraffitiSuite and will be announce in December. Learn more about the prizes.

How To Create a Custom Button Control in Xojo

Gabriel Ludosanu — Fri, 02 May 2025 14:00:00 +0000

This tutorial demonstrates how to create a custom button control in Xojo using the DesktopCanvas class. It covers defining properties, handling mouse events for visual feedback, and drawing the control in the Paint event.

You can read more about DesktopCanvas in the Xojo Docs.

Let’s begin!

Add a Custom Class:

In the Project Navigator, add a new Class.
Name it CanvasButton.
Set its Super class to DesktopCanvas.

Add Properties:

ButtonText As String (Set Scope to Public, Default Value to "Click Me". To make this property visible in the Inspector, right-click the CanvasButton class in the Project Navigator, select ‘Inspector Behaviour…’, scroll through the property list to find the ButtonText variable, and make sure its checkbox is checked.)
IsHovered As Boolean (Set Scope to Private, Default Value to False)
IsPressed As Boolean (Set Scope to Private, Default Value to False)

Define `Pressed` Custom Event:

Go to Insert > Event Definition.
Name the event Pressed. This is the event that will be raised when the button is clicked.

Add Event Handlers:

Select the CanvasButton class in the Project Navigator.
Go to Insert > Event Handler. Add the following event handlers and paste the corresponding code into each:

MouseDown(x As Integer, y As Integer)

// Set internal state to indicate the button is being pressed.
IsPressed = True
// Refresh the control to show the pressed state visually.
Me.Refresh(False)
// Return True to indicate that this event was handled.
Return True

MouseEnter

// Set internal state to indicate the mouse is hovering over the button.
IsHovered = True
// Refresh the control to show the hover state visually.
Me.Refresh(False)

MouseExit

// Set internal state to indicate the mouse is no longer hovering.
IsHovered = False
// Refresh the control to revert from the hover state.
Me.Refresh(False)

MouseUp(x As Integer, y As Integer)

// Check if the button was pressed down AND the mouse is still hovering over it.
If IsPressed And IsHovered Then
   // If true, the button was successfully clicked. Raise the custom Pressed event.
  RaiseEvent Pressed
End If
// Reset the pressed state regardless of whether the click was successful.
IsPressed = False
// Refresh the control to revert from the pressed state.
Me.Refresh(False)

Paint(g As Graphics, areas() As Rect)

// Corner radius of the button shape.
Static CornerRadius As Integer = 4

 // Declare variables for the colors used in drawing.
Var bgColor As Color
Var borderColor As Color = Color.DarkBevelColor
Var TextColor As Color = Color.LightTingeColor

 // Determine the background color based on the button's current state (pressed or hovered).
If IsPressed Or IsHovered Then
  // Use a highlight color if pressed or hovered.
  bgColor = Color.HighlightColor
Else
  // Use the accent theme color for the default state.
  bgColor = Color.AccentThemeColor
End If

// Set the drawing color and draw the background shape with rounded corners.
g.DrawingColor = bgColor
g.FillRoundRectangle(0, 0, g.Width, g.Height, CornerRadius, CornerRadius)

// Set the drawing color and pen size for the border.
g.DrawingColor = borderColor
g.PenSize = 2
// Draw the border shape just inside the background rectangle.
g.DrawRoundRectangle(1, 1, g.Width-2, g.Height-2, CornerRadius, CornerRadius)

// Enable anti-aliasing for smoother text rendering.
g.AntiAliasMode = Graphics.AntiAliasModes.HighQuality
g.AntiAliased = True
// Calculate the width and height of the button text.
Var tw As Double = g.TextWidth(ButtonText)
Var th As Double = g.TextHeight
// Calculate the X position to center the text horizontally.
Var tx As Double = (g.Width - tw) / 2
 // Calculate the Y position to center the text vertically, with a small adjustment.
Var ty As Double = (g.Height + th) / 2 - 3
// Set the drawing color for the text.
g.DrawingColor = TextColor
// Draw the button text at the calculated centered position.
g.DrawText(ButtonText, tx, ty)

Use the Custom Control:

Open Window1.
Drag the CanvasButton class from the Project Navigator onto the window.

Handle the Click Event:

Double-click the CanvasButton instance on the window layout.
Add the custom Pressed event handler.
Add code inside this handler: MessageBox("Custom Button Clicked!").

Run the Project:

Run the project. Test the button by hovering, pressing, and clicking to see the visual feedback and trigger the Pressed event.

And just like that, you’ve built your own custom button! Hope you had fun following along. Keep an eye out for our next tutorials, where we’ll take this button and give it some awesome upgrades!

This project can be downloaded from GitHub at: https://github.com/xolabsro/CanvasButton

More in this series:

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Year of Code 2025: April Project, User Interface

Gabriel Ludosanu — Tue, 08 Apr 2025 15:30:00 +0000

April’s Year of Code theme is all about a great User Interface, I decided to focus on refining the user experience of an existing application. My project involves a user interface revamp of the familiar built-in ToDo desktop app example provided with Xojo.

The goal wasn’t to add new features but to explore how applying thoughtful UI design principles can significantly enhance the look and feel of an application, making it more visually appealing and cohesive.

Here are some of the key aspects of the UI revamp:

Design System Foundation: I started by establishing a basic design system. This involved defining core visual elements to ensure consistency across the entire application interface.
Typography Definition: Specific styles were defined for how titles and standard text should appear. This helps create a clear visual hierarchy and improves readability.
Consistent Color Palette: A specific set of colors (Light & Dark mode) was chosen and implemented throughout the project, contributing to a unified and more polished look.
Refined ListBox Appearance: The standard DesktopListBox control received some visual tweaks to better align with the overall updated aesthetic.

The aim was to demonstrate how focusing on UI details can elevate even a simple example application.

Here’s a glimpse of the revamped ToDo app:

You can find the complete source code for this UI-enhanced ToDo app project on GitHub.

Stay tuned for more exciting projects as we continue our Year of Code 2025 journey!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Year of Code Project

How to Play:

The Prizes:

Handling Feature Requests

Anthony Cyphers — Sat, 15 Mar 2025 20:12:28 +0000

As a developer, feature requests are a fact of life and one’s stress level may vary based on the complexity of the requests you receive. So what’s the best way to handle a feature request? Well, I’m not sure if there’s a best way, but here’s how I do it.

Understand the Need

The first step when I tackle a feature request is to thoroughly understand what the request is really about. People rarely have the ability to articulate exactly what they need, but are great at giving you just enough details — in small bursts — to figure it out if you carefully investigate their use case.

If you’re unsure of what they’re really trying to accomplish, ask for clarification. It’s better to spend more time up-front finding out what you really need to do than it is to rewrite your changes later. If you find yourself frequently modifying new code based on additional requests shortly after writing it then you may need to work on your communication.

Slow down, ask questions, try to get it right the first time. It’s not always as simple as a specification document (assuming you have one).

Understand the Code

Now that you understand the request, it’s time to analyze the code. Let’s be real, very few people can keep their entire codebase in their mind. Read through your code. Like a book. Follow function calls, property setters, everything. Make sure you understand what you’re modifying before you proceed, and look for the areas you’ll need to modify.

Sometimes this is much easier than others depending on the complexity of the project. And take notes! This step is especially important if you’re working on Other People’s Code (OPC).

Understand the Path

Next, develop a plan. Since you’ve read through code and, presumably, developed some ideas on the best way to implement, develop your own specification for the change. Give yourself time to fully work out the new implementation — I use private notes in my support system for wrapping my head around everything, which has the benefit of giving me greater insight if I need to come back later for some reason.

Work out the path forward before you ever modify any code by noting where you’ll make changes and what those changes might entail, keeping in mind that your previous functionality should continue to work as expected. This might involve creating new code paths specifically for the new feature to ensure that you don’t break old, working code. It’s also important to note things outside the scope of the new feature that you’ll need to test afterward to be sure that you didn’t break anything.

Build the Road

After you have a plan, it’s time to start building. If your strategy has been adequately outlined and you enjoy writing code, this is probably the most fun part. Follow your plan and make changes as you’ve outlined them. Be on the lookout for edge cases or caveats that you may have missed in your specification notes, chances are that they do exist.

Test Everything

Finally, testing! Don’t just test the new feature, test the old functionality as well. It’s common that feature requests require modifying existing systems and you don’t want to push out that new release with a cool new feature only to have existing functionality break. Your work will look rushed and careless, and that’s worse than it taking a bit longer to complete.

Bonus Tip

Know when to rewrite. Over time codebases can become monolithic and overly complex based on continually adding features that were never considered when the project or features being modified were first created. If you find yourself spending more and more time trying to understand your code paths or fixing old functionality that new features break, it may be time to develop a new project specification and start from scratch. Don’t be afraid of tossing out something that causes you endless headaches to modify.

Conclusion

Whether working in a team or solo, a slow and methodical approach to feature requests will ensure that your changes last and customers are happy. Don’t rely on code reviews to catch issues or multiple requests after the fact to get everything right. You’ll make mistakes and miss things, but your work will be much better received with a little additional care.

5 Tips for Optimizing Your Xojo Apps for Performance

Gabriel Ludosanu — Thu, 27 Feb 2025 14:00:00 +0000

Performance can be a make-or-break feature for any application, especially when users expect smooth interactions and quick results. Luckily, Xojo provides tools and techniques you can leverage to ensure your apps run as efficiently as possible.

However, functionality should take priority during the initial implementation. Focus on getting the app or feature working correctly and bug-free before considering optimization. Performance improvements are best handled in subsequent iterations. Remember, “Early optimization is the root of all evil.”

Here are five tips to consider when building or refining your Xojo applications.

1. Identify Bottlenecks with the Xojo Profiler

Before diving into specific optimizations, you need to determine where your app is spending the most time. Xojo’s built-in Profiler provides detailed information on method execution time, helping you isolate trouble spots.

Enable the Profiler: In the Build Settings for your project, ensure “Profiling” is turned on. Then run your application in Debug mode.
Analyze Results: After closing your app, review the profiler report to see which methods and lines of code took the longest time.
Focus on High-Impact Areas: Tackle the biggest time sinks first—a small fix in a heavily accessed function can lead to noticeable performance gains.

Pro Tip: Limit changes to one area at a time, then re-profile. This approach helps confirm whether your optimizations actually improved performance. Read more about the Code Profiler feature: https://documentation.xojo.com/getting_started/debugging/code_profiler.html#getting-started-debugging-code-profiler-using-the-code-profiler

2. Use Efficient Data Structures and Algorithms

Choosing data structures wisely can dramatically impact speed, especially in data-intensive applications.

Arrays vs. Dictionaries: For large datasets with frequent lookups, a Dictionary can deliver faster lookups compared to an array, especially when searching by a key.
Avoid Repetitive Property Lookups: If you access the same class property or control value repeatedly inside a loop, store it in a local variable first. This minimizes overhead each iteration.
Algorithmic Complexity: Review algorithms for large tasks. Nested loops that appear simple could become extremely slow for bigger data sets. If possible, replace them with more efficient sorting and searching methods.

Example: Instead of repeatedly using myArray.IndexOf(item) inside a loop, store the index in a variable once or switch to a Dictionary for faster lookups.

3. Offload Work to Threads

Making your application responsive often means running time-consuming tasks in the background.

Why Threads Help: Xojo threads let you perform lengthy computations without freezing the main UI. This creates a better user experience and can let users continue working while the app processes data.
Identify Good Candidates: Processing data, network transactions, or any tasks that take more than a fraction of a second can benefit from being threaded.

Pro Tip: If you only have a short delay (like reading a small file), threading may introduce complexity. Focus on threading tasks that truly benefit from parallel or asynchronous execution.

4. Manage File and Network I/O Efficiently

Disk access and network requests tend to be some of the biggest performance bottlenecks.

Batch Operations: Rather than reading or writing data one line at a time in a loop, try batching reads/writes to minimize overhead.
Cache Strategically: If your app frequently loads the same data (like configuration files), store it in memory for quick access.
Asynchronous Calls: For tasks requiring large data transfers or multiple network requests, consider asynchronous approaches so the UI remains responsive.

Example: When generating reports, accumulate data in a buffer or in-memory structure, and then perform a single file write at the end, instead of dozens or hundreds of small writes.

5. Mind Your Loops and String Operations

Nested loops and repetitive string concatenations are particularly notorious performance killers.

Minimize Nested Loops: Combine or break up loops that needlessly repeat the same work. For example, a single pass that filters and sorts data is typically faster than two separate loops.
Efficient String Handling: Building long strings in a tight loop using the + operator can degrade performance because strings are immutable in many languages, and repeated concatenation can cause extra memory allocations.
Use Add: If you’re concatenating parts of a string repeatedly, consider using an array combined with String.FromArray for more efficient handling.

Example: Instead of doing:

Var largeString As String
For i As Integer = 0 To 1000
  largeString = largeString + "line " + i.ToString
Next

…collect lines in a String array, then String.FromArray() them once. You’ll often see a significant speed boost in large-scale operations.

Conclusion

Optimizing your Xojo apps for performance doesn’t have to be an intimidating process. With the right tools (such as the Code Profiler) and a focus on data structures, threading, efficient I/O, and mindful loop/ string operations, you can significantly speed up your apps and keep the user experience smooth.

Remember to quantify the results by measuring before and after each change. By continuously profiling and fine-tuning your code, you’ll create compelling, efficient Xojo applications that delight your users.

Have fun optimizing and don’t forget to share your own performance tips or success stories in the Xojo community forums!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Introduction to PocketBase: A Backend Alternative for Xojo Developers

Ezekiel Burke — Wed, 19 Feb 2025 16:02:00 +0000

Introduction

When developing applications with Xojo, choosing the right backend is crucial for managing data efficiently. Traditionally, Xojo developers rely on SQL databases such as SQLite, MySQL, or PostgreSQL for their desktop, web, and mobile applications. However, there is an alternative that provides a more flexible and modern approach to backend development: PocketBase.

PocketBase is an open-source backend perfect for your multi-platform Xojo application. It offers a simple-to-use API and a built-in admin panel to manage the data from any web browser. No other tool such as MySQL, Workbench, or SQL Studio is needed. In this post, I will explain how it compares to traditional SQL databases and demonstrate how to integrate it into a Xojo project.

Why Choose PocketBase for Your Xojo App Backend?

PocketBase is a lightweight, self-hosted backend designed for simplicity and flexibility. Unlike traditional SQL databases that require a separate backend service or API layer, PocketBase is an all-in-one solution that combines the database and API.

Key Features:

Embedded Database – Powered by SQLite, eliminating the need for a separate database server.

Built-in User Authentication – Supports email/password logins, OAuth2 sign-ups, and one-time password (OTP) with minimal setup.

File Storage – Store and retrieve files locally or via S3.

Cross-Platform Compatibility – Runs on macOS, Windows, and Linux. Can communicate via URLConnection making it ideal for Xojo’s desktop, web, and mobile platforms.

Easy Deployment – A single binary file that can be self-hosted or deployed anywhere with minimal configuration.

Setting Up PocketBase for a Xojo App

To get started, I have simplified some steps below. If you get stuck or want more in-depth instructions take a look at the documentation.

Download PocketBase
- Visit PocketBase and download the latest release for your operating system.
- Extract the files to your project directory.
Run PocketBase
- Start the PocketBase server by navigating to the extracted folder in the command prompt/terminal.
- Run the command: ./pocketbase serve to start the server.
Access the Admin Panel
- Open http://127.0.0.1:8090/_/ in a web browser and set up an admin account.
Add a User
- In the PocketBase admin panel, create a new record in the users collection. (Collections are the equivalent of a table in SQL.)

Connect Xojo to PocketBase

Now that your PocketBase server is running, integrate authentication into your Xojo desktop app. In this example, we will handle authentication in the open event of the main window. This will demonstrate how Xojo interacts with PocketBase’s authentication API.

Implement the Login Request

Add the following code to the open event of your main window:

Var userEmail As String = "email@email.com"
Var userPassword As String = "MyPassword!"
Var loginURL As String = "http://127.0.0.1:8090" + "/api/collections/users/auth-with-password"
Var conn As New URLConnection
conn.RequestHeader("Content-Type") = "application/json"
 
Var loginPayload As New JSONItem
loginPayload.Value("identity" ) = userEmail
loginPayload.Value("password") = userPassword
conn.SetRequestContent(loginPayload.ToString, "application/json")
 
Var loginResponse As String = conn.SendSync("POST", loginURL)
Var jsonResponse As New JSONItem(loginResponse)
Var userInfo As JSONItem = jsonResponse.Lookup("record", New JSONItem)
Var userID As String = userInfo.Lookup("id", "")
Var authToken As String = jsonResponse.Lookup("token", "")
 
If authToken.Length > 0 Then
  MessageBox("Login successful! Welcome, User ID: " + userID)
Else
  MessageBox("Login failed. Please check your credentials.")
End If

Update Your Credentials and URL

Replace userEmail and userPassword with the credentials you used to create a user in PocketBase. Also, ensure the loginURL matches your PocketBase instance (without /_/ at the end).

Run The App

Launch your Xojo app. If authentication is successful, a message box will display the user’s ID. Otherwise, you will see an error message indicating that the credentials are incorrect.

Wrapping Up

In this article, you have successfully set up a PocketBase server, created a record, and integrated authentication into your Xojo app. PocketBase simplifies backend development by handling authentication and data storage—all without the need for a traditional SQL database.

With PocketBase, there is no need to set up complex user tables, hash passwords, or build a custom API. Collections can be easily managed directly from the web via the admin panel. This means you can spend less time managing infrastructure and more time focusing on bringing your app to market.

To help you get started, I’ve created a collection of example projects, which you can find here:

Xojo-Pocketbase-Examples

If you’d like to discuss how Iron Elephant Solutions has used Xojo and PocketBase in real-world applications, feel free to reach out through our website or add me on LinkedIn.

Ezekiel Burke is the founder of Iron Elephant Solutions. He focuses on building custom, scalable, and affordable software that helps businesses work smarter. With 15+ years of experience, he specializes in full-stack development, process automation and systems integration, creating solutions that simplify complex workflows.

Year of Code 2025: February Project, Database Apps

Paul Lefebvre — Tue, 11 Feb 2025 16:48:26 +0000

February’s Year of Code 2025 topic is Databases and my project is a SQLite object-relation mapping library that I call Storm.

I first created Storm in 2008 when I was working on consulting projects as a way to more rapidly create database apps for clients. It has been updated over the years and the latest version is available on GitHub:

Storm

An ORM lets you write code like this to set database column values and save them:

Var dodgers As New Team
dodgers.Name = "LA Dodgers"
dodgers.Coach = "Dave Roberts"
dodgers.Save

Team is a table in the database with a corresponding class in Xojo that inherits from Storm.DBObject.

The included demo projects shows how you can implement a simple UI for a database with Team and Player tables.

The docs for Storm are contained within its Github repository wiki.

In addition to accessing the full repository on GitHub, you can also download Storm as a ZIP.

I’ve created a forum topic for you to start sharing your Year of Code projects and I’ll also be sure to include this one as well. Remember, participants can win a $100 to use in the Xojo Store!

Year of Code Project

How to Play:

The Prizes:

Year of Code 2025: January Project, Desktop Apps

Paul Lefebvre — Wed, 15 Jan 2025 19:26:16 +0000

January’s Year of Code 2025 topic is Desktop apps and my project is XojoText.

XojoText is a simple text editor that lets you edit multiple files in one window with a list of files in the left sidebar. You can create new blank documents, documents from a selection in another document or from the clipboard.

It is based on the XojoText example that is included with Xojo, but enhanced in these ways:

Word, character, line counts shown at bottom of editing area.
Recent Items menu.
Window menu.
Saves window position.
Prompts to sae changes.
Contextual menu on files in the sidebar.
Click “x” to close files in the sidebar.

Suggestions for improvements and things to add:

Find/Replace capability.
Printing.
PDF generation.

I’ve created a forum topic for you to start sharing your Year of Code projects and I’ll also be sure to include this one as well.

You can download the XojoText project from GitHub here: https://github.com/paullefebvre/XojoText

Year of Code Project

How to Play:

The Prizes:

Year of Code 2025: Kickoff

Paul Lefebvre — Thu, 09 Jan 2025 16:30:00 +0000

Xojo is kicking off 2025 with something for everyone in the Xojo community, an event that will help new users grow their Xojo coding skills and existing users polish theirs. Back in 2018, we did a “Summer of Code” contest that challenged people to create one project a week through the summer. This was a lot of fun and many interesting apps were made that summer. For 2025, we have expanded that idea out to the entire year! However, instead of one app a week, we will make one app a month from January to November 2025. In December we will give away a grand prize!

The Idea

Early each month we will share a blog post that introduces an app “theme” and recaps the prior month. A week or so later, we will create a Forum topic and post an example project created by one of the Xojo team. To participate in the Year of Code, make a Xojo project that that demonstrates the theme in some way, share it on GitHub to make it easily accessible to everyone and then add a post about it (with your GitHub link) to the Forum topic.

If you have not used GitHub before, here is a blog post on how to share a Xojo project on GitHub.

Ideally, these will be small, focused apps that can be made in a few days. The idea is to have fun creating something that others might learn from. But I guarantee you’ll learn something as well. After all, the best way to get better at coding is to always be coding.

How To Participate

Each month Xojo will announce a new theme and share an example project. Share your own projects in the Xojo Forum thread for that month via GitHub, preferably. Projects with code shared at other sites can be eligible as long as the code is accessible to everyone. Learn how to use Xojo and GitHub.

The Prizes

And yes, there will be prizes for those that participate. Each month all participants (everyone who shares a project that month) will be entered for a chance to win a monthly prize of $100 at the Xojo Store plus a 25% off coupon for GraffitiSuite.¹ The $100 can be applied to any Xojo license purchase or Extras Store item. At the end of 2025, all participants from the year will be entered to win the grand prize of a Xojo Pro license, $250 cash and a free year of GraffitiSuite. The more months in which you participate throughout the year, the more chances you’ll have to win the grand prize.

January’s Theme

Now that it is January (Happy New Year, everyone), the 2025 Year of Code kicks off with this theme: Desktop apps. People have used Xojo to make wonderful desktop apps since its inception in 1998 so this is an ideal first theme that is broad enough to allow anyone to participate. Look for a post next week announcing this months’ project details. Once it is posted, I will start a forum topic for others to share GitHub links to their projects and apps. In early February we will do a blog post that highlights what people made this month and introduce February’s theme.

I hope you will join us for the 2025 Year of Code and I look forward to seeing what you make with Xojo!

#2025YearOfCode

Monthly winners are excluded from future monthly prizes but each monthly participant earns an additional entry into the grand prize drawing. ︎

Year of Code Project

How to Play:

The Prizes:

Conditional Statements: Select Case vs. If…Else Explained

Gabriel Ludosanu — Mon, 16 Dec 2024 19:00:00 +0000

When you’re writing code, you often need to make decisions based on different situations. These decisions are handled using conditional statements. Conditional statements let your program choose what code to run based on whether certain conditions are true or false. Two of the main ways to do this are: Select Case and If…Else statements. They both help your program decide what to do, but they work a bit differently. This article will explain how each statement works, when to use them, and how to choose the best one for your code.

The If…Else Statement

You’ve probably seen If...Else statements in other programming languages too. They’re like the basic building blocks for making decisions in your code. The main strength of If...Else is that it’s very flexible. It lets you check if something is true or false and then do different things based on the answer.

You can also combine conditions using And and Or.

And: Checks if both conditions are true. For example, If age > 18 And hasLicense = True Then (You need to be over 18 and have a license).
Or: Checks if at least one of the conditions is true. For example, If score > 90 Or extraCredit = True Then (You can get an A if your score is over 90 or if you did extra credit).

You can even add more options using ElseIf to create more complex sets of rules. Think of it like a choose-your-own-adventure book where the story changes based on your choices.

Pros of If…Else:

Flexibility: Handles all sorts of situations, even complicated ones where you need to check many things at once.
Suitable for Two-Outcome Scenarios: Perfect when you just need a simple true/false check.

Cons of If…Else:

Readability: When you have lots of ElseIf parts, the code can get really long and confusing, like a maze with too many turns.
Maintainability: Changing a big If...Else statement can be tricky. It’s easy to make a mistake and mess up how the code works without realizing it.

Example:

Var age As Integer = 25
Var message As String

If age < 18 Then
  message = "Minor"
ElseIf age >= 18 And age < 65 Then
  message = "Adult"
Else
  message = "Senior"
End If

System.DebugLog(message)

The Select Case Statement

The Select Case statement is like a neat and organized way to deal with a list of options for one thing. Imagine you have a variable, like a number grade. Select Case lets you check that grade against different cases (like “A”, “B”, “C”) and then do something specific for each grade.

Example:

Var grade As String = "B"
Var feedback As String

Select Case grade
Case "A"
  feedback = "Excellent"
Case "B"
  feedback = "Good"
Case "C"
  feedback = "Fair"
Case "D", "F"
  feedback = "Needs Improvement"
Else
  feedback = "Invalid Grade" // This is the default case
End Select

System.DebugLog(feedback)

The Else Case In a Select Case statement, acts like a default. If none of the other cases match the value you’re checking, the code inside Else will run.

Using Ranges in Select Case

You can also check for ranges of values using To. For example:

Var score As Integer = 85
Var grade As String

Select Case score
Case 90 To 100
  grade = "A"
Case 80 To 89
  grade = "B"
Case 70 To 79
  grade = "C"
Case Else
  grade = "D" 
End Select

System.DebugLog(grade)

Pros of Select Case:

Readability: Makes your code super clear when you’re dealing with multiple options for a single thing.
Maintainability: It’s easy to add, remove, or change the different options without messing up the rest of your code.
Efficiency: Sometimes, Select Case can be faster than a long If...Else chain.

Cons of Select Case:

Only Works with One Thing at a Time: It’s mostly for checking one variable or one simple calculation against a list of possibilities.
Less Flexible: It’s not great when you need to check lots of different things at once or do complicated comparisons.
Range limitations: If you are comparing ranges of numbers, you have to be careful about the order of your cases.

When to Use Which

Use If...Else when:
- You only need to check if something is true or false.
- You need to check many different things at the same time using “and” or “or”.
- You need the most flexibility to handle all sorts of situations.
Use Select Case when:
- You’re checking one thing against a list of possible values.
- You want your code to be super clear and easy to understand.
- You want a neat way to organize different options.

Best Practices

Use meaningful names: Choose names for your variables that clearly describe what they store (e.g., studentAge instead of just age).
Keep it short: Try to keep the code blocks within your If...Else or Select Case statements relatively short and focused. If a block gets too long, consider breaking it down into smaller parts.
Comment your code: Add comments to explain what your code is doing, especially in complex If...Else statements. This will help others (and your future self) understand your code.

Conclusion

Both Select Case and If...Else are useful tools for making decisions in your code. Choosing the right one depends on what you need your code to do. If...Else is great for handling complicated situations, while Select Case is perfect for keeping things clear when you have a list of options. Knowing when to use each one will help you write better code that is easier to understand and work with. By thinking about what you need to check and how clear you want your code to be, you can use both of these statements to create awesome apps!

Update

Since the time this article was published, our great Xojo community has taken the discussion even further! On the Xojo Forum, developers have shared advanced examples, creative use cases, and expert tips for using If…Else and Select Case statements.

Be sure to check out the thread here: https://forum.xojo.com/t/re-if-then-vs-select-case/83633

We’re continually inspired by the passion and knowledge of our community—thank you for making Xojo such a collaborative and supportive space!

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Code Editor Selection Matching

Paul Lefebvre — Tue, 10 Dec 2024 16:37:25 +0000

A new feature of the Xojo Code Editor is Selection Matching. When this feature is turned on, selected text is highlighted everywhere it appears in the current Code Editor.

Here you can see that “customerRS” is selected on line 14 and all the other places where it appears in the method is also highlighted.

This feature can be very handy to see how things are used in your code and is much easier than using the Find panel.

Note: The matching is done by full word tokens. So if you highlighted just “customer” in the above code, then nothing is matched because that does not match the “customerRS” tokens.

To turn this feature on, head over to Settings, Coding and check the box for “Display selection matches”.

You can also change the color that is used for the matching by changing the Syntax color “Selection Match Color”.

Everything You Need to Know About Variants in Xojo

Martin T. — Thu, 10 Oct 2024 16:45:00 +0000

One of the most interesting features in Xojo is the Variant data type. We will explore the so-called “Implicit Conversions,” discuss the pros and cons of using Variants, and analyze when it makes sense to use this data type.

For more detailed information, you can refer to the official Xojo documentation on Variants.

What are Variants?

A Variant in Xojo is a data type that can store any type of data. This means that a variable of type Variant can take on different data types without needing to be explicitly converted. This can be very useful when you want to be flexible, but it can also lead to unexpected problems if not handled correctly.

Basic Example

Var dynamicValue As Variant

dynamicValue = 42                              // Integer
dynamicValue = "Hello"                         // String
dynamicValue = 3.14                            // Double
dynamicValue = True                            // Boolean
dynamicValue = Color.RGB(255, 0, 0)            // Color
dynamicValue = New Dictionary("key" : "value") // Dictionary

In the example above, you can see that dynamicValue can take on different data types without the need to explicitly change the type.

Implicit Conversions

Implicit Conversions are automatic type conversions performed by Xojo when using Variants. This means that Xojo tries to interpret the data in a Variant so that it fits the context in which it is used.

Example of an Implicit Conversion

Var dynamicValue As Variant = "123"

Var myInteger As Integer
myInteger = dynamicValue  // Implicit conversion from String to Integer

In this example, the string “123” is automatically converted to an integer when assigned to the integer variable myInteger.

Another Example with Data Types

Var dynamicValue As Variant = "3.14159"

Var myDouble As Double
myDouble = dynamicValue  // Implicit conversion from String to Double

Here, the string “3.14159” is automatically converted to a double. This demonstrates the flexibility of Variants and Xojo’s ability to handle different data types.

Conversion of Floating-Point Numbers

In Xojo, assigning a floating-point number to a Variant will always produce a Double. However, there are other floating-point data types such as Single, Currency, and CGFloat.

Var dynamicValue As Variant = 3.14

Var myDouble As Double
Var mySingle As Single
Var myCurrency As Currency
Var myCGFloat As CGFloat

myDouble = dynamicValue   // Double: 3.14
mySingle = dynamicValue   // Single 3.14 (implicitly converted)
myCurrency = dynamicValue // Currency: 3.14 (implicitly converted)
myCGFloat = dynamicValue  // CGFloat: 3.14 (implicitly converted)

In this example, you can see that assigning dynamicValue (which contains a floating-point number) to different floating-point data types always works, with the implicit conversion performed by Xojo.

Advantages of Implicit Conversions

Flexibility

The biggest advantage of Variants is their flexibility. You can write functions that can work with different data types without requiring explicit type conversion.

Example of a Flexible Function

Function AddValues(value1 As Variant, value2 As Variant) As Variant
  Return value1 + value2
End Function

// Using the function with different data types
Var result As Variant
result = AddValues(10, 20)             // Integer addition
result = AddValues("Hello", " World")  // String concatenation
result = AddValues(3.14, 2.71)         // Double addition

This function can work with integers, strings, and doubles without requiring changes to the code.

Rapid Prototyping

During rapid prototyping, Variants can be useful because they reduce the need to worry about type conversions.

Example of a Quick Prototype

Var quickData As Variant = "42"

If quickData > 10 Then
  MessageBox("Greater than 10")
End If

In this example, the string “42” is automatically converted to an integer to perform the comparison.

Disadvantages of Implicit Conversions

Debugging

It can be difficult to debug errors caused by incorrect type conversions. Since the conversion happens automatically, it is sometimes not obvious why a particular error occurs.

Performance Issues

Implicit conversions can lead to performance issues, especially when large amounts of data need to be converted.

Example of Performance Issues

Var dynamicValue As Variant = "9999999999"
Var myDouble As Double

For i As Integer = 1 To 1000000
  myDouble = dynamicValue  // Performance hit due to repeated conversions
Next

In this example, the conversion is performed during each iteration of the loop, which can impact performance.

Loss of Type Safety

Another risk is the loss of type safety, which can lead to unexpected runtime errors.

Type Property

The Type property is a useful tool to determine the data type of a Variant value. This property returns an integer that corresponds to the type of the value. This can be helpful to ensure that you are handling the correct data type.

Example of Using the Type Property

Var dynamicValue As Variant = "Hello"

Select Case dynamicValue.Type
Case Variant.TypeString
  MessageBox("The variant is a String.")
Case Variant.TypeInt32, _
     Variant.TypeInt64
  MessageBox("The variant is an Integer.")
Case Variant.TypeDouble
  MessageBox("The variant is a Double.")
Case Variant.TypeBoolean
  MessageBox("The variant is a Boolean.")
Else
  MessageBox("The variant is of another type.")
End Select

In this example, dynamicValue.Type is used to determine the type of the Variant value and perform corresponding actions.

When Should You Use Variants?

Suitable Use Cases

Generic Functions

If you are writing functions that need to work with different data types, Variants can be very useful.

Function CompareValues(value1 As Variant, value2 As Variant) As Boolean
  Return value1 = value2
End Function

// Using the function with different data types
Var isEqual As Boolean
isEqual = CompareValues(10, 10)          // True
isEqual = CompareValues("Hello", "Hello")  // True
isEqual = CompareValues(3.14, 2.71)      // False

Interoperability with External APIs

When working with APIs or interfaces that return different data types, Variants can provide an easy way to handle this data.

// Example API response that can return different data types
Function GetApiResponse() As Variant
  // Simulated API response
  Return "42"  // Could also be an Integer or a JSON object
End Function

Var apiResponse As Variant = GetApiResponse

If apiResponse.Type = Variant.TypeString Then
  MessageBox("Response is a string: " + apiResponse)
ElseIf apiResponse.Type = Variant.TypeInt32 Or _
       apiResponse.Type = Variant.TypeInt64 Then
  MessageBox("Response is an integer: " + apiResponse)
End If

Data Structures

In situations where you need data structures that contain different data types (e.g., an array that can contain both strings and numbers), Variants are a good choice.

Var dataList() As Variant
dataList.Add("Xojo")
dataList.Add(2024)
dataList.Add(True)

// Accessing different data types in the array
For Each item As Variant In dataList
  Select Case item.Type
  Case Variant.TypeString
    MessageBox("String: " + item) 
  Case Variant.TypeInt32, _
       Variant.TypeInt64
    MessageBox("Integer: " + item) 
  Case Variant.TypeBoolean
    MessageBox("Boolean: " + item)
  End Select
Next

Situations to Avoid Using Variants

Performance-Critical Applications

When performance is critical, you should avoid Variants because automatic type conversion introduces additional overhead.

Var dynamicValue As Variant = "9999999999"
Var myDouble As Double

For i As Integer = 1 To 1000000
  myDouble = dynamicValue  // Performance hit due to repeated conversions
Next

Code Clarity and Maintainability

When code readability and maintainability are paramount, you should use explicit data types to ensure that the code is understandable to other developers.

Var myString As String = "Hello"
Var myInteger As Integer = 123

Function ConcatenateStrings(s1 As String, s2 As String) As String
  Return s1 + s2
End Function

Var result As String
result = ConcatenateStrings(myString, myInteger.ToString)  // Clear and understandable

The use of Variants in Xojo offers both advantages and disadvantages. While flexibility and rapid prototyping capabilities are compelling arguments, you should be aware of the potential problems that can arise from implicit conversions. Variants are best suited for scenarios where flexibility and generic programming are required. In performance-critical applications or projects that require high maintainability, it is advisable to use explicit data types such as String, Integer, Double, Boolean, Color etc. or, if you decide to use Variant, you can also have the explicit data type of the Variant delivered. To do this, use the Variant …Value properties (for example StringValue, IntegerValue, BooleanValue etc.).

By taking a conscious and deliberate approach to using Variants, you can leverage their advantages while avoiding potential pitfalls.

For more detailed information, you can refer to the official Xojo documentation on https://documentation.xojo.com/api/data_types/variant.html.

Martin T. is a Xojo MVP and has been very involved in testing Android support.

5 Xojo IDE Tips to Improve Productivity in Large Projects

Javier Menendez — Wed, 04 Sep 2024 16:25:49 +0000

When you’re working on small to medium-sized projects, Xojo’s default IDE window view is probably all you need: all the elements of the project are in plain view and you can easily switch between them. However, things inevitably get more complex when dealing with larger projects. You may need to locate and edit several related items, larger projects likely include multiple methods, events, properties and modules, all of which may be be in their own folders created to organize their functionality or components.

In this article we will highlight several functions provided by the Xojo IDE that allow you to speed up and improve productivity in your large projects.

Filter the Navigator

The Navigator filter field allows you to limit the number of visible items in a section to those matching the typed text. This can filter a list to include only the objects used, such as controls, or even items that match the names of events, methods, properties, constants, etc. -practically any of the items added to the project except the code itself.

If you need to keep all elements of your project visible while browsing through matching results, it is preferable to use the standard search which you can access using Command + F (on macOS) or Control + F (Windows and Linux).

Going Directly to a Project Item

However, there are many times when you know the exact name of the item you want to select/display; whether it’s the name of a method, event, or even a control itself. In these cases, it is much quicker to use the Project > Go to Location option (Command + Shift + L on macOS; Control + Shift + L on Windows and Linux).

When you select this command, a dialog box will appear where you can type the path of the item you want to select. So, for example, if you want to go to the method “myMethod” found in the window “MyWindow” you would type: “MyWindow.myMethod”. The text field in that dialog offers auto-completion which means that, in most cases, you will only have to start typing the name of the main item and use the Tab key to access the menu displaying all the matches to select any sub-item you wish to select.

Additionally, and unlike the filter field, the hierarchy of the project elements will remain visible in the Navigator as they are.

Powerful Searches

This is undoubtedly the most powerful option that you can access using the keyboard shortcut Command + F (on macOS) or Ctrl + F (Windows, Linux), or by clicking on the magnifying glass icon in the bottom bar of the IDE.

Once you access the Find panel and start typing in the search field, the list below will start to populate with all the matches (by default); but you will probably find it more useful in larger projects to have the list refresh after you press the Return key. To do this, go to the Preferences window and, in the General section, change the “Find/Filter results appear” option to “After pressing Enter/Return”.

While by default the Find window displays matches found throughout the entire project, there are times when you may want to narrow it down to either the selected item, including any subclasses that may be based on that item, or simply the item in question; you can do this by using the following buttons:

Another added advantage of the search area is that it keeps a history of previously performed searches, thus speeding up the process when you need to revisit a new group of elements. In addition, you can change from simple (textual) searches to the more powerful use of regular expressions (RegEx) when looking for elements in your project.

Of course, this same panel also allows you to replace the searched text with other text on all the matches shown… but be careful before confirming. Make sure that they truly apply to the elements you want and not to others just because they start with the same word entered in the search field!

Bookmarks: Sitting There for You

In many cases, you will use the above systems to edit the code in a given method or event; especially if these are areas of code that you visit frequently. If that is the case, then you will find Bookmarks a really useful feature.

You can add or remove Bookmarks in the code editor by accessing the contextual menu from the currently selected line of code. You can also add as many Bookmarks as you need to a single code block, which is especially useful for large blocks of code on a given method, for example.

Once you have all your Bookmarks defined, you will simply need to select the menu option Bookmarks > Show All to have them displayed in the search area where you can select them.

Tip: Use the Preferences > General > Menu > Edit Menu Shortcuts option to assign a keyboard shortcut to the Bookmarks > Show All command. This will make it quicker to update the bookmarks listed in the Search area when they are not listed.

Tabs and Workspaces

Sometimes it is preferable to have several items in view when working on a large project, so that you can switch between them quickly; or to have the Layout Editor and the Code Editor for the same object. This is where Tabs and Workspaces are extremely useful.

By default, the Xojo IDE window has a single tab that displays all the elements added to the project, but you can open as many tabs as you need, and these tabs will be preserved when you close and reopen the same project, just as Workspaces will.

So, if you need to focus on a particular module or class, you can double-click on the item in the Navigator to open it in a new tab. Want more clarity, especially if your tabs bar is overcrowded? In that case, you can drag the tab in question outside the window boundaries to open it as a new IDE window (a new Workspace). Of course, you can also use keyboard shortcuts to move between open tabs in a single IDE window.

As you can see, Workspaces are new IDE windows for a single project. In fact, you can have as many as you need using the New > Workspace menu option. However, this option is only recommended if your setup has a high-resolution screen or multiple screens connected to your computer.

Conclusions

As we have seen, using filtering, searches, bookmarks, tabs and even the “Go To Location” command, among other options mentioned, will greatly speed up navigation when you are working on large projects.

What other IDE techniques do you use? Share them with us on the Xojo Forum or on social media.

Happy programming with Xojo!

Minimizing Overhead in Xojo Applications: Techniques, Tips, and Tricks

Martin T. — Wed, 10 Jul 2024 14:00:00 +0000

In the world of software development, efficiency is a central aspect. This is especially true for applications developed in Xojo. Excessive overhead can significantly impair performance and negatively affect the user experience. In this article, we will take a detailed look at what overhead is, how to identify it, and what techniques, tips, and tricks can be used to minimize it. We will particularly focus on using code profiling.

What is Overhead?

Overhead refers to the additional computational and memory effort that does not directly contribute to the execution of the main tasks of an application. This can arise from various factors, such as inefficient algorithms, unnecessary computations, or redundant memory allocations. High overhead can lead to slow response times and increased resource consumption.

Identifying Overhead with Code Profiling

To effectively minimize overhead, it is first important to identify it. This is where code profiling comes into play. Profiling is a runtime analysis technique that provides insight into how long certain parts of your code take to execute and how often they are called. Xojo offers integrated tools for this purpose, such as the Profiler, which gives you detailed information about your application’s performance. Code profiling is available on all targets except Android.

Steps to Profiling in Xojo:

Activating the Profiler: Go to the menu item Project > Profile Code to enable or disable the profiler.
Manual Profiling with StartProfiling and StopProfiling: Use the StartProfiling and StopProfiling methods in your code to analyze specific sections.
Analyzing the Profiler Results: After running, you will receive a report showing which methods and functions take the most time.

For more information on the Code Profiler, see the Xojo Documentation.

Example of Manual Profiling

With StartProfiling and StopProfiling, you can target specific parts of your code for profiling. Here’s a simple example:

Var total As Integer = 0

// Start profiling
System.DebugLog("Profiling started")
StartProfiling

For i As Integer = 0 To 1000000
  total = total + i
Next

// Stop profiling
StopProfiling
System.DebugLog("Profiling stopped")

In this example, the profiler is activated only for the loop to analyze its performance precisely.

Techniques to Minimize Overhead

Once you have identified the areas with optimization potential, you can apply various techniques to reduce overhead:

1. Algorithmic Optimizations:

– Use more efficient algorithms. An O(n) solution is better than an O(n^2) solution.

– Avoid recursive algorithms when iterative solutions are available to avoid stack overhead.

2. Memory Management:

– Minimize unnecessary memory allocations and deallocations.

– Use local variables as much as possible and avoid global variables to reduce memory consumption.

3. Data Structures:

– Choose the right data structures for your requirements. For example, arrays are often faster than other structures for sequential data access.

– Use dictionaries for fast lookups as they manage key-value pairs efficiently.

4. Asynchrony and Parallelism:

– Use asynchronous programming and multithreading to perform tasks in parallel and improve the responsiveness of the user interface.

5. Code Simplicity:

– Write clear and simple code. Complex structures and nested loops increase overhead.

– Use Xojo’s pre-built functions and libraries, which are often more optimized than custom implementations.

Tips and Tricks for Optimization

1. Lazy Loading:

Load resources only when they are needed instead of loading everything at the start of the application.

2. Caching:

Implement caching mechanisms to avoid repeated computations and database queries.

3. Avoiding Polymorphism:

Polymorphic calls are often more expensive than direct function calls. Use them only when necessary. Polymorphism is a concept in object-oriented programming that allows objects of different classes to be treated through a common interface. In Xojo, this means you can define methods in a base class and override them in derived classes. However, this can add overhead as the exact method call must be resolved at runtime.

4. Using Breakpoints and Inspectors:

Set breakpoints and use the debugger inspector to check runtime data and identify inefficient parts of the code.

Example: Optimizing a Loop

Here is an example of how to optimize a loop:

// Unoptimized code
Var total As Integer = 0
For i As Integer = 0 To dataArray.LastIndex
  total = total + dataArray(i)
Next

// Optimized code
Var total As Integer = 0
Var lastIndex As Integer = dataArray.LastIndex
For i As Integer = 0 To lastIndex
  total = total + dataArray(i)
Next

In this example, we moved the LastIndex method call out of the loop since repeatedly calling it creates unnecessary overhead.

Minimizing overhead in Xojo applications requires careful analysis and optimization of your code. By using code profiling, you can identify the areas that consume the most runtime and take targeted actions to optimize them. The techniques, tips, and tricks presented here can significantly improve the efficiency of your applications and ensure a better user experience.

Leverage Xojo’s powerful tools to keep your applications lean and fast, and benefit from improved performance.

Happy coding!

Martin T. is a Xojo MVP and has been very involved in testing Android support.

Spotlight On: xDev Magazine

Xojo — Mon, 08 Jul 2024 18:00:00 +0000

Spotlight On posts focus on Xojo community members. We’ll use this space to tell the stories of people using Xojo, share amazing Xojo-made apps and spread awareness of community resources. If you have an app, a project or a person you want to see featured in Spotlight On, tell us about it!

xDev is a bimonthly digital publication and a staple of the Xojo community since 2002. Every issue is packed with fresh and vital information: step-by-step tutorials by Xojo experts, columns for the beginner and expert, “behind-the-scenes” postmortems of popular programs made with Xojo, fascinating interviews, handy tips, product reviews and Xojo news. Subscribe today and start expanding your Xojo world.

10 Questions with Marc Zeedar of xDev Magazine

Mac, Windows or Linux?

Mac.

What do you wish more people would ask you about when it comes to xDev?

I love learning about people’s projects. I find many (most) people are overly modest about their own work and over-idealize the coding of others. Every programmer creates bugs. The truth is that *every* project is interesting, regardless of skill level. That’s one of the things I love about programming: it’s so vast and covers such a broad array of uses. They’re all fascinating.

It’s especially gratifying to hear about xDev articles or tips that readers put into practice. There’s nothing better than learning how the magazine helped someone!

How would you explain your most recent project to a 5 year old?

I got AI to help find writing errors in articles (see xDev 22.4’s “Beginner’s Corner” column).

What’s next on your Learn Next list?

Oh boy. That list is so long! And it doesn’t just include programming. Like I’m working on building a microcamper and I’m wanting to learn more woodworking skills so I can build some custom cabinets. I know just enough to be dangerous now and to realize how much more I need to learn!

In terms of programming, I always feel I’m weak on the algorithms side. There are many project ideas where I have no idea how to even begin. So I’m always open for more learning in problem solving.

In tech, I’d like to learn more about AI from a behind-the-scenes perspective, such as training models. For instance, could I create an AI model trained on xDev content that would make it easier to find coding help from past articles?

When do you think of solutions for big bugs?

Usually several hours after I wished I had! Typically that’s at 3 a.m. when I should have quit and gone to bed at midnight. Then I’m kicking myself for making such an “obvious” error.

What programming moments made you think “Wow, I love my job so much.”

Every time my code actually works! There’s nothing more satisfying than having an idea and then seeing it come to life. Probably 90% of the time when I start a project it’s on a whim and I’m just “playing around” to see if the idea is even feasible. Then when it works I’m totally jazzed and inspired.

I did that recently with my “Sandstorm” simulation (xDev 22.1) [Download this article for free], my “Find the Differences” game (xDev 21.6), and my “Xojo Jigsaw” app (xDev 20.4). They all started out with me just fiddling around and then ended up as surprisingly good apps I could write articles about.

What’s something that has surprised you about coding in the last 10 years?

Probably AI (horribly named since it isn’t intelligent at all), which is problematic, but capable of impressive feats. The idea that it can actually generate useful code is wild to me. It’s still early days and there are serious issues to figure out, but it has incredible potential.

Focusing more on coding itself, I don’t think it’s any one thing, but just the way programming has improved and grown more powerful over the last decade. Each year there are small improvements and after ten years you look back and you’re amazed. The high standards of software these days — what users expect — keeps rising and yet coding is getting more powerful and making achieving those levels possible.

What’s a cool piece of software more people should know about?

Not really software, but a technology: RSS (Really Simple Syndication). It’s old, but so simple (it’s even in the name) and effective. I hear so many people grumbling about bad stuff on the news, social media, screen addiction, etc. and I wonder why they put themselves through that. The beauty of RSS is you can use it to set up your own custom feed of information and ignore all the cruft. I get to ignore politics and nonsense and focus on interesting people and technology.

What’s the coolest thing you worked on recently?

Besides my microcamper? My current project is always the coolest, at least until the next one comes along.

Music or no music while coding?

No music. I wouldn’t hear it anyway. When I go into coding mode (or writing mode or reading mode), I’m not aware of much that’s around me. It’s like I’m underwater.

Thank you to Marc Zeedar for answering our questions. If you want to learn more about xDev visit https://www.xdevmag.com/, you can get your subscription via PDF, or print for those of you who still like to hold your media in your hands. xDev also offers a 500-page printed book of each year’s issues.

Since its launch in 2002, Marc Zeedar is the publisher and editor of *xDev Magazine*, an independent bimonthly publication focused on instructing users of the Xojo development environment. He’s been using Xojo (then called REALbasic) since 1998 when he released his acclaimed Z-Write word processor, a unique tool for creative writers. In his spare time he hikes and camps, reads, writes novels, watches soccer and films, and lets his dog and cat tell him what to do. He lives in beautiful Oregon wine country.

Clean Coding in Xojo: Best Practices for Writing Maintainable Code

Martin T. — Mon, 08 Jul 2024 15:00:00 +0000

Clean coding is a vital aspect of software development that ensures code readability, maintainability, and scalability. In the context of Xojo, adhering to clean coding principles can significantly enhance the quality and longevity of your projects. In this blog post, we’ll explore key practices for clean coding in Xojo, including the advantages and disadvantages of these approaches, with detailed examples and explanations.

Why Clean Coding Matters

Before diving into the specific practices, it’s important to understand why clean coding matters:

1. Readability: Clean code is easier to read and understand, which is crucial when multiple developers are involved or when you revisit your code after some time. This reduces the cognitive load on developers, making it easier to grasp the code’s functionality quickly.

2. Maintainability: Code that follows clean coding principles is easier to maintain and update, reducing the risk of introducing bugs. Maintainable code allows for efficient troubleshooting and quick implementation of changes or new features.

3. Scalability: Clean code can be more easily extended with new features, facilitating the growth of your application. Well-structured code makes it easier to see where and how new functionality can be added without disrupting existing features.

Key Practices for Clean Coding in Xojo

1. Use Meaningful Names

Using meaningful and descriptive names for variables, methods, and classes is one of the simplest yet most powerful practices in clean coding. Avoid abbreviations and opt for clear, self-explanatory names. This practice helps other developers understand your code without needing extensive documentation.

Example:

// Bad
Var n As Integer

// Good
Var userCount As Integer

In the good example, userCount clearly indicates the purpose of the variable, making the code easier to understand at a glance.

2. Follow Consistent Coding and Naming Conventions

Consistent naming conventions make your codebase uniform and easier to navigate. Establish and follow conventions for variables, methods, properties, and classes.

Read more detailed about Coding and Naming Conventions in the Xojo Documentation

3. Keep Methods Short and Focused

Each method should perform a single, well-defined task. If a method is too long or performs multiple tasks, consider refactoring it into smaller, more focused methods. This makes the code more modular and easier to test and maintain.

Example:

// Bad
Sub ProcessUserData()
  ' Code to validate user input
  ' Code to save user data to the database
  ' Code to send a confirmation email
End Sub

// Good
Sub ProcessUserData()
  ValidateUserInput
  SaveUserData
  SendConfirmationEmail
End Sub

Sub ValidateUserInput()
  ' Validation logic
End Sub

Sub SaveUserData()
  ' Database saving logic
End Sub

Sub SendConfirmationEmail()
  ' Email sending logic
End Sub

By breaking down ProcessUserData into smaller methods, each method has a single responsibility, which makes the code easier to understand and maintain.

4. Comment Wisely

Comments should explain why something is done, not what is done. The code itself should be self-explanatory whenever possible. Over-commenting can clutter the code, while under-commenting can make it difficult to understand the rationale behind certain decisions.

Example:

// Bad
// Increment the user count by 1
userCount = userCount + 1

// Good
// Increment the user count to keep track of active users
userCount = userCount + 1

In the good example, the comment provides context for why the increment is necessary, which might not be immediately obvious from the code alone.

5. Use Constants and Enumerations

Avoid using magic numbers and strings. Instead, define constants and enumerations for values that have specific meanings. This makes your code more readable and easier to update.

Example:

// Bad
If statusCode = 200 Then
  ' Success logic
End If

// Good
Const kHTTP_SUCCESS As Integer = 200
If statusCode = kHTTP_SUCCESS Then
  ' Success logic
End If

Using kHTTP_SUCCESS instead of 200 makes the code more readable and the purpose of the value clearer.

Enumerations

Enumerations (enums) are a powerful way to represent a set of related constants. They make your code more readable and maintainable by grouping related values under a single type. This can be particularly useful for handling states, options, or categories in your application.

Example:

// Define an enumeration for user roles
Enum UserRole
  Admin
  Editor
  Viewer
End Enum

// Use the enumeration
Var currentUserRole As UserRole = UserRole.Admin

Select Case currentUserRole
Case UserRole.Admin
  ' Admin-specific logic
Case UserRole.Editor
  ' Editor-specific logic
Case UserRole.Viewer
  ' Viewer-specific logic
End Select

In this example, the UserRole enum defines three possible roles: Admin, Editor, and Viewer. Using an enum makes the code more readable and ensures that only valid roles are assigned to currentUserRole.

6. Handle Errors Gracefully

Implement proper error handling to ensure your application can gracefully recover from unexpected conditions. Use Try…Catch blocks and meaningful error messages. This practice improves the robustness and user experience of your application.

Example:

Try
  ' Code that might throw an exception
Catch e As OutOfBoundsException
  // Log the error and inform the user
  System.DebugLog("Error: " + e.Message)
  MessageBox("An unexpected error occurred.")
End Try

By catching exceptions and providing informative error messages, you help users understand what went wrong and how to proceed, while also aiding in debugging and logging.

7. Refactor Regularly

Refactoring is the process of improving the structure of your code without changing its functionality. Regular refactoring helps keep your code clean and manageable. It involves restructuring your code to improve its internal structure while maintaining its external behavior.

Example:

Before refactoring:

Sub DoEverything()
  ' Lots of code here
End Sub

After refactoring:

Sub DoEverything()
  PerformTaskA
  PerformTaskB
  PerformTaskC
End Sub

Sub PerformTaskA()
  ' Task A code
End Sub

Sub PerformTaskB()
  ' Task B code
End Sub

Sub PerformTaskC()
  ' Task C code
End Sub

By breaking down DoEverything into smaller tasks, the code becomes more modular and easier to maintain.

Advantages and Disadvantages of Clean Coding

Advantages

Improved Readability: Clean code is easier for other developers and yourself to read and understand, which is crucial for effective collaboration and maintenance.
Easier Maintenance: Maintenance tasks are simplified with well- structured and well-documented code, reducing the time and effort required to update and debug the code.
Fewer Bugs: Following clean coding principles reduces the risk of bugs by promoting clarity and simplicity in the code.
Better Collaboration: Teams can work more efficiently together when the code is understandable and consistent, reducing misunderstandings and errors.
Scalability: It’s easier to integrate new features when the code is well- structured, as the modular design allows for more straightforward extensions.

Disadvantages

Time Investment: Clean coding requires more time and effort, especially in naming, documentation, and refactoring. This can slow down initial development but pays off in the long run.
Initial Learning Curve: Developers unfamiliar with clean coding principles need time to learn and apply them, which can temporarily decrease productivity.
Over-Perfection: There’s a risk of spending too much time perfecting the code, which can impact overall productivity and delay project timelines.

Clean coding is not just a set of guidelines but a mindset that can significantly improve the quality of your software. By adopting clean coding practices in Xojo, you ensure that your codebase remains readable, maintainable, and scalable. Whether you are working on a small project or a large application, these principles will help you write better code and build more robust software.

Incorporating clean coding practices into your development workflow might require an initial investment of time and effort, but the benefits far outweigh the costs. Clean code leads to fewer bugs, easier maintenance, and a codebase that can grow and evolve with your project’s needs.

Happy coding!

Martin T. is a Xojo MVP and has been very involved in testing Android support.

From Iteration to Interaction with Type Casting

Gabriel Ludosanu — Wed, 03 Jul 2024 15:00:00 +0000

In software development, efficiency and user experience are paramount. One powerful technique that can help achieve both is the use of type casting combined with iteration. By iterating through controls and casting them to specific types, developers can dynamically manipulate user interface elements, resulting in more responsive and interactive applications.

In this article, we will explore the concepts of type casting and iteration within Xojo applications. We will break down a practical example to demonstrate how these techniques can be used to optimize form handling and enhance user interactions.

Understanding Type Casting

Type casting is a concept where a generic control is converted—or “cast”—to a specific type to access its unique properties and methods. This technique is particularly useful when you need to manipulate various controls dynamically within a loop.

For instance, imagine you have multiple text fields on a Window and you want to apply specific actions only to some controls. By using type casting you can loop through all controls, identify those that you’re looking for, and then apply the desired actions.

Type casting is advantageous because it allows you to:

Access Specific Properties: Gain access to properties and methods specific to the control type
Enhance Code Maintainability: Write cleaner, more readable and reusable code
Improve Performance: Perform operations more efficiently by targeting specific control types directly

In essence, type casting allows developers to create more interactive and user-friendly applications by leveraging the full capabilities of each control type (you will see later in our example).

Iterating Through UI Controls

Iteration is a fundamental programming technique used to repeat a block of code multiple times. In Xojo, iterating through controls allows developers to dynamically interact with each instanced control, making it possible to apply specific actions based on the control type.

To iterate through controls in Xojo, you can use a simple For Each loop, which simplifies the process of accessing each control individually. Here’s a basic example:

For Each control As DesktopUIControl In Self.Controls
// Perform actions on each control
Next

Now, let’s utilize type casting to identify and manipulate all DesktopUIControl type controls. For example, if you want to find all DesktopTextField controls and perform certain actions, like disabling them, you can do so as follows:

// Loop through all controls in the current window or container
For Each control As DesktopUIControl In Self.Controls
  // Check if the current control is a DesktopTextField
  If control IsA DesktopTextField Then
    // Cast the control to a DesktopTextField for specific operations
    Var dtfield As DesktopTextField = DesktopTextField(control)
    // Disable the DesktopTextField type controls
    dtfield.Enabled = False
  End If
Next

Here’s a breakdown of what each part of the code does:

The For Each loop iterates through all controls in Self.Controls. Self refers to the current window or container.
The If statement checks if the current control is an instance of DesktopTextField.
If it is a DesktopTextField type, the control is cast to a DesktopTextField variable named dtfield and then disable it.

Tip: Make sure to read more about the operator IsA at https://documentation.xojo.com/api/language/isa.html

Practical Example

Let’s get into a practical example to see type casting and iteration in action.

Place different type controls on a Window (buttons, text fields, text areas, popup menus, etc.).
Make sure to also place two DesktopTextField controls and name them “PasswordField” and “EmailField”.
In a Button control, add the Pressed event and write the following code:

// Loop through all controls in the current Window or Container
For Each control As DesktopUIControl In Self.Controls
  // Test if the current control is a DesktopTextField
  If control IsA DesktopTextField Then
    // Cast the control to a DesktopTextField for specific operations
    Var dtfield As DesktopTextField = DesktopTextField(control)
    
    // Get the name of the current text field
    Var ctrlName As String = dtfield.Name
    
    // Check if the text field is either the password field or email field
    If (ctrlName = "PasswordField") Or (ctrlName = "EmailField") Then
      // Check if the text field is empty
      If dtfield.Text.IsEmpty = True Then
        // If empty, set focus to this field
        dtfield.SetFocus
        // Exit the loop and the current method/function
        Return
      End If
    End If
  End If
Next

Code breakdown:

The code starts with a For Each loop that iterates through all controls available in the Window/Container (Self.Controls).
It checks if each control is a DesktopTextField.
If it is, the control is cast to a DesktopTextField variable named dtfield.
The name of the text field is stored in the ctrlName variable.
The code then checks if the text field is either the “PasswordField” or “EmailField”.
If it is one of these fields, it checks if the field is empty.
If the field is empty, it sets the focus to this field and exits the current method or function using Return.

The above Xojo code snippet is used to perform a simple form validation. It checks if the password and email fields are filled out, and if either is empty, it sets the focus to the empty field and stops further processing. This is useful for ensuring that users don’t submit a form with these crucial fields left blank.

Conclusion

Mastering software development type casting and iteration not only makes your code more maintainable but it’s also a good strategy for dynamically managing instanced objects.

We encourage you to experiment with these techniques in your own Xojo projects. By applying the principles discussed in this blog post, you’ll be well on your way to creating more efficient and interactive applications.

Make sure to also check the following resources:
1. https://documentation.xojo.com/getting_started/object-oriented_programming/advanced_oop_features.html#casting
2. https://documentation.xojo.com/api/language/isa.html#isa
3. https://blog.xojo.com/2017/12/13/make-your-own-classes-iterables/
4. https://blog.xojo.com/2018/03/21/casting-get-ready-and-keep-the-type/

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

New Database Connections

William Yu — Wed, 26 Jun 2024 15:00:00 +0000

While Xojo has always supported adding database connections, the old method was far from ideal. Let’s delve into the improved approach using the new Database Connection project items and explore some recent additions to our database API.

Out With The Old

The old database connections were quite limiting, requiring you to create a new connection and re-enter all the parameters whenever one changed. With our new Database Connection items, you can now easily update specific connection parameters directly in the inspector.

Additionally, you can now choose whether the item will auto-connect or if you prefer to connect to it later in your code.

Connecting to a Specific Database

There are times when you need to connect to a database for debugging and testing, but for the final builds, you want to connect to your production database/server. Setting this up correctly with the old database connection method required creating two separate connection items—one for debug and one for release. With the new Database Connection items, this process is much simpler and fits more easily into the build process. You now have several new Database Connection subitems that can be customized based on the stage of your build. These subitems are linked to the Stage Code in your Shared Build Settings, ensuring that when you build a final release, your database connection uses the correct settings automatically.

Additional Database Features

In addition to this change, there are two new database APIs that may be useful to you:

A new method, IsConnected, has been added to the SQLiteDatabase, ODBCDatabase, PostgreSQLDatabase, and MySQLCommunityServer classes. This method returns true if the connection is still active, and false if it is not.
We’ve enhanced Database.AddRow with a new signature that returns the unique ID of the newly inserted row. This feature is supported for SQLiteDatabase, ODBCDatabase, PostgreSQLDatabase, and MySQLCommunityServer classes. It is recommended to use this new API instead of the deprecated SQLiteDatabase.LastRowID and MySQLCommunityServer.LastInsertedRowID

Let’s explore how the new Database.AddRow feature can assist you. Previously, only SQLiteDatabase and MySQLCommunityServer had APIs to retrieve the unique ID of the last inserted row. Now, PostgreSQLDatabase and ODBCDatabase also have this capability by using the new Database.AddRow(tableName As String, row As DatabaseRow, idColumnName As String = "") As Integer

The new aspect of this signature is the idColumnName parameter and the return value. For databases that support the SQL RETURNING clause, the idColumnName specifies the column whose value will be returned. For databases that do not support the RETURNING clause, we will use the suitable method for each specific database to return a unique value.

We recognize the significance of databases in your Xojo apps. So with these updates to database connectivity for your desktop, web and console apps, and the addition of new features, we aim to make your database programming easier and more efficient.

William Yu grew up in Canada learning to program BASIC on a Vic-20. He is Xojo’s resident Windows and Linux engineer, among his many other skills. Some may say he has joined the dark side here in the USA, but he will always be a Canadian at heart.

How to use Bootstrap Themes to Customize your Xojo Web Apps

Gabriel Ludosanu — Tue, 18 Jun 2024 14:00:00 +0000

If you’re crafting your latest SaaS (web app) using Xojo, you might already know the power this platform holds. But let’s talk about something equally important – making your app look downright amazing.

Have you ever stumbled upon a website or app and been instantly captivated by its design? That’s the magic of great visual appeal. And guess what? You can bring that same magic to your Xojo web app with the help of Bootstrap themes.

Imagine your app not just as a tool, but as a full visual-interactive experience for your end-users. Whether you’re a design newbie or a seasoned pro, these themes offer a seamless way to enhance your web app’s look and feel.

This tutorial will equip you with all the knowledge to select and use Bootstrap themes for your Xojo web apps. By the end of this guide, you’ll have the tools and confidence to create a visually appealing, user-friendly app that turns heads and wins hearts.

What are Bootstrap themes and why use them in Xojo?

Bootstrap is a popular front-end framework that helps developers create responsive and visually compelling web applications. Bootstrap themes are pre-designed templates built with this framework, making it easier to achieve a professional look with minimal effort.

Xojo, by default, uses a modified Bootstrap theme for its web apps. This means that right out of the box, your Xojo web app already benefits from Bootstrap’s design and sleek aesthetics. There are countless pre-designed themes available online, both free and premium, that you can incorporate into your Xojo web app. These themes can dramatically alter the visual appearance of your app, offering various aesthetic options to suit your needs.

Now that you have a basic understanding of Bootstrap and its role in Xojo, let’s move on to how you can actually implement and customize these themes in your web app.

Step 1: Choose a Bootstrap theme

First, you need to choose a Bootstrap theme that fits the look and feel you want for your Xojo web app. There are numerous resources on the web where you can find free or premium Bootstrap themes. For maximum compatibility with Xojo, we recommend using themes from Bootswatch. Bootswatch provides a variety of free, Xojo-compatible Bootstrap themes.

Step 2: Preview and download the theme

On the Bootswatch website, click the “Preview” button for any theme to see how it will appear.

Once you find a theme you like, click the menu next to the theme’s “Download” button and select the file named bootstrap.min.css. This is the only file you need.

Step 3: Add the theme to your Xojo web app project

Now for the easiest step. Once you have the desired bootstrap.min.css file, simply drag and drop it into the Navigator panel of your Xojo project.

After adding the bootstrap.min.css file to your project, Xojo’s layout editor will instantly reflect the new theme. Moreover, your web app will utilize this theme when running.

Congratulations! You’ve now learned how to incorporate and apply Bootstrap themes to your Xojo web application.

Remember, the right theme can make your web app not just functional, but memorable. And with the countless options available, you’re sure to find a Bootstrap theme that perfectly matches your vision. Don’t hesitate to experiment with different themes and make adjustments as needed to get the perfect look for your app.

Now it’s your turn to put it into practice and create web apps that not only work well but look fantastic too.

If you have any questions or run into any issues, feel free to refer to the official Xojo documentation for more detailed information.

Gabriel is a digital marketing enthusiast who loves coding with Xojo to create cool software tools for any platform. He is always eager to learn and share new ideas!

Beginner Tips – Xojo Programming Blog

Introducing Jade, the Xojo AI Assistant

Getting Started

Using Jade

Other Tips

Wrap

Building Blocks for Beginners: Modules, Classes, Interfaces, and Delegates

Modules

Classes

Interfaces

Delegates

Quick Decision Guide

Quick glossary

How To Create a Custom Button Control in Xojo – Part 4: Adding Focus

1. Track the Focus State

2. Respond to Focus Events

3. Grab Focus on Mouse Click

4. Draw an Inset Focus Ring

5. Enable Canvas Focus

Try It Out

What’s Next?

How To Create a Custom Button Control in Xojo – Part 3: Make Your Controls Inspector-Friendly

Why Inspector Behavior Matters

Step 1: Open Inspector Behavior

Step 2: Expose and Organize Properties

Step 3: Enjoy Design-Time Customization

Step 4: Best Practices and Tips

Conclusion

Build Your First iOS App with Xojo: 10 Practical Steps

1. Define Your Idea

2. Choose The Platform(s)

3. Prototyping

4. Database Design

5. Graphic Resources

6. Localization and Accessibility

7. Testing the App

8. Publish it!

9. Marketing

10. The Next Steps …

To Summarize

How To Create a Custom Button Control in Xojo – Part 2

Adding New Properties for Customization

Updating Event Handlers for the Enabled State

Updating the Paint Event for Enhanced Appearance

Using the Enhanced Custom Control

Conclusion

Year of Code 2025: May Project, Mobile Apps

One More Thing

How To Create a Custom Button Control in Xojo

Add a Custom Class:

Add Properties:

Define Pressed Custom Event:

Add Event Handlers:

Run the Project:

Year of Code 2025: April Project, User Interface

Handling Feature Requests

Understand the Need

Understand the Code

Understand the Path

Build the Road

Test Everything

Bonus Tip

Conclusion

5 Tips for Optimizing Your Xojo Apps for Performance

1. Identify Bottlenecks with the Xojo Profiler

2. Use Efficient Data Structures and Algorithms

3. Offload Work to Threads

4. Manage File and Network I/O Efficiently

5. Mind Your Loops and String Operations

Conclusion

Introduction to PocketBase: A Backend Alternative for Xojo Developers

Introduction

Why Choose PocketBase for Your Xojo App Backend?

Key Features:

Setting Up PocketBase for a Xojo App

Connect Xojo to PocketBase

Implement the Login Request

Update Your Credentials and URL

Run The App

Wrapping Up

Define `Pressed` Custom Event: