Software Development – Xojo Programming Blog

Conditional Compilation in Xojo: #If False and #If True

Martin T. — Fri, 03 Apr 2026 13:42:00 +0000

If you’ve been working with Xojo for a while, you’re likely familiar with conditional compilation directives like #If TargetMacOS or #If DebugBuild. But there are two particularly useful variants that are often overlooked in day-to-day development: #If False and #If True. In this article, we’ll look at what these directives do, when to use them, and why they can be a better choice than regular comments in certain situations.

What Is Conditional Compilation?

Conditional compilation allows you to include or completely exclude sections of code from the final application based on a condition. Unlike an If statement at runtime, this decision is made at compile time. Code excluded through conditional compilation simply does not exist in the compiled application.

#If False – Completely Excluding Code

#If False
  MessageBox("This line will never be compiled")
  Var result As Integer = DoSomething()
#EndIf

When the condition is False, the entire block is ignored by the compiler. It is not compiled, not included in the application, and not even checked for syntax errors. The code is effectively invisible to the compiler.

Why Not Just Comment It Out?

At first glance, #If False seems to do the same thing as a comment. But there are key differences:

1. Nested Comments Are No Problem

If a code block already contains comments, commenting out the entire block quickly becomes messy:

' Var x As Integer = 42 ' Default value
' Var y As Integer = x * 2 ' double it
' ' This is already a comment

With #If False, everything stays clean:

#If False
  Var x As Integer = 42 ' Default value
  Var y As Integer = x * 2 ' double it
  ' This is already a comment
#EndIf

2. Incomplete or Broken Code

Sometimes you want to keep an unfinished code draft without it preventing the build. Since the compiler completely skips the contents of an #If False block, the code inside may even contain syntax errors:

#If False
  ' Experimental approach – not finished yet
  Var data As  = LoadFromServer(
  ProcessResult(data
#EndIf

This code would be useless as a comment because you’d have to comment out each line individually. With #If False, it’s safely stored away.

3. Quickly Disabling Large Code Blocks

For larger sections, #If False / #EndIf is far more practical than prefixing every line with '. Plus, the block can be reactivated instantly by simply changing False to True.

#If True – Always Including Code

#If True
  MessageBox("This line will always be compiled")
#EndIf

An #If True block is always compiled — it behaves identically to regular code. This might sound useless at first, but it does have practical applications.

When Is `#If True` Useful?

1. Quick Toggling During Development

Imagine you’re working on a feature and want to quickly enable or disable certain code sections:

#If True ' <- Set to False to disable the new feature
  ' New feature
  Var service As New CloudSyncService
  service.SyncNow()
#EndIf

By simply changing True to False, you can disable the feature without deleting or commenting out any code.

2. Placeholder for Future Conditions

Sometimes you already know that a code section will later be tied to a condition — such as a platform or build type. With #If True, you can prepare the structure in advance:

#If True ' TODO: Change to TargetMacOS once Windows alternative is ready
  Var folderPath As String = SpecialFolder.Applications.NativePath
#EndIf

3. Visual Code Grouping

In longer methods, #If True can serve as a visual structural block to highlight related code:

#If True ' --- Initialization ---
  Var db As New SQLiteDatabase
  db.DatabaseFile = dbFile
  db.Connect
#EndIf

#If True ' --- Load data ---
  Var rs As RowSet = db.SelectSQL("SELECT * FROM users")
#EndIf

Defining Custom Compiler Constants

Xojo also allows you to define your own constants for conditional compilation.

#If kEnableLogging
  WriteToLog("Application started")
#EndIf

This lets you control features or debug functionality centrally through a constant without having to modify the code itself.

Best Practices

#If False instead of mass comments: For larger code blocks that need to be temporarily disabled, #If False is the cleaner solution.
Add a comment: Always document why a block is disabled:

#If False ' Disabled until bug #1234 is fixed
  ProcessCriticalData()
 #EndIf

Don’t use permanently: #If False blocks should not remain in the code indefinitely. If the code is no longer needed, remove it. If it is needed, activate it.
Prefer platform directives: When dealing with platform-specific code, use the specific constants (TargetMacOS, TargetWindows, etc.) instead of #If True or #If False.
Avoid deep nesting: While nested #If blocks are possible, use them sparingly as they quickly reduce readability.

Conclusion

#If False and #If True are simple yet powerful tools for everyday Xojo development. They offer a cleaner alternative to commenting out large code blocks, enable quick feature toggling during development, and lay the groundwork for a structured, cross-platform codebase. Used thoughtfully, they save time and help you stay organized — even in larger projects.

If you want to automatically convert a selection into a #If/#EndIf block, you can do so via the context menu: “Wrap In > #If / #EndIf”

Happy coding.

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

Building an AI Pair Programmer for Xojo Developers

Garry Pettet — Mon, 09 Mar 2026 15:00:00 +0000

If you’ve tried using ChatGPT, Claude, or Gemini for help with Xojo code, you’ve probably experienced the same frustration most of us have: the AI doesn’t know your project. You end up copying and pasting classes, explaining your architecture, and then watching it hallucinate method or framework names that don’t exist. It works, sort of, but it’s clunky.

I wanted something better. Not a generic chatbot that happens to know some Xojo, but a tool that could actually see what I was working on. That’s why I built Zotto (with Xojo!).

What Is Zotto?

Zotto is a cross-platform macOS and Windows app that acts as an AI pair programmer specifically for Xojo developers. It connects directly to the Xojo IDE, reads the project you’re working on, and gives the AI real context about your code such as classes, method signatures, properties. Essentially the whole project’s structure.

The Problem It Solves

The core issue with using general-purpose AI tools for Xojo development is context. When you ask Claude or ChatGPT a question about your project, the AI has no idea what your codebase looks like. You become the middleman, manually feeding it snippets and hoping it has enough information to give useful advice.

Zotto removes some of that friction. When connected to the IDE, the AI can explore your project on its own using built-in tools:

ProjectOverview gives it the high-level folder structure
ListItems lets it drill into specific folders
GetSignatures shows method and property signatures without dumping all the code
ReadCode pulls up full method implementations when needed
SearchCode does grep-like pattern searches across the codebase
SearchDocs lets it search and retrieve Xojo documentation directly

These tools are designed to be token-efficient. Instead of dumping your entire project into the context window, the AI requests only what it needs, when it needs it. A ProjectOverview call might use 300-500 tokens. A GetSignatures call on a class gives the AI the API surface without the implementation details. This layered approach means even large projects work well within context limits.

Read-Only by Design

One decision I made early on was that Zotto would be read-only. It can read your code, analyse it, suggest changes, and generate snippets — but it cannot modify your project files, create new items, or execute IDE scripts.

This is intentional. I think AI-generated code should be reviewed by a developer before it goes into a project. Zotto gives you copy-pasteable suggestions and lets you decide what to implement. You stay in control.

Bring Your Own Model

Zotto isn’t locked to a single AI provider. It supports Claude, OpenAI, Gemini, Ollama, LM Studio, and any OpenAI-compatible API (which covers services like Grok and OpenRouter). If you’re privacy-conscious or working on sensitive code, you can run it entirely offline with a local model through Ollama or LM Studio. Your code never has to leave your machine.

This also means you’re not paying for Zotto’s AI usage — you use your own API keys or local models, so you’re in full control of costs.

How It Works in Practice

A typical workflow looks like this:

Open your project in the Xojo IDE
Launch Zotto — it detects the IDE automatically
Select which open project to work with
Start chatting

From there, you might ask the AI to review a class, suggest how to refactor a method, help you understand unfamiliar code in a project you’ve inherited, or brainstorm an approach to a new feature. Because the AI can explore the project itself, the conversation feels much more natural than the copy-paste dance with a generic chatbot.

For example, you could ask: “What does the ProcessOrder method in OrderManager do?” Instead of you having to find and paste the code, Zotto’s AI will call ReadCode to look at the method itself, then maybe GetSignatures on the parent class to understand the broader context, and give you a thorough explanation.

Extending with MCP

For developers who want to go further, Zotto supports the Model Context Protocol (MCP). This lets you add custom tool servers — for file system access, Git operations, database queries, or anything else you might want the AI to have access to during a conversation. It’s the same protocol that Claude Desktop and other AI tools support, so existing MCP servers work out of the box.

Built for the Community

Zotto exists because I needed it for my own Xojo development. I was spending too much time being the translator between AI tools and my codebase. Once I had something working, it seemed like other Xojo developers would find it useful too.

There’s a free version you can try that includes full IDE integration and all the built-in tools with a single conversation. A full license is a one-time purchase of £69 — no subscription. You can learn more and download it at zotto.app.

If you have questions or feedback, I’d love to hear from you on the forum.

Garry Pettet is a Consultant Radiologist, Xojo developer and the creator of Zotto. You can find him on the Xojo forum or at zotto.app.

Community Contributions to the Xojo Blog: Spotlight On & Guest Posts in 2025

Alyssa Foley — Thu, 18 Dec 2025 20:25:07 +0000

Besides being a great resource for everything from Xojo code tips and snippets to videos that show you cool things, plus news and announcements, the Xojo Blog also strives to build community among the wide range of people who use Xojo around the world. We welcome guest bloggers from the Xojo community and highlight the many different ways people use Xojo through our Spotlight On series.

In 2025, guest authors shared their expertise and real-world experience on the Xojo Blog. These posts bring fresh perspectives, practical solutions and deep technical insight that help other developers learn faster, solve problems more effectively and feel more connected to the Xojo community.

Guest posts in 2025 included:

Martin T., Xojo MVP: Hide the Tabs in an Android MobileTabPanel Using Declares
Martin T., Xojo MVP: Xojo for Android: A Two-Year Retrospective
Martin T., Xojo MVP: It’s here – Android Design Extensions 4.0
Anthony Cyphers, GraffitiSuite and Xojo MVP: Handling Feature Requests
Kem Tekinay, Xojo MVP: MemoryBlocks For Speed: A Case Study
Kem Tekinay, Xojo MVP: The Beauty of Binary Searches
Jürg Otter: Build a Xojo Plugin with GitHub Actions
Ezekiel Burke, Iron Elephant Solutions: Introduction to PocketBase: A Backend Alternative for Xojo Developers

We are always looking for users in the Xojo community who want to share a problem they’ve solved, a creative solution or an interesting project. If you’re interested in contributing a guest post or have an idea you’d like to explore, send it to me at alyssa@xojo.com.

In 2024, we introduced the Spotlight On series to highlight the work Xojo users do and their experiences using Xojo. Since many Xojo users don’t fit the mold of a traditional developer role, Spotlight On offers a fun and approachable way to learn how someone got started with Xojo and how they use it today. Spotlights can focus on an individual developer, a business or a specific Xojo-based project.

Spotlight On features in 2025:

If you’d like to be featured in a future Spotlight On or know someone in the Xojo community whose story would be great to share, we’d love to hear from you. Reach out with suggestions to me at alyssa@xojo.com.

The Xojo Blog is at its best when it reflects the voices, experiences and creativity of the community itself. Whether through guest posts, Spotlight On posts or shared ideas, we look forward to continuing to learn from and celebrate the people who make Xojo what it is.

Alyssa has been with Xojo for over 18 years. She loves solving problems and building community. You can reach her at alyssa@xojo.com or through any of Xojo’s social media channels. If you can’t reach her she’s probably out hiking the beautiful trails through her city of Portland, Oregon, or maybe enjoying a drink with friends by the river.

The Beauty of Binary Searches

Kem Tekinay — Tue, 16 Dec 2025 17:14:00 +0000

Problem: you need to search an array to see if it contains a particular value. The simple solution is IndexOf if it’s a simple array, or a loop like this:

for each item as ArrayType in myArray
  if item.Matches( myValue ) then
    YesSiree( myValue )
    exit
  end if
next

That’s pretty easy, but what if the array is really big? And what if you have to do this many times?

For example, let’s say your array has 10,000 items. For each value that doesn’t match, your code will have to do 10,000 comparisons. But, if your array can be sorted, you can perform that task with, at most, 14 comparisons using a binary search.

The concept is simple: you take an ordered list and start in the middle. If what you’re trying to match is less than that point, you discard the upper half of the list, then start again at the midpoint of the rest. By continuously cutting the list in half, you will do, at most, Ceil(Log2(arrayCount)) comparisons per value.

For simplicity’s sake, let’s say you want to search an array of strings. (Yes, a Dictionary would be the better choice here, but this is just for illustration.) The code would look something like this:

myArray.Sort

var firstIndex as integer = 0
var lastIndex as integer = myArray.LastIndex

while firstIndex <= lastIndex
  var midPoint as integer = ( lastIndex - firstIndex ) \ 2 + firstIndex

  var compare as string = myArray( midPoint )

  if myValue = compare then
    YesSiree( myValue )
    exit
  end if

  if myValue < compare then
    lastIndex = midPoint - 1
  else
    firstIndex = midPoint + 1
  end if
wend

With that 10,000-item array, the first loop would look at item 5,000. If myValue is greater than that, it would next look at item 7,500. Still greater? Now it will look at item 8,750, and so on. The entire array will be processed efficiently with large chunks never needing examination at all. If you have to do this for 1,000 different values, you will end with, at most, 14,000 comparisons instead of 10 million.

Quite the savings, right?

Kem Tekinay is a Mac consultant and programmer who has been using Xojo since its first release to create custom solutions for clients. He is the author of the popular utilities TFTP Client and RegExRX (both written with Xojo) and lives in Connecticut with his wife Lisa, and their cat.

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!

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…

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.

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.

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:

Decoding ‘Vibe Coding’: What Does It Mean for Developers (and the Code We Write)?

Gabriel Ludosanu — Wed, 02 Apr 2025 15:00:00 +0000

Let’s talk about a term buzzing around: ‘vibe coding.’ Yes, you read that right. Vibe. Coding. As in, feeling the code into existence? As someone immersed in development, stumbling across this concept wasn’t just surprising; it felt like it poked at the very foundations of how we approach building software. It’s more than just a new tool; it represents a potential shift in mindset, sparking debate about the future of our craft.

Apparently, vibe coding is the latest and greatest thing in software development, or so I hear from the younger generation. It seems like it’s all about using AI tools to generate code based on natural language prompts. You tell the AI what you want to build, and it spits out the code. No more late nights wrestling with syntax errors, no more meticulously planning out every class and function. You just… vibe it into existence.

The Origin Story

The term gained traction thanks to Andrej Karpathy, a prominent figure in AI (OpenAI, Tesla). He described ‘vibe coding’ as fully embracing AI generation, iterating based on natural language, and potentially minimizing direct code interaction or even deep review. This idea – letting the ‘vibe’ of the requirement guide the AI, potentially bypassing meticulous human coding – is where the conversation gets really interesting, and perhaps, a little unsettling for seasoned developers.

How It Works (Supposedly)

From what I gather, the process involves describing your desired outcome in plain English (even voice commands are suggested), letting AI generate the code. You then refine through further prompts. The most discussed and debated aspect? The suggestion by proponents that deep, line-by-line understanding of the generated code might become less critical than iterating on the high-level ‘vibe’.

My (Slightly Jaded) Take

Look, progress is essential, and making development more accessible is a worthy goal. We see this with low-code/no-code platforms and the genuine utility of AI assistants. However, as someone who values robust, understandable, and maintainable code, principles that are core to Xojo’s design philosophy, the notion of accepting code without fully grasping its mechanics raises serious questions.

We’ve spent years learning that the devil is in the details: edge cases, security vulnerabilities, performance bottlenecks. Can a ‘vibe’ truly account for all that?

As one Reddit user aptly put it, ‘Coding is easy, testing and maintaining is hard.’ That deep understanding is crucial for the hard parts.

The Potential Upsides (Maybe)

Okay, I’ll admit, there might be some potential benefits to this “vibe coding” thing.

Rapid Prototyping: It could be useful for quickly creating prototypes and experimenting with new ideas.
Lower Barrier to Entry: It might allow non-developers to build simple applications and bring their ideas to life.
Increased Productivity: It could free up developers to focus on higher-level tasks like architecture and problem-solving.

The Concerns (Definitely)

But here are the things that keep me up at night:

Lack of Understanding: If you don’t understand the code, how can you possibly debug it or fix it when things go wrong?
Hidden Risks (Security & Quality): Could relying heavily on AI without rigorous review introduce subtle bugs or security flaws that aren’t immediately apparent?
The Maintainability Maze: What happens to long-term maintainability when the original ‘author’ (the AI) has no memory, and the human overseer lacks deep understanding of the implementation?
Erosion of Craftsmanship?: Does over-reliance risk deskilling developers or devaluing the rigorous problem-solving at the heart of good engineering?

My Verdict

So, is ‘vibe coding’ poised to take over software development? For complex, critical applications, it seems unlikely in its purest form. The risks associated with a lack of deep understanding are simply too high. However, dismissing the power of AI in coding would be equally misguided.

These tools are becoming powerful assistants. The key isn’t choosing between ‘vibes’ and traditional coding; it’s about intelligent integration. Use AI to accelerate development, handle boilerplate, and explore ideas. But never relinquish the crucial step of understanding, testing, and refining the output.

Fundamentals matter. Clarity, solid architecture, and maintainability, the very things Xojo is built to facilitate, become more important, not less, in an AI-assisted world. We need to leverage these tools wisely, as co-pilots, not as autopilots flying blind.

But, what do you think? Am I simply being a traditionalist coder, or do you share some of my concerns regarding “vibe coding”? Let’s discuss it in the Xojo forums. Share your experiences and perspectives. Navigating this evolution is something we should do together as a community.

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!

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.

Spotlight On: Tim Dietrich

Alyssa Foley — Mon, 10 Mar 2025 16: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!

I’ve had the pleasure of working with Tim multiple times over nearly 10 years now. Tim is one of those people who makes a community, he’s a connector, bringing people into a group and highlighting common ground for the benefit of us all. It’s not hard to find out what Tim is doing these days, you can read all about it on his blog, watch his videos and webinars and read his Xojo interview series in xDev Magazine. In this month’s Spotlight On feature, Tim answers questions about his latest, and biggest, project and his ongoing success using Xojo.

Mac, Windows or Linux?

All three.

I do all of my work on a MacBook Pro. That’s where I’m running the Xojo IDE, doing testing, and so on. But I’m developing apps that also run on Windows and Linux, too. When I’m developing a Windows app, I usually do my initial testing using a Windows VM running in Parallels. Over the past few years, the amount of Linux projects that I work on has increased significantly. I’m developing a lot of console apps that run on Linux.

Here’s something that I discovered about a year ago, and that your readers might find interesting. Xojo apps that are compiled for Linux (Linux x86 64-bit in particular) will run on servers that are running Oracle’s “Oracle Linux Server” operating system. Oracle’s cloud (which they call “Oracle Cloud Infrastructure” or “OCI” for short) run that version of Linux, which is similar to Fedora. A lot of companies that are running on NetSuite (which Oracle owns) are “all in” with OCI. So the fact that Xojo apps can be compiled to run on OCI servers is a pretty big deal. I think there’s a lot of opportunity for Xojo developers to meet the demand for custom software coming from companies that are in investing in OCI.

What do you wish more people would ask/talk to you about regarding programming?

I have a pretty popular blog, and I do get a lot of technical questions from readers. Occasionally, I get questions like “How can I break into the NetSuite space?” What they’re really asking about are strategies for finding opportunities, technical things that they should learn about, and so on.

But it’s the non-technical things that they don’t ask about that I think are really important. For example, learning about business in general. Learning about accounting. And if they’re looking to “go solo,” learning how to build authority, stay organized, and so on.

How would you explain your most recent project to a new developer?

One of the biggest challenges that companies face when they’re switching from one business system to another is migrating data between the two systems. Some companies think that this is the final step before “going live” with the new system – and it certainly is.

But the reality is that they’ll likely need to do this data migration several times, especially as they test the new system. In some cases, they’ll run the two systems in parallel and compare the results of the two systems, to make sure the new system is being implemented correctly.

I’m currently working on a very large, very complicated NetSuite implementation, and we ran into this need. Using Xojo, I developed an app called the “Data Bridge” which we’re using to sync data between their current system (which was developed using Progress – https://progress.com) and their NetSuite instance. It takes data that was exported from Progress as pipe-delimited files, parses and validates the data, and then makes API calls to push the data into NetSuite. This is helping us test NetSuite more thoroughly, using current, real data, so that there will be no surprises when we do go live.

What’s next on your “Learn Next” list?

For the longest time, I’ve felt that AI – and especially generative AI – is overhyped. So I mostly ignored it. Now that the excitement has settled down a bit, I’ve started to look at AI in a serious way. NetSuite recently made some generative AI APIs available to developers, so I’ve been experimenting with those. One of the projects that I’m currently working on involves developing a Xojo-based mobile app that integrates with NetSuite, leveraging the data stored in NetSuite as well as its AI functionality.

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

I think that like a lot of developers that have been working professionally for awhile, I was surprised by the popularity of Javascript, and how widespread it’s used, especially for developing backend Web apps. The other thing that has surprised me is the increasing number of developers that really don’t want to write code. There seem to be a lot of people that pursue careers in software development simply because they think it’s a way to “make big money.” One of the things that
I love about the Xojo community is that most of the Xojo developers that I’ve talked to seem to find joy in writing code. (You can also see this on the Forum, too.)

Xojo isn’t the only tool in your kit. What is a piece of software more people should know about?

There are a couple of other development tools that I use and recommend, and that I encourage other Xojo developers to check out.

One is DataGrip by JetBrains, which I started using about a year ago. DataGrip is a cross- platform database tool that supports a very wide range of relational databases. I use it often in my NetSuite work, especially when I need to explore the schema of the Oracle database that a NetSuite instance is powered by.

Another tool that I recommend is RapidAPI (which was formerly known as “Paw”). I’ve been using RapidAPI since it was first released, and it’s my API tool of choice. There’s another API tool called “Postman”that is certainly much more popular, but I really prefer RapidAPI. It seems to me to be much more Mac-like.

One more tool that I want to mention – and this one is brand new – is called “Framous.” Framous makes it easy to add device frames around screenshots. So you can take a screenshot of an app – such as one running on your Mac or in a simulator – and then drop the screenshot into a device frame – such as a Mac or iPhone. It’s great for creating images to be used for marketing purposes. The app is available on the Mac App Store.

When did you start using Xojo?

I started using Xojo in August of 2015 – nearly 10 years ago!

How did you find Xojo?

Hal Gumbert encouraged me to check out Xojo, and I’m so glad that he did. At the time, we were both FileMaker developers. I had grown frustrated with the FileMaker platform and was looking for a new development tool to work with.

What did you first build with Xojo?

When I first started working with Xojo, I was interested in developing iOS apps – and Xojo’s support for the iOS framework had just been released. So the timing was perfect. In fact, then first Xojo license that I purchased was only for iOS. There were two iOS apps that I immediately developed with Xojo. One integrated with FileMaker and the other integrated with Airtable. (At the time, I was serving as Airtable’s “Developer Evangelist.”)

What do you build with it now?

I now use Xojo to develop all kinds of apps – desktop, mobile, Web, and console apps – and for all of the platforms that Xojo supports too (macOS, Windows, Linux, iOS, and Android). When I first started using Xojo, I never would have guessed that someday I’d be developing so many different types of apps.

It surprises me that out of all of the types of apps that I develop with Xojo, these days it’s Linux console apps that I’m developing the most. These apps are primarily used to automate processes involving NetSuite, such as batch file processors, webhook listeners and senders, and more. So essentially I’m using Xojo – and console apps especially – to extend NetSuite’s capabilities.

What is something you worked on recently that you want to talk about?

I mentioned a few of my current projects earlier, but two of the more interesting projects that I’m working on are Suite.js (a JavaScript runtime that’s designed to make NetSuite integration easy) and SuiteBrowser (a Web browser designed specifically for use with NetSuite). Both of those projects might sound like crazy ideas. I mean, what kind of crazy person develops their own web browser?!? But I can tell you, based on the level of interest in them from the NetSuite community, that there’s a genuine need for both of them.

Do you earn a living with Xojo?

Absolutely. So much of my work these days – including my NetSuite work – involves Xojo. I honestly don’t know what I’d do without it.

Also, I want to give a shout out to Christian Schmitz and MonkeyBread Software. His Xojo plug-ins have enabled me to work on Xojo projects that I never would have dreamed of working on, including projects that utilize things like MQTT, Phidgets, and more.

Do you use it for your hobbies?

Yes, I do. My main hobby these days is developing apps that run on Raspberry Pi’s, and of course, I’m using Xojo to create them. As a side note, I recently purchased my fifth Raspberry Pi – a Raspberry Pi 500 – and I love working with it. It reminds me what it was like to use Macs and PCs “back in the day.”

What’s your biggest Xojo success?

Out of all of the apps that I’ve developed with Xojo, the one that I use every day is called SuiteTransmit. SuiteTransmit is a desktop app that monitors the files that I’m working on, detects changes to them, and automatically uploads them to NetSuite. It allows me to develop NetSuite “SuiteScript” apps using my preferred IDE (BBEdit). This simple app, which, thanks to Xojo, took only a few hours to develop, has saved me a lot of time. SuiteTransmit is one of my “secret weapons,” and I don’t think I could have, or would have ever even attempted to develop it, without Xojo.

But my biggest “Xojo success” doesn’t involve any one particular app that I’ve developed with it. Over the years, I’ve blogged about my Xojo work, and been a guest on several Xojo webinars. Last summer, a company that was looking for help implementing NetSuite stumbled upon my NetSuite / Xojo work, liked what they saw, and reached out to me for help. They’re now my biggest client, and the biggest client I’ve had throughout my entire career. And I owe that to Xojo.

Thank you to Tim Dietrich for answering questions and sharing his Xojo experience with the community. Learn more about Tim on his blog, find him on LinkedIn and read his interviews in xDev Magazine.

If you have an app, a project or a person you want to see featured in Spotlight On, tell us about it!

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!

MemoryBlocks For Speed: A Case Study

Kem Tekinay — Wed, 26 Feb 2025 17:00:00 +0000

A few years ago I held a session about MemoryBlocks at the Xojo Developer Conference where I discussed how, generally, MemoryBlocks (and Ptrs) should be avoided except for cases where you must use them, e.g., Declare, or when speed is absolutely critical. I offered this advice because a MemoryBlock can be tedious to work with, and can lead to hard-to-trace bugs.

But when you do need that extra boost, it’s an option to consider, and I recently came across a scenario where it made a huge difference.

The (One Billion Row) Challenge

This came about from a discussion of the “One Billion Row Challenge” on the Xojo Forum, where a programmer is tasked with reading a billion rows of temperature data and consolidating it into statistics for each given city. Our friend Mike D started a project to demonstrate different techniques, and I eventually started my own project. Using MemoryBlock, Ptr, and preemptive threading, I was able to process a billion rows in roughly 8 seconds.

But that’s not the point of this post.

See, in order to process the data, you must first create it, which isn’t as straightforward as it seems.

Creating The Data

Each row of the data file takes the form “City;temp”, where “temp” is single-place decimal between -99.9 and 99.9. For purpose of limits, I used, arbitrarily, 413 random cities out of a list of all cities. The original code looked something like this where “bs” represents a BinaryStream:

Var r As New Random

For i As Integer = 1 To rowCount
  Var city As String = cities(r.InRange(0, cities.LastIndex))
  Var temp As Double = r.InRange(-999, 999) / 10.0

  bs.Write city + ";" + temp.ToString("#0.0") + EndOfLine
Next

This was simple, easy, and slow. To generate the full billion rows took about 2.5 hours.

Memory-Unblocking

Upon investigation, I rediscovered what I already knew. Dealing with strings, both in conversion and concatenation, can be a bottleneck. I won’t go through all the iterations here, but nothing I tried made a significant difference. The only solution was to ditch strings entirely.

I started with creating a MemoryBlock “buffer” (“outMB”) of 1 MB with an associated Ptr (“outPtr”). (You can access the contents of a MemoryBlock through its methods, but those are function calls, which have an overhead. Ptr methods are operators that work with the bytes directly so they are faster.) The plan was to fill the buffer as much as I could, write it to the file, then start again at the top of the buffer.

Keeping a position index, I started with writing the city using outMB.StringValue since there is no equivalent Ptr method for this. Next, I plugged in the value of a semicolon with outPtr.Byte(outMBIndex) = 59.

Working with integers is faster than doubles, so I used a little math to plug in the temperature values directly using If statements and outPtr.Byte.

Finally, I used outPtr.Byte(outMBIndex) = 10 to plug in the linefeed (ASCII 10).

The final code looked something like this:

Const kEOL As Integer = 10
Const kHyphen As Integer = 45
Const kDot As Integer = 46
Const kZero As Integer = 48
Const kSemicolon As Integer = 59

Var r As New Random

Var outMB As New MemoryBlock(1000000)
Var outPtr As Ptr = outMB

Var outMBIndex As Integer = 0

For row As Integer = 1 To rows
  Var cityIndex As Integer = r.InRange(0, cities.LastIndex)
  Var city As string = cities(cityIndex)
  Var cityBytes As Integer = city.Bytes

  If (outMBIndex + cityBytes + 10) >= outMB.Size Then
    bs.Write outMB.StringValue(0, outMBIndex)
    outMBIndex = 0
  End If

  outMB.StringValue(outMBIndex, cityBytes) = city
  outMBIndex = outMBIndex + cityBytes

  outPtr.Byte(outMBIndex) = kSemicolon
  outMBIndex = outMBIndex + 1

  If r.InRange(0, 4) = 0 Then
    outPtr.Byte(outMBIndex) = kHyphen
    outMBIndex = outMBIndex + 1
  End If

  Var temp As Integer = r.InRange(0, 999)
  Var t1 As Integer = temp \ 100
  Var t2 As Integer = (temp \ 10) Mod 10
  Var t3 As Integer = temp Mod 10

  If t1 <> 0 Then
    outPtr.Byte(outMBIndex) = t1 + kZero
    outMBIndex = outMBIndex + 1
  End If

  outPtr.Byte(outMBIndex) = t2 + kZero
  outMBIndex = outMBIndex + 1

  outPtr.Byte(outMBIndex) = kDot
  outMBIndex = outMBIndex + 1

  outPtr.Byte(outMBIndex) = t3 + kZero
  outMBIndex = outMBIndex + 1

  outPtr.Byte(outMBIndex) = kEOL
  outMBIndex = outMBIndex + 1
next

If outMBIndex <> 0 Then
  bs.Write outMB.StringValue(0, outMBIndex)
End If

This code is far longer, harder to follow, and difficult to maintain, which goes back to my original point of why MemoryBlock should be avoided.

It also generates one billion rows of data in about a minute (as opposed to 2.5 hours).

It’s nice to have the option.

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:

User-Centric Mobile Apps Design Principles for Developers

Gabriel Ludosanu — Thu, 06 Feb 2025 16:00:00 +0000

Ever felt overwhelmed by the sheer complexity of designing a mobile app that not only works but also delights users? As a solo developer, you’re juggling multiple roles—designer, developer, marketer, and more. It’s easy to feel stretched thin, especially when it comes to crafting an intuitive and visually appealing app design. Don’t worry, you’re not alone in this struggle. Many indie developers face the same challenge. The good news? With the right design principles and strategies, you can create mobile apps that look great, function seamlessly, and leave a lasting impact on your users.

In this article, we’ll explore actionable, real-world design principles tailored to the unique needs of solo developers. Whether you’re building your first app or looking to improve your design skills, this guide will give you the tools and confidence to create apps that stand out in today’s crowded market.

Why Design Matters for Solo Developers

Before diving into specific principles, let’s address a fundamental question: Why is design so crucial for solo developers? The answer is simple—Users judge your app within seconds, forming quick impressions that impact their decision to continue using it. A poorly designed app drives users away, no matter how powerful its functionality is. Good design, on the other hand, builds trust, enhances usability, and keeps users coming back.

Start with a minimum viable product (MVP): Focus on the core functionality and get it into users hands quickly.
Gather feedback: Use surveys, app store reviews, or in-app feedback tools to understand what users like and dislike.
Refine based on data: Analyze user behavior (e.g., which features are most used) and improve accordingly.

Example:

When developing a language learning app, you might discover that users struggle with navigation. Based on feedback, simplify the menu structure or add tooltips to guide new users.

Tools to Simplify Design for Solo Developers

As a solo developer, you don’t need to reinvent the wheel. Leverage tools that streamline the design process:

Figma: A powerful design tool for creating wireframes and prototypes.
Xojo: Xojo’s drag-and-drop interface, combined with its easy-to-learn language, makes creating mobile apps across different form factors straightforward.
Canva: Great for creating simple, clean graphics for your app.

Conclusion: You’ve Got This!

Designing a mobile app as a solo developer is no small feat, but by following these principles, you can create apps that are both functional and enjoyable to use. Remember to start with your users in mind, focus on simplicity and clarity, and continuously refine your work based on feedback.

Your Next Step: Take a look at your current project (or start a new one!) and apply at least one of the principles discussed in this article. Need a mobile app development platform? Check out Xojo for an intuitive, developer-friendly way to bring your app ideas to life.

Xojo for 4D Developers

Geoff Perlman — Tue, 10 Dec 2024 23:35:07 +0000

If you are a longtime 4D developer you may recognize my name because I worked for 4D, Inc. (then ACIUS, Inc.) back in the early 1990s, as well as authored a book about 4D. But my experience with 4D goes back even further to 1987 when I began using 4D to build database applications for consulting clients. Over time I found the need to build more general purpose applications. This ultimately resulted in my founding the company that has become Xojo, Inc. and developing and publishing what is now Xojo for the last 28 years. Now, with my credentials out of the way, let’s talk about what Xojo can offer 4D developers.

Like 4D, Xojo has a drag and drop user interface builder, a Code Editor, a Debugger and a Compiler as well as a cross-platform framework. While 4D now has an object-oriented language as an option, Xojo has always been object-oriented. The language is a dot syntax not unlike Javascript. You do not have to become an experienced object-oriented programmer to use Xojo. One of its strengths is that you can learn incrementally.

Xojo supports database application development but there are differences between how it and 4D handles that. 4D has its own database engine and query syntax. Xojo supports SQLite, PostgreSQL, MySQL and ODBC for accessing databases. Unsurprisingly it uses SQL as its query syntax. Because 4D is solely designed for database application development, it ties the user interface you create to tables in the database. Xojo does not. 4D’s model prevents you from having to write code to get data from database records in and out of your user interface. While by default Xojo does not provide this, it provides an add-on called DBKit which assists you in connecting to and interacting with databases.

Xojo supports desktop development for Linux, macOS, Windows and Raspberry Pi (Linux on ARM). It supports web development as well and mobile development for iOS and Android. You can also build console apps which can be handy when you need an app with no user interface to run on a server. Xojo uses native controls and compiles to native machine code for x86 and ARM. Whether you come to Xojo to build desktop, web or mobile apps, you’ll find that 95% of what you learn and the code you write will be applicable to all targets. With the exception of iOS (which because of Apple’s requirements must be built from a Mac) you can build your apps from any platform to any platform. Xojo also includes a Remote Debugger which allows you to build from one operating system and run on another. For example, you might do your development on macOS but want to debug on Windows to track down a Windows-specific issue. With the Remote Debugger, this is quite easy.

Xojo is free to use for development. You only purchase a license when you need to deploy. This is a developer license, not a deployment license. That means that you can deploy as many applications as you like to as many users as you like, without any additional cost. Each developer purchases their own license. A Xojo license comes with 12 months of updates. The new Xojo releases available during your license period continue to be available to you even after your license expires. Renewing your license gets you another 12 months of updates. If you only need to deploy cross-platform desktop applications, the Xojo Desktop license is $399USD. Yearly updates are also $399USD. If you wish to build for any platform we support, the Pro license is $799USD. Yearly updates are also $799USD. Compare licenses and find more pricing details at our webstore.

If you’d like to give Xojo a spin, I recommend starting with the QuickStart and then the full tutorial. After that, check out DBKit, the video and its tutorial which will make it easier to build database-oriented applications. These are the desktop tutorials but there are also tutorials for mobile and web application development. Because Xojo is a general, cross-platform development tool rather than one specifically for database applications, what you build with it is truly limited only by your imagination. If you have any further questions, please reach out to us. Our user forum is also filled with experienced and enthusiastic Xojo users that answer and have answered hundreds of questions. And the Xojo Blog has many posts on database development with Xojo.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

A Programming Pioneer has Died

Geoff Perlman — Mon, 18 Nov 2024 19:59:46 +0000

On November 12th Thomas Kurtz, the co-inventor (along with John Kemeny who passed in 1992) of the BASIC programming language died at the age of 96. It would be difficult to overstate the impact he had on computing. BASIC made it possible for so many people (myself included) to begin their journey into programming.

In the late 1970s I became interested in learning to code. My father, who was an electrical engineer and coded in Fortran at work, brought home a book that taught the basics of programming. Written and published by Apple, it appeared to only cover 6502 Assembler, the chip that was in the Apple II. Just a few pages in my eyes began to glaze over and I started to wonder if programming was really for me. Fortunately, I flipped the book over to find it was actually two books in one. From the other side it was a book about AppleSoft BASIC. As I looked at the language, it made immediate sense to me. Assembler was too low level and not a great first language but BASIC was ideal for this purpose. I learned enough to get going and my life was forever changed.

Programming has evolved a lot since then but we still design Xojo with the same principle that Thomas and John espoused with their original version of BASIC: that programming should be accessible to anyone with an interest. We have many users whose first experience with programming was with Xojo just as mine was with BASIC. In our own way, Xojo is continuing what Thomas and John began. Today more people have the ability to learn programming than ever before. Thomas and John both were true pioneers that contributed significantly to making that happen.

Geoff Perlman is the Founder and CEO of Xojo. When he’s not leading the Xojo team he can be found playing drums in Austin, Texas and spending time with his family.

Xojo Web Rescues a .NET Project

Wayne Golding — Wed, 23 Oct 2024 16:40:14 +0000

I had a call recently from a customer whose upstream supplier informed them that they would not be accepting anything less than TLS 1.2 encryption. The customer’s application is written using .NET 1.1 (they are testing a new version but aren’t ready to deploy to production just yet). Their supplier insisted on a 1-week time limit. Can I help?

My answer was, of course, “Let me have a look and get back to you.”

I went to my favourite dev tool, Xojo, and went through the process of developing a solution. The connection is a REST API, so I’ll start with a web project and use the HandleURL event. And I’ll use a URLConnection to pass on the request. Wait … could it be that simple?

Function HandleURL(request As WebRequest, response As WebResponse) Handles HandleURL as Boolean

  // Create the outbound connection
  Var connector As New URLConnection
 
  // Copy the content of the request
  connector.SetRequestContent(request.Body, request.MIMEType)

  // Send the request
  Var result As String
  Try
    result = connector.SendSync("POST", kAddress + request.Path)
  Catch err As RuntimeException
    // Catch DNS, Certificate & Timeout errors
    response.Status = 500
    response.Write(err.Message)
    Return True
  End

  // Return the result of the request
  response.Status = connector.HTTPStatusCode
  response.Write(result)

  Return True

End Function

The answer is, “Yes!” This is all the code in the entire project.

You will notice that there is no security, but in this instance that is fine as the virtual machine is running this is on the same network as the client server and the firewall is configured to only allow connections from that server.

After processing over 60 thousand requests, memory use is 7.3MB and never exceeded 13MB. CPU usage was at the maximum 1.5%.

Even after using Xojo for 20 years this still blows my mind.

Wayne Golding has been a Xojo developer since 2005 and is a Xojo MVP. He operates the IT Company Axis Direct Ltd which primarily develops applications using Xojo that integrate with Xero www.xero.com. Wayne’s hobby is robotics where he uses Xojo to build applications for his Raspberry Pi, often implementing IoT for remote control.

Microservices: Building Modern, Scalable Applications

Gabriel Ludosanu — Tue, 24 Sep 2024 15:37:13 +0000

Imagine building a complex online marketplace with millions of users and a vast product catalog. How can you ensure scalability, flexibility, and resilience in such a demanding environment? Microservices provide a solution. A modern architectural approach that breaks down large scale applications into smaller, independent services, each focused on a specific task.

Microservices offer a alternative to traditional monolithic architectures where all application components are tightly coupled. Instead of one large, monolithic codebase, microservices consist of multiple independent services, each responsible for a specific functionality.

Understanding Microservices and Their Operation

Microservices are like building blocks for your applications. Each block is independent and performs a specific task, but they work together to create a complete and functional system.

Consider a food ordering website built with microservices. You might have:

User Authentication: Manages user logins and registration, offering flexibility for future user management features.
Product Catalog: Manages restaurant menus and items, enabling quick updates and personalized recommendations.
Order Management: Processes orders and tracks their status, providing real-time order updates to users.
Payment Processing: Handles payment transactions securely, ensuring seamless and reliable payments.
Delivery Management: Connects with delivery services and tracks deliveries, offering real-time delivery updates and convenient tracking.

Benefits of Microservices

Microservices offer several advantages for building modern applications:

Improved Scalability: Microservices enable you to scale individual services based on demand, allocating resources more efficiently. For instance, during a holiday sale, you can scale the order processing service independently to handle peak demand.
Enhanced Flexibility: Each microservice is independent and can be developed, deployed, and updated independently. This makes it easier to adapt to changing requirements and introduce new features quickly.
Increased Resilience: If one microservice fails, it will not affect the other services. This ensures that your application stays available even if there are issues with a specific component.
Simplified Development: Smaller, focused services are easier to understand, develop, and assess. This makes it easier for teams to work independently and contribute to various parts of the application.
Improved Deployment: Microservices can be deployed independently, which speeds up the deployment process and allows for continuous integration and delivery.
Easier to Manage: Microservices are easier to manage than monolithic applications, as they are smaller and more focused. This makes it easier to find and resolve issues.

Challenges of Implementing Microservices

While microservices offer many benefits, implementing them comes with its own set of challenges:

Greater Complexity: Compared to managing a monolithic application, maintaining a distributed system with several independent services can be more difficult. You will need to address issues like service discovery, communication, and data consistency.
Distributed Debugging: Debugging issues in a microservices architecture can be more challenging, as you need to track down problems across multiple services.
Data Consistency: Maintaining data consistency across multiple services can be difficult, especially when services update data independently.
Testing and Deployment: Testing and deploying multiple services can be more complex than testing and deploying a single monolithic application.
Security: Securing a microservices architecture requires careful planning, as you need to secure communication between services and protect data across multiple points.
Team Coordination: Collaborating with multiple teams responsible for different services can require increased coordination and communication.

When to Use Microservices

Microservices are not a one-size-fits-all solution. They are best suited for certain scenarios and are not be the ideal choice for others. Here are some factors to consider when deciding whether to use microservices:

Complex Applications: If you are building a large and complex application with many interconnected components, microservices can help you manage complexity and improve scalability.
Rapid Development and Deployment: Microservices allow for faster development and deployment cycles, as teams can work independently on different services.
Continuous Integration and Delivery (CI/CD): Microservices are well-suited for CI/CD workflows, as they can be independently deployed and tested.
Scalability and Flexibility: If your application needs to scale rapidly to handle peak loads or adapt to changing requirements, microservices can provide the necessary flexibility.

However, if your application is simple and you do not need the benefits of a distributed architecture, a monolithic approach might be more suitable. The decision of whether to use microservices depends on the specific needs of your project.

Best Practices for Building and Managing Microservices

Define Clear Service Boundaries: Carefully define the boundaries of each service, ensuring that each service has a specific purpose and a well-defined API.
Use a Consistent Design Pattern: Adopt a consistent design pattern for your microservices, such as RESTful APIs or message queues, to simplify communication and integration.
Use Service Discovery: Use service discovery to simplify how services find and connect with each other, reducing the complexity of managing service dependencies and network configurations – Xojo provides built-in features that makes service discovery easy.
Manage Communication Patterns: Choose the right communication patterns, such as synchronous or asynchronous, based on the needs of your services.
Ensure Data Consistency: Design your services to support data consistency, especially when multiple services share data (check how to use Semaphores or CriticalSection in Xojo).
Implement Robust Error Handling: Build in robust error handling mechanisms to ensure that services can recover from failures and handle exceptions gracefully – check this article for ways to write clean and maintainable code in Xojo.
Automate Deployment and Monitoring: Automate the deployment process and implement comprehensive monitoring to ensure that your microservices are running smoothly – here are some articles on how to automate the deploying process of Xojo built application for different project types.
Use DevOps Practices: Embrace DevOps practices to streamline development, testing, and deployment of your microservices.

Microservices offer a powerful approach to building complex and scalable applications. However, implementing microservices requires careful consideration of the challenges involved. This is where Xojo shines, making the process easy and simple. With its cross-platform app development capabilities, supporting desktop, web, and mobile platforms, and its intuitive visual environment, Xojo empowers developers of all skill levels to create scalable and reliable applications based on microservices architecture.

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!

Want to learn about using microservices with Xojo? Xojo Engineer Ricardo Cruz discuss the reasons for considering microservices, their benefits, challenges and best practices in this XDC 2023 video.

5 Monetization Strategies for App Developers

Gabriel Ludosanu — Tue, 10 Sep 2024 16:05:04 +0000

Desktop application monetization is essential for developers to generate revenue and sustain their businesses. Selecting the right approach from numerous available strategies can significantly impact an application’s success. This article explores top monetization strategies for desktop applications, including one-time purchases, subscription models, freemium models, in-app purchases, and advertising. Understanding the pros and cons of each strategy will help developers make informed decisions to maximize revenue and grow their businesses.

1. One-Time Purchase

Implement a one-time purchase model where users pay a single fee to download and use your desktop application. This approach provides instant revenue and offers several advantages:

Simple, straightforward pricing
Immediate revenue generation
No ongoing costs or commitments for users

However, this model has potential drawbacks:

Limited ongoing revenue, as users only pay once
Requires continuous updates and improvements to maintain user satisfaction
Relies heavily on new customer acquisition for sustained growth

Example: A one-time purchase model is ideal for specialized tools or applications with a specific, well-defined purpose. For example, a desktop application that converts file formats or performs complex calculations for a niche industry would be well-suited for this model. Users typically expect such tools to work reliably without the need for frequent updates or ongoing subscription costs.

2. Subscription Model

Implement a subscription model where users pay a recurring fee to access and use your desktop application. This approach generates ongoing revenue and encourages customer retention.

Benefits:

Predictable, recurring revenue streams
Increased customer retention and loyalty
Ability to continually update and improve the application

Potential drawbacks:

Users may be deterred by ongoing costs, especially for one-time tasks
Requires ongoing development and support, which can be resource-intensive

Example: Successful subscription-based desktop applications offer regular updates, new features, and premium support to justify the recurring fees. Productivity software suites and antivirus programs commonly use subscription models to provide ongoing value to customers.

3. Freemium Model

Implement a freemium model where a basic version of your desktop application is offered for free, with the possibility to upgrade to a premium version with added features or support. This approach attracts users with a free version and encourages upgrades to a paid version.

Benefits:

Attracts a large user base with the free version
Provides opportunities to upsell premium features or support
Allows users to try before buying, reducing purchase risk

Successful implementation:

Clearly define features and limitations of the free version
Offer significant value in the premium version to encourage upgrades
Make the upgrade process easy and seamless for users

Example: A photo editing software might offer a free version with basic editing tools, and a premium version with advanced features like HDR support or batch editing.

4. In-App Purchases

Implement in-app purchases to allow users to buy additional features, content, or services within your desktop application. This approach enhances the user experience and increases revenue.

Types of in-app purchases:

More features or functionality
Premium content (exclusive data or expert advice)
Virtual goods or currency
Ad-free experience or premium support

Successful implementation:

Clearly communicate the value of in-app purchases to users
Make the purchasing process easy and seamless
Ensure in-app purchases are relevant and useful
Avoid aggressive or deceptive monetization tactics

Examples: Productivity applications can use in-app purchases to offer advanced features. For instance, a project management tool might provide basic task tracking for free, but offer in-app purchases for advanced reporting, time tracking, or integration with other popular business tools. This allows users to customize their experience based on their specific needs and budget.

Games often use in-app purchases to enhance player engagement and monetization. A strategy game might offer a base game for free, but include in-app purchases for special units, resource packs, or cosmetic items. This model allows players to enjoy the game without spending money, while providing options for those who want to progress faster or customize their experience.

5. Advertising

Integrate advertising into your desktop application to generate revenue. This approach can be effective but requires careful consideration to keep a positive user experience.

Types of advertising:

Display ads (banner ads or pop-up ads)
Sponsored content (sponsored articles or product placements)
Affiliate marketing (promote other partner products or services)

Successful implementation:

Choose relevant and non-intrusive ad formats
Clearly mark ads to avoid confusing users
Use targeting options to deliver relevant ads based on users’ interests
Monitor user feedback and adjust ad strategy accordingly

Balance revenue generation with user experience when integrating advertising. Overly aggressive or intrusive advertising can drive users away, while insufficient advertising may not generate adequate revenue. Carefully check user engagement and satisfaction to find the right balance for your application.

Conclusion

Monetizing a desktop application requires careful consideration of target audience, application type, and revenue goals. Understanding different monetization strategies allows developers to choose the best approach and maximize revenue.

Each strategy, discussed in this article, offers unique advantages and disadvantages. The right choice depends on the specific application and target audience.

To succeed in monetizing a desktop application:

Understand target audience needs
Choose a monetization strategy aligned with application type and revenue goals
Continuously check and adjust strategy to improve revenue and user experience

By following these guidelines and selecting the right monetization strategy, developers can create successful, profitable desktop applications that meet user needs.

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!

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!

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.

House of the Snapdragon: Windows ARM is Coming

Paul Lefebvre — Tue, 13 Aug 2024 19:03:20 +0000

We’ve gotten a requests over the last few months asking about Xojo’s support for Windows on ARM and it seems like some people are not aware that Xojo already can build apps for Windows ARM. In fact, we added support for building Windows ARM apps two years ago in Xojo 2022 Release 2!

Some of you might not have noticed because, until recently, most people didn’t think much about Windows ARM. After all, nearly everyone still runs Windows on x86-64 CPUs. But lately, Windows on ARM is starting to get more traction, both in the press and in the market.

Back in May, Qualcomm announced the Snapdragon Dev Kit for Windows. This is supposed to be a $900 mini PC (about the size of a Mac mini) for developing Windows ARM apps for the Snapdragon X Elite SoC (system on a chip). I say “supposed to be” because although the press release says it was intended to go on sale on June 18, I can only find pre-order pages for it, so it seems to not be available just yet or out-of-stock.

There have been other ARM PCs for Windows in the past, but their performance has always been less than desirable. The new Snapdragon X Elite is supposed to be roughly equivalent to Apple M3 SoCs.

You don’t have to wait for Qualcomm as Copilot+ PCs and laptops with Snapdragon SoCs are starting to appear elsewhere. Lenovo has the ThinkPad T14s Gen 6, which at about $1700 is not exactly a bargain, but is in the ballpark of many Mac laptops. The Yoga Slim 7x is even cheaper starting at just $1200.

But I’m not here to sell Lenovo products. I’m just pointing out that Windows on ARM is becoming a reality, if slowly. That might be starting to change given Intel’s recent troubles with its Raptor Lake CPUs and most recent earnings report, however. Take it with a grain of salt, but Qualcomm is predicting that Windows ARM could reach 50% of Windows PC market within five years.

That sounds astonishing, but change often happens slowly then all at once.

Building for Windows ARM with Xojo

The good news is that with Xojo you are already prepared for this. To build your existing Xojo desktop project for Windows ARM, you just need to change one property in the Windows Build Settings and click Build. There is no step 3.

Xojo can also build Windows apps for x86-64 and x86-32, which pretty much covers all your bases. Not to mention that it can build macOS apps, Linux apps, web apps, iOS apps and Android apps.

And if you already have an Apple Silicon Mac then you don’t even need to purchase a Windows ARM computer. You can run Windows ARM as a virtual machine on a Mac using Parallels or VMware Fusion. You’ll still need to get your own license for Windows 11, however.

Although you can make your own Windows ARM apps with Xojo today, there are a couple temporary limitations to keep in mind. The first one is that XojoScript is not yet available. The other is that Xojo itself is not yet a native Windows ARM app. Both of these are because the Xojo compiler itself is not yet native on Windows ARM. That will change, but for now Xojo itself runs perfectly fine using the Prism x86-64 emulation layer in Windows. In addition you can use the Remote Debugger to test your apps on Windows ARM from another computer.

Will Windows ARM replace Intel like it did for Macs? It seems hard to believe, but the wind seems to be blowing in that direction. To make sure you’re prepared, download Xojo for free today and start creating your own ARM apps!

How Xojo Simplifies Full-Stack Development for Everyone

Gabriel Ludosanu — Wed, 07 Aug 2024 17:30:00 +0000

The demand for skilled full-stack developers continues to grow in 2024. These developers handle both the frontend and backend of applications, ensuring a smooth user experience from start to finish. As businesses strive to deliver robust, efficient and visually appealing applications, developers and their choice of programming tools can impact the speed, scalability and overall performance of a full software solution.

Presented with choosing what development tool is best for your main, full-stack development needs, let’s discuss the benefits of Xojo development platform for your next web project. With its simplicity, flexibility, and powerful features, Xojo will help you create high-quality web applications quickly and efficiently, with the added bonus of covering backend and frontend development in the same IDE—no more language switching—while also lowering your overall costs.

Overview of Full-Stack Development

Full-stack development covers the entire spectrum of technologies and skills required to create a fully functional web application. This approach involves both the frontend, which users interact with directly, and the backend, which powers the application.

At its core, full-stack development refers to the ability to work on both the client-side and server-side of an application. This means that full-stack developers should be proficient in frontend technologies such as HTML, CSS, JavaScript, as well as backend technologies like Node.js, Python, and frameworks such as React and Django. Full-stack developers possess a broad skill set that includes designing user interfaces, managing databases, and server logic, enabling them to oversee the entire development process.

Usually, a full-stack developer handles:

Frontend Technologies: These consist of HTML for structure, CSS for styling, and JavaScript for interactivity, crucial for crafting engaging user interfaces. Frameworks such as React, Angular, and Vue.js are also typical choices for building dynamic web applications.
Backend Technologies: This segment covers server-side programming languages like Node.js, Python, Ruby, and PHP, coupled with frameworks such as Express, Django, and Ruby on Rails, essential for robust backend development. Databases, both relational (e.g., MySQL, PostgreSQL) and NoSQL (e.g., MongoDB), are also crucial for data management.
APIs (Application Programming Interfaces): APIs enable simple communication between frontend clients and backend applications/servers, facilitating the exchange of data. RESTful APIs and GraphQL are common approaches used in modern web applications.

Advantages in adopting a full-stack approach in software development:

Faster Development Cycles: With a single developer or a small team capable of handling both frontend and backend tasks, projects can progress more quickly, reducing the time to market.
Easy Integration: Full-stack developers have a comprehensive understanding of how the different components of an application interact, leading to better integration and fewer compatibility issues.
Enhanced Problem-Solving: By possessing a complete view of the application, full-stack developers can identify and resolve issues more efficiently, improving overall project quality.

Why choose Xojo as a full-stack development solution?

When it comes to full-stack development, selecting the right programming language(s) or frameworks can significantly impact the efficiency and effectiveness of your projects. Xojo is a powerful choice for anyone seeking a robust, user-friendly and versatile development environment that provides everything needed to transform their ideas into fully fledged, working software products, no matter the platform or environment.

Xojo features ideal for full-stack development:

Built-in Web Server: Xojo has its own built-in web server that allows developers to easily test and deploy web applications (on Linux or Windows servers) without the need for additional software. There is no need to set up complicated web server technologies or deal with compatibility issues and security. Xojo handles all of that for you. In production, you can run a web app built with Xojo as stand-alone or behind Apache or Nginx. You decide what works best for your project.
Visual Development Environment: Xojo offers a visual development environment that allows developers to design user interfaces using drag-and-drop elements. This approach simplifies the process of creating appealing applications, accessible to both novice and experienced developers.
Object-Oriented Programming: Xojo is object-oriented programming (OOP), enabling developers to create modular and reusable code. OOP encourages better organization and maintainability of applications, making it easier to scale projects over time.
Compiled Code: Xojo compiles code into machine code, which results in fast and efficient web applications. In the event that some bad actors gain access to your server, rest assured that Xojo built web apps are more secure than those built with other tools.

In addition to these features, while many programming languages cater to full-stack development by combining and utilizing multiple external solutions, Xojo distinguishes itself as an ideal, singular solution. Compared to languages like JavaScript, Ruby, PHP or Python, Xojo has a gentle learning curve, making it an attractive option for beginners. Its syntax is straightforward and resembles natural language, which helps new developers learn concepts quickly. Xojo’s visual tools and drag-and-drop features enable developers to prototype applications rapidly. This is particularly advantageous for startups and businesses looking to iterate and launch products quickly.

Xojo for Frontend Development

Creating an engaging and user-friendly frontend is crucial for any web application. With Xojo, developers can quickly prototype and design visually appealing interfaces without the need for 3rd party tools or additional frameworks.

Xojo’s visual development environment makes building user interfaces an easy and enjoyable thing. With its drag-and-drop interface, developers can easily design and layout their GUI components- buttons, labels, and text fields- without needing any code at all. This intuitive approach allows developers to focus on the logic of the application rather than getting bogged down by low-level details.

So, what makes Xojo’s frontend capabilities so effective? For starters, it allows frontend developers to quickly:

Prototype and test ideas without writing code;
Easily create complex layouts and designs;
Focus on the logic of the application rather than the UI;
Collaborate more effectively with designers and other team members.

Example: A simple web app frontend built with Xojo

To illustrate the power of Xojo’s visual development environment, let’s take a look at a simple web app frontend built using Xojo. In this example, we’ll create a basic to-do list application with a user-friendly interface without writing any HTML, CSS or JavaScript code.

This ToDo web app design can be quickly prototyped in under 10 minutes with Xojo.

Coding Backend Functionality and Connecting it to the Frontend

While users interact with the frontend of apps, it’s the backend that does the heavy lifting, handling data and core functionality. Xojo makes building these backend systems easier for developers with useful features that create efficient server-side applications without unnecessary complexity. Xojo is a practical choice for developers who want to build solid, functional backends for web (and even desktop or mobile) apps without getting bogged down in overly complicated processes. Here are some notable aspects:

Database Integration: Xojo supports out-of-the box connections to a variety of databases, including MySQL/MariaDB, PostgreSQL, SQLite, and ODBC. Besides the built-in database classes, now there’s also the DBKit project and the new DatabaseConnection project item.
RESTful API Creation: Xojo makes it easy to create RESTful APIs, which are essential for enabling communication between the frontend and backend of a web application. By defining endpoints and handling HTTP requests and responses, developers can facilitate data exchange and enhance the interactivity of their varied applications and clients (web, desktop or mobile).
Session Management: Managing user sessions is crucial for web applications, especially those that require user authentication. Xojo provides built-in support for easy session handling, allowing developers to track user activity and maintain state across different pages, improving the overall user experience.

Integrating the Frontend and Backend

Full-stack development works best when the frontend and backend of an app work well together. Xojo makes this easier by offering a single app development software solution for both parts. Developers can use the same programming language throughout the whole project, which saves time and reduces complications. This approach helps programmers focus on creating a smooth user experience without switching between different tools or languages.

Here are some key points worth taking into account when you want to start building your next successful application:

Unified Language for Development: One of the standout features of Xojo is that it allows developers to work in one programming language, eliminating the need to switch between multiple languages like HTML, CSS, or JavaScript. This means that both the frontend and backend logic can be implemented using Xojo’s straightforward syntax, streamlining the development process, no matter the OS platform they’re building for.
Single Integrated Development Environment (IDE): Xojo’s IDE serves as a centralized hub for managing both frontend design and backend coding. Developers can design user interfaces visually, drag and drop elements, and simultaneously write the corresponding backend code without needing to leave the IDE. This integration enables a more intuitive workflow, reducing the chances of errors and inconsistencies.

As the demand for agile and efficient software development continues to rise, the choice of programming language solutions and frameworks can have a significant impact on both project timelines and budgets. Xojo stands out as a compelling alternative for developers and teams accustomed to traditional stacks like LAMP (Linux, Apache, MySQL, and PHP) or MEAN (MongoDB, Express.js, Angular, and Node.js) or any other.

For organizations and startups already familiar with other development stacks, transitioning to Xojo can lead to significant savings in training costs. Xojo’s intuitive interface and single programming language approach mean that team members can quickly adapt without needing extensive retraining. This is especially beneficial for companies looking to onboard new developers or expand their teams. And as an extra plus, using Xojo, you can expand your application supported platforms to include building native desktop clients (Mac, Windows, Linux) or mobile clients (iOS, Android) , all with just one codebase.

And let’s not forget that managing a full-stack application typically involves maintaining multiple technologies, which can result in higher operational costs. Xojo minimizes the need for additional languages and frameworks, resulting in lower maintenance overhead costs and increased efficiency in full-stack development. Updates, debugging, and scaling become more straightforward, allowing teams to allocate resources more effectively.

Is it fair to call Xojo not just a great full-stack development suite but a full-stack development suite that truly optimizes the entire development process and maximizes productivity?

Download and start using Xojo for free!

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!

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.

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.

Software Development – Xojo Programming Blog

Conditional Compilation in Xojo: #If False and #If True

What Is Conditional Compilation?

#If False – Completely Excluding Code

Why Not Just Comment It Out?

#If True – Always Including Code

When Is #If True Useful?

Defining Custom Compiler Constants

Best Practices

Conclusion

Building an AI Pair Programmer for Xojo Developers

What Is Zotto?

The Problem It Solves

Read-Only by Design

Bring Your Own Model

How It Works in Practice

Extending with MCP

Built for the Community

Community Contributions to the Xojo Blog: Spotlight On & Guest Posts in 2025

The Beauty of Binary Searches

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

Modules

Classes

Interfaces

Delegates

Quick Decision Guide

Quick glossary

Year of Code 2025: May Project, Mobile Apps

One More Thing

Year of Code 2025: April Project, User Interface

Decoding ‘Vibe Coding’: What Does It Mean for Developers (and the Code We Write)?

The Origin Story

How It Works (Supposedly)

My (Slightly Jaded) Take

The Potential Upsides (Maybe)

The Concerns (Definitely)

My Verdict

Handling Feature Requests

Understand the Need

Understand the Code

Understand the Path

Build the Road

Test Everything

Bonus Tip

Conclusion

Spotlight On: Tim Dietrich

Mac, Windows or Linux?

What do you wish more people would ask/talk to you about regarding programming?

How would you explain your most recent project to a new developer?

What’s next on your “Learn Next” list?

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

Xojo isn’t the only tool in your kit. What is a piece of software more people should know about?

When did you start using Xojo?

How did you find Xojo?

What did you first build with Xojo?

What do you build with it now?

What is something you worked on recently that you want to talk about?

Do you earn a living with Xojo?

Do you use it for your hobbies?

What’s your biggest Xojo success?

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

MemoryBlocks For Speed: A Case Study

The (One Billion Row) Challenge

Creating The Data

Memory-Unblocking

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

When Is `#If True` Useful?