Calcapp

Tip: Role-driven drop-down filtering

Fri, 10 Jul 2026 00:00:00 +0000

Control what users see in drop-downs based on their role or company, ensuring each person only accesses relevant options for their responsibilities.

When multiple departments or external partners use the same app, you don’t want everyone seeing every option in your drop-downs. A marketing manager shouldn’t see engineering project codes, and contractors shouldn’t access internal employee resources. Smart drop-down filtering based on user identity solves this automatically.

In private apps, drop-down options can adapt to who’s signed in, showing only what’s relevant to their role or organization. This goes beyond filtering based on user selections (covered here) — the app knows who the user is and adjusts accordingly.

Filtering by role

User roles are typically managed through tags assigned to each person when they’re granted app access. For our project management example, let’s say users have either Employee or Contractor tags.

Consider this project resource table, stored in a hidden form screen named ProjectResources and created using our data editor:

ResourceName	Category	AccessRole
Customer Database Access	Data Systems	Employee
Internal Wiki	Documentation	Employee
Project Asset Library	Shared Resources	Contractor
Contractor Guidelines	Documentation	Contractor
Shared Calendar	Scheduling	Employee
Public Templates	Shared Resources	Contractor

To display only the resources available to the signed-in user, associate this formula with the Values property:

FILTER(ProjectResources!ResourceName, USERHASTAG(ProjectResources!AccessRole))FILTER(ProjectResources!ResourceName; USERHASTAG(ProjectResources!AccessRole))

The FILTER function returns a subset of the ResourceName column based on a logical test. For each row, USERHASTAG checks if the signed-in user has the tag specified in the AccessRole column. When TRUE, that resource name appears in the drop-down. When FALSE, it’s excluded.

Employees see “Customer Database Access,” “Internal Wiki” and “Shared Calendar,” while contractors see “Project Asset Library,” “Contractor Guidelines” and “Public Templates.”

Filtering by company

If you don’t use role tags, company affiliation works just as well. Many organizations identify users by their email domain, automatically determining which company they represent.

Here’s a client project table stored in a form screen named ClientProjects:

ProjectName	ProjectType	ClientDomain
Website Redesign Q1	Design	acmecorp.com
Mobile App Development	Development	acmecorp.com
Brand Guidelines Update	Strategy	techstartup.io
E-commerce Platform	Development	techstartup.io
Marketing Automation	Strategy	globalmfg.com
Supply Chain Dashboard	Analytics	globalmfg.com

To show only projects relevant to the user’s company, use this formula:

FILTER(ClientProjects!ProjectName, ENDSWITH(App.UserEmailAddress, "@" & ClientProjects!ClientDomain))FILTER(ClientProjects!ProjectName; ENDSWITH(App,UserEmailAddress; "@" & ClientProjects!ClientDomain))

This works similarly to role-based filtering. The ENDSWITH function checks if the user’s email address ends with “@” plus the domain from the ClientDomain column. Users from acmecorp.com see only their website and mobile projects, while techstartup.io users see their brand and e-commerce work.

This approach eliminates the need to manually assign company tags — the system determines affiliation automatically from email addresses, reducing administrative overhead while maintaining strict access control.

Note: This technique requires named values, which are not available in our Starter plans.

Tip: Filter drop-downs with optional criteria

Wed, 15 Apr 2026 00:00:00 +0000

Filter drop-downs using criteria that users can set as TRUE, FALSE or "don't care," making large data tables manageable.

Create a new app based on the demo app below ↗

Drop-downs displaying columns from large data tables can be overwhelming. Filtering helps users find what they need by showing only relevant values.

A separate tip covers filtering by text. This tip focuses on filtering based on logical columns (TRUE and FALSE values) in your data table.

Users need three options for each filter criterion — TRUE, FALSE and “I don’t care.” Without that third option, filtering becomes too restrictive. For example, if users want to see all products that are on sale, they shouldn’t need to specify whether those products are discontinued or featured.

We’ll explore this with two example apps. The first demonstrates the concept using switch fields, while the second shows the practical solution using indeterminate drop-downs.

The underlying data table

The next form screen, Products, contains this data table (edited using Calcapp Creator’s built-in data editor):

Product Name	On Sale	Discontinued	Featured
Instant Pot	FALSE	FALSE	TRUE
Smart Speaker	TRUE	FALSE	FALSE
Wireless Earbuds	TRUE	TRUE	FALSE
Electric Mixer	FALSE	TRUE	FALSE
Smartwatch	TRUE	FALSE	TRUE
Bluetooth Speaker	FALSE	FALSE	FALSE
Gaming Console	TRUE	FALSE	TRUE
Digital Camera	FALSE	FALSE	TRUE
LED TV	FALSE	FALSE	FALSE
Game Controller	TRUE	FALSE	TRUE
Fitness Tracker	FALSE	FALSE	TRUE
Home Appliance	TRUE	FALSE	FALSE
Air Purifier	FALSE	TRUE	FALSE
Food Processor	FALSE	FALSE	TRUE
Electric Kettle	TRUE	FALSE	FALSE

Understanding the concept: Switch fields

Here’s the first example app using switch fields:

The text drop-down field at the bottom contains a list of products, which may be on sale, discontinued or featured. Check the Filter switch field to enable filtering with three switch fields.

This simpler approach helps explain the filtering concept, even though we’ll need to enhance it to be truly useful.

With switch fields, users can only specify TRUE or FALSE for each criterion — there’s no “I don’t care” option yet. Initially, all three switch fields are off, meaning only products that are not on sale, not discontinued and not featured appear in the drop-down.

If you enable both the Discontinued and Featured switch fields, no products remain. That’s consistent with the table — no rows have both values set to TRUE.

To achieve this, assign this formula to the Values property of the products drop-down:

IF(Filter, FilteredProducts, Products!ProductName)IF(Filter; FilteredProducts; Products!ProductName)

If the Filter switch field is on, the drop-down comes from the FilteredProducts named value. Otherwise, it contains all product names from the Products form screen (representing the data table).

(A named value is normally hidden and can store any formula result. They help shorten formulas and improve readability.)

Here, we use a named value to represent the filtered values of the drop-down field. Here’s the formula for FilteredProducts:

FILTER(Products!ProductName, (Products!OnSale = OnSale) && (Products!Discontinued = Discontinued) && (Products!Featured = Featured))FILTER(Products!ProductName; (Products!OnSale = OnSale) && (Products!Discontinued = Discontinued) && (Products!Featured = Featured))

FILTER takes an array and returns a version of it, potentially without certain elements (thereby filtering them out). The first parameter is the array to filter and the second is a logical array of the same size as the first array, where TRUE means the element at the same position in the first array is kept and FALSE means it is removed.

Let’s imagine that the second parameter only consists of this formula fragment:

Products!OnSale = OnSaleProducts!OnSale = OnSale

It references the OnSale named value of the Products form screen, thereby representing whether a product is on sale in the data table. It uses the = operator with the OnSale switch field of the first screen.

What does that do? It produces a logical array where the only elements that are TRUE are the ones where the OnSale switch field has a value that is equal to the OnSale column of the data table. If FILTER was given that logical array as its second parameter, it would produce a filtered version of the product names containing only those products that were or were not on sale, depending on the value of the OnSale switch field.

Of course, this is the complete second parameter we give to FILTER:

(Products!OnSale = OnSale) && (Products!Discontinued = Discontinued) && (Products!Featured = Featured)(Products!OnSale = OnSale) && (Products!Discontinued = Discontinued) && (Products!Featured = Featured)

Here, we’re using the && operator to mean “and,” implying that all three switch fields are used for the filtering operation. (If you’re used to Excel, you can also use the * operator.)

The critical limitation

This approach has a fundamental problem: users must specify a value for every criterion. What if they want to see all products on sale but don’t care whether they’re featured or discontinued? They can’t express that with switch fields.

This limitation makes the switch-field approach impractical for real use. We need a way to represent “I don’t care” — which brings us to the actual solution.

The real solution: Indeterminate state

Switch fields can’t represent “I don’t care,” but text drop-down fields can. Here’s the second example app using drop-downs that allow an indeterminate state:

Instead of switch fields, this app uses three text drop-down fields named OnSaleText, DiscontinuedText and FeaturedText. Each offers three choices: Yes, No or leave it blank (representing “I don’t care”).

How it works:

Blank drop-downs: no filtering for that criterion.
Yes or No: filter based on that choice.
Multiple criteria: products must match all non-blank selections.

Try selecting Yes for On Sale and leaving the other two blank. The drop-down shows all products on sale, regardless of whether they’re discontinued or featured. That’s the flexibility we need.

Implementation details

Since this app uses text drop-down fields instead of switch fields, we need named values to convert the text selections (“Yes”, “No”, blank) into logical values (TRUE, FALSE, blank) that the FILTER formula can use.

For example, the formula for the OnSale named value is:

SWITCH(OnSaleText, "Yes", TRUE, "No", FALSE, BLANK())SWITCH(OnSaleText; "Yes"; TRUE; "No"; FALSE; BLANK())

(SWITCH selects between values, but IF, IFS and CHOOSE could also be used.)

The formula for FilteredProducts needs to handle blank values differently from the switch field version:

FILTER(Products!ProductName, (ISBLANK(OnSale) || (Products!OnSale = OnSale)) && (ISBLANK(Discontinued) || (Products!Discontinued = Discontinued)) && (ISBLANK(Featured) || (Products!Featured = Featured)))FILTER(Products!ProductName; (ISBLANK(OnSale) || (Products!OnSale = OnSale)) && (ISBLANK(Discontinued) || (Products!Discontinued = Discontinued)) && (ISBLANK(Featured) || (Products!Featured = Featured)))

Let’s zero in on the OnSale part of the second parameter:

(ISBLANK(OnSale) || (Products!OnSale = OnSale))(ISBLANK(OnSale) || (Products!OnSale = OnSale))

ISBLANK checks if OnSale is blank, meaning no filtering should occur for this criterion. The || operator (or + in Excel) ensures that products are included if filtering is not required.

This formula produces a logical array whose elements are TRUE if the criterion is blank (don’t care) or if it matches the corresponding column in the data table.

The crucial difference from the switch field version: ISBLANK checks whether each criterion is blank, and || (the OR operator) ensures products are included when that criterion doesn’t matter to the user.

Note: This technique requires named values, which are unavailable in Starter plans. You can work around this by directly embedding the formulas instead of using named value references.

Tip: Use initial values with formula-driven drop-downs

Fri, 27 Feb 2026 00:00:00 +0000

Set initial values for formula-driven drop-downs using formulas that adapt to changing options.

For drop-downs with fixed values, you set the initial selection by choosing a value in Calcapp Creator. Simple and direct.

But when drop-down values are determined using a formula, those values aren’t known until the app runs. The drop-down in Creator is disabled because there’s nothing to select from yet.

Instead, you set the initial value using a formula. Select InitialValue from the property drop-down in the inspector:

Example formulas

Select a specific value

If you know that 2 is always part of the available values, use this formula:

Select the first value

If you don’t know what values will be available and want the first one selected:

INDEX(Item.Values, 1)INDEX(Item,Values; 1)

The INDEX function selects the first value from Values. Item references the drop-down field that the InitialValue property belongs to.

Select the last value

INDEX(Item.Values, SIZE(Item.Values))INDEX(Item,Values; SIZE(Item,Values))

SIZE returns the number of values, which INDEX uses to select the last one.

Select the middle value

INDEX(Item.Values, SIZE(Item.Values) / 2)INDEX(Item,Values; SIZE(Item,Values) / 2)

Dynamic re-evaluation

Traditionally, a field’s InitialValue property is only read when navigating to the screen containing that field.

For formula-driven drop-downs, InitialValue is now re-evaluated whenever the available values change. This handles an important scenario: what happens when a user’s selection becomes invalid?

Consider two drop-downs: one for country, another for province. When the user changes countries, the province list updates. But if they had already selected a province, that selection likely becomes invalid since different countries rarely share province names.

Calcapp automatically re-evaluates InitialValue in this situation. If you’ve used a formula like INDEX(Item.Values, 1), the first province in the new list gets selected automatically, keeping the app in a valid state.

Fresh analytics insights from 2025

Mon, 05 Jan 2026 00:00:00 +0000

We've refined our analytics tools to gain deeper insights into how you're using Calcapp. Here are the most popular functions, button types and common errors from apps created in 2025.

We have spent a lot of time refining the analytics tool we built to produce the list of the most popular formula functions to gain deeper insights into how you’re using Calcapp. A year later, here’s a fresh look at some of those data points, all pertaining only to apps created in 2025.

Most popular functions

If we look at the most popular functions used in only the apps created over the past 12 months, we can see that the list hasn’t changed all that much:

Rank	Function name	Percentage
1	IF	52.6%
2	CUMPRINC	14.1%
3	ABS	12.9%
4	ROUND	11.8%
5	ISDEFINED	1.7%
6	DATE	1.0%
7	BLANK	0.9%
8	FORMATNUMBER	0.9%
9	RGB	0.9%
10	AND	0.4%
11	TONUMBER	0.3%
12	SUM	0.2%
13	LEN	0.2%
14	IFS	0.2%
15	TODAY	0.2%
16	ISBLANK	0.2%
17	COLOR	0.2%
18	CONVERT	0.1%
19	PMT	0.1%
20	MAX	0.1%

Interestingly, RGB has entered the top 10, pushing CHOOSE down to 25th place. This suggests that more app creators are customizing their color schemes and creating visually distinctive apps.

(Or it could simply reflect that our new templates use RGB heavily.)

Most popular button types

We also have a list of the most popular button types:

Rank	Button type	Percentage
1	Reset	80.3%
2	Email report	7.7%
3	Go forward	4.4%
4	Go back	2.1%
5	Formula	2.0%
6	Server relay	1.2%
7	Open report	1.0%
8	Browse	0.7%
9	Clipboard copy	0.2%
10	Compose email	0.2%

What we learned here is that reset buttons are by far the most popular. That was the default when you pressed Add button for years, but we changed it a few years ago to email report buttons. That was apparently the wrong call, because you have all dutifully changed those buttons to reset buttons!

That alone is very useful information to us, because it’s actionable. We have changed the default to reset buttons once more. Therefore, it appears that you won’t have to change the button kind more than one time out of five, if you’re a typical user.

Most popular screen types

We also have data on the most popular screen types:

Rank	Screen type	Percentage
1	Form	89.6%
2	List	7.7%
3	Text	2.7%

Nothing terribly surprising here. We’ll revise our handling of different screens in the future, stay tuned.

Most common formula errors

What’s more interesting is that we now have data on the most common formula errors you encounter:

Rank	Error kind	Percentage
1	Invalid name reference	41.6%
2	Circular dependency	21.8%
3	Type mismatch (formula)	14.4%
4	Type mismatch (operator)	10.5%
5	Illegal ordering	3.6%
6	Unknown function	3.4%
7	Invalid text in formula	1.6%
8	Action formula support required	1.1%
9	Function parameter count	1.0%
10	Type mismatch (function)	0.8%

We obviously have our work cut out for us here. To be clear, this list represents formula errors in apps that are stored on our server — which is to say, apps probably abandoned by would-be app authors because of these errors.

(If you get frustrated, please get in touch! During working hours, we often manage to respond immediately when you chat with us. We are also often quick to respond to emails at support@calcapp.net.)

Invalid name references

What this tells us is that referencing fields, buttons and the like is a friction point. That particular error message links to this page, which tries to explain how it works, when you reference items from other screens, but perhaps this explanation isn’t clear enough.

Before we introduced our autocomplete functionality, this figure was actually higher, around 60%. The nice thing about autocomplete is that you can type the name or label of, say, a field, and autocomplete inserts the correct syntax automatically. We think that this has contributed to getting this error down in our statistics, but it’s still concerning to see it being so high.

Circular references

Circular dependencies are tricky. Calcapp is fairly unique in that it diagnoses these errors when you’re building your app (good) instead of just having your app fail with an error message when you run it (bad). However, we have struggled to produce a clear and actionable error message when circular dependencies are found.

So what are these circular dependencies? Plainly put, it’s when a field indirectly or directly references itself in the formula.

What’s the value of Field1 supposed to be? Why, it should be the value of Field1 plus 2! Obviously, that can’t work, and the same goes if Field1 depends on Field2, which depends on Field3, which depends on Field1. It’s difficult to get this across in an error message, and we’ll keep trying to make it clearer.

Helping us serve you better

These insights into how you use Calcapp are invaluable for us. They guide our development priorities and help us understand where our users struggle most. While we’ve made great strides with features like autocomplete, the data shows we still have important work ahead in making formula creation more intuitive and error-resistant. Keep building those apps — and keep letting us know where you get stuck!

Tip: Text-driven drop-down filtering

Sun, 14 Dec 2025 00:00:00 +0000

Add a text field that filters drop-down options based on what users type, making it easier to work with large lists of values.

Create a new app based on the demo app below ↗

Drop-down fields with hundreds or thousands of values can be difficult to navigate. Scrolling through long lists is tedious, and while desktop users can type to jump to values, few know this feature exists and it doesn’t work on mobile devices.

The solution: add a text field that filters the drop-down. Users type their search term, then open the drop-down to see only matching values. This makes large lists manageable on any device.

Example: Searching names

Here’s an example app with 100 names:

The drop-down shows only names matching the text entered in the search field.

How it works

This uses the FILTER function. Here’s the formula for the Values property of the drop-down:

FILTER(Names, CONTAINS(Names, Search))FILTER(Names; CONTAINS(Names; Search))

Names is a named value containing the full list:

{ "Alice", "Bob", "Charlie", … }{ "Alice"; "Bob"; "Charlie"; … }

Case-insensitive search

For case-insensitive filtering, use LOWER to convert both the search term and the names to lowercase:

FILTER(Names, CONTAINS(LOWER(Names), LOWER(Search)))FILTER(Names; CONTAINS(LOWER(Names); LOWER(Search)))

Now searching for “alice”, “ALICE” or “Alice” all produce the same results.

Note: This technique requires named values, which are not available in our Starter plans. You can work around this by directly embedding the array formula instead of using a named value reference.

Tip: Use XLOOKUP with multiple criteria

Fri, 14 Nov 2025 00:00:00 +0000

Combine multiple search criteria in XLOOKUP using AND, OR and parentheses to find exactly the data you need.

Create a new app based on the demo app below ↗

XLOOKUP is excellent for finding data in tables. Let’s explore how to use it with multiple search criteria using this venue table:

Venue	Type	Location	Capacity	Rate	AV	Catering
Grand Ballroom	Hotel	Downtown	500	5000	TRUE	TRUE
Conference Center A	Conference	Business District	200	2000	TRUE	FALSE
Community Hall	Community	Suburbs	150	800	FALSE	TRUE
Rooftop Terrace	Outdoor	Downtown	100	1500	FALSE	FALSE
Executive Boardroom	Conference	Business District	25	500	TRUE	FALSE
Garden Pavilion	Outdoor	Suburbs	80	1200	TRUE	TRUE

The table is created using the data editor and stored in a form screen named Venues.

Basic XLOOKUP usage

Normally, you use XLOOKUP to find exact matches:

XLOOKUP("Hotel", Venues!Type, Venues!Venue)XLOOKUP("Hotel"; Venues!Type; Venues!Venue)

This finds the first venue where the type equals “Hotel” and returns “Grand Ballroom”.

Moving to the TRUE technique

You can achieve the same result by moving the equality check into the search criteria:

XLOOKUP(TRUE, Venues!Type = "Hotel", Venues!Venue)XLOOKUP(TRUE; Venues!Type = "Hotel"; Venues!Venue)

Here’s what happens: XLOOKUP evaluates Venues!Type = "Hotel" for each row. This comparison returns TRUE for “Grand Ballroom” (because its type is “Hotel”) and FALSE for all other venues. Since we’re looking for TRUE, XLOOKUP finds the first row where the comparison is TRUE and returns “Grand Ballroom”.

Both formulas return the same result, but the second approach opens up powerful possibilities. Instead of a simple equality check, you can use any logical expression that evaluates to TRUE or FALSE.

Building complex search criteria

Once you’re searching for TRUE, you can combine multiple conditions using logical operators. Calcapp supports these operators that are common in programming languages:

&& means “and” — both conditions must be TRUE.
|| means “or” — either condition can be TRUE.
! means “not” — turns TRUE into FALSE and vice versa.

(You can also use the function equivalents AND, OR and NOT, but the operators are often easier to read.)

For example, to find conference venues with capacity of at least 100:

XLOOKUP(TRUE, (Venues!Type = "Conference") && (Venues!Capacity >= 100), Venues!Venue)XLOOKUP(TRUE; (Venues!Type = "Conference") && (Venues!Capacity >= 100); Venues!Venue)

This returns “Conference Center A” — the first venue meeting both criteria.

Demo app

Here’s a working example that lets you experiment with different search combinations:

Try this:

Set venue type to “Hotel” — you’ll find “Grand Ballroom” at $5000.
Now add a maximum budget of $4000 — the search will find “Hotel Atrium” instead.
Change venue type to “Outdoor” — you’ll find “Rooftop Terrace”.
Toggle “Requires catering” on — now it finds “Garden Pavilion” instead.

How the demo app works

The demo app shows several search criteria working together:

Venue type: Drop-down to filter by hotel, conference, community or outdoor venues.
Minimum capacity: Number field for required seating.
Maximum budget: Number field for budget constraints.
Requires AV equipment: Switch field for audio/visual needs.
Requires catering: Switch field for food service needs.

When you change any criteria, the app immediately shows the first venue that matches all your requirements.

The XLOOKUP formula

Here’s the core formula that powers the search:

XLOOKUP(TRUE, (VenueType = "" || Venues!Type = VenueType) && (ISBLANK(MinCapacity) || Venues!Capacity >= MinCapacity) && (ISBLANK(MaxBudget) || Venues!Rate <= MaxBudget) && (!RequiredAV || Venues!AV) && (!RequiredCatering || Venues!Catering), Venues!Venue, "No matches found")XLOOKUP(TRUE; (VenueType = "" || Venues!Type = VenueType) && (ISBLANK(MinCapacity) || Venues!Capacity >= MinCapacity) && (ISBLANK(MaxBudget) || Venues!Rate <= MaxBudget) && (!RequiredAV || Venues!AV) && (!RequiredCatering || Venues!Catering); Venues!Venue; "No matches found")

This single formula handles all the search logic. The following sections explain its constituent parts:

Venue type

(VenueType = "" || Venues!Type = VenueType)(VenueType = "" || Venues!Type = VenueType)

Matches if no type selected or if venue type matches selection.

Capacity

(ISBLANK(MinCapacity) || Venues!Capacity >= MinCapacity)(ISBLANK(MinCapacity) || Venues!Capacity >= MinCapacity)

Matches if no minimum specified or if venue has enough capacity.

Budget

(ISBLANK(MaxBudget) || Venues!Rate <= MaxBudget)(ISBLANK(MaxBudget) || Venues!Rate <= MaxBudget)

Matches if no budget specified or if venue is within budget.

AV equipment

(!RequiredAV || Venues!AV)(!RequiredAV || Venues!AV)

Matches if audio-visual equipment not required or if venue has AV.

Catering

(!RequiredCatering || Venues!Catering)(!RequiredCatering || Venues!Catering)

Matches if catering not required or if venue has catering.

All conditions are combined with &&, so venues must meet every specified criterion.

Techniques demonstrated

Optional criteria handling

In order to make criteria optional, the formula uses this pattern:

ISBLANK(field) || conditionISBLANK(field) || condition

If a search field is blank, that criterion is ignored. If it has a value, the venue must match it.

Switch field logic

For switch fields, the formula uses (!RequiredAV || Venues!AV)(!RequiredAV || Venues!AV). When the switch is FALSE (not required), the condition is always TRUE. When the switch is TRUE (required), venues must have that amenity.

Multiple result fields

The app shows venue name, location, capacity and rate by using the same search criteria in separate XLOOKUP formulas:

XLOOKUP(TRUE, [ same criteria ], Venues!Location, "")XLOOKUP(TRUE; [ same criteria ]; Venues!Location; "")

XLOOKUP(TRUE, [ same criteria ], Venues!Capacity, BLANK())XLOOKUP(TRUE; [ same criteria ]; Venues!Capacity; BLANK())

XLOOKUP(TRUE, [ same criteria ], Venues!Rate, BLANK())XLOOKUP(TRUE; [ same criteria ]; Venues!Rate; BLANK())

This ensures all displayed information comes from the same matching venue.

The TRUE search technique

The takeaway is that you can use TRUE as the lookup value instead of searching for specific data. When you write:

XLOOKUP(TRUE, [ some complex condition ], [ Return array ])XLOOKUP(TRUE; [ some complex condition ]; [ Return array ])

XLOOKUP evaluates the complex condition for every row, looking for the first position where it equals TRUE. This lets you use any logical expression as your search criteria.

This technique works with any combination of:

Comparison operators: =, <>, <, >, <=, >=.
Logical operators: &&, ||, !.
Parentheses for grouping complex conditions.
Field references and literal values.
Functions like ISBLANK for optional criteria.

Building your own search apps

This approach works for any data table where you need sophisticated filtering:

Product catalogs: Search by category, price range, features and availability.
Employee directories: Filter by department, role, location and skills.
Event listings: Find events by date, type, location and ticket price.
Inventory systems: Search by product type, quantity, supplier and status.

The pattern is always the same: combine multiple conditions with logical operators, then let XLOOKUP find the first matching row. Use the same criteria in multiple formulas to retrieve different fields from that row.

Try the demo app above to experiment with different search combinations and see how multiple criteria can help you find exactly the data you need.

Bug report: Some drop-down fields lost their values

Tue, 04 Nov 2025 00:00:00 +0000

Our October 15 update introduced a serious error affecting number drop-down fields. We have deployed an automatic fix for the vast majority of affected apps.

Our October 15 release unfortunately introduced a subtle error that significantly impacted app functionality. A small percentage of all number drop-down fields had their values replaced by zeroes.

While this only affected 0.45% of all apps, that still represents many hundreds of apps, and we sincerely apologize to everyone who was affected by this issue.

Our response

As soon as we became aware of the problem, we worked through the weekend to develop the tools needed to fix the issue properly. We have now deployed an automatic fix to the vast majority of all affected apps, and you should find that your app works correctly again.

However, for apps that were modified after our October 15 release, we couldn’t automatically apply the fix because doing so would have meant rolling back all changes you made from that date forward. We have reached out to all affected users through email and offered our assistance. We would be happy to restore your app to a version from October 15 with working number drop-down menus, but we need your confirmation first.

What happened?

Apps built with Calcapp undergo a migration process when we release major updates. Apps have an internal format that is hidden from view, and this format is updated every time we make a major release. We have a heavily-tested, automatic process for upgrading all apps before we release a new Calcapp version.

This particular new version was number 13 (perhaps no coincidence?), and our automatic process for converting all apps from version 12 to version 13 was evidently not tested thoroughly enough.

As you may recall, the headline feature of our October release was the ability to set drop-down field values using formulas. This required converting all drop-down values from one format to another automatically. While this worked perfectly in our controlled testing environment, it failed for a small percentage of real-world apps, explaining why their values were replaced by zeroes.

Our commitment

This is the first time our migration process has introduced a data loss bug, and we sincerely apologize for any inconvenience this caused. We’re happy to report that almost all apps have now been fixed and work correctly again. We are taking steps to ensure that this won’t happen again.

Feature: 20 new industry-specific templates

Thu, 23 Oct 2025 11:00:00 +0000

We've added 20 comprehensive templates covering major industries, from agriculture to transportation. Each template includes realistic calculations, giving you a solid foundation for building apps in your field.

Building an app from scratch can be daunting, especially when you’re not sure how to structure calculations for your specific industry. That’s why we’ve created 20 new templates covering major business verticals, each designed to showcase real-world calculations and best practices.

These new templates are front and center when you open Calcapp Creator and select the New app tab, organized with emoji icons for easy recognition:

Each template includes multiple screens with realistic data and calculations that demonstrate common use cases for that industry. Whether you’re calculating construction costs, patient BMI scores, marketing campaign ROI or energy consumption, these templates provide a starting point with actual formulas you can build upon.

Previously, our template collection was hit and miss. While we’ve created close to 30 templates over the years, they were never comprehensive enough to cover the breadth of industries using Calcapp. These new templates fill that gap.

An Excel-first perspective

We had outside help when creating these templates, and this brings an interesting perspective: they were built using expert-level Excel knowledge but from a newcomer’s perspective to Calcapp. This means you’ll find approaches that Excel users will recognize immediately, such as using the IFS function instead of our streamlined IF function (which also handles many conditions).

These apps use color-coding pervasively for result values. They use the same colors in many places and do so by repeating RGB formulas with the same parameters everywhere.

As software engineers, we typically prefer abstraction and keeping code DRY (Don’t Repeat Yourself). We would likely have created named values with color values that we could reference from formulas instead of duplicating RGB parameters everywhere.

However, we recognize that many users prefer the direct approach they’re familiar with from Excel — similar to using cell references instead of named ranges. These templates reflect that real-world preference, showing that there are multiple valid ways to structure your apps.

Beyond the Blank template

We’ve also added a new Blank with back end template that takes advantage of our new FirstScreen feature. This template starts you with a structure for organizing hidden calculations, data tables and other back-office logic that powers your app without cluttering the user interface.

This approach demonstrates how to separate your app’s logic from its presentation, keeping complex calculations organized behind the scenes while presenting a clean interface to users.

The comprehensive nature of these templates means you can see how experienced app builders structure their work, from simple calculations to complex multi-screen workflows. Each template serves as both a starting point and a learning resource.

Feature: Emojis in app names are now highlighted

Thu, 23 Oct 2025 10:00:00 +0000

When your app name starts with an emoji, we now display it larger and more prominently, making your app list easier to scan and navigate. This builds on what many users already do to organize their apps.

Many Calcapp users have discovered a clever way to organize their apps: they start app names with an emoji to create visual categories. A green checkmark for approved apps, a construction emoji for building projects, a heart for favorites — emojis make it easier to scan long lists of apps at a glance.

We’ve been watching this trend and decided to make it even better. When your app name starts with an emoji, Calcapp now recognizes it and displays the emoji larger and more prominently above the app name, similar to how text messages display emoji-only messages in a larger size.

This enhancement makes your emoji-categorized apps even easier to identify and navigate, especially when you have many apps in your account. The larger emoji serves as a visual anchor that helps you quickly find what you’re looking for.

Recognition of user innovation

This feature represents something we love about our user community: you often find creative solutions that inspire us to build better tools. We’ve seen users adopt emoji prefixes organically as a way to bring order to their app collections, and this feature is our way of recognizing and enhancing that innovation.

Whether you’re using emojis to indicate status, categorize by industry or simply make your apps more visually appealing, the enhanced display makes these organizational systems more effective.

A lighthearted milestone

This may well be the least significant Calcapp feature ever to receive its own Feature blog post. But sometimes the smallest improvements make the biggest difference in daily workflows. When you’re managing dozens or hundreds of apps, every bit of visual clarity helps.

The new highlighting works automatically — there’s nothing to configure or enable. Just start your app name with an emoji and watch it become more prominent in your app list.

Want to learn more creative ways to use emojis in your app organization? Check out our tips for organizing apps with emojis for inspiration and practical strategies.

Tip: Organize your apps with emojis

Thu, 23 Oct 2025 09:00:00 +0000

Using emojis as the first character of your app names creates powerful visual organization systems. With Calcapp now highlighting these emojis prominently, your app management becomes even more efficient.

App names that start with emojis aren’t just fun — they’re a powerful organizational tool. With emojis now highlighted prominently in your app list, you can create sophisticated categorization systems that make managing large collections of apps effortless.

Adding emojis to your system

Before exploring organization strategies, here’s how to insert emojis on different platforms:

Windows: Use Windows key+. to open the emoji panel, or search for “Character Map” in the Start menu for the traditional character selection tool.
macOS: Press Control+Command+Space to open the emoji picker, or use the Edit menu and select “Emoji & Symbols.”
Linux (GNOME): Open the “Characters” application from your application menu to browse and insert emojis.

Once you’ve added an emoji as the first character of your app name, Calcapp will automatically display it larger and more prominently in your app list.

Status-based organization

Use emojis to communicate the status of your apps at a glance:

✅ Green checkmark: Apps currently in production or approved for use
❌ Red X: Apps that need fixes or haven’t passed quality checks
🚧 Construction sign: Apps under active development
🔒 Lock: Private or restricted-access apps
⭐ Star: Your most important or frequently used apps
🧪 Test tube: Experimental or beta versions
📋 Clipboard: Template apps you duplicate for new projects

This system lets you quickly identify which apps are ready for users, which need attention and which are works in progress.

Industry categorization

For consultants or agencies managing apps across multiple industries:

🏥 Healthcare: Patient calculators, dosage apps, BMI tools
🏗️ Construction: Cost estimators, material calculators, project planners
💰 Finance: Loan calculators, investment tools, budget planners
📚 Education: Grade calculators, assignment trackers, study tools
🍕 Food service: Recipe scalers, cost calculators, inventory trackers
🚗 Automotive: Maintenance schedules, fuel efficiency, parts pricing

When you sort your apps by name, all apps in the same category will appear together, making project management much simpler.

Client-based systems

Service providers can organize apps by client using distinctive emojis:

🏢 Building: Corporate clients
🏪 Shop: Retail clients
🎯 Target: Marketing agencies
🔧 Wrench: Manufacturing clients
💊 Pill: Healthcare organizations

You might even assign specific emojis to individual major clients, making it easy to find all apps related to a particular account.

Version management with emojis

Combine emojis with our app versioning strategy for even better organization:

📱 Mobile phone: Current production version
🔄 Refresh: Updated version awaiting approval
📦 Package: Archived versions for reference
🎯 Target: Beta versions for testing

Since you can create unlimited copies of your apps for free, emoji-based version control helps you track the evolution of your work without cluttering your app list.

Advanced sorting strategies

App lists can be sorted by modification time (default) or alphabetically by name. When sorting by name, apps are actually sorted by their emoji first, then by the remaining text. This creates powerful grouping opportunities:

Use numbered emojis (1️⃣, 2️⃣, 3️⃣) to force specific ordering
Group related apps with similar emojis (🟢, 🟡, 🔴 for traffic light status)
Use seasonal emojis (🌸, ☀️, 🍂, ❄️) for time-sensitive apps

The key is consistency — develop a system that makes sense for your workflow and stick with it.

Managing large app collections

We have around 600 apps in our account, and emoji organization has become essential for navigation. Whether you’re a power user with dozens of apps or just getting started, emoji categorization scales with your needs.

Consider creating a simple legend document that explains your emoji system, especially if you work with teammates who need to understand your organizational scheme.

With emojis now highlighted prominently in Calcapp, your visual organization system becomes even more effective, turning your app list into an intuitive, scannable dashboard of your work.

Release: Our October, 2025 update is here

Wed, 15 Oct 2025 12:00:00 +0000

Define drop-down values with formulas to enable filtering, sorting and multi-level menus. Launch options and customizable first screens let apps adapt to their context, including the host page. QR codes and a redesigned workflow make publishing apps effortless.

What's new?

Formula-driven drop-down values. Drop-down fields can now use formulas to determine their values, enabling data table integration, multi-level menus and dynamic filtering. Learn more »
Redesigned publishing workflow. We've redesigned the publishing workflow to prevent accidental overwrites and give you better control over when changes go live. Learn more »
Launch options. Build a single app that adapts to different contexts, including the host page for embedded apps. Launch options are accessible from formulas. Learn more »
Customize the first screen shown. Control which screen users see first based on user roles, launch options or saved field values. This is also a great opportunity to hide data tables and calculations. Learn more »
QR codes for your apps. QR codes for your apps make it easy to test and share your apps across devices. Learn more »
Bulgarian language support. Thanks to a user in Bulgaria, we now support 31 fully translated languages, making Calcapp accessible to an even broader global audience. Learn more »

Tips for getting the most out of Calcapp

Populate drop-downs from data tables. Pull values directly from data table columns, eliminating manual copying and keeping everything synchronized automatically. Changes to your data tables instantly reflect in all connected drop-downs. Learn more »
Multi-level drop-downs. Create drop-downs that adapt their options based on selections in other drop-downs. Perfect for country/state selections, category/product filtering, and other hierarchical data relationships. Learn more »

Quality improvements

Formula reliability improvements. Numerous edge cases in formula evaluation have been resolved, making complex formulas more reliable and predictable. Learn more »
Creator stability enhancements. We've fixed two annoying bugs in Calcapp Creator that were hard to reproduce. Formula popups now dismiss properly and multi-selection works reliably. Learn more »

Miscellaneous

Revised learning guides. We've overhauled our learning guides with clearer headlines, bullet points instead of prose and more concise explanations to make them easier to scan. Learn more »
Template apps from our tips. Eight tip blog posts with demo apps now have template versions you can open directly in Calcapp Creator, making advanced techniques easier to learn. Learn more »

What's next

In the coming year, we'll be sharing more tips and techniques that build on these new capabilities, showing you how to create increasingly sophisticated apps with the tools now at your disposal.

We're also working on a major new project that will expand Calcapp's capabilities in significant ways. Stay tuned for more information in 2026.

Feature: Formula-driven drop-down values

Wed, 15 Oct 2025 11:00:00 +0000

Drop-down fields can now use formulas to determine their values, enabling data table integration, multi-level menus and dynamic filtering.

Drop-down fields are essential for letting users select from lists of options. With this release, they become much more versatile: you can now assign formulas to the Values property of number drop-down fields and text drop-down fields.

The benefits are numerous:

Reference data table columns directly instead of manually copying values.
Create multi-level drop-downs where selecting from one field determines the options in another.
Filter drop-down options based on text input, date ranges or other criteria. (Like the role of the signed-in user.)
Sort options differently based on user input.

Assigning a formula

To associate a formula with the Values property, press the new fx button in the inspector:

Array syntax

Dynamic drop-downs use arrays (lists of values) to provide their options. Arrays are written between curly braces, with elements separated by commas:

{ 3, 5, 7 }{ 3; 5; 7 }

This creates a drop-down with three numeric options. For text drop-downs, use quoted strings:

{ "Small", "Medium", "Large" }{ "Small"; "Medium"; "Large" }

You can conditionally include elements using IF. If 7 should only be available when Field1 is valid, use this formula:

{ 3, 5, IF(Field1.Valid, 7) }{ 3; 5; IF(Field1,Valid; 7) }

When Field1 is invalid, the drop-down shows only “3” and “5”. When valid, all three options appear.

To use the values of another drop-down, MyDropDown, use this formula:

MyDropDown.ValuesMyDropDown,Values

When you determine the values to use by setting them directly in the designer, you can simply select one of them from the drop-down to determine which value is shown initialy.

That doesn’t work if you use a formula. In that case, you need to assign a formula to the InitialValue property.

What you can build

This enhancement enables several practical techniques. We’re launching with two detailed tip posts:

Tip: Populate drop-downs from data tables. Pull values directly from data table columns, eliminating manual copying and keeping everything synchronized automatically.
Tip: Multi-level drop-downs. Create drop-downs that adapt their options based on selections in other drop-downs, enabling sophisticated multi-level filtering.

All next year, we’ll be publishing additional tips covering text-driven filtering, date-based filtering, role-driven access control, dynamic sorting, and working with initial values in formula-driven drop-downs.

For a comprehensive overview of all available techniques, see the Values documentation, which includes concise explanations of the complete range of possibilities with formula-driven drop-downs.

We have also improved the performance of drop-down fields. While we don’t suggest that you put thousands of options in a drop-down field, Calcapp should now be able to handle that many options.

Feature: Redesigned publishing workflow

Wed, 15 Oct 2025 10:00:00 +0000

We've redesigned the publishing workflow to prevent accidental overwrites and give you better control over when changes go live.

Our publishing workflow has had two related problems since the dawn of time:

The Publish button immediately replaced your stable, working app with whatever you were currently working on. One misclick pushed half-finished changes to your users without any confirmation or review.
Emailing links to your app, sharing it on social media or embedding it in your website — all those sharing features required you to first update your published app, overwriting it with whatever changes you were working on.

Our redesigned workflow solves both problems with a simple but important change: separating access to your published app from the act of publishing new changes.

Now when you press the Publish button, you see this dialog that gives you choices instead of immediately overwriting your app:

If the app has been published in the past, you’ll see this dialog instead:

For previously published apps, the dialog shows when it was last published, helping you decide whether to update or just access the current version’s sharing features.

The crucial difference: you can now get links, sharing options and embedding code for your stable published app without touching your work-in-progress. And when you do choose to publish updates, you’re making a deliberate choice rather than accidentally overwriting something that works.

The sharing features themselves have also improved with QR codes for easier mobile access and better support for launch options when generating links.

This new feature finally introduces a publishing process that gives you proper control over when your changes go live — and when they don’t.

Feature: Launch options

Wed, 15 Oct 2025 09:00:00 +0000

Build a single app that adapts to different contexts, including the host page for embedded apps. Launch options are accessible from formulas.

You’ve built a loan calculator that your clients love. Then they ask: “Can you make one for our mortgage division? Different rates, our logo, our colors?” So you duplicate the app and customize it.

Then the car loan team reaches out, making the same request. More duplication. Then the business loan department. Soon you’re maintaining four identical apps that differ only in branding and a few parameters.

Every bug fix needs to be applied four times. Every improvement gets rolled out four times. Every formula update requires four separate edits. You’ve multiplied your maintenance burden by the number of variations you support.

This multiplication problem affects anyone building apps for multiple contexts: consultants serving different clients, companies with multiple divisions, agencies creating branded calculators for various websites.

Launch options eliminate this duplication entirely and are available today.

This feature is only available in our White Label plans introduced in 2023.

How launch options work

Launch options are values passed to your app through its address. Instead of building separate apps, you build one app that reads these values and adapts accordingly.

Here’s a standard app address:

connect.calcapp.net/?app=abc123

Here’s the same app with launch options:

connect.calcapp.net/?app=abc123#Client=MortgageCorp&InterestRate=3.5

Now your single app can display MortgageCorp’s branding and use their specific interest rate — all without touching the core app.

Different clients get different addresses pointing to the same underlying app:

Mortgage division: #Client=MortgageCorp&InterestRate=3.5
Auto loans: #Client=AutoLoans&InterestRate=4.2
Business credit: #Client=BusinessCredit&InterestRate=6.1

One app, unlimited variations. When you fix a bug or add a feature, every variation benefits immediately.

Defining launch options

When you open your app in Calcapp Creator, you’ll notice that there’s a new section in the inspector:

To add your first launch option, simply start typing a name (no spaces). To add another one, start typing in the newly-revealed empty space.

Launch options are either numbers, text strings or logical values (TRUE or FALSE). That matters when you use them in formulas — you won’t be able to apply SUM to a text string, for example.

Setting launch option values

When you publish an app that uses launch options (using the Publish app button), you’ll see a new step for setting launch option values:

When you proceed to the next step, your launch option values are part of your app’s address.

If you like, you can also set launch options just by changing the address manually. However, note that text strings in particular can be tricky. Having Creator create your app links for you, including launch parameter values, is the safer choice.

Using launch options from formulas

As you have no doubt seen from the screenshots above, use LaunchOptions to access the values you have set for your launch options:

App.LaunchOptions!InterestRateApp,LaunchOptions!InterestRate

App.LaunchOptions!ClientApp,LaunchOptions!Client

Most of Calcapp’s many properties can set be through formulas, which can now take launch options into account.

What if you want a logo to be visible only if the client is Contoso? Add a new text box for the logo and use this formula with its Visible property:

App.LaunchOptions!Client = "Contoso"App,LaunchOptions!Client = "Contoso"

What if you want the colors of your app to match the brand colors of your client? Associate a formula like the following with properties like BackgroundColor, PrimaryColor and AccentColor on your first screen:

SWITCH(App.LaunchOptions!Client, "Contoso", COLOR("#fa43ae"), "Acme", COLOR("#bb23ca"))SWITCH(App,LaunchOptions!Client; "Contoso"; COLOR("#fa43ae"); "Acme"; COLOR("#bb23ca"))

Launch options pair perfectly with the new FirstScreen property of an app. Read the announcement post for an example.

The end of app multiplication

Launch options transform how you think about building apps for multiple contexts. Instead of asking “How many copies do I need?” you ask “What should vary between contexts?”

That loan calculator that started as four separate apps? Now it’s one app with launch options for client branding, interest rates and loan types. One app to maintain. One place to fix bugs. One location for improvements.

Whether you’re a consultant serving multiple clients, a company with various divisions or an agency building branded calculators, launch options let you scale your apps without multiplying your workload.

Feature: Customize the first screen shown

Wed, 15 Oct 2025 08:00:00 +0000

Control which screen users see first based on user roles, launch options or saved field values. This is also a great opportunity to hide data tables and calculations.

Most apps show the same first screen to every user. But what if different users need different starting points? What if employees should see a dashboard while contractors see a welcome screen? What if your app could adapt its entry point based on context?

The new FirstScreen property lets you control exactly which screen users see when they open your app. You can set it to a specific screen or use a formula to make it dynamic, creating personalized experiences that adapt to user roles, launch options or any other logic in your app.

It’s important to note that users can’t “go back” from the first screen you set. If you have defined several screens that come before that first screen in Creator, those are not accessible by pressing Back in the app. However, you can use a go forward button to let users reach those screens.

Setting the first screen

You’ll find the new property in the inspector when you first open your app in Creator:

If you open the drop-down menu, you’ll find a list of all the screens in your app, allowing you to select a different one. Use a formula to determine the first screen by pressing the fx button.

Using with launch options

Our new launch option feature enables apps to adapt depending on their context through the addresses used to launch them.

Let’s assume that the launch option Client is set and the app is launched through this address:

connect.calcapp.net/?app=abc123#Client=MortgageCorp

You can then associate a formula like the following with FirstScreen to select a special first screen if the client is “MortgageCorp”:

IF(App.LaunchOptions!Client = "MortgageCorp", MortgageCorpScreen)IF(App,LaunchOptions!Client = "MortgageCorp"; MortgageCorpScreen)

With launch options, a single app can essentially masquerade as many different apps, just by modifying the app address.

Hiding your back end

Over the years, we have added features that let you add logic and data tables to your app that form its “back end,” things that your users interact with only indirectly and never see as part of your user interface.

Hidden fields, named values and data tables normally need to be hidden away, and having them as part of your regular form screens only serves to clutter them in Calcapp Creator.

Traditionally, this problem has been solved in one of two ways:

In apps with list screens, you can place a navigator at the bottom and make it hidden. Under this navigator, you put all the background elements. Sometimes this requires another list screen to organize everything, sometimes a single form screen suffices.
In apps without list screens, you put background screens at the end, then set NextScreenAvailable to FALSE on the last user-facing screen to prevent users from going further. The downside is a grayed-out Next button in your app.

The FirstScreen property offers a cleaner solution: put all background logic at the beginning of your app, then use FirstScreen to jump directly to the screen users should see. Your app stays organized without workarounds.

User-based personalization

Beyond app organization and launch options, FirstScreen enables personalization based on who’s using your app.

Role-based access

For private apps, use USERHASTAG to show different first screens based on user tags. This formula presents different screens for employees versus contractors:

IF(USERHASTAG("Employee"), EmployeeScreen, USERHASTAG("Contractor"), ContractorScreen)IF(USERHASTAG("Employee"); EmployeeScreen; USERHASTAG("Contractor"); ContractorScreen)

Use NextScreen on both screens to merge users back to a common second screen, keeping the rest of the experience unified.

Email-based access

If you don’t use tags, check the user’s email address instead:

IF(ENDSWITH(App.UserEmailAddress, "@ourcorp.com"), EmployeeScreen, ContractorScreen)IF(ENDSWITH(App,UserEmailAddress; "@ourcorp.com"); EmployeeScreen; ContractorScreen)

This shows EmployeeScreen for company email addresses and ContractorScreen for everyone else.

Using saved field values

As fields can remember their values between sessions, you can check previous user input to determine the appropriate starting screen based on their history with your app.

Creating adaptive experiences

The FirstScreen property transforms apps from one-size-fits-all to adaptive experiences. Whether you’re personalizing based on user roles, adapting to different contexts through launch options, or simply organizing your app’s structure better, this feature gives you the control to ensure every user starts their journey at exactly the right place.

Combined with formulas, FirstScreen becomes a powerful tool for creating sophisticated app experiences that feel tailored to each user’s needs.

Feature: QR codes for your apps

Wed, 15 Oct 2025 07:00:00 +0000

QR codes for your apps make it easy to test and share your apps across devices.

There’s a fundamental mismatch in how we build and consume apps: most people develop on desktop computers but primarily use apps on their phones. This creates a friction point every time you want to test your latest changes or share your app with others.

Traditional solutions require typing long addresses, sending yourself emails or dealing with complex sharing workflows. But there’s a better way.

Our redesigned publishing workflow includes QR code support that solves this desktop-to-mobile handoff problem elegantly:

Point any modern smartphone camera at the QR code, and your app opens instantly. No typing, no fumbling with addresses, no friction. If you hover over the QR code, a download button appears, allowing you to download a high-resolution version for your own use.

This capability transforms several important workflows:

Instant testing: Build on desktop, test on mobile immediately. Instead of typing addresses or sending yourself emails, just point your phone at the screen. (For draft versions, you can always use connect.calcapp.net to open works-in-progress directly.)

Professional sharing: Use the high-resolution QR codes for business cards, flyers, websites and ads.

Accessibility: Eliminate typing barriers entirely. QR codes work for users who struggle with complex addresses or small phone keyboards.

QR codes became mainstream during the pandemic as everyone learned to scan codes for menus, payments and information. We’re building on that familiarity to help you get your creations from the development environment to users’ hands as smoothly as possible.

PS. Did you know that QR codes were invented in Japan in the 1990s to track automobile parts and have special support for Japanese characters (Kanji)? “QR” stands for “quick response.” The inventors made the technology freely available to encourage widespread adoption. Wikipedia has other fun facts.

Feature: Bulgarian language support

Wed, 15 Oct 2025 06:00:00 +0000

Thanks to a user in Bulgaria, we now support 31 fully translated languages, making Calcapp accessible to an even broader global audience.

Thanks to an intrepid user in Bulgaria, Calcapp now supports Bulgarian as its 31st fully translated language. This means Bulgarian-language apps now display proper text labels like Back (to move back to the previous screen) and Open (to open a downloaded report), in addition to the number and date formatting that Calcapp has supported for years.

Want your language fully supported? Get in touch and we’ll work with you to make it happen.

Since we introduced multilingual support seven years ago, Calcapp has supported 79 languages and 147 language variants for number and date formatting. For example, 123,456.78 in US English is rendered as “123 456,78” in Swedish, and “October 24, 2043” is rendered as “24 oktober, 2043” in Swedish. However, only a subset of these languages have full translations for app interface labels.

Why language support matters

Out of curiosity, we analyzed what languages our published apps use. When we look only at apps created by paying customers, English accounts for less than half of all published apps. More than half of our customer base creates apps in other languages.

This suggests that multilingual support isn’t just a nice feature — it’s essential. Without it, we likely would have lost more than half of our customers to competitors. The investment in language support has clearly paid off.

Here’s the breakdown of all published apps (including test apps from trial users, which explains English’s dominance as the default):

Beyond adding Bulgarian, we’ve also improved translations for several existing languages, ensuring that interface labels better match what native speakers expect. These refinements make apps feel more natural and professional to users around the world.

Bug report: Formula reliability improvements

Wed, 15 Oct 2025 05:00:00 +0000

Numerous edge cases in formula evaluation have been resolved, making complex formulas more reliable and predictable.

Originally, our latest release was planned for this spring. What happened? Well, we hit a snag.

When we wrote one of the blog posts describing the new Values property of number and text drop-down fields, the numbers in the example app we developed didn’t update properly. Puzzled, we looked into the issue, not knowing that we’d have to spend months reworking Calcapp to make the app work.

We fixed a very similar issue roughly one year ago. The issue then was that referencing named values through functions like IF and SWITCH would lead to subtle bugs — calculations wouldn’t update and we couldn’t reliably detect cycles.

Cycles occur when formulas reference themselves, either directly or through a chain of other properties. While this might seem obvious to avoid, it can happen accidentally in complex apps with many interconnected formulas.

The fix we introduced a year ago turned out not to fix all issues with named values. It turned out to be a band-aid and not a long-term fix, so we had to go back to the drawing board and do this right.

What we fixed

Beyond the named values issues, we found other subtle problems. For example, consider a property like IncludedFields of reset buttons. A formula like the following would work in some cases but not others:

SUM(ResetButton1.IncludedFields)SUM(ResetButton1,IncludedFields)

This used to work fine if that property was set with a formula, but would give an error if you selected fields in the inspector instead. This inconsistency has now been fixed.

There are many other similar problems that have been resolved, particularly when named values reference other named values in complex ways.

Our commitment to formulas

Sometimes customers ask us if Excel is running in the background on our server to power our apps and formula editing experience. The answer is no — that wouldn’t be practical (or legal). We use our fully custom formula engine, which consists of hundreds of thousands of lines of code developed over 16 years.

We believe Calcapp’s formulas are its best feature. They enable the flexibility that ensures your apps meet your needs. We will continue investing to make sure this foundational part of Calcapp remains reliable, no matter how complex your formulas become.

Bug report: Creator stability enhancements

Wed, 15 Oct 2025 04:00:00 +0000

We've fixed two annoying bugs in Calcapp Creator that were hard to reproduce. Formula popups now dismiss properly and multi-selection works reliably.

Calcapp Creator, our app designer, has been afflicted with two minor but annoying bugs for some time now. The problem was that we couldn’t consistently reproduce them, which made them much more challenging to fix.

Fortunately, we managed to fix both for this release. These fixes, along with several other improvements, make Calcapp Creator feel more polished and reliable.

When you edit formulas, we helpfully show you where you are in a particular function (first or second parameter to XLOOKUP?), along with concise documentation. This feature was introduced roughly two years ago.

At the same time, we introduced formula autocomplete, which shows you a list of suggestions for things like functions and fields you may be trying to reference.

It turned out that when both were displayed at the same time—the function information and the autocomplete popup—moving away from the formula editor would only dismiss the autocomplete popup, not the function information.

Sure, you could press a button to dismiss that information, but this was still annoying. What was more annoying for us was that it took a while to figure out that this only happened when both were showing at the same time.

This problem has now been fixed, making the app authoring experience much more polished. Finally.

Checking many items

You may not be aware, but you can speed up your workflow quite a bit by editing multiple fields, buttons and other elements at the same time. Just press the check mark next to all the items you want to edit, and the inspector will apply all changes you make to all the selected items.

(This feature even enables you to edit the formulas of multiple properties at the same time!)

The only problem was that this feature stopped working occasionally. You’d check multiple items and be rewarded with an empty inspector. Not good.

We encountered this problem on numerous occasions, but every time we got ready to track down the issue, everything worked just fine.

Then, a week or two later, we’d encounter the same problem again, realizing that the pesky bug still lingered.

It turned out that every time we tried to track down the issue, we started fresh with a newly loaded Calcapp Creator, which wasn’t very effective because the problem only manifested after you opened a new app.

With the problem being fully reproducible, we were finally able to fix the bug. Along with the popup fix mentioned above, we think this makes for a much more polished experience.

Additional polish improvements

Beyond the two main bug fixes, we’ve addressed several other issues that contribute to a more polished Creator experience:

When selecting a screen from the inspector (such as the Target property of go back buttons or the new FirstScreen property of your app), the display could get garbled for long screen names. Fixed.
We use your location for various things, especially when displaying prices when you make plan changes (we even translate the VAT term to 25 different languages). To do that, we subscribe to a service that tells us your country from your IP address. This service can fail intermittently, which makes Creator crash. We now recover from those failures more gracefully.
We’ve modernized our embedding features by dropping Internet Explorer support. When embedding your apps in a web page, you can include a JavaScript library enabling your page to communicate with the app, realizing things such as auto-height. The embed tab now reflects this change, though existing apps using our Internet Explorer support will continue working for the time being.

While individually small, these improvements collectively make Calcapp Creator feel more reliable. The formula popup and multi-selection fixes in particular eliminate two of the most annoying workflow interruptions our users experienced.

Tip: Populate drop-downs from data tables

Wed, 15 Oct 2025 03:00:00 +0000

Pull values directly from data table columns, eliminating manual copying and keeping everything synchronized automatically. Changes to your data tables instantly reflect in all connected drop-downs.

Drop-down fields often need to display values that already exist in your data tables — product names, categories, colors and other attributes stored in the data editor.

Previously, you had to copy these values from your data table and paste them into each drop-down field. Worse, whenever you updated the data table, you had to remember to manually update every affected drop-down field. This created maintenance headaches and opportunities for things to get out of sync.

Now that drop-down field values can be defined using formulas, there’s a better way: pull values directly from your data tables. Update the table once, and every drop-down field reflects the change automatically.

How it works

Imagine you have the following data table of products:

Name	Kind	Size	Color	Price
Ocean Breeze Knit	Sweater	Medium	Blue	29
Deep Blue Comfort	Sweater	Large	Blue	49
Royal Glow Pullover	Sweater	Large	Purple	39
Violet Cozy Wrap	Sweater	Small	Purple	29
Moonlight Shift	Dress	Small	Gray	69
Midnight Elegance	Dress	Large	Black	129
Sapphire Flow	Dress	Medium	Blue	72
Shadow Flex Shorts	Shorts	Medium	Black	39
Onyx Sport Shorts	Shorts	Large	Black	52
Ash Drift Shorts	Shorts	Medium	Gray	49
Mystic Air Shorts	Shorts	Large	Purple	19

Create a form screen called Products and use the data editor to create one named value for each column. The product names become accessible as the Name named value, colors as the Color named value, and so on.

To create a drop-down field that lets users select a product, assign this formula to its Values property:

Products!NameProducts!Name

That’s it. The drop-down now displays all product names from the table.

Handling duplicates

What if you want users to select a color? This formula works, but creates a problem:

Products!ColorProducts!Color

While there are only four unique colors (blue, purple, gray and black), the drop-down displays eleven entries — one for every product — with many duplicates.

Remove duplicates using the UNIQUE function:

UNIQUE(Products!Color)UNIQUE(Products!Color)

For alphabetical order, add the SORT function:

SORT(UNIQUE(Products!Color))SORT(UNIQUE(Products!Color))

Now your drop-down shows each color exactly once, sorted alphabetically.

Note: This technique requires named values and the data editor, which are not available in our Starter plans.

Tip: Multi-level drop-downs

Wed, 15 Oct 2025 02:00:00 +0000

Create drop-downs that adapt their options based on selections in other drop-downs. Perfect for country/state selections, category/product filtering, and other hierarchical data relationships.

Create a new app based on the demo app below ↗

Multi-level drop-downs are a common pattern: select a country, then choose from states or provinces specific to that country. Select a category, then pick from products in that category. The second drop-down adapts based on the first selection.

Previously, this required complex workarounds involving multiple hidden drop-down fields that appeared and disappeared based on the first selection. Now that the Values property can be set using formulas that return arrays, multi-level drop-downs are straightforward to implement.

Example: North American regions

Here’s an app that lets users select a country in North America. The state or province drop-down adapts its values based on the country selection:

The app uses three named values: UsStates, MexicanStates and CanadianStatesTerritories. Here’s the start of the UsStates value:

{ "Alabama", "Alaska", "Arizona", … }{ "Alabama"; "Alaska"; "Arizona"; … }

The Values property of the state/province drop-down uses this formula:

SWITCH(Country, "Canada", CanadianStatesTerritories, "United States", UsStates, "Mexico", MexicanStates)SWITCH(Country; "Canada"; CanadianStatesTerritories; "United States"; UsStates; "Mexico"; MexicanStates)

This uses the SWITCH function, but IF, IFS and CHOOSE work equally well.

Dynamic labels

Canadian provinces are either states or territories. The drop-down label reflects this using a formula for the Label property:

SWITCH(Country, "Canada", "State or territory", "State")SWITCH(Country; "Canada"; "State or territory"; "State")

Selecting a default value

Drop-downs with formula-based values don’t have a default selection. When the country changes, no state or province is initially selected.

To automatically select the first option, assign this formula to the InitialValue property:

INDEX(Item.Values, 1)INDEX(Item,Values; 1)

The Item formula parameter accesses the current drop-down field, letting you reference its Values property. (You could also write State.ValuesState,Values to reference the field by name.)

Note: This technique requires named values, which are not available in our Starter plans. You can work around this by directly embedding the array formulas instead of using named value references.

Revised learning guides

Wed, 15 Oct 2025 01:00:00 +0000

We've overhauled our learning guides with clearer headlines, bullet points instead of prose and more concise explanations to make them easier to scan.

We’ve given our learning guides a comprehensive overhaul to make them easier to follow and more effective for users at all levels.

The main improvements include:

Clearer headlines that help you find exactly what you’re looking for.
Bullet points instead of dense prose to make scanning and finding information faster.
More concise explanations that get to the point without sacrificing clarity.

As Calcapp continues to grow with new features and capabilities, our goal is to provide a comprehensive yet accessible overview of the entire platform. We want the guides to give you a thorough understanding without becoming a lengthy read.

To achieve this, we’ve actually added new material covering the recent features, while managing to reduce the word count (from roughly 32,000 words to 27,000 words, a 16 percent reduction). This means you can quickly get up to speed on everything Calcapp offers, from basic app building to advanced formula techniques.

Whether you’re new to Calcapp or looking to explore features you haven’t used yet, the updated guides should provide a much smoother learning experience.

If you haven’t read the guides in a couple of years, now is a great time to dive in and scan them to see if there’s anything you’ve missed!

Our tip demo apps are now available as templates

Wed, 15 Oct 2025 00:00:00 +0000

Eight tip blog posts with demo apps now have template versions you can open directly in Calcapp Creator, making advanced techniques easier to learn.

Since 2017, we have published 39 tip blog posts — informative articles covering interesting techniques you can use in your own apps. Eight of these posts include live app demos to illustrate the techniques in action.

Until now, you couldn’t work with those demo apps in Calcapp Creator. We recognize that being able to study and modify these examples is valuable for learning, so starting today, those eight tip posts now include a link that creates a new app in Creator based on the demo app.

When you create a new app in Creator, you’ll also find these tip templates available alongside the standard sample apps and Blank template option.

Here are the tip posts now available as templates:

These templates make it easier to understand advanced techniques and adapt them for your own projects. Simply open any tip post and look for the template link to get started.

Update: Now all our sample app posts also come with these convenient links.

A new release is coming

Tue, 29 Jul 2025 00:00:00 +0000

We're preparing a new release with formula-powered drop-down values and other exciting new features. Behind the scenes, we've also been modernizing Calcapp for the future.

The first thing we do when evaluating a new service is to check out the blog, as we don’t want to invest time and money in a service that isn’t being actively developed or supported. In our experience, a well-maintained service usually goes hand in hand with a well-maintained blog.

By that metric, we have let you down recently. With only one blog entry posted this year, it may seem like Calcapp is dormant.

Thankfully, nothing could be further from the truth — we’re moving full-speed ahead with a new release. While smaller in scope than some of our previous ones, this release is packed with important new features that will enable entirely new kinds of apps.

We’ll keep some of features under wraps for now, but the headline addition is this: you will be able to set the values of drop-down fields using formulas. That single change unlocks a wealth of possibilities, including:

Populate drop-downs from data tables. Link drop-down fields directly to a column in a data table — no more copying and pasting values.
Multi-level drop-downs. Use one drop-down field to determine the values displayed in another.
Text-driven drop-down filtering. Allow your users to filter a drop-down field using a text field.
Filter drop-downs with switch fields. Use switch fields to refine the available drop-down values.
Filter drop-downs using dates. Filter drop-down values based on start and end dates selected in date and time fields.
Filter drop-downs using user roles. Private apps require users to sign in. If a role is assigned to a user, you can use that role to filter what’s shown in a drop-down.
Custom sort order. For drop-downs with many values, order matters. Customize the sort order to make options easier to scan.

This new feature places significant demands on our formula engine. In fact, while writing one of the upcoming blog posts about these features, we uncovered several issues.

The culprits? Named values, which we’ve come to rely on heavily when building apps. Under stress, they didn’t always behave correctly — surfacing issues similar to the ones we identified and fixed last year. We’ve spent the past few months diving deep into these problems, and we’re now nearing the finish line.

Since our last major release nearly two years ago, most of our time has actually gone into a far-reaching project to modernize Calcapp and prepare it for the future. Specifically, we’re working to make it easy to use our formula engine in new contexts.

That work will have exciting implications down the line — we look forward to sharing more when it’s ready.

In the meantime, we’re thrilled about our upcoming release, which should be ready in the coming months.

Our most popular formula functions

Thu, 09 Jan 2025 00:00:00 +0000

Which of our many formula functions are used the most? This post lists the 50 most popular functions.

It’s the start of a brand new year, and we thought it would be fun to kick things off by sharing a look at what functions you’re using the most in Calcapp!

The list holds some interesting surprises — while it’s no shock that the IF function takes the top spot with over a million uses, we didn’t expect to see the financial function CUMPRINC coming in as the second most popular.

Without further ado, these are the 50 most popular functions:

Function name	Usage count
IF	1,124,124
CUMPRINC	249,885
ABS	232,818
ROUND	208,927
BLANK	182,306
ISDEFINED	122,643
CHOOSE	113,207
COLOR	63,443
TONUMBER	37,785
FORMATNUMBER	25,618
FV	20,373
MIN	20,099
SUM	15,895
LEN	15,465
AND	13,757
IFERROR	10,897
TODAY	10,298
ISERROR	9,264
FIND	9,209
CEILING	7,797
OR	7,687
FORMATPERCENTAGE	7,455
TRUNC	5,931
ISBLANK	5,035
MROUND	4,605
REGEXREPLACE	4,498
ROUNDUP	4,332
NOT	4,139
CONVERT	3,755
FLOOR	3,638
SUBSTITUTE	3,595
RANDBETWEEN	3,212
SQRT	2,762
MOD	2,545
PRODUCT	2,532
RADIANS	2,263
HSB	2,172
PMT	1,928
MAX	1,915
TOTEXT	1,893
ROUNDDOWN	1,863
NOW	1,857
COS	1,772
REGEXMATCH	1,351
HSL	1,293
CONCATENATE	1,214
MONTH	1,163
DATE	1,155
YEAR	1,150

The ten most popular functions are now displayed permanently on the first formula reference page.

Looking ahead

Tue, 12 Nov 2024 00:00:00 +0000

Calcapp is evolving! Exciting updates are on the horizon, including enhanced web integration, data handling and AI features.

As 2024 draws to a close, we wanted to take a moment to give you an update on what’s going on with Calcapp.

First and foremost, thanks for being a part of our community and for trusting us as a valued customer. It’s because of you that we’re able to keep improving Calcapp. There are many exciting new features on the horizon that will improve your workflow and make the apps you build even better.

Supporting you when you’re building your apps

Every plan we offer includes support. That means if you ever find yourself stuck, we’re just an email or a chat message away. (While our chat system isn’t staffed 24/7, we’ll get back to you as soon as possible during office hours in Western Europe.)

However, if you want us to fully build an app for you, we offer that as part of our professional services program. As the world’s foremost Calcapp experts, we’re able to build apps for you that use all the bells and whistles of the platform, and we’re likely able to do so faster and more cost-efficiently than your own team, which would need time to get up to speed first.

Some customers want us to build apps and maintain them for them, while others just want us to create the beginnings of an app, enabling them to take the reins once the groundwork has been laid.

Both approaches are equally valid. Reach out to us and we’ll be happy to discuss your requirements in detail.

Building the future

Behing the scenes, we’re laying the foundation for the next chapter of Calcapp. Our vision is to make Calcapp more versatile, powerful, and user-friendly. We’re exploring new features that will enable smoother web integration and more robust data handling, which we know are major goals for many of you. We’re also excited about the potential of integrating AI into Calcapp to streamline workflows, offer smart suggestions and make app building even more intuitive.

These projects are foundational, and while it will take time before they’re ready for release, we are deeply committed to this vision. It’s thrilling to think of where Calcapp will go from here. We’re excited to shape this future together and promise to keep you updated as our work progresses.

We couldn’t do any of this without you. Your trust, enthusiasm and financial support allow us to push boundaries and dream big for Calcapp. We can’t wait to share more about what’s coming next.

Tip: Display only selected screens

Tue, 15 Oct 2024 00:00:00 +0000

If you have an app for a large product catalog, with screens for every product, having a large list screen leading to all products may not be practical. This tip explores an alternative.

Create a new app based on the demo app below ↗

Many of our clients create apps for their product catalog. A straight-forward way of modeling this in an app is to use a list screen, containing all products, and then have form screens associated with every list screen navigator, holding the product calculations.

For the client project we’re currently working on, our client wanted a different approach. Having the users of the app go back and forth between individual form screens and the list screen containing all products would be too slow. Instead, our client wanted the users of the app to be asked which products they intended to use, and then have the app present screens for those exact products, and only those products.

Here’s an app demonstrating this technique:

The first screen is a form screen, not a list screen. It has one switch field for every product. The user is required to toggle at least one of these switch fields to its “on” position. Once that is done, the user may proceed to the next screen by pressing Next in the upper-right corner or by pressing the Proceed button.

To determine if the user has selected at least one product, a named value, HasSelection, uses this formula:

SIZE(FILTER(ProductScreen.SwitchFields, ProductScreen.SwitchFields)) >= 1SIZE(FILTER(ProductScreen,SwitchFields; ProductScreen,SwitchFields)) >= 1

The Enabled property of the Proceed button and the NextScreenAvailable property of the form screen both reference HasSelection.

To understand how the formula above works, refer to our last tip, which covers this topic in detail.

(If you’re on a Starter plan or an old plan, you may not have access to named values. Here, you can simply use an invisible switch field instead of a named value.)

When users proceed to the next screen, they are presented with calculations related to the first product they selected. When proceeding from that screen, they are presented with calculations related to the second product they selected, and so on.

To make this work, formulas are associated with the NextScreen property of all relevant screens, which determines which screen is shown when the user moves forward.

Here is the NextScreen formula of the first screen:

ProductA!ThisOrFollowingScreenProductA!ThisOrFollowingScreen

The idea here is that the screen that follows the first screen is either the screen for the first product, Product A, or a screen that follows it, depending on what products have been toggled on the first screen.

ThisOrFollowingScreen is a named value, belonging to the ProductA screen, with this formula:

IF(ProductScreen!ProductA, ProductA, ProductScreen!ProductB, ProductB, ProductScreen!ProductC, ProductC, ProductScreen!ProductD, ProductD, ProductScreen!ProductE, ProductE, ProductScreen!ProductF, ProductF, ProductScreen!ProductG, ProductG, ProductScreen!ProductH, ProductH, ProductScreen!ProductI, ProductI, ProductScreen!ProductJ, ProductJ, LastScreen)IF(ProductScreen!ProductA; ProductA; ProductScreen!ProductB; ProductB; ProductScreen!ProductC; ProductC; ProductScreen!ProductD; ProductD; ProductScreen!ProductE; ProductE; ProductScreen!ProductF; ProductF; ProductScreen!ProductG; ProductG; ProductScreen!ProductH; ProductH; ProductScreen!ProductI; ProductI; ProductScreen!ProductJ; ProductJ; LastScreen)

It’s a big formula, but it’s quite easy and repetitive. If Product A has been toggled to its “on” position on the first screen, the named value returns the ProductA screen. Otherwise, if Product B has been toggled to its “on” position, the named value returns the ProductB screen, and so on.

The NextScreen property of the ProductB screen uses this formula:

ProductB!ThisOrFollowingScreenProductB!ThisOrFollowingScreen

The ThisOrFollowingScreen named value of ProductB uses this formula:

IF(ProductScreen!ProductB, ProductB, ProductScreen!ProductC, ProductC, ProductScreen!ProductD, ProductD, ProductScreen!ProductE, ProductE, ProductScreen!ProductF, ProductF, ProductScreen!ProductG, ProductG, ProductScreen!ProductH, ProductH, ProductScreen!ProductI, ProductI, ProductScreen!ProductJ, ProductJ, LastScreen)IF(ProductScreen!ProductB; ProductB; ProductScreen!ProductC; ProductC; ProductScreen!ProductD; ProductD; ProductScreen!ProductE; ProductE; ProductScreen!ProductF; ProductF; ProductScreen!ProductG; ProductG; ProductScreen!ProductH; ProductH; ProductScreen!ProductI; ProductI; ProductScreen!ProductJ; ProductJ; LastScreen)

It is identical to the formula of the ThisOrFollowingScreen named value of the ProductA screen, but does not include ProductA.

(Again, these examples use named values, which are not available in Starter plans. You can get these examples running by replacing the references to named values in formulas with the formulas of the named values. It’s not as convenient, but it works.)

And that’s all there’s to it. Only the screens that are relevant to the user are presented, and there is no need to go back to a list screen to select different products.

As a bonus, the last screen holds a tally of the costs of all the selected products. Every screen has a Cost field. To calculate the sum, this formula is used:

SUM(IF(ProductScreen!ProductA, ProductA!Cost, 0), IF(ProductScreen!ProductB, ProductB!Cost, 0), IF(ProductScreen!ProductC, ProductC!Cost, 0), IF(ProductScreen!ProductD, ProductD!Cost, 0), IF(ProductScreen!ProductE, ProductE!Cost, 0), IF(ProductScreen!ProductF, ProductF!Cost, 0), IF(ProductScreen!ProductG, ProductG!Cost, 0), IF(ProductScreen!ProductH, ProductH!Cost, 0), IF(ProductScreen!ProductI, ProductI!Cost, 0), IF(ProductScreen!ProductJ, ProductJ!Cost, 0))SUM(IF(ProductScreen!ProductA; ProductA!Cost; 0); IF(ProductScreen!ProductB; ProductB!Cost; 0); IF(ProductScreen!ProductC; ProductC!Cost; 0); IF(ProductScreen!ProductD; ProductD!Cost; 0); IF(ProductScreen!ProductE; ProductE!Cost; 0); IF(ProductScreen!ProductF; ProductF!Cost; 0); IF(ProductScreen!ProductG; ProductG!Cost; 0); IF(ProductScreen!ProductH; ProductH!Cost; 0); IF(ProductScreen!ProductI; ProductI!Cost; 0); IF(ProductScreen!ProductJ; ProductJ!Cost; 0))

The SUM formula function is provided ten parameters, one for every product. Each parameter is such that it returns the cost of a product if the corresponding switch field has been switched to its “on” position on the first screen, and zero otherwise.

In effect, the sum total of all products that have been switched on is returned.

Tip: Determine the number of toggled switch fields

Tue, 06 Aug 2024 00:00:00 +0000

This tip explores requiring users to flick a certain number of switch fields before being allowed to proceed.

Create a new app based on the demo app below ↗

Sometimes, you need users to select a fixed number of options in the form of switch fields. If the user toggles the wrong number of options, an error message should be displayed and the user prevented from moving on the next screen:

In the app above, exactly three fields must be toggled on — no more, no less.

To accomplish this, we need the FILTER and SIZE functions. This formula is associated with the Visible property of the text box displaying the error message:

SIZE(FILTER(MainScreen.SwitchFields, MainScreen.SwitchFields)) <> 3SIZE(FILTER(MainScreen,SwitchFields; MainScreen,SwitchFields)) <> 3

Let’s unpack the formula one part at a time.

FILTER(MainScreen.SwitchFields, MainScreen.SwitchFields)FILTER(MainScreen,SwitchFields; MainScreen,SwitchFields) filters the switch fields of MainScreen, returning an array holding only those switch fields that have been toggled to their on positions.

The first parameter is the array to filter, MainScreen.SwitchFieldsMainScreen,SwitchFields, which unsurprisingly consists of all switch fields of MainScreen.

The second parameter is a logical array of the same size as the first array, determining which elements to keep. FILTER({ 1, 2 }, { FALSE, TRUE })FILTER({ 1; 2 }; { FALSE; TRUE }), for instance, returns { 2 }{ 2 }.

When MainScreen.SwitchFieldsMainScreen,SwitchFields is provided as the second parameter, Calcapp accesses the Value property of every switch field, meaning that MainScreen.SwitchFieldsMainScreen,SwitchFields and MainScreen.SwitchFields.ValueMainScreen,SwitchFields,Value are equivalent in this context.

The end result is that an array consisting of only the switch fields whose values are TRUE are returned from FILTER.

Next, SIZE returns the number of elements of the array returned from FILTER. In other words, SIZE returns the number of switch fields that have been toggled on.

Finally, remember that the overall formula is associated with the Visible property of the text box displaying the error message. As the error message should be shown if not exactly three switch fields have been toggled on, <> is used:

SIZE(FILTER(MainScreen.SwitchFields, MainScreen.SwitchFields)) <> 3SIZE(FILTER(MainScreen,SwitchFields; MainScreen,SwitchFields)) <> 3

To prevent users from moving on to the next screen if not exactly three switch fields have been toggled on, the NextScreenAvailable property of the form screen should be used.

Bug report: Formulas now work better

Thu, 13 Jun 2024 00:00:00 +0000

Named values can reference anything in an app and are a great way to cut down on formula repetition. They now work properly even when pushed to the maximum. We have fixed other issues as well.

On occasion, we build apps for clients using Calcapp. This is often a great way for a client to get started, by having us convert a spreadsheet and demonstrating best practices in the process.

(Contact us if you’d like to learn more about our professional services.)

It’s also great for us, as we get to spend some quality time using Calcapp, and not just building and maintaining it. During the course of that work, we sometimes find problems with Calcapp itself that we then track down and fix.

This post details what we found and fixed this time around.

The Item formula parameter

In August last year, we introduced support for accessing the current item from a formula simply by writing Item.

Let’s say that you have this Valid formula connected to NumberField1:

NumberField1 > MaximumReadingNumberField1 > MaximumReading

Now, let’s assume that you have a hundred such number fields, which all should use similar formulas connected to their Valid properties (NumberField2 > MaximumReadingNumberField2 > MaximumReading, etc).

That quickly becomes hard to maintain and repetitive, as changing the formula now involves changing one hundred of them. Wouldn’t it be great if they all could use the same formula? Had that been the case, you could actually edit them all at the same time.

This is what Item facilitates. It’s a stand-in for the item itself, in this case NumberField1 and others. So you can use this formula instead:

Item > MaximumReadingItem > MaximumReading

While the formula above worked fine prior to this fix, there are other valid formulas that produced error messages until we released the fix today.

Specifically, consider a number field. There are properties that are specific to number fields (like MaximumValue) and there are properties that are supported by all kinds of fields, including text fields and date and time fields (like (Visible).

Associating a formula with a property specific to a number field would enable said formula to access an Item value offering the full set of properties supported by number fields. However, a formula associated with a property shared between all kinds of fields would have access to an Item value only offering access to the shared properties, not the ones specific to number fields.

In other words, formulas associated with the Visible property of a number field could not access properties specific to number fields, like MaximumValue.

That was an oversight on our part, and has now been fixed.

Named values

Named values have also been available since August last year. They can be used to represent any value a formula can represent. The new data editor uses them to great effect to represent tabular data.

However, named values can truly represent anything, and when we worked on our last client project we wanted to make full use of them. The only problem was that they did not appear to work right.

Here’s an app that demonstrates the problem, being edited in Calcapp Creator:

Users enter miles traveled in the number fields of the app. Only number fields related to the selected state are shown, which is accomplished using a text drop-down field and the Visible property of the form groups housing the number fields.

To cut down on repetition, we use a number of named values to represent various parts of the app. First, there’s the Legs named value, which allows us to reference the relevant number fields from elsewhere in the app.

Here’s its formula:

IF(Wisconsin.Visible, Wisconsin.NumberFields, Missouri.Visible, Missouri.NumberFields)IF(Wisconsin,Visible; Wisconsin,NumberFields; Missouri,Visible; Missouri,NumberFields)

In other words, if the Wisconsin form group is visible, because the user has selected Wisconsin from the text drop-down field, Legs references the number fields of the Wisconsin form group. Conversely, Legs references the number fields of the Missouri form group if Missouri has been selected from the text drop-down field.

Next, let’s say that the only miles traveled that are deemed eligible are those that are 100 miles or less. To accomplish that, each number field uses a MaximumValue property which is set to 100.

The final named value is named EligibleMiles and includes only those number fields whose values are 100 or less. Here’s its formula:

FILTER(Legs, Legs.Value.Valid)FILTER(Legs; Legs,Value,Valid)

It filters the number fields identified by the Legs named value by only including those that are valid, that is, have values that are 100 or less.

(You might be tempted to write Legs.ValidLegs,Valid, but that would reference a Valid property belonging directly to the Legs named value. There is no such property — Valid is a property of fields. As such, the Value property of the named value must be accessed explicitly in the formula. As it references number fields, .Valid,Valid can be written directly following .Value,Value in the formula.)

Finally, the last number field displays the sum total of all eligible miles that have been entered, using this formula:

SUM(EligibleLegs)SUM(EligibleLegs)

The only problem with this app? Before our update this morning, it just plain didn’t work. As you can see in the screenshot above, the sum of all eligible legs was always zero.

There were other problems as well:

The app above contains only valid formulas, and yet, many of them are flagged as invalid.

The root cause was that Calcapp did not handle multiple levels of indirection well with named values. We have spent weeks completely overhauling this part of Calcapp and are happy to report that everything now works properly.

While the example above is admittedly somewhat contrived, we keep encountering situations where named values make for shorter, easier-to-read formulas. Even if you push them to the maximum, they should now work properly.

Other fixes

We also encountered a few other issues. The parameter popup, that displays information on the function parameter you’re editing, would sometimes fail to close when you moved away from the formula field.

Also, you have been able to determine the next screen of list screen navigators since our August release. Unfortunately, though, when moving between navigators, the next screen in the inspector would sometimes fail to update.

As of today, both issues have been fixed.

Bug report: A grab bag of fixes

Thu, 09 May 2024 00:00:00 +0000

We recently fixed three issues, ranging from server reliability issues to minor problems with the user experience. This blog post explores all three.

Even when we appear to be quiet, a lot of work is going on behind the scenes to ensure that Calcapp continues performing to your expectations. In this post, we’ll highlight some of that work.

Server reliability

Calcapp experiences very little downtime, meaning that apps can be edited and run at all hours. We don’t have any “maintenance windows” during which Calcapp is unavailable. Even when we release major updates, we ensure that apps can be run, even if we have to disable app editing for a short while.

Unfortunately, we have experienced some server downtime lately. We noticed this issue several weeks ago, and started monitoring the situation closely.

Today, we once again experienced downtime, and noticed that the culprit was an innocuous-looking invalid formula:

field1 + Field2 + Field3 + Field4 + Field5 + Field6 + Field7 + Field8 + Field9 + Field10 + Field11 + Field12 + Field13 + Field14 + Field15field1 + Field2 + Field3 + Field4 + Field5 + Field6 + Field7 + Field8 + Field9 + Field10 + Field11 + Field12 + Field13 + Field14 + Field15

Notice the problem? Field1 has been subtly misspelled, “F” should not appear in lower case.

For various reasons, that particular invalid formula threw us for a loop, taking literally hours for our server to make sense of. (Had there been fewer field references in the formula, or had the misspelled field appeared later in the formula, there would have been no issue.)

Once we realized what the problem was, we were able to quickly fix it.

Bonus tip: If you want to sum all fields from Field1 through Field15, SUM(Field1:Field15)SUM(Field1:Field15) is preferable to the formula above. It’s shorter, easier to maintain and wouldn’t have caused the performance issue that brought our server to its knees.

Editing data tables with line breaks

A customer noticed a disconcerting problem today. Using our new-ish data editor, adding text cells with line breaks worked fine. (You can press Alt+Enter to insert them.) However, editing the data would produce a blank data editor, as though there was nothing there for it to edit.

While the data wasn’t technically lost, it appeared that way to our customer, as it became hard to edit. (Editing the formulas produced by the data editor would have worked as expected, though.)

Luckily, we were able to quickly find the culprit. We delivered the fix to our customer within an hour of receiving the report.

Copying and pasting fields

We’d like to think that Calcapp Creator looks simple on the surface, but hides lots of time-saving features. One such feature is that formulas are automatically updated when you change the names of various items, like fields and buttons, that may be referenced from formulas.

Another such feature is that formulas are automatically updated when you copy and paste fields. Consider two input fields, A and B, and a result field Result, whose formula is A + BA + B.

If you copy these three fields and paste them back on the same screen, the new A field is named A2 and the new B field is named B2 (so as to not conflict with the existing A and B fields). The formula of the new Result field (Result2) is changed to read A2 + B2A2 + B2, as Calcapp Creator assumes that it should reference the new fields and not the old ones.

Unfortunately, this feature broke in August last year. An intrepid customer noticed, and we were able to quickly fix the issue.

The moral of the story? If you notice unexpected behavior, please get in touch. We are deeply committed to giving you a quality experience with Calcapp, but if anything is amiss, we can’t do anything about it if we are not made aware.

In other words, please contact us through the chat widget or by emailing us if Calcapp is not performing to your satisfaction.

Tip: Calculate the elapsed time between two dates without DATEDIF

Fri, 23 Feb 2024 00:00:00 +0000

Calculating the number of days, months or years between two dates can be done with DATEDIF in Excel, or using plain formulas in Calcapp. These formulas are explored in this tip.

Calculating the number of days, months or years between two dates is a common scenario in apps created with Calcapp. Excel provides the DATEDIF formula function for this purpose, but Calcapp does not currently support it.

(DATEDIF is a compatibility function Microsoft added to support Lotus 1-2-3, a competing spreadsheet which was principally popular in the 1980s. While it isn’t fully supported by Excel – it doesn’t appear in the Insert Function dialog box – it is still commonly used.)

In this post, we’ll look at a few popular ways that DATEDIF is used and determine how to achieve the exact same results with Calcapp, without DATEDIF.

All the formula examples assume that there are two date and time fields named Date1 and Date2.

Calculating the number of days between two dates

When DATEDIF is used with its third parameter set to “D”, the number of complete days between two dates is calculated.

Both Excel and Calcapp represent dates as so-called sequential serial numbers. The integer part of the number represents the number of days that have elapsed since December 31, 1899, and the fractional part represents the time of day. (Learn more here.)

As such, the number 10.75 represents the 10th of January, 1900, at 6 PM (18:00). (0.75 means that three quarters of a day have elapsed.)

Armed with this knowledge, determining the number of days between two dates is easy: we just subtract one number from the other:

Date2 - Date1Date2 - Date1

If the two dates have time components, the formula above returns a fractional number, unlike DATEDIF. To more fully replicate the behavior of DATEDIF, which only counts whole days, we’ll need to remove the fractional component using the TRUNC function:

TRUNC(Date2 - Date1)TRUNC(Date2 - Date1)

If Date1 represents a later date than Date2, we’ll get a negative number. There are two approaches to solving this issue that we’ll explore here. DATEDIF returns a #NUM! error, but our favored approach is to make the negative number a positive one using ABS:

TRUNC(ABS(Date2 - Date1))TRUNC(ABS(Date2 - Date1))

To instead return a #N/A error (there is no way to manually return a #NUM! error), we can use the NA function:

IF(Date2 >= Date1, TRUNC(Date2 - Date1), NA())IF(Date2 >= Date1; TRUNC(Date2 - Date1); NA())

Calculating the number of months between two dates

When DATEDIF is used with its third parameter set to “M”, the number of complete months between two dates is calculated.

To make work easier for us, we’ll fully follow the DATEDIF approach here, of requiring that Date2 represents a later date than Date1, and otherwise return a #N/A error.

To account for dates that fall on different years, we use the YEAR function to extract the different years, and multiply that number by 12 to get the number of months. We add that number to the number of months that differ between the two dates, a number we get from invoking the MONTH function on both dates and subtracting the Date1 number from the Date2 number.

Lastly, we need to ensure that only complete months are counted. If the dates fall on different days, we therefore subtract one from the calculated value.

Here’s the finished formula:

IF(Date2 >= Date1, (YEAR(Date2) - YEAR(Date1)) * 12 + (MONTH(Date2) - MONTH(Date1)) - IF(DAY(Date2) < DAY(Date1), 1, 0), NA())IF(Date2 >= Date1; (YEAR(Date2) - YEAR(Date1)) * 12 + (MONTH(Date2) - MONTH(Date1)) - IF(DAY(Date2) < DAY(Date1); 1; 0); NA())

Calculating the number of years between two dates

When DATEDIF is used with its third parameter set to “Y”, the number of complete years between two dates is calculated.

The formula for performing the calculation is similar to the one for calculating the number of complete months:

YEAR(Date2) - YEAR(Date1) - IF(YEAR(Date2) <> YEAR(Date1), 1, 0)YEAR(Date2) - YEAR(Date1) - IF(YEAR(Date2) <> YEAR(Date1); 1; 0)

DATEDIF also supports the “MD”, “YM” and “YD” units, which ignores various date components. Let us know if you’d like us to cover those variations as well!

Sample app: Store invisible, permanent information when a button is pressed

Thu, 21 Dec 2023 00:00:00 +0000

Apps can store invisible information when a button is pressed, which is retained even when the app is closed. Our sample app uses this technique to enforce that a button is only pressed once per day.

Create a new app based on this sample app ↗

We see a lot of apps built with Calcapp that simply collect information and send it back to the office. But what if the user should only be allowed to send the data once per day?

Prior to our last release, it wasn’t possible for an app to enforce such a rule. Now, though, you can use formula buttons, in conjunction with persistent fields, to make this a reality.

The technique described in this post is applicable to many other kinds of apps. We will demonstrate a technique enabling buttons to store information — any information — for subsequent use when the user comes back to the app, even after restarting their device.

You’re encouraged to view the app and its formulas as you read along. It’s available as a template when you create a new app under the Sample: Daily yield report name.

Usage

Without further ado, here’s the app:

The user is expected to fill out the yield once per day. When the button is pressed, the data is emailed back to the office and a message appears. If the user has never submitted the yield before, a simple message informs the user that the data has been submitted. Otherwise, the yield difference is also displayed:

If the user tries to submit the yield again the same day, this message appears:

How it works

The key to the app is the use of a formula button, which runs formulas in response to being pressed. Refer to our blog post from August to learn more.

Action formulas have access to special functions. Here, we’ll use the EMAILREPORT function to email data back to the office.

Action formulas also have access to :=, which assigns values to properties. For instance, := can be used to change the values of fields.

The key to making this app work is that it has two hidden fields, which are also persistent. A persistent field stores its value to the user’s device, which is read back when the app is started again.

(Unfortunately, that means that the user is allowed to submit the yield on their cell phone and on their desktop computer, all on the same day.)

The field where the user enters the yield is named Yield. There’s also a hidden, persistent field named LastYield. A final hidden, persistent field is LastSubmissionDate.

The formula button is grayed-out if the user hasn’t filled in the Yield field. To achieve that, this formula is associated with the Enabled property of the button:

ISDEFINED(Yield)ISDEFINED(Yield)

Next, here’s part of the action formula associated with the OnPress property of the formula button:

IF(ISDEFINED(LastSubmissionDate) && (TODAY() <= LastSubmissionDate), ALERT("A yield has already been reported today, please
return tomorrow.", "Warning"), …)IF(ISDEFINED(LastSubmissionDate) && (TODAY() <= LastSubmissionDate); ALERT("A yield has already been reported today, please
return tomorrow."; "Warning"); …)

Above, we’re only looking at a part of the formula. The elided part has been replaced with …

The formula above checks the LastSubmissionDate field and its value. If it is defined (meaning that it holds a value) and it is equal to the return value of TODAY, or greater than it, a warning message is displayed using the ALERT function, warning the user that they have already pressed the button today.

The first time the app is started, LastSubmissionDate does not hold a value, meaning that ISDEFINED(LastSubmissionDate)ISDEFINED(LastSubmissionDate) returns FALSE and the message isn’t shown. (&& means “and”.)

Today’s date should be stored in the LastSubmissionDate field when the button is pressed. To do so, this formula fragment must be run by the button:

LastSubmissionDate := TODAY()LastSubmissionDate := TODAY()

The next time the button is pressed, ISDEFINED(LastSubmissionDate)ISDEFINED(LastSubmissionDate) returns TRUE and the next part of the formula, TODAY() <= LastSubmissionDateTODAY() <= LastSubmissionDate is evaluated. That part only returns TRUE if the value stored in LastSubmissionDate indicates that the button was last pressed on the same day (or in the future), which makes the button display the warning message.

We also need to store the yield when the button is pressed, so that we can show the change in the submission message:

LastYield := YieldLastYield := Yield

Here’s the full formula fragment that was elided with … in the action formula above, which is run if the warning message isn’t displayed:

EMAILREPORT({ Yield }, "office@example.com"); ALERT("Submission successful." & IF(ISDEFINED(LastYield), NEWLINE() & "Yield
difference: " & FORMATNUMBER((Yield - LastYield) / Yield * 100, 0, 2) & "%"), "Success"); LastYield := Yield; LastSubmissionDate := TODAY()EMAILREPORT({ Yield }; "office@example.com");; ALERT("Submission successful." & IF(ISDEFINED(LastYield); NEWLINE() & "Yield
difference: " & FORMATNUMBER((Yield - LastYield) / Yield * 100; 0; 2) & "%"); "Success");; LastYield := Yield;; LastSubmissionDate := TODAY()

EMAILREPORT({ Yield }, "office@example.com")EMAILREPORT({ Yield }; "office@example.com") sends email to the office, containing just the yield. (A real app should probably also collect the user’s identity and send that as part of the report.)

The ALERT part of the formula shows a message to the user, informing them that the submission was successful. It also displays the yield difference using this formula fragment:

FORMATNUMBER((Yield - LastYield) / Yield * 100, 0, 2) & "%"FORMATNUMBER((Yield - LastYield) / Yield * 100; 0; 2) & "%"

FORMATNUMBER above takes a number and formats it. In this case, it uses a minimum of zero decimal places, and a maximum of two decimal places.

& joins text strings together. Above, it adds a percentage sign to the end of the number displayed to the user.

Finally, the formula fragment assigns values to the hidden, persistent fields LastYield and LastSubmissionDate, which is the information that makes the app work.

Taking it all together, here’s the full action formula:

IF(ISDEFINED(LastSubmissionDate) && (TODAY() <= LastSubmissionDate), ALERT("A yield has already been reported today, please
return tomorrow.", "Warning"), EMAILREPORT({ Yield }, "office@example.com"); ALERT("Submission successful." & IF(ISDEFINED(LastYield), NEWLINE() & "Yield
difference: " & FORMATNUMBER((Yield - LastYield) / Yield * 100, 0, 2) & "%"), "Success"); LastYield := Yield; LastSubmissionDate := TODAY())IF(ISDEFINED(LastSubmissionDate) && (TODAY() <= LastSubmissionDate); ALERT("A yield has already been reported today, please
return tomorrow."; "Warning"); EMAILREPORT({ Yield }; "office@example.com");; ALERT("Submission successful." & IF(ISDEFINED(LastYield); NEWLINE() & "Yield
difference: " & FORMATNUMBER((Yield - LastYield) / Yield * 100; 0; 2) & "%"); "Success");; LastYield := Yield;; LastSubmissionDate := TODAY())

Feature: Streamlined experience for our Unlimited plan

Sun, 24 Sep 2023 00:00:00 +0000

Our Unlimited plan offers an experience completely free of limits, now supported by a new streamlined user interface.

Some of our customers have requirements not easily met by our regular plans. Those needs may include thousands of public apps, or tens of thousands of users of private apps, which would be cost-prohibitive with our regular plans.

Still other customers may prefer not to pay extra for every public app they create, and instead pay a fixed yearly fee for unlimited access to Calcapp.

We have accommodated these customers from the start with our Unlimited plan, but the experience has not been tailored for them. That changes today.

Here’s the start screen for an app, with an Unlimited plan:

Notice anything different? The Change plan button is no longer in the upper-left corner. Instead, there is a simple toggle between private and public apps. Much easier.

Also, the Manage apps window now only differentiates between public and private apps (instead of listing all your apps by plan):

Pricing of our Unlimited plan is determined through negotiation. Contact us to learn more.

Release: Our August, 2023 update is here

Fri, 11 Aug 2023 22:00:00 +0000

Our most significant release yet is here, with 23 blog posts to describe it all. Build previously-unthinkable apps with action formulas. Import and edit spreadsheet-like data and use eleven new button types. The app designer now supports undo, formula autocomplete, a new email editor and much more.

What's new?

Eleven new button types. Eleven new types of buttons make your apps easier to use and more powerful. Buttons can run action formulas, change the active screen, copy text to the clipboard, show messages and more. Learn more »
Make buttons perform actions with action formulas. Action formulas make things happen, unlike regular functions, which just calculate values. They are our biggest new feature ever. Use them to model complex business logic when buttons are pressed. Learn more »
An editor for tabular data. Our new data editor allows you to easily create and edit spreadsheet-like data tables. Data can be imported from spreadsheets through copy and paste. Use XLOOKUP to look up values in data tables. Learn more »
Undo and redo. Calcapp Creator now features undo and redo buttons that bring your work back if you inadvertently delete it. Learn more »
Autocomplete for formulas. Our new formula autocomplete system provides helpful suggestions for what you may want to type next. To reference a field on any screen, just type part of its name or label and let us do the rest. Learn more »
Edit text properties as templates. All text properties can now be edited as templates. Change the text as you normally would in the inspector and insert formula fragments between special markers. This makes it much easier to edit email bodies sent by your app. Learn more »
Access all items as a single array. The new Items property allows you to access all items, including fields and buttons, as a single array. That makes it easy to calculate the sum of all fields of a screen, or determine if all fields of your app are valid, with short, readable formulas. Learn more »
Edit formulas of multiple items at the same time. When multiple items are checked in the app designer, you can now edit all their formulas at the same time. We also describe the new special formula value Item and various performance improvements. Learn more »
A grab bag of new features. The screens sidebar can now be resized, line breaks can be inserted into formulas, sliders work better on touch screens and you get more disk space for images. Our latest release is full of minor features such as these. Learn more »
Use LET to avoid repetition in formulas. The new function LET enables you to assign names to values for use inside a single formula. LET can make formulas shorter and easier to read and can help them run faster. Learn more »
Named values. Named values allow you to assign names to values returned from formulas. Unlike hidden fields, named values can represent anything a formula can return, including screens and arrays. Learn more »
Customizable link targets. Browse buttons and the BROWSE function allow you to determine if links open in a new web browser window or tab or replace the app. An app-wide default setting can also be changed, which also affects where text box links open. Learn more »
Improvements to reports. The bodies of sent emails can now be edited as a template, making for a more comfortable experience. The fields to include can be set visually. Most report-related properties can now be set through formulas, and report-related action functions offer lots of flexibility. Learn more »
More ways to access our documentation. Our documentation is now integrated into Calcapp Creator. A popup now appears with function parameter information when editing formulas. Documentation is also part of autocomplete. Learn more »
Easily determine what fields to reset or include in a report. The fields to reset and the fields to include in a report can now be set directly in the inspector, without using a formula. Learn more »
Easily decide the next screen. The screen following other screens and navigators can now be set directly in the inspector, without using a formula. Learn more »
Named function parameters. Function parameters can now be named, making formulas easier to read. Named parameters can also make formulas significantly shorter. Learn more »

Tips for getting the most out of Calcapp

Ask users questions with action formulas. Use action formulas to ask users a series of questions. The answers are then fed into action functions that act on the information given. Learn more »
Perform calculations when a button is pressed. Use a formula button to calculate results only when a button is pressed, instead of while the user is typing. This technique uses the new assignment operator. Learn more »
Require a button to be pressed. Prevent users from seeing certain information, or from moving on to the next screen, if a button has not been pressed. This can be achieved through a formula button and a hidden field. Learn more »

More news

Changes to our subscription plans. We are introducing a new set of plans at higher price points. Existing apps stay on the old plans at the old prices, with access to most of our new features. The new button types, the data editor, named values and action formulas require you to upgrade to a 2023 plan. Learn more »
Sample app: Edit tags using action formulas. This sample app allows users to edit tags, which are often used on online marketplaces like eBay. The app demonstrates many new Calcapp features, like action formulas, the LET function, navigation buttons and clipboard copy buttons. Learn more »

Feature: Eleven new button types

Fri, 11 Aug 2023 21:00:00 +0000

Eleven new types of buttons make your apps easier to use and more powerful. Buttons can run action formulas, change the active screen, copy text to the clipboard, show messages and more.

For the longest time, Calcapp has offered four different button types:

Reset buttons reset fields.
Email report buttons send reports through email.
Open report buttons open reports on the user’s device.
Server relay buttons, which send data to other servers (often through Zapier).

Today changes. We’re now introducing a whopping eleven new button types, which will make your apps easier to use and more powerful.

Here’s the full list:

Formula buttons run action formulas.
Alert buttons show messages.
Clipboard copy buttons copy text to the clipboard.
Go back and go forward buttons change the active screen.
Print screen buttons launch the user’s print dialog.
Compose email buttons launch the user’s email client.
Compose SMS buttons launch the user’s text message client.
Dial buttons launch the user’s dialer.
Open map buttons show maps using the user’s map app.
Browse buttons show a web page in the user’s web browser.

The new button types are not available in any of our legacy plans, meaning that you may need to upgrade to access them. Most new buttons types are available in our 2023 Business plans. All button types, including formula buttons, are available in our 2023 White Label plans. Everything is fully functional in Calcapp Creator’s preview sidebar, though, so you can get a feel for the new features, regardless of your plan.

Formula buttons

Formula buttons run so-called action formulas, which have access to 30 brand new action functions.

These are some of the things you can do with a formula button:

Send a report, but only if the entered data is valid. Otherwise, show the user an alert box.
Ask the user a series of questions, before sending a report incorporating the entered answers.
Send multiple reports, incorporating different information, to different email addresses.
Open a report on the user’s device, while also sending a message to the team’s internal Slack channel. (Integration with Slack, and other third-party services like Google Sheets, Excel and Salesforce require a third-party service like Zapier.)
Reset all fields, but only if the user first consents by pressing a button to that effect in a message box. Then, move the user back to the first screen, and ensure that previously-hidden text boxes are once more visible.

This action formula asks the user for their name and greets them once the name has been entered:

AWAIT(PROMPT("What's your name?"), BANNER("Hi " & Result & "!"))AWAIT(PROMPT("What's your name?"); BANNER("Hi " & Result & "!"))

Formula buttons can also be used to realize the oft-requested calculation buttons, that only perform calculations once the user presses a button.

Action formulas are a huge new addition to Calcapp. Refer to our dedicated blog post on the subject for more information.

Alert buttons

An alert button displays a message to your users, with a single button that dismisses the message:

The title, body and button label of the message are all set through templates. That means that you can enter text strings as you normally would, but you can also enter formula fragments, enclosed within {{ and }} markers.

In other words, all information displayed in the alert box can be dynamic and take into account information entered by your users and calculated by your app.

For even more flexibility, consider using a formula button and the ALERT function. This formula asks the user a question and displays the result using an alert box:

AWAIT(PROMPT.NUMBER("Enter area:"), ALERT("The cost
is " & Result * 1500 & "."))AWAIT(PROMPT.NUMBER("Enter area:"); ALERT("The cost
is " & Result * 1500 & "."))

Clipboard copy buttons

A clipboard copy button copies text to the user’s clipboard. The text to copy is entered using a template, which means that it can incorporate information from your app.

If you embed your app in a website, you need to change the HTML markup you use slightly, otherwise copying to the clipboard won’t work.

An embedded app runs in an iframe on the host page. You need to add allow="clipboard-write" to the list of attributes for the iframe element:

<iframe seamless
src="https://connect.calcapp.net/?app=abc123"
allow="clipboard-write">
</iframe>

For even more flexibility, consider using a formula button and the CLIPBOARDCOPY function. This formula asks the user a question, copies the result to the clipboard and shows a banner with the text Copied!:

AWAIT(PROMPT.NUMBER("Enter area:"), CLIPBOARDCOPY("The cost is " & Result * 1500 & "."); BANNER("Copied!"))AWAIT(PROMPT.NUMBER("Enter area:"); CLIPBOARDCOPY("The cost is " & Result * 1500 & ".");; BANNER("Copied!"))

Prior to this release, users had to press Next in the upper-right corner of an app to proceed to the next screen. We have seen many creative ways to direct your users’ attention to this button, including pictures with arrows.

Of course, having a button right where your fields are is often preferable. Now, it’s finally possible.

A go forward button that you don’t customize moves the user forward to the screen you have defined in Calcapp Creator (reachable using the button in the top-right corner of your app).

Similarly, a go back button that you don’t customize moves the user back one screen.

A go forward button can be customized to move the user forward to whatever screen you select in the inspector. To use conditional logic, associate a formula with the Target property that uses the IF function.

Here’s an example of such a formula:

IF(AND(Screen1.Items.Valid), DetailsScreen, ErrorScreen)IF(AND(Screen1,Items,Valid); DetailsScreen; ErrorScreen)

The formula above checks to see if all items of Screen1 are valid (another new feature). If so, the user is brought forward to DetailsScreen. Otherwise, ErrorScreen is shown.

You can also customize what screen to go back to using a go back button, with a screen you select in the inspector or through a formula. However, if you select a screen that the user has not previously visited, nothing will happen.

For even more flexibility, consider using a formula button and the GOFORWARD and GOBACK functions. This formula asks the user to confirm if they want to start over. If so, it resets all fields and brings the user back to the first screen:

AWAIT(CONFIRM("Start over?", Title: "Question"), RESET({ App }); GOBACK(StartScreen))AWAIT(CONFIRM("Start over?"; Title: "Question"); RESET({ App });; GOBACK(StartScreen))

(The formula above uses a named parameter, another new feature.)

Browsing the web, printing, composing an email and more

The remaining six button types open a link in the user’s web browser, dial a phone number for the user, compose an email or a text message (SMS), open a map at a certain location and offer to print the current screen.

Print screen buttons simply invoke the system print dialog, which typically not only supports printing the current screen, but can also convert it to a PDF file. While Calcapp can generate PDF files on its own, they are currently limited to text. If you don’t want to use a third-party service that can generate PDF files with images, asking the user to use the system print dialog may be a viable alternative.

Opening links from your app has been possible since 2017. However, buttons are often more attention-grabbing than simple text links. A new browse button makes that possible. Also, unlike plain links, browse buttons allow you to decide where the links open (for instance, in a named browser tab, or replacing your app).

An email compose button makes it possible for users to send an email using their standard email client (a native app or a web-based service, depending on your user’s preferences). You can pre-fill most fields, including the body and the recipients, and you can use templates to do so (meaning that you can easily mix pre-set text with information from your app).

The text message compose buttons and dial buttons typically only work on cell phones (though a desktop user with Skype installed can likely make use of a dial button). Again, you can pre-set most text message fields and the phone number of both buttons using templates.

Finally, open map buttons open a map using either a search query (which can be an address), or coordinates (latitude and longitude). The user’s installed map app is preferred. If all else fails, Google Maps is opened in the user’s web browser.

These features are also accessible through formula buttons. These are the relevant formula functions: PRINTSCREEN, BROWSE, COMPOSE.EMAIL, COMPOSE.SMS, DIAL and OPENMAP.

Feature: Make buttons perform actions with action formulas

Fri, 11 Aug 2023 20:00:00 +0000

Action formulas make things happen, unlike regular functions, which calculate values. They are our biggest new feature yet. Use them to model complex business logic.

Action formulas are the biggest addition to Calcapp yet. Unlike regular formulas, which calculate values, action formulas make things happen.

These are some of the things an action formula can do:

Send a report, but only if the entered data is valid. Otherwise, show the user an alert box.
Ask the user a series of questions, before sending a report incorporating the entered answers.
Send multiple reports, incorporating different information, to different email addresses.
Open a report on the user’s device, while also sending a message to the team’s internal Slack channel. (Integration with Slack, and other third-party services like Google Sheets, Excel and Salesforce require a third-party service like Zapier.)
Reset all fields, but only if the user first consents by pressing a button to that effect in a message box. Then, move the user back to the first screen, and ensure that previously-hidden text boxes are once more visible.

To support action formulas, we have introduced 30 new action functions, which can do everything that a regular button can do, and more. Action formulas also support the := operator, which assigns values to properties. They can only be used from action formulas.

This action formula asks the user for their name and greets them once the name has been entered:

AWAIT(PROMPT("What's your name?"), BANNER("Hi " & Result & "!"))AWAIT(PROMPT("What's your name?"); BANNER("Hi " & Result & "!"))

Action formulas can perform multiple actions, either one after another, or by waiting for one to complete before invoking the next one. Action formulas can also use conditional logic, meaning that an action is only performed if one condition is TRUE, otherwise another action is performed. This makes it possible to model complex business logic.

These formulas can only be attached to the OnPress property of formula buttons. We will consider enabling action formulas elsewhere in the future.

Action formulas are not available in any of our legacy plans, meaning that you may need to upgrade to access them. They are available in our 2023 White Label plans. Action formulas are fully functional in Calcapp Creator’s preview sidebar, though, so you can get a feel for them, regardless of your plan.

Using IF to express conditions

Use a function like IF or SWITCH to perform one action if a condition evaluates to TRUE and another action otherwise.

This formula sends an email if all fields in the app are valid and shows a message otherwise:

IF(AND(App.Fields.Valid), EMAILREPORT({ App }, "test@example.com"), ALERT("Please correct the fields first."))IF(AND(App,Fields,Valid); EMAILREPORT({ App }; "test@example.com"); ALERT("Please correct the fields first."))

App.Fields.ValidApp,Fields,Valid returns a logical array, where TRUE indicates that a corresponding field is valid and FALSE indicates that a corresponding field is invalid. AND returns TRUE only if all those elements are TRUE, meaning that all fields are valid.

Fields is a new property. Learn more about it here.

Running multiple actions

An action formula can perform any number of actions. Separate actions with ;;;.

This action formula assigns two values to two different fields and hides a text box:

Field1 := SUM(FormGroup1); Field2 := Field1 * 10; TextBox1.Visible := FALSEField1 := SUM(FormGroup1);; Field2 := Field1 * 10;; TextBox1,Visible := FALSE

By chaining together multiple actions with ;;;, you can create buttons that do nothing but calculate values. For some apps, this can be an appealing alternative to having Calcapp calculate values as the user types.

This formula resets all fields of the app and then brings the user back to the first screen:

RESET(App); GOBACK(FirstScreen)RESET(App);; GOBACK(FirstScreen)

This formula assigns values to the fields of a screen named SecondScreen, before taking users to it:

SecondScreen!Result1 := FirstScreen!Field1 * 2; SecondScreen!Result2 := FirstScreen!Field2 * FirstScreen!Field1; GOFORWARD(SecondScreen)SecondScreen!Result1 := FirstScreen!Field1 * 2;; SecondScreen!Result2 := FirstScreen!Field2 * FirstScreen!Field1;; GOFORWARD(SecondScreen)

If users should only be able to reach the second screen through the button, and not by pressing Next in the upper-right corner, ensure that the NextScreenAvailable property of whatever screen precedes it is set to FALSE.

Waiting for actions to complete

Many action functions perform actions that can take some time to complete. EMAILREPORT, for instance, sends a report through email. It does so by asking our server to create the report and send it, which takes a second or two.

EMAILREPORT lets you perform other actions while our server is busy fulfilling the request. This action formula asks our server to start the process, and then immediately shows a banner:

EMAILREPORT({ App }, "test@example.com"); BANNER("Sending the report, hold tight!")EMAILREPORT({ App }; "test@example.com");; BANNER("Sending the report, hold tight!")

If you want to perform an action once the report has been successfully sent, use the AWAIT function. This formula shows another banner when the report has been sent:

AWAIT(EMAILREPORT({ App }, "test@example.com"), BANNER("All done!")); BANNER("Sending the report, hold tight!")AWAIT(EMAILREPORT({ App }; "test@example.com"); BANNER("All done!"));; BANNER("Sending the report, hold tight!")

Handling errors

The AWAIT function takes three parameters: the action, the formula fragment which is run when the action completes successfully and the formula fragment which is run if there is a problem completing the action. Only one of the latter two parameters must be provided, meaning that you can write a formula that only takes action if a completing the first action fails.

This formula shows an error message if sending a report fails:

AWAIT(EMAILREPORT({ App }, "test@example.com"), OnFailure: ALERT("Could not send report: " & Error.Message))AWAIT(EMAILREPORT({ App }; "test@example.com"); OnFailure: ALERT("Could not send report: " & Error,Message))

Above, the third parameter, OnFailure, is given a name. That enables us to completely leave out the second parameter, which we don’t need. An alternative to naming the third parameter is to use BLANK()BLANK() as the value for the second parameter:

AWAIT(EMAILREPORT({ App }, "test@example.com"), BLANK(), ALERT("Could not send report: " & Error.Message))AWAIT(EMAILREPORT({ App }; "test@example.com"); BLANK(); ALERT("Could not send report: " & Error,Message))

The third parameter has access to a special value, named Error, which has more information on the error, including an error message.

If an action function does not complete successfully, and you don’t handle the error by providing an OnFailure parameter, your app will show an error message. If you don’t want your users to see any error messages, not even your own, you can pass BLANK()BLANK() as the OnFailure parameter.

Closing words

Formula buttons can also be used to realize the oft-requested calculation buttons, that only perform calculations once the user presses a button. The key addition that makes this possible is the new := operator, which assigns values to properties. Learn more about calculation buttons.

New functions like PROMPT may be used to query users for information. Learn more about asking users questions.

Finally, action formulas are the culmination of a multi-year effort. Five and a half years ago, we publicly mused about what they might look like.

We think that the action formulas we present today are far stronger than that early proposal. This is mostly thanks to our new formula engine, which was built from the ground up to support action formulas. Now that action formulas are a reality, it is finally complete.

Feature: An editor for tabular data

Fri, 11 Aug 2023 19:00:00 +0000

Our new data editor allows you to easily create and edit spreadsheet-like data tables. Data can be imported from spreadsheets through copy and paste. Use XLOOKUP to look up values in data tables.

Many apps created with Calcapp look up values found in data tables and present the results to the user, rather than doing traditional math. This data can include everything from tax brackets to information on the products offered by a company.

In this release, we are introducing a spreadsheet-like data editor for creating and updating tabular data, in the form of named values.

Named values are not available in any of our legacy plans, meaning that you may need to upgrade to access named values and the data editor. These features are available in our 2023 Business and White Label plans. They are fully functional in Calcapp Creator’s preview sidebar, though, so you can get a feel for them, regardless of your plan.

Introducing our new data editor

This is what our new data editor looks like:

To insert data and bring up the data editor, press the new DATA button in the app designer:

The first row must consist of column names.

To transfer data from your spreadsheet, follow these instructions:

Switch to your spreadsheet.
Select the desired range.
Copy the data to the clipboard (press Ctrl+C on PC or ⌘+C on Mac).
Switch back to Calcapp Creator and the data editor.
Select the cell in the upper left corner.
Paste the data from your spreadsheet (press Ctrl+V or ⌘+V on Mac).

When you click Save, one named value per column is created:

Editing the data

The DATA button changes to DATA when a compatible named value is selected, allowing you to edit the data using the data editor.

You can also change the generated formulas of the named values directly. If the formulas look as though they could have been generated by the data editor, you are still able to edit them using the data editor.

If you need to rename a column, rename the named value in the app designer instead of renaming the column in the data editor. If you do the latter, the data editor will leave the named value corresponding to the old column in place, and add a new named value with the new column name.

Detecting numbers and dates

If you enter dates or numbers in the data editor, it should produce named values whose formulas are number or date arrays, and not text arrays. That enables them to be acted upon by functions and operators that accept numbers and dates.

To that end, the data editor automatically detects numbers and dates. In order for that to work, the language setting must match the data (which can differ from the language of the app).

Set the language by pressing the button:

Detected numbers appear on a blue background and detected dates appear on a pink background.

Select a range and press the button to force Calcapp to interpret the range as text.

For an example of when this might be useful, consider phone numbers, without hyphens. Calcapp might interpret them as numbers, which is probably not what you want — after all, there is no point in doing arithmetic with phone numbers, and if they have leading zeroes, those should be displayed to a user. As such, they should be interpreted as text.

Likewise, press the button to make Calcapp try to automatically detect if the selected range represents numbers or dates.

Using dedicated screens for data

The data editor creates and works with named values that are part of the current screen. For small tables with a few columns, that can work well.

However, if your tables are large or are used from multiple screens, it’s a good idea to move them to dedicated screens, never shown to your users.

Named values, corresponding to the table with sweaters, dresses and shorts above, could be put on a screen named Products, for instance. That would enable you to reference, say, the Color named value by writing Products!ColorProducts!Color in a formula.

To ensure that your users cannot reach these data screens, there are a few techniques you can use:

If your app contains a list screen, you can create a navigator that is permanently invisible that leads to the data screens.
If your app only consists of form screens, put the data screens after the last user-visible form screen. Prevent your users from reaching the data screens using the NextScreenAvailable property of the last user-visible screen.

If you have multiple data screens, create a list screen whose navigators lead to these data screens, and make the list screen itself unreachable using the techniques listed above.

Accessing data from formulas

The named values created from the Products table can easily be used from formulas. This section discusses some commonly-used formulas for processing the data.

If you want to try the formulas on this page for yourself, here’s the data as a Google Sheets spreadsheet.

This formula calculates the average product price:

AVERAGE(Products!Price)AVERAGE(Products!Price)

This formula returns the number of products costing more than $100:

COUNTIF(Products!Price, ">100")COUNTIF(Products!Price; ">100")

This formula returns the kind of the product costing the most:

INDEX(Products!Kind, XMATCH(MAX(Products!Price), Products!Price))INDEX(Products!Kind; XMATCH(MAX(Products!Price); Products!Price))

This formula returns the color of the product costing $129, “Black”:

XLOOKUP(129, Products!Price, Products!Color)XLOOKUP(129; Products!Price; Products!Color)

To learn how XLOOKUP works, refer to our documentation, which contains many more formula samples.

Using XLOOKUP with multiple criteria

What if we need to use multiple criteria with XLOOKUP, and not just a single one?

Let’s assume that there are three text drop-down fields, named Kind, Size and Color, each containing the values found in the appropriate column in the table.

This formula returns the price of the product matching the selected kind, size and color:

XLOOKUP(TRUE, (Kind = Products!Kind) && (Size = Products!Size) && (Color = Products!Color), Products!Price)XLOOKUP(TRUE; (Kind = Products!Kind) && (Size = Products!Size) && (Color = Products!Color); Products!Price)

(Kind, Size and Color in the formula refer to the text drop-down fields, whereas names starting with Products! refer to named values that are part of the Products screen.)

Let’s repeat the products table here, for easy reference:

Kind	Size	Color	Price
Sweater	Medium	Blue	29
Sweater	Large	Blue	49
Sweater	Large	Purple	39
Sweater	Small	Purple	29
Dress	Small	Gray	69
Dress	Large	Black	129
Dress	Medium	Blue	72
Shorts	Medium	Black	39
Shorts	Large	Black	52
Shorts	Medium	Gray	49
Shorts	Large	Purple	19

(Kind = Products!Kind)(Kind = Products!Kind) in the formula above returns a logical array, with a size corresponding to the number of products. Elements that are TRUE indicate that the selected kind (sweater, dress or shorts?) matches the kind found in the table. Elements that are FALSE indicate that there is no match.

To see this, let’s assume that the user selects Sweater from the Kind text drop-down field. If so, (Kind = Products!Kind)(Kind = Products!Kind) returns an array whose first four elements are TRUE, and whose remaining elements are FALSE. That makes sense, as if you look at the data table above, the first four products are sweaters.

(Size = Products!Size)(Size = Products!Size) and (Color = Products!Color)(Color = Products!Color) work similarly.

When they are all put together using &&, a logical array is returned where TRUE elements indicate that the kind, size and color are all a match. XLOOKUP is then instructed to find the first TRUE element in that array, and returns the matching price from the Products!Price named value.

To see this even more clearly, read our documentation for XLOOKUP. It contains an example that is similar to this one, but is simpler.

A walk down memory lane

Looking up tabular data has always been possible with Calcapp, but has often been needlessly difficult. Initially, you had to manually convert all data to IF formulas. In 2018, new features made it possible for drop-down fields to access data, which was converted to formulas using an app we wrote.

In 2021, we introduced support for arrays and the XLOOKUP function — which can do everything VLOOKUP and HLOOKUP in Excel can do. We also introduced another app that converts tabular data to formulas, this time using XLOOKUP.

Data from tables still had to awkwardly reside inside all formulas that used them — they couldn’t be stored separately and simply be referenced from other formulas. That led to data being duplicated in many formulas, making it tedious and error-prone to update data.

With the introduction of named values, you can finally store the data separately, making data duplication a thing of the past.

Once we had added support for named values, we saw an opportunity to create a better way to manage tabular data in Calcapp. The end result is the data editor.

Changes to our subscription plans

Fri, 11 Aug 2023 18:00:00 +0000

We are introducing a new set of plans at higher price points. Existing apps stay on the old plans at the old prices, with access to most of our new features. The new button types, the data editor, named values and action formulas require you to upgrade to a 2023 plan.

As part of our new release, we are introducing a new set of plans, at higher price points.

If you’re a customer today, nothing changes. You get access to most of the new features, and what you pay stays the same.

However, if you want access to most of the new button types, the data editor or named values, you must upgrade to a 2023 Business plan. If you want access to formula buttons and action formulas, you must upgrade to a 2023 White Label plan.

The 2023 Business plan costs $29 per month (USD) and the 2023 White Label plan costs $69 per month. If you go for an annual plan, you get 20 percent off.

The 2023 Starter plan is still $9 per month, because we strongly feel that it should be inexpensive to create a simple calculator (and because our Starter customers tend to upgrade). The 2023 version does not include access to any buttons, though.

The legacy plans are no longer available when you switch plans. Existing apps will continue to stay on them, though, and there are no plans at this time to fully discontinue them.

To upgrade to a 2023 plan, click the Change plan button in the inspector when you first open an app.

Rationale

A lot of our customers are seeing their costs go up, due to inflation and other factors, and we’re no different. As such, we’d like to boost revenue, but without causing our customers economic hardship, most of which are small- and medium-sized businesses.

By allowing existing apps to stay on the legacy plans, while making some of the new features exclusive to our new plans, we are trying to thread the needle: boost revenue from some of our existing customers, without increasing costs for customers who choose to stay on the legacy plans.

For more on our thinking, refer to what we wrote when we announced this change more than two months ago.

Feature: Undo and redo

Fri, 11 Aug 2023 17:00:00 +0000

Calcapp Creator now features undo and redo buttons that bring your work back if you inadvertently delete it.

It’s been a long time coming, but our latest release finally adds support for undoing and redoing actions you take while building apps in Calcapp Creator. Here are the new buttons in the toolbar:

All actions you take in the main designer can be undone through these buttons. However, performing actions in other windows (such as editing users of private apps and making changes to your subscription) can typically not be undone.

The new data editor provides its own undo and redo buttons.

Apps other than Calcapp Creator typically store past actions in memory, a precious commodity. For that reason, these apps often limit the number of steps you can undo to a small number. Calcapp Creator is different, in that your browser’s built-in database is used to store large changes. For that reason, you can undo a large number of changes, specifically 500 changes.

When Calcapp first launched as a beta in early 2016, we weren’t sure if there would be a market for our new product. As such, we prioritized adding features to adding a proper undo system. After all, why spend time on adding support for undo if the product would not find any takers?

It did find takers, and in highsight, we should have added support for undo and redo much earlier. If you have ever lost data from inadvertently removing something from your app, and cursed the lack of an undo button, we’re sorry it took this long.

With proper support for undo and redo, there is less of a need to regularly store checkpoints of your work. We think that many users, ourselves included, will find editing apps to be a less stressful experience, knowing that if you take the wrong action, getting your work back is only a button away.

Feature: Autocomplete for formulas

Fri, 11 Aug 2023 16:00:00 +0000

Our new formula autocomplete system provides helpful suggestions for what you may want to type next. To reference a field on any screen, just type part of its name or label and let us do the rest.

In the past, Calcapp Creator hasn’t offered much help when writing formulas. In fact, writing a formula was much like writing a plain text document or email.

Unlike a plain text document, though, a formula requires you to adhere to a rigid format. Failure to do so results in error messages being displayed and, more significantly, means that you cannot update your app.

Modern editors typically offer help during the formula editing process, offering to complete text you’re writing and providing helpful suggestions.

As of today, Calcapp Creator provides one of those modern editors. Here’s our new autocomplete feature in action:

When you type, autocomplete tries to match your input to what you might want to add next and displays helpful suggestions in a menu. To accept a suggestion with your keyboard, select it using your arrow keys and press Enter (not Tab).

Here are some of the things Calcapp Creator now helps you add to your formulas:

Formula functions.
Screen references.
Items of the current screen.
Items of other screens (after you write the name of a screen, followed by !).
Properties (after you write the name of an item or a screen, followed by .,).
Enums (like the colors presented to you after you write Color.Color,).
Special values (like Item in most formulas, and Element when using the FILTER function).
TRUE and FALSE.
Names of function parameters.
Parentheses — ( ) — and brackets — { } (used to construct arrays).

The autocomplete system engages automatically. If it does not, and you’d like to see suggestions, press Ctrl+Space on PC, or ⌘+Space on Mac.

Calcapp Creator understands the formulas you’re writing. What that means is that if you write 2 + , you’ll be presented with functions that return numbers and fields with numeric values, but text-returning functions and text fields won’t be suggested.

Similarly, TRUE and FALSE are only suggested if the context warrants it, like if you’re trying to pass a value for the UseAccountingStyle parameter of FORMATNUMBER.

To reference a field (any item, really), just start typing either its name or its label. If the field appears on a different screen, the screen name and ! are inserted automatically. We’ve found this to be a huge time saver.

Finally, our formula documentation is displayed when functions and properties are suggested.

Feature: Edit text properties as templates

Fri, 11 Aug 2023 15:00:00 +0000

All text properties can now be edited as templates. Change the text as you normally would in the inspector and insert formula fragments between special markers. This makes it much easier to edit email bodies sent by your app.

Calcapp has many text properties that can be customized using the inspector in Calcapp Creator, including these:

Values of text fields.
Email bodies of email report buttons.
File names of open report buttons.
Validation messages of fields.

Like other calculated properties, text properties can be set through formulas. In prior releases, this was done by clicking the fx button next to the property in the inspector. By using a formula, information entered into the app by your users and calculated by your app can be made part of the calculated value.

Unfortunately, setting text properties through formulas can be awkward. Let’s say that you want to set the Body property of an email report button using a formula. The goal is to send an email with a body like the following:

Dear Sally,

The weight is 23.30 lbs.

In prior releases, you had to use a formula like the following to achieve this:

"Dear " & Name & "," & NEWLINE() & NEWLINE() & "The weight is " & Weight & " lbs.""Dear " & Name & "," & NEWLINE() & NEWLINE() & "The weight is " & Weight & " lbs."

There are a few problems here:

You need to know that & is used to join text strings together.
You need to know that you should use the NEWLINE formula function to produce line breaks and paragraphs.
Producing a formula like the one above is needlessly complicated, even if you know everything there is to know about formulas.
It inhibits the writing process, by making you focus on things other than the text.

You can now use templates instead, directly in the inspector. A template allows you to write text as you normally do, including blank lines, and insert formula fragments between {{ and }} markers.

Autocomplete is active when editing formula fragments, making template editing a first-class formula editing experience.

Here’s the template version of the formula above:

Dear {{Name}},

The weight is {{Weight}} lbs.

You can enter any formula fragments between {{ and }} markers, not just references to fields. These formula fragments can be arbitrarily complex.

This is what using the template looks like in the inspector, with the area where you write the email body marked in red:

Above, the Body property has been selected in the property selector (also marked in red), causing its formula to be displayed. As you can see, a template is nothing more than an easy way to write a formula.

(Templates don’t use the NEWLINE function. Instead, they insert line breaks in the formula, which is now supported.)

If you prefer editing the text property as a regular formula, you need to select the property from the property selector next to the formula field.

We have removed the fx buttons from text properties in the inspector, and replaced them by buttons. They insert {{ into your formulas and starts autocomplete.

Templates have been enabled for all text properties in the inspector. Some text properties, such as field labels, have never been in the inspector, and still require you to edit the formula like before.

There’s one property that previously was not part of the inspector and now is: text field values:

This change makes it possible to edit text field values as templates. If you prefer editing them as formulas instead, simply use the formula field as you normally would.

If you include line breaks in text field values, be sure to toggle Multiple lines in the inspector to its “on” position, so that they are displayed.

Feature: Access all items as a single array

Fri, 11 Aug 2023 14:00:00 +0000

The new Items property allows you to access all items, including fields and buttons, as a single array. That makes it easy to calculate the sum of all fields of a screen, or determine if all fields of your app are valid, with short, readable formulas.

You can now access all items of a form group, a form screen or the entire app as an array. An item in this context is a button, a field, a text box, a navigator, a named value or a form group.

To illustrate the many uses of this new feature, let’s look at a couple of examples:

Summing all number fields of a form group

Let’s say that the form group Readings contains number fields whose values should be summed. This formula returns the sum:

SUM(Readings)SUM(Readings)

Calcapp interprets the formula above as this equivalent formula:

SUM(Readings.Items)SUM(Readings,Items)

If the Readings form group only consists of the number fields Reading1, Reading2, Reading3 Reading4, in that order, these two formulas are also equivalent (and worked in our previous release):

SUM(Reading1:Reading4)SUM(Reading1:Reading4)

SUM({ Reading1, Reading2, Reading3, Reading4 })SUM({ Reading1; Reading2; Reading3; Reading4 })

The chief advantage to using the Items property instead of a range is that you no longer need to worry about updating the formula when you add more fields. If you add a fifth number field, Reading5, that should be included in the calculations, the two formulas above need to be updated. The first two formulas, though, will continue working, making for fewer errors and less error-prone maintenance work.

Determining if all switch fields have been toggled

Assume that the form group Switches only consists of four switch fields, Switch1, Switch2, Switch3 and Switch4, in that order. These traditional formulas return whether they have all been toggled to their “on” positions:

AND(Switch1, Switch2, Switch3, Switch4)AND(Switch1; Switch2; Switch3; Switch4)

Switch1 && Switch2 && Switch3 && Switch4Switch1 && Switch2 && Switch3 && Switch4

Ranges can again provide a space-saving way to express the formulas above:

AND(Switch1:Switch4)AND(Switch1:Switch4)

Again, the Items property provides a better way, which does not require that the formula is updated as switch fields are added:

AND(Switches)AND(Switches)

Determining if all fields are valid

The array of items holds the items themselves, including all their properties, and not just their values.

As such, this formula returns whether all fields of the Switches form group are valid:

AND(Switches.Items.Valid)AND(Switches,Items,Valid)

Above, the Items property must be spelled out, as the Switches form group does not have a property named Valid, but the items of Switches do.

Making the background color of the app red if any field is invalid

So far, we have only looked at the Items property of form groups. Form screens also support this property, meaning that any example above can work at the level of a form screen and not just a form group.

In fact, we can access all items of the entire app, all at once. This formula returns whether all fields are valid:

AND(App.Items.Valid)AND(App,Items,Valid)

(Your app is normally named App in formulas, but can be renamed on the first screen that is shown when you open an app in Calcapp Creator.)

This formula returns whether any field is valid (meaning that a single valid field makes the formula return TRUE):

OR(App.Items.Valid)OR(App,Items,Valid)

This formula returns whether any field is invalid, by turning all TRUE elements of the array to FALSE, and vice versa, using NOT:

OR(NOT(App.Items.Valid))OR(NOT(App,Items,Valid))

Putting it all together, this formula returns the color red if any field is invalid, and otherwise returns a blank value:

IF(OR(NOT(App.Items.Valid)), Color.Red)IF(OR(NOT(App,Items,Valid)); Color,Red)

If this formula is associated with the BackgroundColor property of the first screen, and no other screens have their background colors set, the end result is that the entire app turns red when a single field is invalid.

Enabling a button only if all fields have been filled out

Let’s assume that the DataEntry form screen consists of a number of fields, all of which must be filled out in order for a button at the bottom of the screen to become enabled.

This formula, which should be associated with the Enabled property of the button, does just that:

AND(ISDEFINED(DataEntry))AND(ISDEFINED(DataEntry))

If all fields need to be filled out and also pass validation, use this formula instead:

AND(ISDEFINED(DataEntry)) && AND(DataEntry.Items.Valid)AND(ISDEFINED(DataEntry)) && AND(DataEntry,Items,Valid)

Accessing only certain types of fields

Most of the time, accessing the Items property works well. While it includes not just fields, but also buttons, text boxes, navigators, named values and form groups, most formulas involving Items can only be interpreted one way.

Here’s one such formula:

AND(Screen1.Items.Valid)AND(Screen1,Items,Valid)

It returns whether all fields of Screen1 are valid, simply because only fields support the Valid property. The meaning of that formula may change in the future, though, if other items gain support for a property named “Valid.”

Sometimes, it’s preferable to be more specific. We also provide the following properties:

Form groups: Fields, DateTimeFields, NumberDropDownFields, NumberFields, SwitchFields, TextDropDownFields and TextFields.

Form screens: Fields, DateTimeFields, NumberDropDownFields, NumberFields, SwitchFields, TextDropDownFields and TextFields.

The entire app: Fields, DateTimeFields, NumberDropDownFields, NumberFields, SwitchFields, TextDropDownFields and TextFields.

(The links above lead to our full documentation, which contains many more examples than this blog post.)

If we use the Fields property instead of the Items property, the Valid formula above looks like this:

AND(Screen1.Fields.Valid)AND(Screen1,Fields,Valid)

The meaning of this formula won’t change in the future, even if buttons gain a property named “Valid.”

Also, while AND(Screen1)AND(Screen1) does return whether all switch fields of Screen1 have been toggled to their “on” positions, the formula may be hard to understand. This alternative is probably clearer:

AND(Screen1.SwitchFields)AND(Screen1,SwitchFields)

Sometimes, being more specific is the only way to write a correct formula. Consider a screen, Screen1, which consists of a number of date and time fields, as well as number fields. If we want to return the sum of all its number fields, we may try this formula:

SUM(Screen1)SUM(Screen1)

However, you will find that the returned sum is not correct. The reason is that the formula above also includes the date and time fields and their values.

Remember that number fields are not the only fields whose values are numbers, that also applies to date and time fields. (Details here.) In effect, the formulas above return the sum of all number fields and all date and time fields of Screen1, which is probably not what we want.

The solution is, again, to be more specific. This formula does what we want:

SUM(Screen1.NumberFields)SUM(Screen1,NumberFields)

Filtering fields

If we combine the Fields property with the FILTER function, we can apply an operation to just a few fields and not to all of them.

For example, this formula returns the sum of all fields of Screen1 which are considered Valid, and ignores the others:

SUM(FILTER(Screen1.Fields, Screen1.Fields.Valid))SUM(FILTER(Screen1,Fields; Screen1,Fields,Valid))

This formula returns the sum of all number fields whose values are greater than zero:

SUM(FILTER(Screen1.NumberFields, Screen1.NumberFields > 0))SUM(FILTER(Screen1,NumberFields; Screen1,NumberFields > 0))

This formula returns the number of text fields whose backgrounds are red:

SIZE(FILTER(Screen1.TextFields, Screen1.TextFields.BackgroundColor = Color.Red))SIZE(FILTER(Screen1,TextFields; Screen1,TextFields,BackgroundColor = Color,Red))

This formula returns the largest value entered in a number field whose label includes the word “mandatory”:

MAX(FILTER(Screen1.NumberFields, CONTAINS(Screen1.NumberFields.Label, "mandatory")))MAX(FILTER(Screen1,NumberFields; CONTAINS(Screen1,NumberFields,Label; "mandatory")))

Finally, this formula returns the average value entered in all number fields whose names start with “F”:

AVERAGE(FILTER(Screen1.NumberFields, STARTSWITH(Screen1.NumberFields.Label, "F")))AVERAGE(FILTER(Screen1,NumberFields; STARTSWITH(Screen1,NumberFields,Label; "F")))

(All items now have names, which is described in greater detail here.)

Feature: Edit formulas of multiple items at the same time

Fri, 11 Aug 2023 13:00:00 +0000

When multiple items are checked in the app designer that use the same formula, this shared formula can now be edited. We also describe the new special formula value Item and the related performance improvements we've made.

Calcapp Creator has always allowed you to edit multiple items (including fields and buttons) at the same time. Simply check all the relevant items (which as of today is a lot easier) and make changes in the inspector. You’ll find that the changes have been applied to all the relevant checked items.

For instance, let’s say that you have created 100 currency fields, but forgot to change the currency from the default. Simply by checking those 100 items (which, again, is now easy) and selecting the desired currency once, the changes are applied to all relevant checked items.

Traditionally, that has not applied to formulas, though. Previously, if you checked multiple items, the fx symbols next to calculated properties in the inspector would go away, and the property selector and the formula field would be grayed out.

Today, that changes. Now, when you check multiple items and select a property whose formulas are either missing or are identical across all checked items, you can simply edit the formula once, and have the changes apply to all relevant checked items.

Here’s an example app, where we want the Visible properties of all checked fields to use the same formula:

As you can see, we are allowed to edit the shared formula of all five checked fields.

So what happens if the relevant formulas aren’t all identical? The formula field will then display a message to that effect:

To resolve the issue, just start typing in the formula field, and you’re presented with this box:

Select a single formula, and that one formula will be set for all items.

Referencing the current item from a formula

In the example above, all formulas reference the same switch field. What if you instead want to reference the item the formula belongs to?

Whether a field is valid typically depends on the value of the field. Let’s say that the relief pressure valves in the example should not be assigned values that are less than 110 psi or greater than 200 psi.

Normally, making this work for all fields is fairly easy. We simply check them all, and enter 110 for the minimum value and 200 for the maximum value under Validity in the inspector.

Let’s add a complicating wrinkle, though. Let’s say that having fields validated can be annoying at times, and it is imperative that users can disable validation. To achieve that, we add the switch field ValidateValues.

Suddenly, we can no longer rely on the minimum and maximum values in the inspector, now we need to determine validity using a formula.

(We could use either the Valid property, or use both the MinimumValue and MaximumValue properties. Here, we’ll somewhat arbitrarily do the former.)

Here’s the Valid formula for Valve1:

!ValidateValues || ((Valve1 >= 110) && (Valve1 <= 200))!ValidateValues || ((Valve1 >= 110) && (Valve1 <= 200))

In other words, the field is considered valid if the ValidateValues switch field is toggled to its “off” position, or if the value of Valve1 is greater or equal to 110 and less than or equal to 200.

Here’s the almost-identical Valid formula for Valve2:

!ValidateValues || ((Valve2 >= 110) && (Valve2 <= 200))!ValidateValues || ((Valve2 >= 110) && (Valve2 <= 200))

It would appear that we can’t use a single formula for all fields, as all the formulas need to reference the relevant field and its value: The Valid formula for Valve1 must reference Valve1, the the Valid formula for Valve2 must reference Valve2, etc.

That’s where the new Item value comes into play. All formulas associated with items have access to this new special value, and it always references the current item (including fields and buttons).

That means that we can use a single formula for all the fields after all:

!ValidateValues || ((Item >= 110) && (Item <= 200))!ValidateValues || ((Item >= 110) && (Item <= 200))

As such, this feature enables you to conveniently edit the shared formula of all five valve fields of the example at the same time.

Note that when you access Item from a formula, what you are accessing is the entire item, and not just, say, a field value.

That means that this formula, associated with the BackgroundColor property of a field, will work:

IF(!Item.Valid, Color.Red700)IF(!Item,Valid; Color,Red700)

In other words, the background color of a field will turn red if the item is not valid.

We expect that this feature will lead to many more apps with identical formulas, as they are now so easy to create and maintain. For that reason, we have done a lot of work in Calcapp Connect (which runs your apps) to ensure that apps with a lot of identical properties, and identical formulas, run faster and consume less memory.

This section is somewhat technical. Feel free to skip ahead to the next blog post if you’re not interested in the details.

Before, if you had 1,000 fields which all used the same Visible formula, Calcapp would needlessly create 1,000 identical so-called property instances when your app was run.

A property instance is necessary when a property is associated with a formula. They consume memory, and make your apps run somewhat slower, so we try not to create them unnecessarily. For instance, if your field is always visible, we’ll just make a note of the fact that it’s visible, without creating a property instance, and the same goes for all properties with unchanging values.

We did create them unnecessarily before, if lots of items shared the exact same formula. It was unnecessary, because a single property instance would have sufficed.

That’s exactly what we do now. We look at all your formulas when your app is run, and we let items share property instances if they aren’t different from one another. The end result is that such apps start and run faster.

We’ve done that work for another reason as well: the new Items property, and related properties, make it easy to access potentially thousands of items in one fell swoop.

You can, for instance, make the background color of the app red if any field in the entire app is invalid, by associating this formula with the BackgroundColor property of the first screen:

IF(OR(NOT(App.Fields.Valid)), Color.Red700)IF(OR(NOT(App,Fields,Valid)); Color,Red700)

Colors are actually fairly complicated in Calcapp. If a screen doesn’t have a background color set, it uses the background color from the preceding screen, and so on. Ultimately, if no preceding screen has a background color set, it uses the one from your theme.

For various reasons, the formula above used to cause an explosion in the number of property instances that were created, especially for very large apps. The end result was that our powerful desktop computers in the office could barely run a simple, but large, test app that used the technique described above.

Now that property instances are shared if possible, that large test app runs very quickly. That means that you shouldn’t run into situations where your reasonably-sized apps run slowly, even if you use all the new features of this release.

Feature: A grab bag of new features

Fri, 11 Aug 2023 12:00:00 +0000

The screens sidebar can now be resized, line breaks can be inserted into formulas, sliders work better on touch screens and you get more disk space for images. Our latest release is full of minor features such as these.

Our new release contains major new features, but also many minor ones, that aren’t significant enough to warrant a blog post of their own. This page collects these smaller improvements.

The screens sidebar lists all your screens and allows you to reorder them. For large apps in particular, it acts as an overview of your app, allowing you to quickly move from one screen to another.

The only problem was that it wasn’t resizable. Long screen labels would get truncated, and some deeply nested screens would barely be visible.

You can now easily resize the sidebar by pressing the button:

There are three widths. Press the button to toggle to the next-larger width, or back to the standard size if the maximum width is selected.

Better sliders for your apps

Sliders can be enabled for number fields by toggling the appropriate option in the inspector, and allow your users to change a value by moving a handle:

Sliders could be hard to use on touch screens, though. Specifically, sliders would inhibit the vertical motion used for scrolling, preventing that from happening. This would happen even if the user was sliding vertically and not horizontally.

One solution was to start the scroll motion outside of sliders, but that was an issue for apps where most fields had sliders.

Now, sliders behave more like standard sliders on iOS and Android in that they expect you to scroll horizontally for some distance before they assume that you’re trying to manipulate the handle of the slider. That means that if you want to scroll vertically, sliders are much less likely to interfere with that motion.

Insert line breaks in formulas

You can now insert line breaks in formulas by pressing Alt+Enter. This is useful when you want to enter line breaks in literal text strings (text within quotation marks). Previously, the only way to do this was to use the NEWLINE function (or to type CHAR(10)CHAR(10)).

Outside of literal text, line breaks make no difference to Calcapp, but you’re welcome to use them if you think they make your formula easier to read and edit.

With the introduction of templates, you may not find yourself needing this feature as much as you otherwise would have. When you edit a template, simply press Enter to insert a line break (which will also cause a line break to be inserted into the corresponding formula).

Here’s a user editing the Body property of an email report button, illustrating both a template and a formula with line breaks:

Easily check multiple items in the app designer

Previously, if you wanted to check a range of items in Calcapp Creator (say, Field1 through Field20), you had to individually click their check boxes.

Calcapp Creator tried to ease this process by checking or unchecking all items of a form group for you when you checked or unchecked the form group, but this sometimes interfered with what you were trying to do.

Now, you can check or uncheck ranges of items simply by pressing and holding the Shift key. Check boxes next to form groups no longer try to check or uncheck the items of the form groups when Shift is held.

If you like to edit your apps on a device without a physical keyboard (like a tablet or a cell phone), you need to press a new toggle button in the toolbar instead:

Determine if a field is persistent from a formula

Persistent fields retain their values, even when your users close your app and open it again. Make a field persistent by toggling the Remember value property in the inspector.

This property still does not allow you to associate a formula with it. However, you can now determine if a field is persistent from a formula, by accessing the new read-only Persistent property.

This action formula resets all fields of the app which are not persistent:

RESET(FILTER(App.Fields, NOT(App.Fields.Persistent)))RESET(FILTER(App,Fields; NOT(App,Fields,Persistent)))

Reset buttons can be instructed not to reset persistent fields. By introducing this new property, the RESET action function can perform the same feat, in conjunction with the FILTER function.

Access the name of an item from a formula

All items now feature a new read-only property, Name, including all fields and buttons.

Names can be assigned manually in Calcapp Creator, but are usually assigned automatically based on the label. When you update the label, the name is by default also updated, as well as all formulas that reference the item.

You assign names manually simply by writing a new name in the name field:

In the image above, the first field would ordinarily have been named HorizontalCoordinate (based on the label, with no spaces), which is quite wordy. Above, we have renamed the field X, which makes formulas much shorter.

To make the name follow the label once more, just select the name and remove it (press Delete or Backspace).

You can now access the name of an item from a formula, making this formula always return TRUE:

Field1.Name = "Field"Field1,Name = "Field"

While that’s not terribly useful, it becomes useful in conjunction with the new Items property of form groups, form screens and the app itself (along with related properties, like Fields), along with the FILTER function.

This formula returns the sum of all fields of FormGroup1, whose names start with “Credit”:

SUM(FILTER(FormGroup1.Items, STARTSWITH(FormGroup1.Fields.Name, "Credit")))SUM(FILTER(FormGroup1,Items; STARTSWITH(FormGroup1,Fields,Name; "Credit")))

If you devise a naming scheme for your fields, this can be a useful way of targeting just a selection of them.

These are some of the other functions, besides STARTSWITH, that you may find useful when determining which names to include:

ENDSWITH.
CONTAINS.
REGEXMATCH (advanced).

Access the current item from a formula

In most formulas, you can now write Item to reference the current field, button, text box, form group or navigator that is associated with the current property.

For instance, if the following Valid formulas are associated with Field1, both are equivalent:

(Field1 > 10) && (Field1 < 20)(Field1 > 10) && (Field1 < 20)

(Item > 10) && (Item < 20)(Item > 10) && (Item < 20)

Item is equivalent to named item references like Field1, meaning that it is a reference to the item as a whole, and not just, say, a field value. That means that you can access properties off Item, by writing something like Item.VisibleItem,Visible in a formula.

This feature is primarily useful when you want many items to share the same formula. This topic is explored in-depth here.

New design when creating a new screen

We were never fans of the crude icon design we put together for the screen that appears when you create a new screen:

This vestige of the past has now been replaced with this new design:

No more cell phone previews

The cell phone previews from the app preview sidebar of Calcapp Creator have been removed. As you may recall, you were presented with a list of cell phone models, and selecting one would cause the preview to be resized to approximately match the selected model.

This feature was designed at a time when there was a lot of variability between different cell phone models, in terms of their screen sizes. Nowadays, cell phones tend to come with large screens no matter what model you choose, making this feature a lot less relevant.

Also, we struggled to keep the list up-to-date with new models, making Calcapp Creator look unnecessarily dated. (The oldest iPhone model we supported was an iPhone 5 from 2012 and the newest iPhone model was the iPhone X from 2017.)

Instead of updating the list, we hereby banish this feature to the dustbin of history.

More space for images

The total space for images, per customer, used to be 200 MB. For image-heavy apps, that proved too little. Every customer now has access to 1024 MB (one gigabyte) of storage.

Feature: Use LET to avoid repetition in formulas

Fri, 11 Aug 2023 11:00:00 +0000

The new function LET enables you to assign names to values for use inside a single formula. LET can make formulas shorter and easier to read and can help them run faster.

Our new release introduces support for the LET function, which enables you to write shorter, more descriptive formulas that run faster.

At its core, LET makes it possible to assign names to values, which can be used in calculations that appear to the right in the same formula.

The best way to demonstrate this is with an example:

LET(Area := Width * Height, Cost := Area * 1500, Cost + 1000)LET(Area := Width * Height; Cost := Area * 1500; Cost + 1000)

The formula above first multiplies the values of the Width and Height fields together and assigns the name Area to the resulting value. It then multiplies this value by 1500, assigning it the name Cost. Finally, it adds 1000 to the Cost value and returns the sum.

The formula above can also be written (Width * Height * 1500) + 1000(Width * Height * 1500) + 1000, which is significantly shorter, but isn’t as descriptive.

LET is primarily useful when you need to repeat formula fragments in a formula, allowing you to assign a single name to the repeating part and then refer back to it. That can make formulas shorter and make apps perform better, as it gives Calcapp less work to do.

LET is also useful when you want your formulas to be self-documenting, so that other people can more easily determine how they work.

If you need to assign names to values that are accessible from any formula, use named values instead (introduced here).

LET works particularly well with action formulas (formulas run in response to buttons being pressed, another new feature). Refer to our full documentation for more on that topic.

LET in Microsoft Excel

Microsoft Excel introduced support for LET back in 2020. Their version differs from the Calcapp version in that you need to use ,; instead of := to separate names from values.

Being able to use := is a Calcapp extension, which we think makes formulas easier to read. You can use ,; instead of := if you like. This may be useful if you copy and paste formulas between Excel and Calcapp Creator.

LET and arrays

The values you use with LET can be of any type, including arrays. This formula returns the array elements that are greater than 3:

LET(Array := { 1, 2, 3, 4, 5 }, FILTER(Array, Array > 3))LET(Array := { 1; 2; 3; 4; 5 }; FILTER(Array; Array > 3))

The version without LET would involve repeating the array:

FILTER({ 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 } > 3)FILTER({ 1; 2; 3; 4; 5 }; { 1; 2; 3; 4; 5 } > 3)

You can also filter an array without repeating it, and without using LET, using a feature specific to Calcapp:

FILTER({ 1, 2, 3, 4, 5 }, Element > 3)FILTER({ 1; 2; 3; 4; 5 }; Element > 3)

Be sure to check out our full documentation for more on LET, including lots of formula samples.

Feature: Named values

Fri, 11 Aug 2023 10:00:00 +0000

Named values allow you to assign names to values returned from formulas. Unlike hidden fields, named values can represent anything a formula can return, including screens and arrays.

Our new release adds support for named values. Like a hidden field, a named value can be referenced from any formula. Unlike a hidden field, a named value can represent anything, including screens and arrays. Named values are normally hidden from the user.

Create a named value by creating a new field and selecting Named value from the field drop-down in the inspector:

This is what the inspector looks like when a named value is selected:

To determine the value represented by a named value, press the fx button next to Value and edit the formula.

You can use named values to cut down on repetition in formulas. Instead of duplicating a formula fragment in many formulas, use a named value instead and reference the named value from the formulas by writing its name. That makes formulas easier to read and can boost performance too, as it gives Calcapp less to do.

If you have experience with traditional programming, you can think of a named value as a variable. While a variable only changes when you explicitly assign a value to it, a named value updates automatically when the values its formula relies on change.

If you want to name values for use in a single formula, consider using the LET function instead (introduced in this post).

For more detailed information on named values, including lots of sample formulas, refer to our full documentation.

Named values are not available in any of our legacy plans, meaning that you may need to upgrade to access this feature. They are available in our 2023 Business and White Label plans. They are fully functional in Calcapp Creator’s preview sidebar, though, so you can get a feel for them, regardless of your plan.

Named values versus hidden fields

We introduced hidden fields back in 2016, to solve the same issue solved by named values. Hidden fields are number fields, switch fields or text fields that are invisible to the user. They are not invisible to other formulas, though, and as a result can be used to cut down on formula repetition and make formulas easier to read.

Since their introduction, Calcapp has gained the ability to reference more things than numbers, logical values (TRUE or FALSE) and text strings. In particular, our last big release made it possible to refer to things such as screens, fields, buttons and arrays.

Consider this formula:

NumberField1NumberField1

If you assign this formula to a hidden number field and reference it from another formula, the value of the field (say, 4) is returned, because number field values expect their formulas to represent numbers.

If you instead assign the formula to a named value and reference it from another formula, the actual field is returned, including its value and all its other properties, like Visible.

To see the difference, let’s assume that the named value is named ActiveField.

This formula adds 2 to the value of ActiveField, because + expects both values to be numbers:

ActiveField + 2ActiveField + 2

This formula returns 2 if the active field is visible, and 4 otherwise:

IF(ActiveField.Visible, 2, 4)IF(ActiveField,Visible; 2; 4)

While ActiveField + 2ActiveField + 2 would have worked if ActiveField had been a hidden number field, IF(ActiveField.Visible, 2, 4)IF(ActiveField,Visible; 2; 4) only works if ActiveField is a named value.

The reason is that ActiveField, as a named value, represents the field in its entirety, and not just its value. For that reason, properties like Visible can be accessed.

Finally, consider this formula:

IF(ActiveField.Valid, EMAILREPORT({ ActiveField }, "test@example.com"), BANNER("Could not send report."))IF(ActiveField,Valid; EMAILREPORT({ ActiveField }; "test@example.com"); BANNER("Could not send report."))

This formula is an action formula, and must be associated with the OnPress property of a formula button. (Action formulas are new to this release.) It only sends a report if the active field is valid, and otherwise displays an error message.

The sent report includes only the active field and its value. Again, this works because ActiveField is a reference to the field itself, and not only to its value.

Named values, hidden fields and the assignment operator

The new := operator may be used to assign values to properties from action formulas. This formula calculates a value which it then assigns to Field1:

Field1 := 42 * Field2Field1 := 42 * Field2

This action formula hides a text box if Field1 is less than ten:

IF(Field1 < 10, TextBox1.Visible := FALSE)IF(Field1 < 10; TextBox1,Visible := FALSE)

Assume that we have two formula buttons that move the user to different screens (through the GOFORWARD action function). Let’s also assume that we want to keep track of what button the user pressed by storing a text string.

Where should we store the text string? You may think that a named value would be the appropriate place, but named values cannot be used with :=. In fact, named values can only determine their values through formulas.

Instead, you need to use a hidden text field. If we name it SelectedButton, this is the formula we need for one of the buttons:

SelectedButton := "edit"; GOFORWARD(EditScreen)SelectedButton := "edit";; GOFORWARD(EditScreen)

Named values, tabular data and arrays

As named values can represent anything, they can also represent data in the form of arrays. That capability makes it possible to create and update data separately from other formulas.

Assume that the following formula is associated with the named value Name, a part of the screen Employee:

{ "Bill", "Sally", "Amy", "Joe" }{ "Bill"; "Sally"; "Amy"; "Joe" }

Further, assume that the following formula is associated with the named value Salary, residing on the same screen:

{ 40000, 55000, 70000, 65000 }{ 40000; 55000; 70000; 65000 }

The first element of Name corresponds to the first element of Salary, the second element of Name corresponds to the second element of Salary, etc. In other words, the two named values correspond to columns in a data table, holding the salaries of four employees.

Using these two named values, the following formula looks up the salary of an employee whose name is stored in the Name field:

XLOOKUP(Name, Employees!Name, Employees!Salary)XLOOKUP(Name; Employees!Name; Employees!Salary)

The following formula returns the average salary of all employees:

AVERAGE(Employees!Salary)AVERAGE(Employees!Salary)

This formula returns the number of employees who earn more than $50,000 per year:

COUNTIF(Employees!Salary, ">50000")COUNTIF(Employees!Salary; ">50000")

Finally, this formula looks up the name of the employee with the highest salary:

INDEX(Employees!Name, XMATCH(MAX(Employees!Salary), Employees!Salary))INDEX(Employees!Name; XMATCH(MAX(Employees!Salary); Employees!Salary))

Without named values, both arrays would have had to be duplicated in all these formulas.

Having named values reference arrays is so useful that we built a major feature around them: our new data editor, which allows data to be edited in the same way as a spreadsheet. Under the hood, the data editor creates and updates named values, corresponding to columns in the tabular data.

Using named values to create aliases

Named values can be used to create aliases, or alternative names, for names in Calcapp that are perhaps overly long.

The action function OPENREPORT allows the format of the sent report to be given as the second parameter. Here’s a formula that requests plain text:

OPENREPORT({ App}, OpenReportFormat.PlainText)OPENREPORT({ App}; OpenReportFormat,PlainText)

If you find yourself using the OPENREPORT function many times, you may want to consider creating an alias for OpenReportFormat.PlainTextOpenReportFormat,PlainText.

Assume that this formula is associated with the named value Plain:

OpenReportFormat.PlainTextOpenReportFormat,PlainText

With this named value, the OPENREPORT formula above can be made shorter:

OPENREPORT({ App}, Plain)OPENREPORT({ App}; Plain)

Making named values visible

Named values are normally hidden. However, you can make them visible by toggling their Visible property. This is useful when you’re testing your app, as it makes it possible to inspect the values used from your formulas. As there is little other reason to make named values visible, their appearance cannot be changed.

You are welcome to use a formula to determine whether a named value is visible. That can be used to add a “debug mode” to your app, which can be enabled from a Settings screen (perhaps only visible if you, the app author, is using the app, through UserEmailAddress or USERHASTAG).

This tip from 2017 discusses adding a debug mode to make hidden fields visible, but it is equally applicable to named values.

Feature: Customizable link targets

Fri, 11 Aug 2023 09:00:00 +0000

Browse buttons and the BROWSE function allow you to determine if links open in a new web browser window or tab or replace the app. An app-wide default setting can also be changed, which also affects where text box links open.

Calcapp has supported adding website links since 2017, when we added support for formatted text to text boxes. Our new release adds two more ways to link to websites: browse buttons and the BROWSE action function both open the user’s web browser at a certain address.

When a link is opened on the web, the default behavior is for it to open in the current web browser window or tab. HTML allows this behavior to be customized, so that a link is opened in a new tab or window. This is known as the target of the link.

If the current page is running as part of a so-called iframe (which can be seen as a rectangular area of a host page that houses a different web page), HTML allows the link to replace the host page, instead of the default behavior, which is to just replace the current page residing in that rectangular box.

This is relevant, as apps created with Calcapp can be embedded in your website, and iframes are used to make that happen. Read on to learn more about how link targets are changing for embedded apps.

Browse buttons and the BROWSE function

The new browse button allows this behavior to be customized. Here are the inspector properties shown when a browse button is selected, with the new target property highlighted:

Here are the available options:

(The names have intentionally been chosen to match the target attribute of HTML <a> elements, documented here.)

This is what the options mean:

Value	Meaning
Default	Use the app-wide link target setting. See below for more information.
Self	The link replaces the app (and just the app, if it has been embedded in another website.)
Blank	The link is opened in a new web browser tab or window.
Parent	The link replaces the page hosting the iframe element. If the app isn't embedded, the link is opened in a new web browser tab or window.
Top	The link replaces the top-most page hosting the iframe element. This is only different from Parent if the iframe hosting the app is itself hosted in another iframe.
Named target	The link is opened in a web browser window or tab with a certain name (which is provided separately in the inspector). If a different link has previously been opened with a target name matching this link's target name, this link replaces the other link in the other tab or window.

The target property is a calculated property, meaning that it can be set through a formula. Refer to our documentation for that property for more information.

The BROWSE function also allows the target to be set. The linked page has more information on how to use the function.

(BROWSE is an action function and must be run through a formula button.)

Default behavior

Previously, all links opened in a new web browser window or tab (corresponding to the new Blank option). This made a lot of sense for stand-alone apps, which would otherwise have been replaced by the opened link.

However, this behavior caused issues for embedded apps. Links that were part of the app always opened in a new window or tab, which often was not the behavior used by the links on the host page. From a user’s perspective, the difference in behavior made little sense.

With our our new release, the default behavior differs depending on if the app is running stand-alone or embedded in a host page. For stand-alone apps, the default behavior remains for links to open in a new window or tab (the Blank option above). For embedded apps, the new default behavior is for links to replace the top-most host page (the Top option above).

(Whether an app is considered to be embedded is related to how it’s used and not to the plan it’s on.)

The default behavior can be customized in the inspector when the start screen is shown (press the button until you reach it):

The only way to determine where text box links open is through this setting. Browse buttons and the BROWSE function default to using this setting, but allow the behavior to be customized on a per-button or per-function basis.

Newly-created apps use the new default behavior, described above. However, apps created using a prior version of Calcapp retain the old behavior of all links opening in a new window or tab, meaning that this setting must be changed manually if you’d prefer the new behavior.

Feature: Improvements to reports

Fri, 11 Aug 2023 08:00:00 +0000

The bodies of sent emails can now be edited as templates, making for a more comfortable experience. The fields to include can be set visually. Most report-related properties can now be set through formulas, and report-related action functions offer lots of flexibility.

One of the most used button types is email report buttons, which enable your apps to send emails with the information collected and calculated by your app. When we first introduced the feature in 2016, you were limited to sending your app’s field values.

In 2021, we introduced the new Body property, enabling you to leave out field values altogether and fully set the body using a formula.

That setup now becomes the default. When you create a new email report button, it will be configured to not include field values. Instead, it will present an email editor very much like what you’d find in an email client, complete with the ability to set recipients, a subject line and a body.

Editing the body of your email

The email body in the inspector now expands in width when it becomes focused, more closely mimicking a traditional email client and allowing you to write more comfortably.

More important is the fact that the body, and all other text properties, are now templates. What that means is that you can easily insert formula fragments, simply by placing them between {{ and }} markers.

Here’s an example:

Previously, you would have had to associate a formula like the following with the the Body property of the email report button:

"Dear " & Name & "," & NEWLINE() & NEWLINE() & "We hope this email finds you well…""Dear " & Name & "," & NEWLINE() & NEWLINE() & "We hope this email finds you well…"

Autocomplete is active when editing formula fragments, making template editing a first-class formula editing experience.

You’re not limited to referencing fields within the {{ and }} markers, you can use arbitrarily complicated calculations.

Including field values

If you want to include field values, be sure to select Include this screen’s fields, Include all fields or Include specific fields from the drop-down that initially reads Don’t include fields.

If you select Include specific fields, a property labeled Included fields appears, along with a new pen button for determing what fields to include visually:

When you press this button, this box appears:

When you’re done selecting your fields, press Next to change the order of the fields in the report:

Selecting what fields to include was introduced in 2021, but required the formula of the IncludedFields property to be edited manually. We think that having a graphical way to determine what fields to include makes the feature accessible to many more users (and is easier to use even if you’re a formula savant).

More properties are now calculated properties

Many of the properties related to email report buttons, open report buttons and server relay buttons were previously regular properties, meaning that you couldn’t associate them with formulas. That meant that the only way to allow your users to, say, determine if a CSV report or a PDF report should be sent was to include multiple buttons.

That is mostly a thing of the past with this release, which converts most properties to true calculated properties.

Here’s the complete list of properties you can now associate with formulas:

Email report buttons: FieldInclusion, Format, IncludeBlankValues, IncludeHiddenFields, IncludeScreenLabels, ResetFields and SeparateScreens.

Open report buttons: FieldInclusion, Format, IncludeBlankValues, IncludeHiddenFields, IncludeScreenLabels, ResetFields and SeparateScreens.

Server relay buttons: Address, FieldInclusion, IncludeBlankValues, IncludeHiddenFields and ResetFields.

Let’s enable a user to determine if a CSV or PDF report should be sent: Assume that there’s a text drop-down field named FormatSelection, with the options “CSV” and “PDF”, as well as an email report button.

Associate this formula with the Format property of the email report button:

SWITCH(FormatSelection, "CSV", EmailReportFormat.Dsv, "PDF", EmailReportFormat.Pdf)SWITCH(FormatSelection; "CSV"; EmailReportFormat,Dsv; "PDF"; EmailReportFormat,Pdf)

Our new release introduces 30 new action functions, which can be used from formulas associated with the OnPress property of formula buttons.

These are the new functions related to reports: EMAILREPORT, EMAILREPORT.CSV, EMAILREPORT.DSV, EMAILREPORT.TSV, OPENREPORT, OPENREPORT.CSV, OPENREPORT.DSV, OPENREPORT.TSV and RELAY.

There is nothing a report button can do that the functions above cannot. All features are accessible, and we have even introduced named parameters to make the new functions easy to use.

Action formulas make it possible to do report-related things that were previously unimaginable. This formula collects an email address through a prompt and then sends an email to that address:

AWAIT(PROMPT("Enter the email address:"), EMAILREPORT({ App }, Result, SubjectLine: "The latest readings", Body: "Refer to the readings below:"))AWAIT(PROMPT("Enter the email address:"); EMAILREPORT({ App }; Result; SubjectLine: "The latest readings"; Body: "Refer to the readings below:"))

Through action formulas, a single button can send different reports to different addresses, while also sending a message to the internal Slack channel, resetting fields and moving the user to a different screen. Refer to our dedicated blog post for an expanded discussion and many sample formulas.

The EMAILREPORT and OPENREPORT functions can be configured to send field values as delimiter-separated values (including CSV), but EMAILREPORT.DSV and OPENREPORT.DSV offer more options for configuring these values. EMAILREPORT.CSV, EMAILREPORT.TSV, OPENREPORT.CSV and OPENREPORT.TSV are convenience functions that are pre-configured to use commas or tabs as separators.

Sample app: Edit tags using action formulas

Fri, 11 Aug 2023 07:00:00 +0000

This sample app allows users to edit tags, which are often used on online marketplaces like eBay. The app demonstrates many new Calcapp features, like action formulas, the LET function, navigation buttons and clipboard copy buttons.

Create a new app based on this sample app ↗

We boldly claim that action formulas are the biggest addition to Calcapp ever, and that they enable you to create apps that would not have been possible without them. With this new sample app, we put that claim to the test.

There are various online marketplaces that allow you to post products and describe them using text tags, such as eBay. These tags are usually limited not only in terms of how many you can use, but also in terms of their character lengths. It is often to a seller’s benefit to use as many tags as possible, and to put as much information as possible in them.

However, sometimes these online marketplaces offer poor tools for creating and editing tags. With that problem as our inspiration, we set out to create an app that serves as the solution.

The app is embedded below, and this post describes how you use it. It also goes into the nitty-gritty of how it was built and explains all the formulas.

The app uses many new features introduced in this release, principally action formulas, but also three new button types (specifically, clipboard copy buttons, go back buttons and go forward buttons), as well as the new LET function.

You’re encouraged to view the app and its formulas as you read along. It’s available as a template when you create a new app under the Sample: Tag editor name.

Usage

Here’s the app:

You can go straight to the tag editor by pressing I want to create new tags. Here’s what it looks like:

Type tags into the text fields, and be sure to heed the warnings about tags being too long. (The maximum tag length is set to 30 characters.) Press the plus and minus buttons to edit more or fewer tags, respectively.

When you’re satisfied, press the Copy to clipboard button to copy the tags, separated by commas, to the clipboard. That enables them to be easily pasted into the online marketplace.

If you want to edit existing comma-separated tags, press the I want to edit existing tags button. Here’s what that screen looks like:

To edit those tags, press the Let’s go! button. You’re then taken to the tag editor, this time with the tags already filled out:

You’ll find that the tag editor looks slightly different. There are new fields that list the original tags that you entered in the preceding step. Those are not editable.

The editable fields are just below the others, and initially contain the tags from the preceding step. You’re welcome to edit those tags, though. This is a good way to tweak your tags, and compare the tweaked tags to the original tags you entered.

Under the hood

The welcome screen

The welcome screen has two buttons that move the user to another screen. The first button takes the user to the screen named PasteTagsScreen, while the second button takes the user to the screen named EditTagsScreen.

For reasons that will become clear later on, we need to keep track of which button the user presses, so we can refer back to it later. To do that, we need the buttons to be formula buttons, so they can run action formulas.

These action formulas do two things: First, they record the decision the user makes. Then, they take the user to a screen corresponding to their choice.

To record the decision the user makes, we’ll add a new hidden text field named Choice. The first button, that enables the user to edit existing tags, assigns the text string existing to Choice, while the second button, which enables the user to create new tags, assigns the text string new.

This is the formula associated with the OnPress property of the first button:

Choice := "existing"; GOFORWARD(PasteTagsScreen)Choice := "existing";; GOFORWARD(PasteTagsScreen)

:= assigns the appropriate value to Choice. Then, the GOFORWARD action function is used to bring the user forward to PasteTagsScreen.

This is the formula associated with the OnPress property of the second button:

Choice := "new"; RESET(App); GOFORWARD(EditTagsScreen)Choice := "new";; RESET(App);; GOFORWARD(EditTagsScreen)

Again, := assigns the appropriate value to Choice. Before we change the active screen to EditTagsScreen with GOFORWARD, we also make sure that all the fields of the entire app are reset using the RESET action function.

As we only want users to be able to move to other screens through the two buttons, the NextScreenAvailable property of the welcome screen must be toggled to its “off” setting in the inspector.

To select the screen, click anywhere in the blue area at the top of the app. Then, click the toggle next to Next screen available in the inspector. Both areas are marked in this image:

The paste screen

If the user presses the I want to edit existing tags button, they are taken to the screen named PasteTagsScreen. Once there, they can paste tags from their online marketplace.

The screen is simple, with a text field named Tags and a button labeled Let’s go! This button reads the entered tags, populates the screen enabling users to edit tags — EditTagsScreen — and finally moves the user forward to just that screen.

The button is a formula button, and runs an action formula that does what is described above. Here’s the formula:

LET(SplitArray, TRIM(TEXTSPLIT(Tags, ",")), Tag1, IF(SIZE(SplitArray) >= 1, INDEX(SplitArray, 1), BLANK()), Tag2, IF(SIZE(SplitArray) >= 2, INDEX(SplitArray, 2), BLANK()), Tag3, IF(SIZE(SplitArray) >= 3, INDEX(SplitArray, 3), BLANK()), EditTagsScreen!Original1 := Tag1; EditTagsScreen!Editable1 := Tag1; EditTagsScreen!Original2 := Tag2; EditTagsScreen!Editable2 := Tag2; EditTagsScreen!Original3 := Tag3; EditTagsScreen!Editable3 := Tag3; EditTagsScreen!TagCount := MAX(1, SIZE(SplitArray))); GOFORWARD(EditTagsScreen)LET(SplitArray; TRIM(TEXTSPLIT(Tags; ",")); Tag1; IF(SIZE(SplitArray) >= 1; INDEX(SplitArray; 1); BLANK()); Tag2; IF(SIZE(SplitArray) >= 2; INDEX(SplitArray; 2); BLANK()); Tag3; IF(SIZE(SplitArray) >= 3; INDEX(SplitArray; 3); BLANK()); EditTagsScreen!Original1 := Tag1;; EditTagsScreen!Editable1 := Tag1;; EditTagsScreen!Original2 := Tag2;; EditTagsScreen!Editable2 := Tag2;; EditTagsScreen!Original3 := Tag3;; EditTagsScreen!Editable3 := Tag3;; EditTagsScreen!TagCount := MAX(1; SIZE(SplitArray)));; GOFORWARD(EditTagsScreen)

(The app supports up to ten tags, but for reasons of brevity we’ll pretend that it only supports three tags when reproducing its formulas. Refer to the sample app in Calcapp Creator to see the full formulas.)

The formula above uses the new LET function (which is covered by this blog post). It is used to assign names to values, which can be used in later calculations in the same formula. The formula would have included lots of repeated TEXTSPLIT invocations without LET, which would have made it slower and harder to read.

it assigns the name SplitArray to an array holding the tags entered by the user. If you’re not familiar with arrays, you can think of them as lists of values.

If the Tags text field contains the text string “First tag, Second tag,” the goal is for SplitArray to contain an array equivalent to this formula:

{ "First tag", "Second tag" }{ "First tag"; "Second tag" }

To achieve this, we use the TEXTSPLIT function, which splits apart text strings and returns arrays of text strings, representing the constituent parts of the original text string.

This formula splits apart the value of the Tags text field using a comma as a delimiter:

TEXTSPLIT(Tags, ",")TEXTSPLIT(Tags; ",")

In other words, all the text that is to the left of the first comma is placed in the first element of the array, the text that is to the right of the first comma, but to the left of the second comma, is placed in the second element, etc.

The TRIM function is invoked on the array returned from TEXTSPLIT, so that space characters that appear before and after the actual tags are removed.

After assigning a value to SplitArray, the formula assigns values to Tag1, Tag2 and Tag3. Here’s the formula fragment used for Tag1:

IF(SIZE(SplitArray) >= 1, INDEX(SplitArray, 1), BLANK())IF(SIZE(SplitArray) >= 1; INDEX(SplitArray; 1); BLANK())

The SIZE function returns the number of elements in an array. In this context, it returns the number of tags entered by the user in the Tags text field. Tag1 is assigned the first element of SplitArray if there is at least one element in it, otherwise it is given a blank value. Tag2 and Tag3 are similar.

Finally, once Tag1, Tag2 and Tag3 have been given their values, it’s time to use these values to populate the next screen, EditTagsScreen.

The next screen has text fields where tags are entered. For reasons that will become clear in the next section, there are two text fields per tag. For the first tag, these are Original1 and Editable1.

The next order of business is to assign values to both Original1 and Editable1, where both values are equal to the Tag1 value we have created:

EditTagsScreen!Original1 := Tag1; EditTagsScreen!Editable1 := Tag1;EditTagsScreen!Original1 := Tag1;; EditTagsScreen!Editable1 := Tag1;;

Again, the second and third tags are handled similarly.

EditTagsScreen has another field we need to concern ourselves with. TagCount contains the number of visible tags. (Users can press buttons to make more or fewer tags appear.)

If the user has entered three tags in the Tags text field, we want three tags to be visible. To do so, we use this formula fragment:

EditTagsScreen!TagCount := MAX(1, SIZE(SplitArray))EditTagsScreen!TagCount := MAX(1; SIZE(SplitArray))

SplitArray contains the tags entered by the user as an array, and the SIZE function is used to return the number of tags.

We wrap the return value from SIZE using the MAX function to ensure that the lowest number that is returned is 1. The reason is that even if users don’t enter anything in the Tags field, we still want a single tag to be editable on the next screen.

Finally, we use the GOFORWARD function to move the user forward to EditTagsScreen:

GOFORWARD(EditTagsScreen)GOFORWARD(EditTagsScreen)

The edit tags screen

The edit tags screen consists of three text fields per tag, which are all part of a single form group. The first tag consists of the text fields Original1, Editable1 and CharactersLeft1.

When users reach EditTagsScreen through PasteTagsScreen, all text fields are visible. The first tag read from the Tags text field of PasteTagsScreen is assigned to both the Original1 and Editable1 text fields.

The Original1 text field is always disabled, so that users can compare the tag they are changing to the original. The Editable1 text field is the one that users modify.

When users reach EditTagsScreen directly from the welcome screen, though, the Original1 field is not visible. To achieve this, we make use of the fact that we have noted which button the user pressed, by storing either existing or new in the Choice hidden field of the welcome screen.

This formula is associated with the Visible property of Original1:

WelcomeScreen!Choice = "existing"WelcomeScreen!Choice = "existing"

That means that when users reach this screen directly from the welcome screen, Editable1 is visible, but Original1 is not. The default label of Editable1 is “Editable”, and we’d like it to simply read “Tag” if Original1 is not visible.

To achieve this, we associate this formula with the Label property of Editable1:

IF(WelcomeScreen!Choice = "existing", "Editable", "Tag")IF(WelcomeScreen!Choice = "existing"; "Editable"; "Tag")

The CharactersLeft1 field holds the number of characters that the user may add to the tag without running afoul of the length limits. Here’s its formula:

MaxCharacters - LEN(Editable1)MaxCharacters - LEN(Editable1)

The MaxCharacters hidden number field holds the value 30. (Feel free to change it to anything you like to suit the online marketplace you’re using, or better yet, enable the user to edit it directly.) The LEN function calculates the length of a text string.

To be extra clear, we modify the label of the form group to hold the same information, along with a warning triangle if there are too many characters in the tag.

Here’s the formula of the Label property of Tag1FormGroup:

LET(CharactersLeft, MaxCharacters - LEN(Editable1), "Tag 1 — " & CharactersLeft & " characters left" & IF(CharactersLeft < 0, " ⚠️"))LET(CharactersLeft; MaxCharacters - LEN(Editable1); "Tag 1 — " & CharactersLeft & " characters left" & IF(CharactersLeft < 0; " ⚠️"))

It uses the LET function to assign a name to the number of remaining characters. It would have been easier to simply refer to the CharactersLeft1 field, but this way, we can remove those redundant fields in the future, without having to change any other formulas.

The actual label is calculated using &, which is used to join text strings together. A warning triangle is only added if the number of remaining characters is a negative number.

The final bit of business we need to attend to for the first tag is whether it should be visible. There is a field, TagCount, which holds the number of tags to show to the user. There is a stepper associated with that field, enabling users to show more or fewer fields.

To make it work, we associate the following formula with the Visible property of Tag1FormGroup:

TagCount >= 1TagCount >= 1

(Technically, the first tag is always visible, because a number lower than 1 is never assigned to TagCount. This formula mostly exists for consistency with the other tags.)

That’s it for the first tag! The fields and formulas that realize the other two tags are similar. Refer to the sample app in Calcapp Creator to see how it all comes together.

We’re nearly done! There is a text field, Tags, that brings all tags together, as a comma-separated text string. Here’s its formula:

LET(TagArray, TRIM({ Editable1, Editable2, Editable3 }), TEXTJOIN(", ", TRUE, TagArray))LET(TagArray; TRIM({ Editable1; Editable2; Editable3 }); TEXTJOIN(", "; TRUE; TagArray))

Again, we use LET to assign names to make the formula easier to read. First, we collect the tags edited by the user as an array. We apply the TRIM function to this array, to ensure that no space characters appear before or after the tags. Finally, we use TEXTJOIN to create a single text string from the array elements, effectively creating a comma-separated text string containing all the tags.

That’s the text string that users should copy to the clipboard, to paste directly into the online marketplace they use.

To make it easy to copy the text string to the clipboard, a clipboard copy button appears directly underneath the text field, whose CopiedText property is set to TagsTags, referencing the text field.

The last item that appears on this screen is a button that allows the user to go back to the previous screen. It also removes the tags entered on PasteTagsScreen.

To achieve this, the button is a formula button, and the following action formula is associated with its OnPress property:

PasteTagsScreen!Tags := ""; GOBACK()PasteTagsScreen!Tags := "";; GOBACK()

Feature: More ways to access our documentation

Fri, 11 Aug 2023 06:00:00 +0000

Our documentation is now integrated into Calcapp Creator. A popup now appears with function parameter information when editing formulas. Documentation is also part of autocomplete.

In 2021, we dramatically improved our documentation. We added thousands of formula examples and wrote enough text to rival The Lord of the Rings trilogy.

The only problem was that the documentation wasn’t very accessible. It wasn’t built into Calcapp Creator in any meaningful way, so you had to go to our separate documentation site to read it. It was easy to forget that it was there, and feel bewildered when a formula error popped up, not knowing where to turn.

Today, we are taking steps to integrate the documentation much more closely with the app designer.

When you write formulas, and specifically when you’re editing a parameter to a function, a helpful popup will appear to let you know what parameter you’re editing and what it does:

The popup displays the name of the function you’re editing, with the current parameter highlighted in purple. (? is displayed after optional parameters and … is displayed if you can pass multiple parameters.)

Below the first line is the first sentence of the documentation for the parameter. Press More » to be brought directly to the full documentation.

If you find that the parameter popup is getting in the way, close it using the ✕ button. If you want it to reappear, switch to a different item in the app designer and then back to the original item.

Autocomplete integration

Autocomplete enables you to quickly find the function or property you’re looking for when editing formulas (among other things). Our documentation has now been integrated into autocomplete, appearing when you select a function or a property.

Here, the TEXTSPLIT function is selected, and the first sentence from its documentation appears to the left:

Like with the parameter popup, you can access the full documentation by pressing More ».

When autocomplete shows properties, the first sentence from the documentation is also displayed:

Formula examples

When the formula field isn’t displaying a formula, it now displays a formula example:

The formula examples are specific to a certain property. Here’s a formula example for the Valid property of a number field:

Some properties, like the Value property of number fields, have multiple formula examples. The example shown is chosen at random.

Categorized properties

Finally, the properties in the left-hand sidebar of our documentation website have now been categorized:

Currently, only colors and various Items properties appear in their own categories. We think it makes the list of properties less cluttered, especially for things like form screens, which have many properties.

Tip: Ask users questions with action formulas

Fri, 11 Aug 2023 05:00:00 +0000

Use action formulas to ask users a series of questions. The answers are then fed into action functions that act on the information given.

Action formulas can be used for a variety of things, including sending messages if a field is valid and displaying an alert box if it isn’t, as well as performing calculations only when a button is pressed.

This tip focuses on asking users questions, using message boxes. What makes this possible are the new action functions PROMPT and PROMPT.NUMBER.

Both action functions are used to ask users for information. PROMPT reads text strings, whereas PROMPT.NUMBER only reads numbers. AWAIT is used to read the entered values.

This formula asks the user to enter the email address where a report should be sent, before sending the report:

AWAIT(PROMPT("Enter email address:"), EMAILREPORT({ App }, Result))AWAIT(PROMPT("Enter email address:"); EMAILREPORT({ App }; Result))

The second parameter to AWAIT has access to a special value named Result, containing the result communicated by the action. For PROMPT the result is the text string entered by the user. For PROMPT.NUMBER, the result is the number entered by the user.

(This is similar to the third parameter to AWAIT, which has access to a special value named Error, with additional information on what went wrong.)

If you like, you can use -> to rename the Result value:

AWAIT(PROMPT("Enter email address:"), EmailAddress -> EMAILREPORT({ App }, EmailAddress))AWAIT(PROMPT("Enter email address:"); EmailAddress -> EMAILREPORT({ App }; EmailAddress))

You can ask the user any number of questions:

AWAIT(PROMPT("First value:"), Value1 -> AWAIT(PROMPT("Second value:"), Value2 -> ALERT("First value: " & Value1 & ", second value: " & Value2 & ".")))AWAIT(PROMPT("First value:"); Value1 -> AWAIT(PROMPT("Second value:"); Value2 -> ALERT("First value: " & Value1 & ", second value: " & Value2 & ".")))

When asking multiple questions with PROMPT, it is necessary to rename the Result value. If we don’t, there is no way to access results other than the last one.

Finally, use CONFIRM to ask users to confirm a choice. This formula asks the user to confirm before resetting all fields of the app, immediately followed by displaying the first screen:

AWAIT(CONFIRM("Start over?"), RESET(App); GOBACK(FirstScreen))AWAIT(CONFIRM("Start over?"); RESET(App);; GOBACK(FirstScreen))

Tip: Perform calculations when a button is pressed

Fri, 11 Aug 2023 04:00:00 +0000

Use a formula button to calculate results when a button is pressed instead of while the user is typing.

Create a new app based on the demo app below ↗

Apps normally perform calculations while the user is typing. Sometimes, though, you don’t want to distract users while they enter data, and only show the results once a button is pressed. Our new release makes this possible.

Here’s the Body Mass Index (BMI) sample app, modified to use a calculation button instead of calculating results right away:

Formula buttons are the tool of choice because they run so-called action formulas. These formulas can do things like send reports, copy values to the clipboard and show a different screen.

Crucially, they can also assign values to fields, using the new := operator. The new operator makes it easy to add calculation buttons, simply by associating formulas that use the := operator with the OnPress properties of formula buttons.

The modified BMI sample app above has removed the formula from the CalculatedBmi hidden field. Instead, its new calculation button uses this action formula:

CalculatedBmi := WeightInKg / HeightInM^2CalculatedBmi := WeightInKg / HeightInM^2

The calculation to the right of the := operator is the exact same formula that was previously associated with the CalculatedBmi hidden field.

This is the only modification you need to make to the BMI sample app to make it calculate its results using a button. There are still other hidden fields — Category and BmiRatio — that are not calculated explicitly by the new button. Instead, these fields rely on the CalculatedBmi field, and are updated when the button assigns a new value to it.

A calculation button can calculate several results, by separating calculations with ;;;.

This action formula explicitly assigns values not only to the CalculatedBmi field, but also to the Category and BmiRatio fields:

CalculatedBmi := WeightInKg / HeightInM^2; Category := IF(CalculatedBmi < 18.5, "underweight", IF(CalculatedBmi < 25, "normal", IF(CalculatedBmi < 30, "overweight", "obese"))); BmiRatio := (MIN(30, MAX(18.5, CalculatedBmi)) - 18.5) / (30 - 18.5)CalculatedBmi := WeightInKg / HeightInM^2;; Category := IF(CalculatedBmi < 18,5; "underweight"; IF(CalculatedBmi < 25; "normal"; IF(CalculatedBmi < 30; "overweight"; "obese")));; BmiRatio := (MIN(30; MAX(18,5; CalculatedBmi)) - 18,5) / (30 - 18,5)

Consider adding line breaks to formulas like the one above to make it easier to read, just after ;;;. To insert a line break, press Alt+Enter.

For details on how the calculations work, refer to the blog post we wrote when announcing the BMI sample app.

Tip: Require a button to be pressed

Fri, 11 Aug 2023 03:00:00 +0000

Prevent users from seeing certain information, or from moving on to the next screen, if a button has not been pressed. This can be achieved through a formula button and a hidden field.

Create a new app based on the demo app below ↗

Sometimes, it is important for users to perform an action before they can proceed. For instance, you may want to require a button to be pressed before showing a calculated value.

Here’s an example app that demonstrates what we’d like to accomplish (try pressing the button):

As you can see, the extra information is only displayed once the button has been pressed.

With our new release, you can achieve this using formula buttons. A formula button runs a so-called action formula, which can take any action you like, including changing the active screen or sending an email back to the office with the collected information.

Of course, regular buttons can do all that too. What makes formula buttons appealing here is that they can perform multiple actions, including assigning values to fields.

In order to keep track of whether the user has pressed the button, we’ll add a hidden switch field, which we’ll name IsFormSubmitted.

Then, we’ll add a formula button, with the following formula associated with its OnPress property:

IsFormSubmitted := TRUE; EMAILREPORT(App, "office@example.com")IsFormSubmitted := TRUE;; EMAILREPORT(App; "office@example.com")

The formula above does two things: it sets IsFormSubmitted to TRUE, and it sends a report through email, containing all fields of the app, using the EMAILREPORT function. That function can do everything a regular email report button can, by setting the appropriate parameters.

Now that the IsFormSubmitted field reflects whether the button has been pressed, we can rely on its value from formulas.

The example app above has the following formula associated with the Visible property of the form group holding the results:

IsFormSubmittedIsFormSubmitted

The form group holding the contact form has the following formula associated with its Visible property:

NOT(IsFormSubmitted)NOT(IsFormSubmitted)

The formula above ensures that the contact form becomes invisible once the button has been pressed.

The OnPress formula above has one potential problem: it immediately sets IsFormSubmitted to TRUE. That means that users get access to the results even if the report is not sent successfully, which may not be what we want.

Here’s another version which waits for the EMAILREPORT function to notify us that the report has been sent successfully:

AWAIT(EMAILREPORT(App, "office@example.com"), IsFormSubmitted := TRUE)AWAIT(EMAILREPORT(App; "office@example.com"); IsFormSubmitted := TRUE)

(Note that even if a report is sent successfully, that does not mean that it will necessarily arrive at its destination, due to factors outside the control of your app.)

If you instead want to prevent users from moving on to the next screen until the button has been pressed, associate this formula with the NextScreenAvailable property of the screen:

IsFormSubmittedIsFormSubmitted

To learn more about how this property is set, refer to the blog post describing our new sample app, which has detailed instructions.

Feature: Easily determine what fields to reset or include in a report

Fri, 11 Aug 2023 02:00:00 +0000

The fields to reset and the fields to include in a report can now be set directly in the inspector, without using a formula.

Prior to our last big release, determining what fields to include in a report or what fields to reset was difficult or impossible. That’s why we introduced the new IncludedFields property of email report buttons, open report buttons, server relay buttons and reset buttons.

(Refer to our blog posts from 2021 for all the details, covering reports and reset buttons.)

The only downside was that you had to use formulas to determine what fields to include. That approach is powerful, because it enables you to determine what fields to include based on information entered in the app and calculated by the app.

Typically, though, what fields to include does not change. Requiring you to use formulas for something as basic as selecting what fields to use arguably isn’t particularly user-friendly, especially for apps that contain few other formulas.

For that reason, our new release introduces a field picker.

To determine what fields to reset using a field picker, select Reset specific fields from the drop-down in the inspector when a reset field is selected:

Fields to reset appears in the inspector, along with a button for selecting the fields:

Click the pen button, and this field picker appears:

The left-hand side of the field picker contains all screens. Press a screen, and the right-hand side of the field picker displays all fields of the selected screen. Make sure that the fields you wish to reset all checked, and then press Save.

Press the button in the upper-left corner to check all fields and the button to uncheck all fields.

The order of the fields isn’t important when resetting fields, or when sending them to a third-party service like Zapier through a server relay button. However, when fields are included in reports, the order matters.

For that reason, the field picker has a second page where you decide what fields to include in a report:

The grayed-out text on the right contains the name of the screen the field is part of, as well as the name of its form group. If there is no grayed-out text, the field is part of the same screen and form group as the field above it.

Drag the handle to change the order of the fields and press the button to go back to the original order. When you’re done, press Save.

Feature: Easily decide the next screen

Fri, 11 Aug 2023 01:00:00 +0000

The screen that follows other screens and navigators can now be set directly in the inspector, without using a formula.

Our last big release made it possible to determine what screen should follow another screen or navigator using a formula.

That feature has many uses, including being able to use IF to show a warning message instead of a regular form screen when the user attempts to move forward if a value doesn’t check out. The feature can also be used to make all list screen navigators go to the same screen.

For full details, refer to the blog post we wrote in 2021.

While it’s often useful to associate a formula with the NextScreen property, it is very common for these formulas to simply state the name of a screen. This is the case when all navigators of a list screen lead to the same screen, for instance.

That makes this feature needlessly hard to use, especially for users who are not comfortable with formulas. (We have customers whose apps only collect data and send it off using a report button. These apps often use no formulas at all.)

For that reason, the inspector now lets you decide the next screen using a drop-down:

By default, the regular next screen is displayed (reachable in Calcapp Creator by pressing the button in the top-right corner of the app). If you press the drop-down, a menu containing all screens in the app is displayed:

We also use the new screen selector for the Target properties of the new go forward and go back buttons:

If you already have formulas associated with the NextScreen property that only state the name of a screen, you can safely remove these formulas and select the screen from the drop-down menu instead.

Feature: Named function parameters

Fri, 11 Aug 2023 00:00:00 +0000

Function parameters can now be named, making formulas easier to read. Named parameters can also make formulas significantly shorter.

Some of Calcapp’s formula functions accept a large number of parameters, which can make formulas hard to read. Our new release includes support for named parameters, allowing you to precede a parameter value with its name, followed by : and a space.

For instance, these two formulas are now equivalent:

FORMATNUMBER(23, 2, 2, FALSE, 1, FALSE, "$")FORMATNUMBER(23; 2; 2; FALSE; 1; FALSE; "$")

FORMATNUMBER(Number: 23, MinimumNumberOfDecimalPlaces: 2, MaximumNumberOfDecimalPlaces: 2, OmitThousandsSeparators: FALSE, MinimumNumberOfIntegerDigits: 1, UseAccountingStyle: FALSE, LeadingUnit: "$")FORMATNUMBER(Number: 23; MinimumNumberOfDecimalPlaces: 2; MaximumNumberOfDecimalPlaces: 2; OmitThousandsSeparators: FALSE; MinimumNumberOfIntegerDigits: 1; UseAccountingStyle: FALSE; LeadingUnit: "$")

All parameters don’t need to be named, but once a parameter has been named, the remaining parameters must also be named.

Named parameters make it possible to provide parameters out-of-order and to omit optional parameters that normally would have been expected to precede a parameter, had it not been named. Omitted optional parameters use default values.

The formula above happens to use default values for all parameters other than Number and LeadingUnit. As such, those optional parameters can be removed from the formula.

To put that into practice, consider this formula:

FORMATNUMBER(23, LeadingUnit: "$")FORMATNUMBER(23; LeadingUnit: "$")

The delightfully-short formula above is fully equivalent to the first two formulas.

We suggest that you use named parameters when they help make a formula easier to read.

We added named parameters to Calcapp to make existing functions like FORMATNUMBER easier to use, but also in consideration of new functions like EMAILREPORT and OPENREPORT. Those functions support a very large number of optional parameters, and named parameters enable you to only provide the parameters you care about, omitting the rest.

To learn the names of the parameters to formula functions, use our formula documentation. Also, all parameter names are part of our new autocomplete feature, making them easy to insert.

Colons in ranges versus colons used for named parameters

: is also used in formulas to create ranges, like Field1:Field4Field1:Field4, which often expands to { Field1, Field2, Field3, Field4 }{ Field1; Field2; Field3; Field4 }. Previously, you could write : with space either to the left or to the right. Now, however, Calcapp will interpret : with a space to the right as an attempt to name a parameter.

As part of our automatic migration process, we have changed all formulas with ambiguous : characters, so that they are always interpreted as being part of ranges.

Our next release and upcoming subscription changes

Fri, 02 Jun 2023 00:00:00 +0000

Our new release is our biggest yet. In this blog post, we explain why it's taken longer than anticipated, and detail some upcoming changes to your subscription.

Back in September, we announced major new features for our next release. However, in December, we shared that we had delayed the release.

Now that it’s June, we owe you an update, and an explanation for the delay.

The good news is that the release is coming along well, and that it will be our biggest one yet. The delay was not due to development issues, but because we have been adding new features. Many of these features have been requested by our customers for years.

(Spoiler alert: Calcapp Creator is finally getting support for undo and redo, an editor for data tables, formulas that perform actions when buttons are pressed, lots of new button types and much-improved formula editing, not to mention lots of quality-of-life improvements. For more, read the blog posts linked to above.)

So, why did we decide to include all these features in a single big release instead of releasing them individually? To answer that, let’s step back and consider what you get with your subscription.

What’s in a subscription?

Calcapp is licenced on a subscription basis, meaning that you pay us a monthly or annual fee to get access. Here’s what you’re getting for your money:

Reliable servers. Your users should have unimpeded access to your apps, and you should be able to update them with no downtime. It’s a rare week when we don’t achieve 100% uptime.
Timely bug fixes. We constantly fix bugs to ensure a smooth experience. In 2020, we had to rewrite our support for offline apps due to changes in web browser technology. Our customers didn’t notice the difference, and that’s how it should be.
Support. We offer assistance, troubleshooting and guidance as part of your subscription. Need help adapting or troubleshooting your app? Just write us an email, or open the chat window.
New features. We always strive to improve Calcapp with new features that enhance your experience and make possible new kinds of apps.

Upcoming changes to our subscription plans

Our new release will introduce higher-priced subscription plans. If you don’t explicitly upgrade your apps to the new plans, they will remain on the original plans, at the original price. That means that you won’t see your costs go up unless you change to one of the new plans.

We introduced paid plans over four years ago and we have never raised our prices since then. Once our next release is complete, Calcapp will be a significantly better product than it was in 2019, and it will continue to improve. We offer features not found elsewhere, including the best formula engine in the business, yet remain more affordable than the competition. We think we can justify more expensive plans on the basis of features alone.

Also, our operational costs have gone up over the past year, and a revenue boost would be welcome. We understand that many of our customers are in the same boat, though, and we’d like not to add to any financial woes you may be experiencing.

That’s why it’s important to us that if you make no changes to your subscription, your prices won’t go up. It’s our way of saying “thank you” to our existing customers, who have enabled us to work full-time on our favorite project.

Some of the new features we plan to deliver will be exclusive to our new plans, meaning you’ll need to upgrade in order to access them.

At the same time, we want to ensure that you continue to receive significant value from your subscription, even if you choose not to upgrade. As noted above, one of the pillars of our subscriptions is getting access to new features for as long as you subscribe, and we don’t want that to change, no matter if you upgrade to a new plan or not.

That brings us to why we decided to put so many new features in our upcoming release. The reason is that we want to deliver new features not only for customers who choose to upgrade, but also to customers who elect not to. And that requires a big release.

You won’t be able to move your apps to our existing subscription plans once our new release is out. If you want to lock in the lower prices, be sure to make all subscription changes as soon as possible.

Beta testers needed

When we started charging for Calcapp in 2019, it had been in beta since early 2016. That long beta period helped us deliver a rock-solid product.

Considering the ambitious nature of our new release, we believe a new beta program is necessary to ensure it meets our standards. Do you want early access to the new release, to help us identify bugs before we ship? If so, please get in touch with us!

Tip: Easily copy and paste fields between apps

Wed, 12 Apr 2023 00:00:00 +0000

When copying and pasting fields and screens from one app to another, it really helps if both are displayed side-by-side. This tip explores how to achive this.

With Calcapp Creator, you can copy and paste not just individual fields, but also entire screens, including all the screens that follow them. That means that it’s easy to copy parts of an app, or even the entire app, to another app.

However, it may not be apparent that you don’t need to close the app you’re copying data from and then open the app you want to copy the data to. In fact, you can keep both apps open at the same time, which saves a lot of time.

You can do this by opening Calcapp Creator in separate tabs in your web browser, but our favorite way of doing this is to have two apps open in two separate windows, displayed side-by-side:

(The one thing you can’t do with this feature is to copy and paste fields and screens from one screen of the app to another screen of the same app.)

To get two windows to appear side-by-side, you can either line them up manually, or use a feature provided by your operating system, if available. Windows 10 and Windows 11, for instance, support snapping your windows to achieve this effect, and macOS supports Split View.

Tip: Decide which image to show with a formula

Sun, 05 Feb 2023 00:00:00 +0000

Conveying a calculated result by showing a specific image in your app can help improve its usability. This concise tip explores this simple technique.

Create a new app based on the demo app below ↗

Using a formula to present a result, in the form of a number field or a text field, is straight-forward. What if you instead want to convey a result by showing a specific image? Luckily, deciding which image to show using a formula is not only possible, but easy to do.

Imagine an app intended for warehouse staff, who need to retrieve an item, select an appropriate package for it and then make sure that it reaches its intended destination. An app is perfect here — imagine a staff member who enters the characteristics of the item, including its dimensions, into an app and is shown visually what packaging to use.

Here’s an app that uses a simple text drop-down field to determine what image to show:

Every image is part of a separate text box (which can include more information, such as an image caption). The app above associates separate formulas with the Visible properties of the three text boxes.

There is also a text drop-down field, named ImageSelector, which determines which image is shown. It contains three items, which you need to reference from the formulas.

Here’s the first Visible formula, which determines if the first text box should be shown:

ImageSelector = "Mountain"ImageSelector = "Mountain"

Use similar formulas for the other images. The text on the right-hand side of = must match the text of the text drop-down field.

To add a text box, press Add text in the main designer and then add an image to it. To edit a Visible formula, press the button with a gray fx symbol next to Visible in the inspector.

Our next release has been delayed

Wed, 21 Dec 2022 00:00:00 +0000

Our next release has been slightly delayed, because we are adding new features to it. Two of those features are announced in this post, including a better formula editing experience and an easy way to check multiple items in Calcapp Creator.

In September, we announced a slew of new features for our upcoming release and noted that we expected to release it “in the coming months.”

However, in close consultation with our customers, we have decided to incorporate a fair number of additional features into our next release. The good news is that it will be our biggest release ever, with many new features that enable new types of apps to be built, along with a host of improvements to the app authoring experience. The bad news is that you will need to wait a while longer before you get access to it.

In addition to the features we previously teased, these new features are also slated to be part of our next release:

Intelligent formula completion

In November last year, we dramatically improved our formula documentation. It contains thousands of formula examples, which you can copy and paste into the formula field in Calcapp Creator.

Currently, the documentation is a part of our main website, and you can’t gain access to it from inside of the app designer. Moreover, when you type formulas, there is no help or guidance to be had. While we’ve worked hard to make the error messages presented to you as clear as possible, there is no help to be had while typing formulas in Calcapp Creator itself.

Spreadsheets were much the same way in years past, but have recently become more helpful. (Microsoft calls their implementation in Excel AutoComplete and Google Sheets offers a similar feature.) You get helpful suggestions when typing formulas, and snippets of documentation appear when you supply functions with their parameters. Crucially, you are provided with the name of the current function parameter, meaning that memorizing the parameter order is a thing of the past.

Calcapp will gain a similar feature set in our next release. When you type, a box will appear allowing you to easily insert function names, parameter names, field names and more:

If you type the name of a screen (or select it from the box) followed by !, you’ll be given the opportunity to select which of its fields to reference:

If you type the name of a screen, a field or another item, followed by .,, you get to select a property to reference:

Finally, if you edit a parameter to a function, a popup appears showing exactly which parameter you’re editing, along with a snippet from the documentation and a link to the full text:

The formula editing experience has been upgraded in other ways as well, including bracket matching (when the cursor is by a parenthesis or an array brace, the corresponding parenthesis or array brace “on the other side” is highlighted), the ability to insert line breaks and more.

Selecting multiple items in Calcapp Creator

When you’re creating an app, checking multiple fields or other items is often the best way to quickly make changes. You can remove multiple items at once, and edit properties of multiple items at once. For instance, if you check ten number fields, you can make them all enabled or disabled, without having to make these changes individually.

In form screens, fields, buttons and text boxes are part of form groups. When you check a form group, all its constituent items are also checked, and vice versa when you uncheck the form group. We envisioned this as a way to quickly check multiple items.

However, sometimes you need to quickly check multiple items, that just happen to be adjacent, and are not necessarily part of the same form group. Also, sometimes you want to check a form group, without checking its constituent items. (If you remove just a form group and not its items, for instance, its items are merged into the form group above it.)

The standard way of enabling multiple adjacent items to be checked is to press and hold the Shift key while checking items, and this is exactly the workflow that Calcapp Creator will soon support. As some of our Calcapp Creator users are on touch devices, there will also be a button you can toggle to access the new feature:

A preview of the new data editor

One of our most-requested features ever is the ability to easily handle tabular data. Our November release last year added support for the powerful XLOOKUP function, but you still had to use a clunky external app to convert your tabular data for use with your apps (and to this day, you still do).

As noted in September, our new data editor will soon make this process go a lot smoother. We have essentially completed it, so here are four screenshots of it to whet your appetite:

This is shaping up to be our biggest release yet, and we’re working hard to deliver it to you as soon are we’re able.

Tip: Use iteration with REDUCE

Tue, 15 Nov 2022 00:00:00 +0000

Iteration means that a value is calculated by performing a number of steps, where the result of the previous step is fed into the current step. Use REDUCE to implement iteration with Calcapp.

When solving a math problem, there are two broad ways to go about doing it: a direct way, and using iteration.

The simplest possible example is probably multiplying a number by an integer. You can either use multiplication directly (say, 9 * 39 * 3), or you can iteratively add nine together three times (9 + 9 + 99 + 9 + 9). Both methods arrive at the same result, though the direct method is easier and faster.

However, it isn’t always easy, or even possible, to use a direct method, meaning iteration may be your only option. Calcapp’s XIRR function, for instance, uses iteration to calculate its result.

Using iteration in Excel

Iteration is fairly easy to use in a spreadsheet like Microsoft Excel. Let’s say that we have a starting balance of $10,000 and that we gain an unrealistic one percent in interest every day. We wish to calculate what our balance is on every day for the next 28 days.

(For the moment, let’s ignore the fact that there is a straight-forward direct way of calculating the result, using either the FV function or the ^ operator.)

In Excel, we have a starting balance in cell B1:

The formula of cell B2 references the value in cell B1 and multiplies it by 101% (B1 * 101%B1 * 101%). The formula of cell B3, in turn, references the value in cell B2 and multiplies it by 101% (B2 * 101%B2 * 101%).

It continues like that, all the way to day 28. Excel makes it easy to create all these formulas, using its Auto Fill feature.

Using iteration in Calcapp

If we have solved a problem in Excel using iteration, how can we get Calcapp to calculate the same results?

One way would be to add many hidden fields to a form screen, using the exact same type of formulas as used with Excel. While that works for a few hundred iterations, you will find that adding thousands or even tens of thousands of hidden fields to an app makes Calcapp Creator, our app designer, sluggish (though the resulting apps tend to run well). Also, duplicating and subtly changing thousands of formulas — without the benefit of Auto Fill — means a lot of tedious, repetitive work.

A better solution is to use the REDUCE function, which we introduced last year. (Excel gained initial support for REDUCE a few months before Calcapp did, which was too late for us to be influenced by Microsoft’s work. That means that they are slightly different.)

This function reduces a value to a single value using a user-supplied formula. It takes an array as its first parameter and then runs the formula fragment given as its second parameter once for every element of the array.

REDUCE keeps track of the value returned from the second parameter and adds it to its so-called accumulator (which is initially set to the value you provide as the third parameter). The result returned from REDUCE is the value of the accumulator after all elements of the array have been processed.

This formula calculates the sum of all values of the array { 1, 2, 3 }{ 1; 2; 3 }, 6:

REDUCE({ 1, 2, 3 }, Accumulator + Value, 0)REDUCE({ 1; 2; 3 }; Accumulator + Value; 0)

The initial accumulator is set to 0 (the third parameter above). The second parameter, Accumulator + ValueAccumulator + Value, is then invoked with Value set to 1, which causes the second parameter to return 0 + 1 = 10 + 1 = 1. As a result, REDUCE stores 1 as the accumulator before continuing.

REDUCE then invokes the second parameter once more, this time with Accumulator set to 1 and Value set to 2. This time around, the second parameter returns 1 + 2 = 31 + 2 = 3, which again is stored as the accumulator.

Finally, the second parameter is invoked with Accumulator and Value both set to 3, meaning that the second parameter returns 3 + 3 = 63 + 3 = 6, which is also the value returned from REDUCE.

(If you want to learn how to calculate averages, minimum and maximum values and more, refer to our REDUCE documentation.)

We can use the same technique to calculate interest. This formula returns the balance on day 28 — $13,212.91 — provided that the interest is set to one percent:

REDUCE(SEQUENCE(28), Accumulator * 101%, 10000)REDUCE(SEQUENCE(28); Accumulator * 101%; 10000)

The goal is to get REDUCE to run the second parameter 28 times. In order for that to happen, the first parameter must be an array with 28 elements. The SEQUENCE function is used to return such an array. (Only the size of the array is important, not the values of its elements, which are not used here.)

Returning all intermediate values as an array

The formula above and the Excel spreadsheet both return the same number for day 28. However, what if we also need to retain all the intermediate values? The goal is for an array to be returned containing these values (exactly matching the Excel spreadsheet):

{ 10000, 10100, 10201, 10303.01, 10406.04, 10510.10, 10615.20, 10721.35, 10828.57, 10936.85, 11046.22, 11156.68, 11268.25, 11380.93, 11494.74, 11609.69, 11725.79, 11843.04, 11961.47, 12081.09, 12201.90, 12323.92, 12447.16, 12571.63, 12697.35, 12824.32, 12952.56, 13082.09, 13212.91 }{ 10000; 10100; 10201; 10303,01; 10406,04; 10510,10; 10615,20; 10721,35; 10828,57; 10936,85; 11046,22; 11156,68; 11268,25; 11380,93; 11494,74; 11609,69; 11725,79; 11843,04; 11961,47; 12081,09; 12201,90; 12323,92; 12447,16; 12571,63; 12697,35; 12824,32; 12952,56; 13082,09; 13212,91 }

Here’s a version of the formula above that does just that:

REDUCE(SEQUENCE(28), Accumulator | INDEX(Accumulator, Index) * 101%, { 10000 })REDUCE(SEQUENCE(28); Accumulator | INDEX(Accumulator; Index) * 101%; { 10000 })

There’s a lot going on above, so let’s take it one step at a time.

First, the initial accumulator, in the form of the third parameter, is set to { 10000 }{ 10000 } instead of 10000. In other words, it is set to an array containing the single element 10000. This enables REDUCE to return an array of numbers instead of a single number.

When the second parameter accesses the Accumulator value, it is an array, initially containing just 10000. The goal is to add elements to this array at the very end. To achieve this, | is used, which is formally known as the array concatenation operator.

| is similar to &, which joins text strings together. This formula returns “Test”:

"Te" & "st""Te" & "st"

This formula returns { 1, 2, 3, 4 }{ 1; 2; 3; 4 }:

{ 1, 2 } | { 3, 4 }{ 1; 2 } | { 3; 4 }

The part on the right-hand side can also be a single value. This formula returns { 1, 2, 3 }{ 1; 2; 3 }:

{ 1, 2 } | 3{ 1; 2 } | 3

In the REDUCE formula above, | is used to add elements to the array which is ultimately returned. Accumulator is initially set to { 10000 }{ 10000 }, meaning that what | does is that it adds an element that follows the first element, 10000. When the second parameter is run subsequently, every new calculated value is added to the end of the accumulator array.

The final part of the puzzle is how we calculate the next element to add to the array. The first REDUCE formula, introduced at the beginning of this post, multiplied the last value by 101 percent, and this is what we need to do here too.

The Accumulator value accessible to the second parameter, though, no longer represents the running total. Instead, the accumulator is an array of all values calculated so far. What we need is the last element of this array.

In order to retrieve it, we use this formula fragment:

INDEX(Accumulator, Index)INDEX(Accumulator; Index)

The INDEX function returns an element from an array at the given index. INDEX({ 10, 20, 30 }, 2)INDEX({ 10; 20; 30 }; 2), for instance, returns 20.

The Index value available to the second parameter is a special value indicating the position of the array element currently being processed. It happens to be equal to the size of the Accumulator array. As a result, the formula above returns the last element of the array, which is what we want.

The final order of business is to multiply this value by 101 percent, after which REDUCE returns the array containing the balances of all days.

To access the balance of a specific day, use INDEX. Let’s assume that there is a field named DayNumber (possibly with a slider), holding the number of the day the user is interested in. This final formula returns the balance on that particular day:

INDEX(REDUCE(SEQUENCE(28), Accumulator | INDEX(Accumulator, Index) * 101%, { 10000 }), DayNumber)INDEX(REDUCE(SEQUENCE(28); Accumulator | INDEX(Accumulator; Index) * 101%; { 10000 }); DayNumber)

Action formulas and a tabular data editor are coming soon

Sun, 11 Sep 2022 00:00:00 +0000

Calcapp will become significantly better in the coming months. Action formulas will enable buttons to run formulas, and a new data editor will allow you to easily incorporate spreadsheet data into your apps.

When we released our big update to our formula engine in November last year, we promised that more features related to the formula engine were coming. Today, we’d like to announce that we’re nearing the end of our current development cycle, and that these features will be released in the coming months.

Here’s a sneak preview of the new features:

Action formulas

We have teased action formulas since 2020, and they are finally almost ready to ship. At its core, an action formula has access to special functions which perform actions. Our next release will allow you to create special buttons that run these formulas when the button is pressed.

These are some of the things you’ll be able to do with an action formula:

Send a report, but only if the entered data is valid. Otherwise, show the user an alert box.
Ask the user a series of questions, before sending a report incorporating the entered answers.
Create a button that calculates values only when pressed.
Send multiple reports, incorporating different information, to different email addresses.
Open a report on the user’s device, while also sending a message to the team’s internal Slack channel. (Integration with Slack, and other third-party services like Google Sheets, Excel and Salesforce will require a third-party service like Zapier, just like today.)
Reset all fields, but only if the user first consents by pressing a button to that effect in a message box. Then, move the user back to the first screen, and ensure that previously-hidden text boxes are once more visible.

This action formula asks the user for their name and greets them once the name has been entered:

AWAIT(PROMPT("What's your name?"), BANNER("Hi " & Result & "!"))

This action formula sends a report, containing all fields of the app, and shows a banner if the report could not be sent successfully:

AWAIT(EMAILREPORT({ App }, "test@example.com"), OnFailure: BANNER("Could not send report"))

Finally, this action formula asks the user to enter a number, and once the user has done so, the entered number and the entered number divided by two are shown in a banner:

AWAIT(PROMPT.NUMBER("Enter number:"), BANNER("Half of " & Result & " is " & (Result / 2) & "."))

Many more actions

Today, buttons can only email and open reports, reset fields and send data to third-party services like Zapier. Soon, many more actions will be available:

Copy text to the system clipboard.
Show an alert box, which users need to dismiss by pressing a button.
Open an email compose window on the user’s device, with pre-filled fields.
Open a text message (SMS) compose window, again with pre-filled fields.
Dial a phone number.
Open a web page in the user’s web browser.
Move forward to a screen you determine.
Move backward to a previously-visited screen you determine.
Open a map using the user’s installed map app, or on the web.
Print the current screen or save it as a PDF document.

All of the properties of these new buttons are calculated properties, meaning that their values can be determined using formulas.

Also, the existing buttons have also been revamped, so that many more of their properties can be determined using formulas. For instance, you’ll be able to determine if a report is sent as a CSV file or as a PDF document using a formula.

All the new features are also available to action formulas, which support even more features:

Show a banner message, which disappears automatically.
Ask the user for confirmation.
Ask the user to enter a text string or a number, which can then be used to take further action.

Action formulas will also be able to assign any value to any property using the new := operator. Field1.Visible := FALSE will hide Field1.

Named parameters

Some functions accept a large number of parameters, which can make formulas hard to read. Our new release includes support for named parameters, allowing you to precede a parameter value with its name, followed by :.

For instance, these two formulas will be equivalent:

FORMATNUMBER(23, 2, 2, FALSE, 1, FALSE, "$")

FORMATNUMBER(Number: 23, MinimumNumberOfDecimalPlaces: 2, MaximumNumberOfDecimalPlaces: 2, OmitThousandsSeparators: FALSE, MinimumNumberOfIntegerDigits: 1, UseAccountingStyle: FALSE, LeadingUnit: "$")

All parameters don’t need to be named, but once a parameter has been named, the remaining parameters must also be named.

The formula above uses default values for all parameters other than Number and LeadingUnit. As such, those optional parameters can be removed from the formula:

FORMATNUMBER(23, LeadingUnit: "$")

We suggest that you use named parameters when they help make a formula easier to read.

Named parameters were added to Calcapp to make existing functions like FORMATNUMBER easier to use, but also in consideration of new functions like EMAILREPORT and OPENREPORT. Those functions support a very large number of optional parameters, and named parameters will enable you to only provide the parameters you care about, omitting the rest.

The LET function

The new LET function, which is also part of Excel 2021, allows you to name values you use in formulas. That means that you no longer need to repeat calculations that otherwise would have appeared multiple times, making formulas run faster and making them shorter and easier to read.

This formula should be read as “give X the value 2, Y the value 4 plus X, and return Y divided by two”:

LET(X := 2, Y := 4 + X, Y / 2)

By assigning names to values, you can make formulas easier to read. If a formula consists of many moving parts, being able to name values serves as valuable documentation.

This is especially important for apps maintained by multiple people, allowing other members of your organization to more easily understand how your formulas work. Being able to name values has been available to traditional software developers for decades.

LET adds a lot of value to regular formulas, but works especially well with action formulas. If you need to, say, send a report with certain values and reset them afterwards to blank values, doing so without LET invariably leads to formula duplication.

Here’s an attempt without LET:

EMAILREPORT({ Field1, Field3:Field10 }, "test@example.com"); RESET.BLANK({ Field1, Field3:Field10 })

With LET, there is no need to duplicate what fields to send and reset:

LET(Fields := { Field1, Field3:Field10 }, EMAILREPORT(Fields, "test@example.com"); RESET.BLANK(Fields))

Being able to type := to assign values to fields is a Calcapp extension. Excel 2021 requires that you use , or ; instead (depending on your language settings). We think that using := makes formulas easier to read, but you’re also welcome to use , or ; if you’re used to that syntax from Excel.

Named values

Calcapp gained support for hidden fields way back in 2016. They allow you to assign names to calculations and use them from other formulas. This is somewhat similar to LET, but LET allows you to name values that are only accessible from a single formula, whereas hidden fields are accessible to the entire app.

Hidden fields have one major drawback, though: they can only represent numbers, logical values and text strings.

That wasn’t a problem before our new formula engine was introduced last year, because before that time, Calcapp actually only handled numbers, logical values and text strings. Today, formulas can reference many more things, including fields, buttons and — most importantly – arrays.

Simply put, there is currently no way to name an array and make it available to other parts of your app. That means that arrays have to be duplicated left and right in your app, which is especially worrisome for arrays that contain a lot of data (possibly converted from a spreadsheet using our app).

With named values, those issues go away, as a named value can represent anything a formula can return in Calcapp, including arrays. They are, by default, hidden, but you can make them visible to help spot problems in your app (optionally using a formula).

As such, visualizing arrays, as suggested by this tip, will no longer require text fields and the TEXTJOIN function.

An editor for your tabular data

Historically, we have never done a very good job of helping you work with data maintained as tables in a spreadsheet. In 2018, we introduced the CHOOSE function and the Index property of drop-down fields, allowing values to be selected based on what value the user selected from a drop-down field.

That release also introduced a new app, written in Calcapp using advanced new text processing functions introduced just to make that app a reality. The app allows Calcapp authors to convert spreadsheet tables to CHOOSE formulas, one column at a time.

CHOOSE is a poor substitute for true table lookups, though. This issue was finally rectified last year, when our new formula engine introduced support for the new XLOOKUP function (which can do everything that HLOOKUP and VLOOKUP can do). There was also a new app for generating XLOOKUP formulas from spreadsheet tables, requiring Calcapp authors to copy and paste data, one column at a time.

While having support for true table lookups is great, the status quo leaves much to be desired. First, converting tabular data to formulas is time-consuming and dull. Having to repeat the process every time the data needs to be updated makes matters worse.

Second, the tabular data can potentially be large, making apps slow to download and use. If multiple formulas need to look up data, they need to repeat the same table data. That means that when that data needs to be updated, it’s easy to miss a formula, making for inconsistent, buggy apps.

Thankfully, those concerns are soon a thing of the past. Our new release will introduce a data editor, allowing you to copy and paste spreadsheet tables in full to Calcapp Creator. When you need to update said data, you’ll be able to bring up the same data editor and make edits either manually, or by pasting data from your spreadsheet.

The new data editor is powered by named values (see above). Every column causes a new named value to be created (or altered), containing arrays which can be passed directly to functions like XLOOKUP and SUMIFS.

If you like, you can create screens that are not reachable by your users which consist entirely of named values. Every such screen represents a table.

Imagine a screen named Employees, with the following named values (created automatically from data by the data editor): Name and Salary. You’ll be able to find the salary of an employee using this XLOOKUP formula:

XLOOKUP(Name, Employees!Name, Employees!Salary)

Back in 2020, we promised much better support for tabular data in a future Calcapp 4 product. While the new data editor goes some way towards realizing those ambitions, it does not fully do so.

Specifically, tables remain read-only, unable to incorporate changes made in the app. If you want data entered in the app to be reflected in a spreadsheet table, you need to use a third-party product, such as Zapier, with your app, and even then, the app cannot reflect the entered data the next time it is started.

We will soon begin to explore ways of making apps produced with Calcapp truly data-aware.

Minor feature additions

Today, all links opened from an app open in a new window or tab. This is appropriate for stand-alone apps, but not always for apps embedded in an existing website (where you may want links to open in the existing window or tab).

Our new release will make this behavior fully customizable. The selected behavior will, for the time being, apply to all text box links, with no ability to determine the behavior on a per-link basis. However, the new buttons that open web pages will support selecting the behavior on a per-button basis, and the corresponding action function BROWSE will also allow this behavior to be determined at a more granular level.

Finally, our new release will make the new formula documentation we introduced last year far more accessible. Specifically, when you edit the formula of a property in Calcapp Creator, a button will allow you to visit the documentation for that property directly. Also, a link in the inspector will allow you to browse the documentation for the element you’re editing.

We think that this release, with its support for action formulas and an editor for spreadsheet tables, has the potential to be even more important than our release from last year, which was our most ambitious release to date. This release may not be bigger, strictly speaking, but it arguably introduces features that are even more desirable than those we introduced last year.

Look for the new release in the coming months. Be sure to subscribe to our newsletter (bring up the menu with your email address on it in Calcapp Creator and select Account settings…) to be notified when that happens.

Tip: Summarize switch field selections in a single sentence

Thu, 02 Jun 2022 00:00:00 +0000

Can the switch field selections made by a user be summed up in a single text field sentence? Yes, and there are two ways to do it, one using old-style formulas and one using the new formula engine we introduced in November.

Create a new app based on the demo app below ↗

A customer recently got in touch and asked if it was possible to summarize the switch field selections made by a user in a single text field. The answer is yes — and what’s interesting is that there are two ways to do it, one using classic Calcapp formulas, and one fully taking advantage of our new formula engine.

First, let’s consider a sample app. Here, the user is asked to select which weekdays they worked. The results are summarized in a text field:

What’s interesting here are the formulas associated with the “Days worked” text fields. Here’s the old-style formula:

IF(Monday || Tuesday || Wednesday || Thursday || Friday, IF(Monday, "Monday") & IF(Tuesday, IF(Monday, ", ") & "Tuesday") & IF(Wednesday, IF(Monday || Tuesday, ", ") & "Wednesday") & IF(Thursday, IF(Monday || Tuesday || Wednesday, ", ") & "Thursday") & IF(Friday, IF(Monday || Tuesday || Wednesday || Thursday, ", ") & "Friday") & ".", "None.")IF(Monday || Tuesday || Wednesday || Thursday || Friday; IF(Monday; "Monday") & IF(Tuesday; IF(Monday; ", ") & "Tuesday") & IF(Wednesday; IF(Monday || Tuesday; ", ") & "Wednesday") & IF(Thursday; IF(Monday || Tuesday || Wednesday; ", ") & "Thursday") & IF(Friday; IF(Monday || Tuesday || Wednesday || Thursday; ", ") & "Friday") & "."; "None.")

And here’s the formula that takes full advantage of the new formula engine:

IF(OR(Monday:Friday), TEXTJOIN(", ", FALSE, FILTER(Monday:Friday, Monday:Friday = TRUE).Label) & ".", "None.")IF(OR(Monday:Friday); TEXTJOIN(", "; FALSE; FILTER(Monday:Friday; Monday:Friday = TRUE),Label) & "."; "None.")

We’ll go over the formulas in detail soon, but suffice to say that the new formula is not only shorter, but also a lot less repetitive. For employees potentially working seven days a week, we could easily add two new switch fields, Saturday and Sunday, type Monday:SundayMonday:Sunday instead of Monday:FridayMonday:Friday in the formula and be done. With the old-style formula, achieving the same end result would be a lot more work.

Dissecting the old-style formula

First, let’s look at the old-style formula to see why it works. Here it is again:

First, let’s strip away the second parameter to the first IF function:

IF(Monday || Tuesday || Wednesday || Thursday || Friday, …, "None.")IF(Monday || Tuesday || Wednesday || Thursday || Friday; …, "None.")

What this formula does is that it uses the second parameter (here ellipsized as ...) only if the user has selected one or several days. Otherwise, the third parameter is selected and “None.” is used. || is Calcapp’s “logical or” operator, meaning that Monday || Tuesday || Wednesday || Thursday || FridayMonday || Tuesday || Wednesday || Thursday || Friday simply means Monday or Tuesday or Wednesday or Thursday or Friday.

Now, let’s look at that second parameter to IF:

IF(Monday, "Monday") & IF(Tuesday, IF(Monday, ", ") & "Tuesday") & IF(Wednesday, IF(Monday || Tuesday, ", ") & "Wednesday") & IF(Thursday, IF(Monday || Tuesday || Wednesday, ", ") & "Thursday") & IF(Friday, IF(Monday || Tuesday || Wednesday || Thursday, ", ") & "Friday") & "."IF(Monday; "Monday") & IF(Tuesday; IF(Monday; ", ") & "Tuesday") & IF(Wednesday; IF(Monday || Tuesday; ", ") & "Wednesday") & IF(Thursday; IF(Monday || Tuesday || Wednesday; ", ") & "Thursday") & IF(Friday; IF(Monday || Tuesday || Wednesday || Thursday; ", ") & "Friday") & "."

IF(Monday, "Monday")IF(Monday; "Monday") is pretty self-explanatory — if the switch field Monday has been toggled to its “on” position, the text string “Monday” is used. Otherwise, a blank value is used.

& is Calcapp’s concatenation operator, which joins text strings together. That means that "a" & "b""a" & "b" is a convoluted way of writing "ab""ab".

IF(Tuesday, IF(Monday, ", ") & "Tuesday")IF(Tuesday; IF(Monday; ", ") & "Tuesday") requires more of an explanation. What’s IF(Monday, ", ")IF(Monday; ", ") doing there? Simply put, it’s there to make sure that a comma separates “Monday” and “Tuesday”, but only if the user has toggled the Monday switch field to its “on” position.

IF(Wednesday, IF(Monday || Tuesday, ", ") & "Wednesday")IF(Wednesday; IF(Monday || Tuesday; ", ") & "Wednesday") is similar. IF(Monday || Tuesday, ", ")IF(Monday || Tuesday; ", ") adds a leading comma only if the user has selected Monday or Tuesday, that is, only if there is text preceding “Wednesday”. Again, note the use of the “logical or” operator ||.

The remaining parts of the formula follow the same pattern.

Dissecting the new-style formula

The approach illustrated above may work acceptably if we only have five or seven switch fields, but what if we have a hundred?

The new formula engine provides a concise solution that performs identically to the old-style approach. Here it is, again:

First, let’s temporarily remove the second parameter to the first IF function:

IF(OR(Monday:Friday), …, "None.")IF(OR(Monday:Friday); …, "None.")

Like the old-style approach, this formula uses the text string “None.” if the user has toggled none of the switch fields to an “on” position. Otherwise, it uses the ellipsized second parameter.

Essentially, this approach replaces Monday || Tuesday || Wednesday || Thursday || FridayMonday || Tuesday || Wednesday || Thursday || Friday with OR(Monday:Friday)OR(Monday:Friday), which perform identically. The new approach has the benefit of being shorter, and of scaling to an arbitrary number of switch fields (we would just need to replace FridayFriday with the new last field).

How does it work? You may recall from our November introduction that Monday:FridayMonday:Friday is a range, which in this case is a short-hand for expressing the array { Monday, Tuesday, Wednesday, Thursday, Friday }{ Monday; Tuesday; Wednesday; Thursday; Friday }.

An array is a list of values, known as elements. The OR function returns TRUE only if at least a single element is TRUE. Here, it returns TRUE only if the user has toggled one or several switch fields to their “on” positions.

Now, let’s look at the second parameter to the IF function:

TEXTJOIN(", ", FALSE, FILTER(Monday:Friday, Monday:Friday = TRUE).Label) & "."TEXTJOIN(", "; FALSE; FILTER(Monday:Friday; Monday:Friday = TRUE),Label) & "."

FILTER takes the array to filter as its first parameter and a logical array of the same size as its second parameter, which determines which elements of the first array are returned. If an element of the second array is TRUE, the corresponding element of the first array is included in the returned array, otherwise, the element is dropped.

Here, the array to filter is Monday:FridayMonday:Friday — an array of switch fields — and the logical array is Monday:Friday = TRUEMonday:Friday = TRUE. As you might expect, the logical array consists of five elements — one for every weekday — and it is TRUE only where the user has toggled the corresponding switch field to its “on” position. As a result, FILTER returns an array of switch fields that the user has toggled.

Before we move on to TEXTJOIN, there’s one final bit of business to discuss. After FILTER(…)FILTER(…), the eagle-eyed reader may have noticed that .Label,Label has been added:

FILTER(…).LabelFILTER(…),Label

Recall that FILTER returns an array of switch fields. A switch field supports various properties, including Label, which returns the label of the field. As a result, by appending .Label,Label, we effectively transform an array of switch fields to an array of text strings, representing their labels.

TEXTJOIN joins array elements together in a single text string, separating the elements with the delimiter given as the first parameter. For instance, TEXTJOIN("x", FALSE, { "a", "b", "c" })TEXTJOIN("x"; FALSE; { "a"; "b"; "c" }) returns “axbxc”.

Putting it all together, TEXTJOIN takes an array of text strings representing weekdays and produces a single text string, where every weekday is separated by a comma and a space.

Again, the new approach is cleaner, shorter and scales to an arbitrary number of switch fields. The one downside is that you need to have a better understanding of how formulas work — but once you do, you will find that you can supercharge a lot of older formulas, making them more concise, more powerful and easier to maintain.

Tip: Display all US legal holidays for a given year

Mon, 18 Apr 2022 00:00:00 +0000

In this post, we create an app that displays all legal US holidays for a given year. The app adapts a formula created for Microsoft Excel and uses new functions introduced with our new formula engine, like FORMATDATE, FILTER and TEXTJOIN.

Create a new app based on the demo app below ↗

Legal holidays are days established by law that are not considered to be working days. While different countries use different legal holidays, we’ll only consider legal holidays in the United States for this tip.

What if you want to display a list of all legal holidays for a given year? That used to be difficult to do with Calcapp, but with our new formula engine and its support for arrays, this is actually fairly straight-forward.

This tip introduces a simple app where the year is entered in the number field Year and a list of the legal holidays is presented in the text field LegalHolidays. Here’s an embedded version of the app, which you can also run as a stand-alone app:

If you’re familiar with spreadsheets in general, and Microsoft Excel 2021 in particular, Calcapp’s formula language should be very easy to pick up. You are generally able to use Excel resources to learn about solving problems and apply those solutions in Calcapp.

For this problem, that’s exactly what we did. We found an article discussing US public holidays on the website of Extend Office, which lists not only the public holidays, but also formulas for calculating them for a given year.

Some legal holidays fall on particular dates every year, like New Year’s Day (January 1). Other holidays are trickier, like Labor Day, which falls on the first Monday in September.

To calculate the date for Labor Day, we’ll use this formula:

DATE(Year, 9, 1) + CHOOSE(WEEKDAY(DATE(Year, 9, 1)), 1, 0, 6, 5, 4, 3, 2)DATE(Year; 9; 1) + CHOOSE(WEEKDAY(DATE(Year; 9; 1)); 1; 0; 6; 5; 4; 3; 2)

The first part, DATE(Year, 9, 1)DATE(Year; 9; 1), returns September 1 of the year indicated by the Year field. We then add a number of days to that date, calculated by this part of the formula:

CHOOSE(WEEKDAY(DATE(Year, 9, 1)), 1, 0, 6, 5, 4, 3, 2)CHOOSE(WEEKDAY(DATE(Year; 9; 1)); 1; 0; 6; 5; 4; 3; 2)

The WEEKDAY function returns a number corresponding to the day of the week for a given date (in this case, September 1). When no second parameter is given to WEEKDAY, 1 is returned for Sunday, 2 is returned for Monday, and so on.

CHOOSE returns the parameter indicated by its first parameter. CHOOSE(2, "one", "two", "three")CHOOSE(2; "one"; "two"; "three") returns “two”, because the first parameter indicates that of the remaining parameters, the second one should be chosen.

In the formula above, the value returned from WEEKDAY is fed into CHOOSE. If September 1 is a Sunday, 1 is added. Why? Because Labor Day always falls on a Monday. If September 1 is already a Monday, 0 is added, and if September 1 is a Tuesday, 6 is added, so that the coming Monday is calculated.

To calculate an array containing the legal holidays of a certain year, we use this lengthy formula:

{ DATE(Year, 1, 1), DATE(Year, 1, 1) + 14 + CHOOSE(WEEKDAY(DATE(Year, 1, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 2, 1) + 14 + CHOOSE(WEEKDAY(DATE(Year, 2, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 6, 1) - WEEKDAY(DATE(Year, 6, 6)), DATE(Year, 6, 19), DATE(Year, 7, 4), DATE(Year, 9, 1) + CHOOSE(WEEKDAY(DATE(Year, 9, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 10, 1) + 7 + CHOOSE(WEEKDAY(DATE(Year, 10, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 11, 11), DATE(Year, 11, 1) + 21 + CHOOSE(WEEKDAY(DATE(Year, 11, 1)), 4, 3, 2, 1, 0, 6, 5), DATE(Year, 12, 25) }{ DATE(Year; 1; 1); DATE(Year; 1; 1) + 14 + CHOOSE(WEEKDAY(DATE(Year; 1; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 2; 1) + 14 + CHOOSE(WEEKDAY(DATE(Year; 2; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 6; 1) - WEEKDAY(DATE(Year; 6; 6)); DATE(Year; 6; 19); DATE(Year; 7; 4); DATE(Year; 9; 1) + CHOOSE(WEEKDAY(DATE(Year; 9; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 10; 1) + 7 + CHOOSE(WEEKDAY(DATE(Year; 10; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 11; 11); DATE(Year; 11; 1) + 21 + CHOOSE(WEEKDAY(DATE(Year; 11; 1)); 4; 3; 2; 1; 0; 6; 5); DATE(Year; 12; 25) }

This formula has been adapted from the Extend Office article, with Juneteenth added (which was made a federal holiday only last year).

The formula above includes all dates, regardless of whether they fall on a Saturday or a Sunday, though. We can easily filter out days that fall on weekends using FILTER.

There is a version of FILTER that takes an array as its first parameter and a formula fragment as its second parameter, which we’ll use here. The formula fragment has access to the element under consideration under the Element name, and is expected to return TRUE if the element should be kept and FALSE otherwise.

This formula returns the array { 1, 3 }{ 1; 3 }, as only odd elements are kept:

FILTER({ 1, 2, 3 }, ISODD(Element))FILTER({ 1; 2; 3 }; ISODD(Element))

To determine if a date should be kept, we’ll use the WEEKDAY function. When invoked with 2 as its second parameter, 1 is returned for Monday, 2 is returned for Tuesday, 5 is returned for Friday, and so on. That means that we can check the return value to see if it is less than or equal to 5 to filter out dates that fall on a weekend:

FILTER(…, WEEKDAY(Element, 2) <= 5)FILTER(…, WEEKDAY(Element; 2) <= 5)

If we plug in the long array formula fragment with the dates in place of ..., we finally have our formula!

Now, we just need to present it in a text field. First, we’ll use the FORMATDATE function to format all dates of the array as text. When FORMATDATE is invoked with an array, it is invoked once for every array element, with the results collected as an array. This formula does what we need:

FORMATDATE(FILTER(…, WEEKDAY(Element, 2) <= 5), DateFormat.FullDayInWeek)FORMATDATE(FILTER(…, WEEKDAY(Element; 2) <= 5); DateFormat,FullDayInWeek)

Now, instead of an array containing sequential serial numbers, representing dates of legal holidays, we have a text array containing the formatted versions of these dates. In order to present a value in a text field, though, we need a plain text string.

To create said text string, TEXTJOIN is used. It takes an array of text strings and joins all the text strings together in a single text string. Its third parameter is the array to join together and its first parameter is the delimiter, separating the elements.

The delimiter is often set to something like “, “ (which uses a comma to separate array elements), but here, we want each date to appear on its own line. (The text field must be configured to display multiple lines by toggling the Multiple lines property in the inspector when the text field is selected in Calcapp Creator.)

To that end, we use the NEWLINE function in place of the delimiter, which returns a line break:

TEXTJOIN(NEWLINE(), FALSE, FORMATDATE(FILTER(…, WEEKDAY(Element, 2) <= 5), DateFormat.FullDayInWeek))TEXTJOIN(NEWLINE(); FALSE; FORMATDATE(FILTER(…, WEEKDAY(Element; 2) <= 5); DateFormat,FullDayInWeek))

The last step is to plug in the long array in place of .... Here is the complete formula, which returns a text string representing all legal US holidays of a certain year:

TEXTJOIN(NEWLINE(), FALSE, FORMATDATE(FILTER({ DATE(Year, 1, 1), DATE(Year, 1, 1) + 14 + CHOOSE(WEEKDAY(DATE(Year, 1, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 2, 1) + 14 + CHOOSE(WEEKDAY(DATE(Year, 2, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 6, 1) - WEEKDAY(DATE(Year, 6, 6)), DATE(Year, 6, 19), DATE(Year, 7, 4), DATE(Year, 9, 1) + CHOOSE(WEEKDAY(DATE(Year, 9, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 10, 1) + 7 + CHOOSE(WEEKDAY(DATE(Year, 10, 1)), 1, 0, 6, 5, 4, 3, 2), DATE(Year, 11, 11), DATE(Year, 11, 1) + 21 + CHOOSE(WEEKDAY(DATE(Year, 11, 1)), 4, 3, 2, 1, 0, 6, 5), DATE(Year, 12, 25) }, WEEKDAY(Element, 2) <= 5), DateFormat.FullDayInWeek))TEXTJOIN(NEWLINE(); FALSE; FORMATDATE(FILTER({ DATE(Year; 1; 1); DATE(Year; 1; 1) + 14 + CHOOSE(WEEKDAY(DATE(Year; 1; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 2; 1) + 14 + CHOOSE(WEEKDAY(DATE(Year; 2; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 6; 1) - WEEKDAY(DATE(Year; 6; 6)); DATE(Year; 6; 19); DATE(Year; 7; 4); DATE(Year; 9; 1) + CHOOSE(WEEKDAY(DATE(Year; 9; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 10; 1) + 7 + CHOOSE(WEEKDAY(DATE(Year; 10; 1)); 1; 0; 6; 5; 4; 3; 2); DATE(Year; 11; 11); DATE(Year; 11; 1) + 21 + CHOOSE(WEEKDAY(DATE(Year; 11; 1)); 4; 3; 2; 1; 0; 6; 5); DATE(Year; 12; 25) }; WEEKDAY(Element; 2) <= 5); DateFormat,FullDayInWeek))

Tip: Custom formatting of dates

Tue, 01 Mar 2022 00:00:00 +0000

When formatting dates, you can choose from five pre-defined date formats. What if you want a custom date format? For output fields, you can use text fields and formulas to achieve this. This post explores two formula approaches.

Handling dates and times has been a key part of many apps built with Calcapp, ever since we introduced support way back in 2016. Our November release improved upon this support by making it possible to format dates and times using formulas with the new functions FORMATDATE and FORMATTIME.

However, one thing has remained the same: you are still limited to the date and time formats we support. Here they are, along with the names you need to use with FORMATDATE:

Date format	US English example
`DateFormat.Month`	Nov 1981
`DateFormat.Numeric` (default)	14/11/81
`DateFormat.Abbreviated`	Nov 14, 1981
`DateFormat.Full`	November 14, 1981
`DateFormat.FullDayInWeek`	Saturday, November 14, 1981

What if you want something a bit more custom, though? As things stand, the only way to get the weekday to be part of the formatted value is to use DateFormat.FullDayInWeek, but then you also need to accept that the month is written out in full, which may not be desirable.

You can customize how dates are formatted using formulas. This currently only works with output fields (that is, fields which display calculated values, as opposed to input fields that allow the user to enter data).

(If you’d like to format the values displayed in input fields using a formula, we’d love to make that happen. Write us and let us know, so we can prioritize this work!)

Using CHOOSE, WEEKDAY, MONTH, DAY and YEAR to format a date

We can use a formula to fully replicate what DateFormat.FullDayInWeek does. Recall that this date format produces the following text:

Saturday, November 14, 1981

Now, we are looking to produce this text instead:

Saturday, Nov 14, 1981

Let’s assume that the date to format is contained in a date and time field named Date. Let’s also assume that we add a new text field, which will hold a formatted version of the Date value, using full weekdays and abbreviated month names.

Here’s the full formula, which we’ll dissect in a bit:

CHOOSE(WEEKDAY(Date), "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday") & ", " & CHOOSE(MONTH(Date), "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec") & " " & DAY(Date) & ", " & YEAR(Date)CHOOSE(WEEKDAY(Date); "Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday") & ", " & CHOOSE(MONTH(Date); "Jan"; "Feb"; "Mar"; "Apr"; "May"; "Jun"; "Jul"; "Aug"; "Sep"; "Oct"; "Nov"; "Dec") & " " & DAY(Date) & ", " & YEAR(Date)

The formula above makes heavy use of the & operator, which joins text strings together. "ab" & "cd""ab" & "cd" returns “abcd”.

First off, let’s look at how deriving the weekday name from the Date value works. Here’s that part of the formula:

CHOOSE(WEEKDAY(Date), "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday")CHOOSE(WEEKDAY(Date); "Sunday"; "Monday"; "Tuesday"; "Wednesday"; "Thursday"; "Friday"; "Saturday")

WEEKDAY returns a number corresponding to the day of the week. If a second parameter is not given, 1 is returned for Sunday, 2 is returned for Monday, and so on.

That’s perfect for the CHOOSE function, which returns the second parameter if the first parameter is set to 1, the third parameter if the second parameter is set to 2, etc. CHOOSE(2, "one", "two", "three")CHOOSE(2; "one"; "two"; "three") returns “two”. By plugging in the return value from WEEKDAY into CHOOSE, we get the behavior we’re looking for.

Next, we join together the weekday with “, “, followed by the abbreviated month name, using MONTH to extract a number corresponding with the month of the Date field, starting with 1. We then join together that text string with “ “ and DAY(Date)DAY(Date), which creates a space between the abbreviated month name and the day of the month.

Finally, we join together the text string with “, “ and YEAR(Date)YEAR(Date), which adds the year after a comma and a space. Now we’re done!

Using regular expressions to format a date (advanced)

The solution above successfully formats a date using full weekdays and abbreviated month names. To do so, however, it essentially reinvents what the FORMATDATE function does. What if we could take the output generated by that function and alter the month name, removing everything that follows its first three letters (so that “January” becomes “Jan”)?

We can, and there are multiple ways to do it. You could use the text processing functions Calcapp has inherited from spreadsheets, functions like FIND, MID, LEFT and RIGHT.

However, regular expressions are much more powerful than the old text processing functions, though there is a learning curve. When Calcapp gained support for regular expressions in 2018, we wrote a lengthy introduction, which we invite you to read.

Feel free to ignore this section if you like – using CHOOSE, WEEKDAY, MONTH, DAY and YEAR to format a date works perfectly well, and is much easier to understand.

REGEXREPLACE matches a text string against a regular expression, where the text string is given as the first parameter and the regular expression is given as the second parameter. The replacement text string is given as the third parameter.

This formula removes all numbers from a text string, returning “abc”:

REGEXREPLACE("a1b2c3", "\d", "", TRUE)REGEXREPLACE("a1b2c3"; "\d"; ""; TRUE)

The second parameter, \d is the regular expression, which matches a single number (d stands for digit). The third parameter ensures that all those numbers are replaced with the empty text string, effectively meaning that they are removed. The fourth parameter, TRUE, ensures that all numbers are replaced, not just the first one.

Here’s a formula which takes the FORMATDATE output and shortens the month name:

REGEXREPLACE(FORMATDATE(Date, DateFormat.FullDayInWeek), "^([^,]+, \w\w\w)[^\d](.)$", "$1 $2")REGEXREPLACE(FORMATDATE(Date; DateFormat,FullDayInWeek); "^([^,]+, \w\w\w)[^\d](.)$"; "$1 $2")

Refer to our full primer on regular expressions to truly understand the regular expression above.

The first part, ^([^,]+, \w\w\w), uses a capturing group to capture the weekday and the first three letters of the month name. ^ matches the beginning of the text string. The parentheses capture the entire contents as the first capturing group. [^,]+ means “capture everything up until the first comma.” , \w\w\w means “capture the first three letters that follow a comma and a space.”

The final part, [^\d]*(.*)$ captures the rest of the text string. [^\d]* means “capture everything up until the first number” (representing the day). It is not part of a capturing group (there are no parentheses) – as we shall soon see, that essentially means that we throw it away. Finally, (.*)$ means “capture everything that remains, up until the end”. There are parentheses, meaning that “everything that remains” is captured as the second capturing group.

The third parameter to REGEXREPLACE is set to $1 $2. This means that the resulting text string is composed of the contents of the first capturing group, represented by $1 (containing the weekday and the first three letters of the month name), followed by a space, followed by the contents of the second capturing group, represented by $2 (containing the day and the year).

Depending on your perspective, this may seem like a much more difficult way to format the date than simply joining a few text strings together. Use whichever method you prefer.

Tip: Add separators to reports

Mon, 10 Jan 2022 00:00:00 +0000

Add separators between fields — essentially, line breaks — anywhere you like in your reports by following the steps of this tip.

Our big release in November improved many long-standing requests related to reports. It enabled you to send formula-driven emails, use a formula to determine what fields to include in a report and added many new options for reports using comma-separated (CSV) or tab-separated (TSV) values.

However, a fair number of long-standing feature requests have not yet been addressed. The biggest is likely the PDF report designer we have promised for an embarrassingly long time now. While we have nothing new to announce regarding the PDF report designer, there are compelling third-party alternatives that can easily be used with Calcapp, as detailed by this blog post from 2020.

Another feature our customers have requested for years concerns the ability to add separators to reports, that is, line breaks between groups of fields. PDF reports automatically separate different screens (optionally with headings for each and every screen), but sometimes it’s desirable to have line breaks without having to create a new screen.

We recently made some minor changes which enable this exact functionality, meaning that you can now introduce line breaks wherever you like by following these steps:

Add a new text field. Select abc from the inspector after you have pressed Add field (which creates a number field).
Make the field invisible by toggling the Visible property in the inspector, so that the separator does not show up in the user interface of your app.
Assign the field a label equal to a single space character. If the field is the second separator of the screen, use two space characters, and so on. This is important, as you otherwise get unsightly “ (2)”, “ (3)” labels in your report (which normally serve to differentiate fields with identical labels, but here they need to be suppressed by using ostensibly different labels).
Assign the formula " "" " to the separator fields.
Add a new report button, by pressing Add button and then selecting something like Open report from the drop-down in the inspector that initially reads Reset field. You need to include invisible fields by toggling the Include hidden fields property, so that the separator fields are included.

The steps above have the effect of adding fields with labels and values which are only made up of invisible space characters. This isn’t particularly elegant, but it works.

We are aware that many customers expect reports to include everything in a screen, including text boxes, buttons and field group separators (which would have made this tip superfluous). This is something that we will realize in a future release.

For now, though, this tip enables you to add field separators to reports anywhere you like.

Release: Our November, 2021 update is here

Fri, 12 Nov 2021 22:00:00 +0000

Our biggest release ever is here, celebrated with 23 blog posts. Use 100+ new functions, including XLOOKUP and SUMIFS. Determine the next screen and what fields are included in a report using formulas. Several thousand formula examples help you get started with all the new features.

What's new?

A new formula engine — and a note from our co-founder. Two years in the making, our new formula engine is finally ready. It powers more than 100 new functions, operators and properties, making more types of apps possible than ever before. Learn more »
100+ new functions. We now support 102 new functions, including Excel 2021 marvels like XLOOKUP and FILTER, spreadsheet classics like SUMIF, COUNTIFS, INDEX and MATCH as well as the power user favorites MAP and REDUCE. Learn more »
Arrays and ranges. Calcapp now supports arrays and ranges. Arrays are collections of values which enable many of our new functions and properties. A range is a short-hand for constructing arrays with many elements. (Need to sum 100 fields? Easy!) Learn more »
Look up values with XLOOKUP. Excel 2021's XLOOKUP function is now fully supported. It does everything VLOOKUP and HLOOKUP do and more. Use an app to convert table data to XLOOKUP formulas. Learn more »
Use SUMIF, SUMIFS and others like them. AVERAGEIF, COUNTIF, MINIFS, MAXIFS, PRODUCTIF, SUMIF and variants are now supported. Use our formula fragment extension for complex conditions. Learn more »
Send formula-driven emails. Fully determine the bodies of emails you send using formulas. You can also use formulas to set text that appears before or after field values in reports. Learn more »
Use a formula to determine what fields to include in a report. Gain full flexibility using our new functions. Want to only include fields with values greater than five? Just use FILTER. Also, hidden fields can now be left out of reports. Learn more »
Decide the next screen with a formula. Skip straight to the results if the entered data checks out, or collect supplemental information otherwise. Stop copying and pasting screens — now you can make many screens send the user to the same destination. Learn more »
Decimal commas in formulas. Formulas written with decimal commas are now fully supported. Set your preference the next time you open Calcapp Creator. Learn more »
Dramatically improved documentation for formulas and properties. What's got half a million words? The Lord of the Rings trilogy. And our new formula and property documentation, which is now on the web. Thousands of formula examples make getting started with all the new features easy. Learn more »
IF without all the parentheses, SWITCH and IFBLANK. Use the IF function with multiple conditions without having to use more than two parentheses. Use SWITCH when you need to test the same value for equality against other values. Learn more »
More options for CSV and TSV files. CSV files produced by report buttons can now be customized to make them compatible with more apps and services. Change the decimal separator and the delimiter separating values and lay out values vertically instead of horizontally. Learn more »
More customizable reset buttons. Use a formula to determine what fields are reset by a reset button. These buttons can now assign blank values to fields. Learn more »
Download and start large apps faster. Many under-the-hood improvements make large apps download and start faster and consume less space when stored for offline use. Learn more »
Include array elements conditionally with IF. Use IF to determine if an element should be part of an array. Learn more »
Join arrays together with |. Use the new operator | to join together arrays with other arrays and values. Learn more »
No more typos when referencing colors. Colors can now be referenced with no risk of typos, thanks to "enums." XLOOKUP, XMATCH and FORMATDATE also support enums, which help warn you of errors early. Learn more »

Tips for getting the most out of Calcapp

Debug arrays by inspecting their elements. If a function isn't returning the value you expect, you need to look at the parameters it receives by creating new temporary fields visualizing the parameters. To do so with an array, you need to convert it to a text string first using the TEXTJOIN function. Learn more »
Avoid gotchas when adding text boxes and buttons in the middle of a range. Ranges are an effective means of creating arrays containing many elements. However, it is easy to lose track of what elements they contain, which can have surprising results. This tip explores this topic in depth. Learn more »

More news

Panels are now known as screens — and other name changes. Panels have been renamed to screens to better reflect the expectations of app authors. There are other name changes, which better reflect how Calcapp is used today and how we expect it to be used tomorrow. Learn more »
Backward compatibility and our new formula engine. We work hard to ensure that your apps continue working, even as we add features to Calcapp. With our new formula engine, we have made some minor changes, but they should not affect your existing apps. Learn more »
Sample app: Convert spreadsheet tables to XLOOKUP formulas. Our latest sample app converts spreadsheet column data to formulas that use the XLOOKUP function. This post explains in detail how it was built. Learn more »

Feature: A new formula engine — and a note from our co-founder

Fri, 12 Nov 2021 21:00:00 +0000

After two years, our new formula engine is finally ready. It powers more than 100 new functions, operators and properties, making more types of apps possible than ever before.

Our new formula engine adds new features that allow us to support more than 100 new functions and enables us to make the existing functions more flexible. The revamped IF function accepts multiple conditions without any extra parentheses and the new SWITCH function enables concise conditions to be expressed. Learn more »

Arrays enable a large number of new functions, like popular conditional functions like SUMIF and SUMIFS. These two functions make it easy to return a sum consisting of only numbers that match one or more conditions. Other conditional functions return averages, products and counts. Learn more »

We also have support for the full set of new “dynamic array” functions introduced with Microsoft Excel 2021, including FILTER, SORT, SORTBY and SEQUENCE. The jewel in the crown is XLOOKUP (along with MATCH and INDEX), which enables true look-ups. As data still needs to be part of formulas, we have written an app — in Calcapp — that does the conversion for you. Learn more »

There are a lot of other great new additions to the function library (whose documentation has been dramatically expanded). There are many new math, financial and statistical functions — most enabled by the engine’s array support — convenient new text functions like ISEMAIL and TEXTSPLIT, and advanced new functions like MAP and REDUCE, which borrow from the playbook of traditional programming. Read the entire list »

There are also new properties which would not have been possible without the new engine. NextScreen may be used to determine what screen the user is brought to using a formula. You can make apps dramatically smaller — and therefore easier to maintain — by having multiple screens and list screen navigators bring the user to the same screen. Learn more »

It is now finally possible to determine what fields are included in a report using a formula. There are also countless new report features, including much-improved support for exporting data to comma-separated values. Learn more »

Speaking of reports, you can now determine the entire body of an email solely using formulas, complete with separate paragraphs. You can also add text before or after field values — or omit them altogether. Learn more »

This list just scratches the surface of this release. Be sure to read the complete release notes to learn more!

A note from our co-founder

I never thought it would take two years, but it did. Completing a new formula engine for Calcapp has been the largest, most ambitious undertaking we have attempted in the history of the project.

The new engine brings tangible benefits to Calcapp today. You get more than 100 new functions and useful new properties greatly expanding what you can do with the platform — as well as much-improved documentation — which we discuss above.

From a cost-benefit perspective, though, spending two years on a new formula engine may seem like a strange choice. In the short term, we could probably have gotten more bang for our buck by focusing on other worthy areas.

After all, there is no shortage of features we could work on. Native apps. More customizable user interfaces. Data tables – obviating the need to shoe-horn data into formulas. App store support. If you were mostly fine with our previous formula support, it is understandable if you are puzzled by this decision to prioritize the formula engine above so many other useful additions.

The short answer is that we chose to work on the formula engine because we felt that it was in the best long-term interests of the project. We have a vision of where we want to take Calcapp in the future, and many of these features depend on the new abilities of the formula engine. Without it, our vision could not be fully realized.

Also, I’m convinced that an app builder such as Calcapp must have a robust formula language at its core in order to be useful. There are few other vendors in this space who share this conviction or who are prepared to make the same kind of investment that we are. I believe that this focus sets us apart from the competition and that it will pay dividends well into the future.

That future isn’t far-off. Soon, we will leverage the new engine to bring you action formulas. When a button is pressed, you will be able to write a formula that determines what actions to take, using brand-new action functions. This feature will make your apps far more dynamic and better able to react to the data entered by your users, and it wouldn’t have been possible without the new formula engine.

On another note, it has almost been six years since we released the first Calcapp beta and two and a half years since we ended the beta and introduced paid plans.

Calcapp did not find its audience immediately. It took several years’ worth of effort for us to deliver a compelling product, one that people were willing to stick around for.

Once we had that product, and once we took the plunge and commercialized Calcapp, we were rewarded with customers who stick around for the long term. It is thanks to that financial stability that we can devote several years of effort to working on an ambitious project such as the formula engine.

If you’re a customer, thank you. Your support enables us to keep working on realizing that vision I formulated years ago, when my father (and co-founder) needed a life-saving app for his hospital department and there were no real options for him in the market.

He was fortunate to have a programmer for a son who could realize his vision. Not everyone is so lucky, but now that Calcapp and the larger no-code ecosystem exist, you don’t need to be.

David Polberger
Co-founder, Calcapp

Feature: 100+ new functions

Fri, 12 Nov 2021 20:00:00 +0000

We now support 102 new functions, including Excel 2021 marvels like XLOOKUP and FILTER, spreadsheet classics like SUMIF, COUNTIFS, INDEX and MATCH as well as the power user favorites MAP and REDUCE.

Thanks to our new formula engine, we have been able to add support for 102 new functions and a few new operators to this release, for a grand total of 387 functions.

Many of the functions are new — either Calcapp exclusives, like ISEMAIL, or transplants from Microsoft Excel 2021, like XLOOKUP — while many others are classic functions found in most spreadsheets.

Calcapp went from supporting 20 functions to 244 functions overnight in 2016. At that time, we didn’t have support for arrays. As a result, we couldn’t add functions like SUMIF and FVSCHEDULE, as there was no way to express these functions without arrays. We’re thrilled to finally be able to bring you these classic functions.

We haven’t been content to just bring Calcapp up to speed with the older versions of Excel, we have added support for all eight dynamic array functions introduced with Excel 2021 (and Microsoft 365 before that): FILTER, RANDARRAY, SEQUENCE, SORT, SORTBY, UNIQUE, XLOOKUP and XMATCH.

Many of the new functions come with Calcapp extensions. FILTER, XLOOKUP and all conditional functions (SUMIF, SUMIFS and others) all use some kind of a condition parameter to determine which element or elements to select. Traditionally, this is done by providing either a single value the function should look for, a text string specifying a condition or a logical array determining which elements to keep.

Calcapp gives you a choice of doing it the traditional way, or using formula fragments, which makes functions like SUMIF considerably more powerful. A formula fragment has access to the full power of the formula language (including the ability to reference values everywhere in the app and the ability to invoke arbitrary functions). Check out the links above to learn more.

(If you have been exposed to a traditional programming language like JavaScript, you may be interested to know that a formula fragment is our name for an anonymous function, or a lambda. We think that our name is easier to understand for people used to spreadsheets.)

Last but not least, all functions and operators now come with detailed documentation, with thousands of examples tailored for Calcapp and app creation.

New date and time functions

ISOWEEKNUM	Returns the ISO week number of the given date, from 1 through 54.
NETWORKDAYS	Returns the number of working days between two dates.
WORKDAY.INTL	Returns a date advanced or set back a number of working days.

New financial functions

FVSCHEDULE	Returns the future value of a lump sum, with changing future interest rates.
IRR	Calculates the internal rate of return of a series of cash flows.
MIRR	Returns the modified internal rate of return of a series of cash flows.
XIRR	Calculates the internal rate of return of a series of irregular cash flows.
XNPV	Returns the net present value of an investment with irregular cash payments.

New information functions

SIZE	Returns the size of the given array, that is, the number of elements that are contained in the array.
TOCOLOR	Returns the given value converted to a color.
TYPE	Returns the type of the given value.

New logical functions

IFBLANK	Returns a value unchanged if it is not blank and a different value otherwise.
IFS	Returns one of the given values based on logical conditions.
SWITCH	Tests a given parameter for equality against a list of parameters and returns a parameter associated with the parameter which matched the first parameter.

New lookup functions

FILTER	Filters the first array using the second parameter.
INDEX	Returns the array element at the given position.
MAP	Applies the transformation specified by the given formula fragment to all array elements and returns the resulting array.
MATCH	Returns the position that a given value appears at in the given lookup array, or returns an #N/A error if the value cannot be found.
REDUCE	Reduces an array of values to a single value using a user-supplied formula.
REVERSEARRAY	Reverses the given array and returns it.
SORT	Sorts and returns the given array.
SORTBY	Sorts and returns a given array, where the sort order is based on sort arrays given to this function.
UNIQUE	Returns a version of the given array with all duplicate values removed.
XLOOKUP	Returns the array element in the second array with the same position as an element in the first array which is equal to a given value.
XMATCH	Returns the position that a given value appears at in the given lookup array, or returns an #N/A error if the value cannot be found.

New math functions

MDETERM	Returns the matrix determinant of the given matrix.
MINVERSE	Returns the inverse matrix of the given matrix.
MMULT	Returns the matrix product of the given matrices.
MUNIT	Returns the unit matrix for the given dimension.
PRODUCTIF	Returns the product of the array elements that satisfy a condition (multiplying them together).
PRODUCTIFS	Returns the product of all array elements which satisfy one or several conditions (multiplying them together).
RANDARRAY	Returns an array with random numbers.
SEQUENCE	Returns an array containing a sequence of numbers.
SUMIF	Returns the sum of the array elements that satisfy a condition (adding them together).
SUMIFS	Returns the sum of all array elements which satisfy one or several conditions (adding them together).
SUMPRODUCT	Multiplies all the given arrays together and returns the sum of products.
SUMX2MY2	Returns the sum of the differences between the corresponding squared elements of the given two arrays.
SUMX2PY2	Returns the sum of the squares of all elements of the given two arrays.
SUMXMY2	Returns the sum of the squared differences between the corresponding elements of the given two arrays.

New operators

\| Array concatenation	Joins together two arrays, or joins a value to an array, and returns the result.
-- Double negation	Returns 0 if the given operand is FALSE, 1 if it is TRUE and the operand unchanged if is a number.
== Simple equality	Returns whether the first value is equal to the second value.
!= Simple inequality	Returns whether the first value is not equal to the second value.

New statistical functions

AVERAGEA	Returns the average (arithmetic mean) of the parameters.
AVERAGEIF	Returns the average (arithmetic mean) of the array elements that satisfy a condition.
AVERAGEIFS	Returns the average (arithmetic mean) of all array elements which satisfy one or several conditions.
CORREL	Returns the Pearson correlation coefficient of two sets of data.
COUNT	Returns the number of values which can be interpreted as numbers.
COUNTA	Returns the number of values which are not blank.
COUNTBLANK	Returns the number of elements of the given array which are either blank or are equal to the empty text string.
COUNTIF	Returns the number of array elements which satisfy a condition.
COUNTIFS	Returns the number of array elements which satisfy one or several conditions.
COVARIANCE.P	Returns the population covariance, that is, the covariance of the product of paired deviations, for an entire population.
COVARIANCE.S	Returns the sample covariance, that is, the covariance of the product of paired deviations, for a sample of the population.
FORECAST	Fits a straight line to data using linear regression and returns the vertical coordinate of a point on that line.
FREQUENCY	Returns the frequency distribution of the values of the first array when grouped into the intervals of the second array.
GROWTH	Returns the points of an exponential curve of the form y = b * m ^ x through the given data points using linear regression.
INTERCEPT	Fits a straight line to data using linear regression and returns its intercept on the vertical axis.
LARGE	Returns the nth largest number in the given array, where n is given as the second parameter.
LINEST	Finds a straight line, y = m * x + b, that best fits the given data, and returns an array containing two values corresponding to m and b in the equation above.
MAXA	Returns the largest number of the given numbers.
MAXIFS	Returns the largest number of all array elements which satisfy one or several conditions.
MINA	Returns the smallest number of the given numbers.
MINIFS	Returns the smallest number of all array elements which satisfy one or several conditions.
MODE.MULT	Returns the values that appear most frequently.
MODE.SNGL	Returns the value that appears most frequently.
PEARSON	Returns the Pearson correlation coefficient of two sets of data.
PERCENTILE.EXC	Returns the number of the given array at the kth percentile, where k is a number between 0 and 1 (exclusive), which can also be specified with the % operator (.
PERCENTILE.INC	Returns the number of the given array at the kth percentile, where k is a number between 0 and 1 (inclusive), which can also be specified with the % operator (.
PERCENTRANK.EXC	Returns the percentile rank of a number in an array.
PERCENTRANK.INC	Returns the percentile rank of a number in an array.
PROB	Returns the probability that a value is inside a given interval.
QUARTILE.EXC	Returns the number of the given array at the given quartile value.
QUARTILE.INC	Returns the number of the given array at the given quartile value.
RANK.AVG	Returns the rank of the given number in the given number array.
RANK.EQ	Returns the rank of the given number in the given number array.
RSQ	Returns the square of the Pearson correlation coefficient of two sets of data.
SERIESSUM	Returns the sum of the first terms of a power series.
SLOPE	Fits a straight line to data using linear regression and returns its slope.
SMALL	Returns the nth smallest number in the given array, where n is given as the second parameter.
STDEVA	Returns the sample standard deviation of the parameters.
STDEVPA	Returns the population standard deviation of the parameters.
STEYX	Fits a straight line to data using linear regression and returns the standard error of the actual vertical coordinates compared to the vertical coordinates of the straight line.
TRIMMEAN	Returns the mean (average) of the given values, ignoring a percentage of array elements at the beginning and end of the given array.
VARA	Returns the sample variance of the parameters.
VARPA	Returns the population variance of the parameters.
Z.TEST	Returns the one-tailed cumulative probability value of a Z-test.

New text functions

CHARAT	Returns the character at the given position.
CONCAT	Joins any number of values together as a single text string and returns it.
CONTAINS	Returns whether a text string contains another text string.
ENDSWITH	Returns whether a text string ends with another text string.
FORMATDATE	Returns a date as text.
FORMATTIME	Returns a time as text.
ISEMAIL	Returns whether the given text string is probably an email address.
NEWLINE	Returns a line break character, which causes the character following it to appear on the next line.
PARSEDATE	Interprets a text string as a date and returns it.
PARSETIME	Interprets a text string as a time and returns it.
REGEXEXTRACTALL	Extracts the parts of a text string identified by a JavaScript regular expression and returns an array with the extracted text.
REGEXSPLIT	Divides a text string into parts using a regular expression as a delimiter, returning the parts as an array.
REVERSE	Reverses the given text string and returns it.
SEARCH	Finds a text string nestled within another text string and returns its position.
STARTSWITH	Returns whether a text string starts with another text string.
TEXTJOIN	Joins a number of text strings together, separating them with a delimiter, and returns the resulting text string.
TEXTSPLIT	Divides a text string into parts using a delimiter, returning the parts as an array.

Read the complete list of supported functions »

Feature: Arrays and ranges

Fri, 12 Nov 2021 19:00:00 +0000

Calcapp now supports arrays and ranges. Arrays are collections of values which enable many of our new functions and properties. A range is a short-hand for constructing arrays with many elements. (Need to sum 100 fields? Easy!)

Our new formula engine introduces support for arrays and ranges. These are the constructs that make possible many of the new functions and properties of this release. They enable you to write space-saving formulas like SUM(Field1:Field10)SUM(Field1:Field10) and to determine what fields are included in a report using a formula.

While arrays and ranges provide great features today, they will become even more important in the future. In fact, many of the features we are working on for our next-generation Calcapp 4 project are built on arrays and ranges.

So what are arrays? An array is simply a list of values. If you like, you can think of an array as a value that consists of many values. The values of an array are known as the elements of the array.

A number array, consisting of the numbers 1, -2 and 3, is written like this:

{ 1, -2, 3 }{ 1; -2; 3 }

If you’re familiar with spreadsheets, you may recognize this construct as an array constant. And you’d be right, but arrays in Calcapp are more powerful.

In Calcapp, array elements can consist of arbitrary calculations which call functions. Also, their elements don’t have to stay the same as your users go about using your app. (That means that they aren’t necessarily constant.) In fact, arrays in Calcapp are very similar to arrays in traditional programming languages, like JavaScript.

This formula is also valid, with three elements:

{ 1, ABS(-2), 3 }{ 1; ABS(-2); 3 }

Here’s another valid formula, with two elements:

{ Field1 * Field2, SQRT(ABS(-4)) }{ Field1 * Field2; SQRT(ABS(-4)) }

The first element of this array changes when the values of Field1 and Field2 change.

Arrays are passed to many of our new functions, including SUMIF, XLOOKUP, INDEX, XMATCH, NETWORKDAYS.INTL and SUMPRODUCT. Also, there are properties whose formulas must return arrays, including the IncludedFields property of reset buttons, email report buttons, open report buttons and server relay buttons.

In order to determine the number of elements of an array, use the new (and Calcapp-exclusive) SIZE function. This is especially useful in conjunction with the FILTER function, which returns a filtered version of an array. With SIZE and FILTER, you can determine the number of array elements that satisfy a condition.

Follow the links in the paragraph above to access more information about these functions and properties. Our newly-revamped documentation includes lots of examples, making it easy to get started with the new features.

Note: When you enter formulas that use arrays and ranges in Calcapp Creator, there is no need to press any special keys like Ctrl + Shift + Enter. That particular key combination is required by older versions of Microsoft Excel, but does not apply to Calcapp.

Ranges

In spreadsheets, a range refers to a part of the spreadsheet grid, like A1:B10, which is a range encompassing the cells A1 and B10 and all the cells that appear between them:

Spreadsheets differentiate between ranges and array constants. Many spreadsheet functions (like SUMIF) only work with ranges and not array constants, whereas others happily work with both (like XLOOKUP). We find that confusing, and you’ll be happy to learn that Calcapp does not make a distinction between arrays and ranges.

Moreover, Calcapp is an app builder and does not have a spreadsheet grid, so defining a range as a collection of cells does not work for us.

So what is a range in Calcapp? A range is just an easy short-hand for constructing arrays. In fact, ranges and arrays look the same to Calcapp internally.

To make sense of this, consider a form screen which consists of exactly six fields, Field1, Field2, Field3, Field4, Field5 and Field6, in that order.

This formula returns the sum of all of these fields:

SUM({ Field1, Field2, Field3, Field4, Field5, Field6 })SUM({ Field1; Field2; Field3; Field4; Field5; Field6 })

Can we make this shorter? Yes we can, using ranges:

SUM(Field1:Field6)SUM(Field1:Field6)

Ranges rely on the order of your form screen elements. The range above formally contains Field1, Field6 and all elements that appear between them.

To drive the point home that ranges are just arrays, this formula also works:

SUM({ Field1:Field6 })SUM({ Field1:Field6 })

In fact, you can combine ranges and individually-named elements. This formula returns the sum of Field1, Field2, Field3, Field4 and Field6:

SUM({ Field1:Field4, Field6 })SUM({ Field1:Field4; Field6 })

Ranges are an effective means of creating arrays containing many elements. However, it is easy to lose track of what elements they contain, which can have surprising results. This post explores this topic in depth.

Most functions now accept arrays

There are many functions which explicitly require their parameters to be arrays, like COUNTIFS and SUMPRODUCT. What about all the regular functions that Calcapp has supported since its inception, like ABS, DATE, NPV and COS, surely they don’t support arrays?

They do, actually, and there are very few that don’t. Consider these formulas:

ABS(-4)ABS(-4)

ABS({ -4, 4 })ABS({ -4; 4 })

The first formula returns the absolute value of -4, 4. The second formula returns the array { 4, 4 }{ 4; 4 }.

When a function like ABS, which doesn’t natively support arrays, is given an array, Calcapp’s formula engine invokes ABS once for every array element and collects the results in an array. That makes these formulas equivalent:

ABS({ -4, 4 })ABS({ -4; 4 })

{ ABS(-4), ABS(4) }{ ABS(-4); ABS(4) }

Microsoft pioneered this behavior with Excel 2021 (though the feature was available earlier to Microsoft 365 subscribers). It is known as lifting.

Consider these DATE formulas:

DATE(1981, 11, 14)DATE(1981; 11; 14)

DATE(1981, { 11, 5 }, 14)DATE(1981; { 11; 5 }; 14)

DATE(1981, { 11, 5 }, { 14, 28 })DATE(1981; { 11; 5 }; { 14; 28 })

The first formula returns the date November 14, 1981. The second formula returns an array consisting of the dates November 14, 1981 and May 14, 1981. The third formula returns an array consisting of the dates November 14, 1981 and May 28, 1981.

The second formula above uses an array for the month parameter. This causes the formula engine to invoke the DATE function twice, first pairing 1981 with 11 and 14, and then pairing 1981 with 5 and 14. That makes these formulas equivalent:

DATE(1981, { 11, 5 }, 14)DATE(1981; { 11; 5 }; 14)

{ DATE(1981, 11, 14), DATE(1981, 5, 14) }{ DATE(1981; 11; 14); DATE(1981; 5; 14) }

The third formula, DATE(1981, { 11, 5 }, { 14, 28 })DATE(1981; { 11; 5 }; { 14; 28 }), uses arrays for both the month and day parameters. They both contain two elements, causing the formula engine to invoke the DATE function twice, first pairing 1981 with 11 and 14, and then pairing 1981 with 5 and 28. That makes these formulas equivalent:

DATE(1981, { 11, 5 }, { 14, 28 })DATE(1981; { 11; 5 }; { 14; 28 })

{ DATE(1981, 11, 14), DATE(1981, 5, 28) }{ DATE(1981; 11; 14); DATE(1981; 5; 28) }

(What happens if you pass arrays that don’t have the same number of elements? The returned array will contain not available values.)

The documentation for ABS (click Details) states that ABS returns Number or { Number } (a number or an array of numbers). That’s how you spot a function in our documentation that returns an array if one or several parameters are arrays — we call them array-capable functions.

(Technically, an array-capable function returns an array if one or several of its parameters, which are documented to either accept a regular value or an array, are invoked with arrays.)

Explore all the examples in our formula and property documentation to find lots of helpful tips on where you can use arrays with regular functions to great effect.

Arrays and matrix functions

Spreadsheets and Calcapp alike support specialized math functions for handling matrices, such as MMULT. A matrix is a two-dimensional array, which is an array whose elements are arrays. A matrix can be visualized as a two-dimensional area containing values, in contrast to a regular, one-dimensional array which can be visualized as a single line containing values.

Matrices are written differently in Calcapp compared to most spreadsheets. For instance, =MMULT({ 3, 5; 1, 2 }, { 2, 6; 1, 1 }) (written =MMULT({ 3; 5\ 1; 2 }; { 2; 6\ 1; 1 }) with decimal commas) is written like this in Calcapp:

MMULT({{ 3, 5 }, { 1, 2 }}, {{ 2, 6 }, { 1, 1 }})MMULT({{ 3; 5 }; { 1; 2 }}; {{ 2; 6 }; { 1; 1 }})

Calcapp’s syntax for two-dimensional arrays is closer to what traditional programming uses than the syntax used by spreadsheets. We designed it this way as we prefer to use semicolons to separate statements in action formulas, which will be the focus of our next release.

Feature: Look up values with XLOOKUP

Fri, 12 Nov 2021 18:00:00 +0000

Excel 2021's XLOOKUP function is now fully supported. It does everything VLOOKUP and HLOOKUP do and more. Use an app to convert table data to XLOOKUP formulas.

August 11, 2023 update: We now recommend that you use the data editor to import and edit spreadsheet data. It is significantly easier to use than the app described here.

Original text: People have been asking us for a way to look up values since we launched our first beta. In 2018, we introduced support for the CHOOSE function and wrote an app that makes it easy to convert tabular data to CHOOSE formulas, alleviating some of the pain (see below).

We’re happy to announce that we now have full support for the XLOOKUP function, which Microsoft introduced with Excel 2021 (and has been available to Microsoft 365 subscribers for a while now). If you prefer using INDEX and MATCH, we support them too (along with the new XMATCH, which has all the features of XLOOKUP).

This formula returns 300, because the sought value, 30, is the third element in the first array, which causes XLOOKUP to return the third element in the second array, 300:

XLOOKUP(30, { 10, 20, 30 }, { 100, 200, 300 })XLOOKUP(30; { 10; 20; 30 }; { 100; 200; 300 })

The first array is known as the lookup array and the second array is known as the result array. We have written an app that does the conversion from table data to formulas, see below.

Don’t miss our extensive documentation covering XLOOKUP, INDEX, MATCH and XMATCH, with lots of examples.

XLOOKUP versus INDEX and XMATCH

Looking up a value involves two steps. First, an element matching the sought value in the lookup array must be found. Then, the corresponding element in the result array is returned. If the second element in the lookup array matches the sought value, the second element in the result array is returned.

These two steps can be performed explicitly, using XMATCH or MATCH (XMATCH is easier to use and offers more features) and INDEX. MATCH and XMATCH return the position of the sought value in the array. INDEX is then given this position as its second parameter, and returns the element at that position from the array given as its first parameter.

As a result, these formulas are equivalent:

XLOOKUP(30, { 10, 20, 30 }, { 100, 200, 300 })XLOOKUP(30; { 10; 20; 30 }; { 100; 200; 300 })

INDEX({ 100, 200, 300 }, XMATCH(30, { 10, 20, 30 }))INDEX({ 100; 200; 300 }; XMATCH(30; { 10; 20; 30 }))

Using XLOOKUP directly leads to shorter formulas that may be easier to understand. Combining XMATCH with INDEX has the advantage of giving you more flexibility. Which variant you choose is mostly a matter of personal preference.

What about VLOOKUP and HLOOKUP?

There is nothing that VLOOKUP and HLOOKUP can do that XLOOKUP doesn’t handle. In fact, XLOOKUP is preferable even if you use Excel, as it has more features and more sensible defaults. (You get exact matches by default.) If you have been hoping that Calcapp would some day support something like VLOOKUP and HLOOKUP, that day has finally come.

Calcapp probably won’t support VLOOKUP and HLOOKUP in the future, primarily because these functions are tied to a spreadsheet grid. Calcapp isn’t a spreadsheet, and there is no grid. When you use VLOOKUP, you specify a range encompassing your table (or parts of your table) and a column number (counting from the left) of the column containing the values you seek. Without a grid, that doesn’t make sense.

XLOOKUP is different, in that it accepts two arrays. (In Excel, it also works with ranges, which are tied to the spreadsheet grid.) Now that Calcapp has a new formula engine which supports arrays, we can easily add support for something like XLOOKUP.

We are thrilled that Microsoft happened to introduce a new lookup function at roughly the same time that we needed to add one to Calcapp — and at that, a lookup function that is fully compatible with our new formula engine. We would much rather support a lookup function pioneered by Microsoft than come up with our own variant.

Converting table data to formulas

While our XLOOKUP support is complete, there is an important caveat. All data needs to be put into formulas, because Calcapp still does not have native support for tables.

We recognize that being able to import data directly to a table in Calcapp Creator would be preferable. That feature is coming in our next-generation Calcapp 4 project.

The good news is that we have created an app that does the conversion for you. To demonstrate how to use it, we’ll use this small sample table:

Product	Price	Color
Sample 1	5.20	Indigo
Sample 2	5.20	Ivory
Sample 3	5.92	Khaki
Sample 4	5.92	Lavender
Sample 5	7.04	Silver
Sample 6	7.04	Snow
Sample 7	7.55	Tan
Sample 8	7.55	Teal
Sample 9	9.59	Thistle
Sample 10	9.59	Violet

For this exercise, we’ll need to copy column data from the table, which only works from a spreadsheet. Here is the table, as a Google Sheets spreadsheet.

To look up the price based on the product name (contained in the Product text drop-down field), we need to generate an XLOOKUP formula. To do so, we use the app.

Here’s an embedded version of the app, which you can also run as a stand-alone app:

To generate an XLOOKUP formula locating prices, follow these steps:

Write “Product” in the Sought value field, which causes the first parameter to the generated XLOOKUP formula to be set to “Product”.
Select all product names from the spreadsheet. Select Sample 1 through Sample 10, press Ctrl+C (or ⌘+C if you’re on a Mac) to copy the selection to the clipboard.
Paste this data into the Lookup values field in the app. Click the empty field, and then press Ctrl+V (or ⌘+V if you’re on a Mac).
Copy all prices to the clipboard.
Paste this data into the Result values field in the app.

The app generates the correct formula for you:

XLOOKUP(Product, { "Sample 1", "Sample 2", "Sample 3", "Sample 4", "Sample 5", "Sample 6", "Sample 7", "Sample 8", "Sample 9", "Sample 10" }, { 5.20, 5.20, 5.92, 5.92, 7.04, 7.04, 7.55, 7.55, 9.59, 9.59 })XLOOKUP(Product; { "Sample 1"; "Sample 2"; "Sample 3"; "Sample 4"; "Sample 5"; "Sample 6"; "Sample 7"; "Sample 8"; "Sample 9"; "Sample 10" }; { 5,20; 5,20; 5,92; 5,92; 7,04; 7,04; 7,55; 7,55; 9,59; 9,59 })

If you repeat the same steps for the Color column, this formula is generated:

XLOOKUP(Product, { "Sample 1", "Sample 2", "Sample 3", "Sample 4", "Sample 5", "Sample 6", "Sample 7", "Sample 8", "Sample 9", "Sample 10" }, { "Indigo", "Ivory", "Khaki", "Lavender", "Silver", "Snow", "Tan", "Teal", "Thistle", "Violet" })XLOOKUP(Product; { "Sample 1"; "Sample 2"; "Sample 3"; "Sample 4"; "Sample 5"; "Sample 6"; "Sample 7"; "Sample 8"; "Sample 9"; "Sample 10" }; { "Indigo"; "Ivory"; "Khaki"; "Lavender"; "Silver"; "Snow"; "Tan"; "Teal"; "Thistle"; "Violet" })

Note that the app automatically detects if the values are numbers or text. If they are numbers (potentially starting with a currency symbol, such as “$”), the elements of the generated array are not quoted. For this to work, you need to ensure that you have selected the correct decimal separator from the Decimal separator text drop-down field.

To learn how the app was built, we have written a blog post that walks you through it.

XLOOKUP versus CHOOSE

Associating values from a table with the options available from a text drop-down field can also be done using the CHOOSE function and the Index property of text drop-down fields. We provide instructions and an app that generates such formulas.

CHOOSE formulas have the advantage that they are compact. They rely on the position of the option selected by the user and therefore don’t need to be provided with lookup values. They can also be expected to be faster.

However, CHOOSE formulas are very limited compared to XLOOKUP formulas. With XLOOKUP, you can look up any value you desire, and take advantage of all the features that XLOOKUP offers, such as inexact text matching and the like (learn more). CHOOSE formulas are mostly practical to use when you need to associate a single value with an option selected from a text drop-down field.

Feature: Use SUMIF, SUMIFS and others like them

Fri, 12 Nov 2021 17:00:00 +0000

AVERAGEIF, COUNTIF, MINIFS, MAXIFS, PRODUCTIF, SUMIF and variants are now supported. Use our formula fragment extension for complex conditions.

While Calcapp has supported hundreds of functions since 2016, there have been conspicuous holes in our function coverage. Most notably, we have not supported the popular conditional functions AVERAGEIF, AVERAGEIFS, COUNTIF, COUNTIFS, MINIFS, MAXIFS, SUMIF and SUMIFS.

As you have probably gathered from the fact that the preceding paragraph is full of links to our formula documentation, we now have full support for these functions. We have also added support for PRODUCTIF and PRODUCTIFS, which are (as far as we know) exclusive to Calcapp and have been requested by spreadsheet users for years. They work precisely like the SUMIF and SUMIFS functions, but multiply numbers instead of adding them together.

It is possible to simulate these functions using just the IF function and regular calculations. However, that tends to produce very long formulas that are hard to maintain. With support for these conditional functions, we now enable many more spreadsheets to be easily converted to apps, with no hoops to jump through.

What can these functions be used for?

In their simplest form, these conditional functions accept an array as their first parameter and then apply an operation on its elements (like adding them together), but only if the element under consideration passes a test (a condition).

For instance, you can easily get the sum of all numbers of an array that are greater than 1. This formula does just that, using SUMIF:

SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1")

The formula above returns 5 (2 + 32 + 3). It does not return 6 (1 + 2 + 31 + 2 + 3), as only 2 and 3 are greater than 1, as specified by the ">1"">1" parameter.

This formula returns the sum of all field values of the Field1:Field10Field1:Field10 range which are less than 3:

SUMIF(Field1:Field10, "<3")SUMIF(Field1:Field10; "<3")

Before this release, an app author would have had to invoke IF multiple times to achieve the same result:

IF(Field1 < 3, Field1) + IF(Field2 < 3, Field2) + IF(Field3 < 3, Field3) + IF(Field4 < 3, Field4) + IF(Field5 < 3, Field5) + IF(Field6 < 3, Field6) + IF(Field7 < 3, Field7) + IF(Field8 < 3, Field8) + IF(Field9 < 3, Field9) + IF(Field10 < 3, Field10)IF(Field1 < 3; Field1) + IF(Field2 < 3; Field2) + IF(Field3 < 3; Field3) + IF(Field4 < 3; Field4) + IF(Field5 < 3; Field5) + IF(Field6 < 3; Field6) + IF(Field7 < 3; Field7) + IF(Field8 < 3; Field8) + IF(Field9 < 3; Field9) + IF(Field10 < 3; Field10)

If you need multiple conditions, use the SUMIFS function:

SUMIFS({ 10, 20, 30 }, { 1, 2, 3 }, ">1", { "Eve", "Eve", "Bill" }, "Eve")SUMIFS({ 10; 20; 30 }; { 1; 2; 3 }; ">1"; { "Eve"; "Eve"; "Bill" }; "Eve")

The formula above returns 20, because that is the only element of the first array where both corresponding elements in the other arrays satisfy their conditions.

In the second array { 1, 2, 3 }{ 1; 2; 3 }, 2 and 3 satisfy the ">1"">1" condition, as they are both greater than 1. In the third array, { "Eve", "Eve", "Bill" }{ "Eve"; "Eve"; "Bill" }, the two first elements satisfy the "Eve""Eve" condition, requiring matching elements to be equal to “Eve”. In other words, the second and third elements of the second array match their corresponding condition, while the first and second elements of the third array match their corresponding condition. As such, only the second element of the first array is considered, resulting in a return value of 20.

As noted, the SUMIF and SUMIFS functions above calculate sums (adding numbers together). The PRODUCTIF and PRODUCTIFS functions calculate products (multiplying numbers together). AVERAGEIF and AVERAGEIFS calculate averages and COUNTIF and COUNTIFS count how many elements satisfy the given condition or conditions.

MINIFS finds the smallest number among a set of numbers that satisfy one or several conditions. Conversely, MAXIFS finds the largest number among a set of numbers that satisfy one or several conditions.

Comparing array elements to field values

The text strings that need to be given to these functions lend themselves well to comparing elements against constant values. However, what if you need to compare elements against field values (or any other values derived through formulas)?

In that common case, you need to use the text concatenation operator, &. Here’s a formula returning the sum of all values that are greater than the value of Field1:

SUMIF({ 1, 2, 3 }, ">" & Field1)SUMIF({ 1; 2; 3 }; ">" & Field1)

This formula returns the sum of all field values of the Field2:Field10Field2:Field10 range which are less than or equal to Field1.ValueField1,Value:

SUMIF(Field2:Field10, "<=" & Field1)SUMIF(Field2:Field10; "<=" & Field1)

The formula above uses a range to construct an array containing many elements. It is easy to lose track of what elements a range contains, though, which can have surprising results. This post explores this topic in depth.

A word on decimal separators

Calcapp allows you to write formulas using either decimal points or decimal commas. You might think that the decimal separator preference you have specified for formulas would apply to the text string given to conditional functions, but that is not the case.

Conditional functions like SUMIF and SUMIFS do support both decimal points and decimal commas. When they need to interpret a period or a comma in the text string you supply, they don’t rely on your decimal separator formula preference, they rely on the language of the app.

That means that if your app is in German, you must use a comma as a decimal separator, even if your preference for formulas calls for using a decimal point:

SUMIF({ 1, 2, 3 }, ">1,1")SUMIF({ 1, 2, 3 }, ">1,1")

The same logic applies in reverse if you prefer using decimal commas in formulas, but your app is in US English:

SUMIF({ 1, 2, 3 }; ">1.1")SUMIF({ 1, 2, 3 }; ">1.1")

This situation should be rare, but it’s something to be aware of if you get surprising results.

The reason we designed it this way is because when you join text strings like “<=” together with field values using &, Calcapp uses the decimal separator of the language the app has been configured to use when converting the field value to a text string. For that reason, the conditional functions must do the same.

Of course, if you want to sidestep this issue completely, you can use a formula fragment instead of a textual condition. That is the subject for our next section.

Using formula fragments instead of textual conditions

The conditional functions are quite limited in terms of what conditions you can express. With a function like SUMIF, you can only express a single condition. Functions like SUMIFS enable multiple conditions to be expressed, but all conditions need to match — there is no room for including a value which matches one of two conditions (logical or).

We have introduced extensions specific to Calcapp which enable you to use formula fragments to determine if an element should or should not be included. A formula fragment can use any function or operator, meaning that they are infinitely flexible.

In a formula fragment, the element under consideration is available as the Element value. These formulas are equivalent, with the second one using a formula fragment:

SUMIF({ 1, 2, 3 }, ">1")SUMIF({ 1; 2; 3 }; ">1")

SUMIF({ 1, 2, 3 }, Element > 1)SUMIF({ 1; 2; 3 }; Element > 1)

Note that the formula fragment is not a text string, but just a regular part of the overall formula. That means that you can easily restrict elements to those that are greater than 1 or are odd (|| means “or”):

SUMIF({ 1, 2, 3 }, (Element > 1) || ISODD(Element))SUMIF({ 1; 2; 3 }; (Element > 1) || ISODD(Element))

In practice, the formula above returns 6 (1 + 2 + 31 + 2 + 3), as 1 is included on account of being an odd number.

Refer to our documentation for these functions for many more examples.

When you use a formula fragment with ranges, you may encounter error messages if your range inadvertently contains, say, text boxes and buttons. This post explores this topic in depth.

Using FILTER instead of the specialized conditional functions

The work SUMIF performs can be divided into two parts: filtering out the unwanted elements from the array and then returning the sum of the elements which made the cut. Just like XLOOKUP invocations can be replaced by using both INDEX and XMATCH, SUMIF and the other conditional functions can be replaced by using the new FILTER function together with specialized functions calculating a result (for SUMIF, that specialized function is SUM — or REDUCE if you are feeling adventurous).

FILTER accepts an array as its first parameter and returns a version of this array which only contains elements that have passed a test you have supplied.

The most commonly used variant of FILTER expresses this test as a logical array given as the second parameter, which should contain the same number of elements as the array to filter. If an element of the second array is TRUE, the corresponding element of the array to filter is part of the returned array. If it is FALSE, the element is dropped.

This formula returns an array of fields whose values are greater than 4:

FILTER(Field1:Field3, Field1:Field3 > 4)FILTER(Field1:Field3; Field1:Field3 > 4)

If we combine FILTER with SUM, we can replicate the SUMIF function. These formulas are equivalent:

SUMIF(Field1:Field3, ">4")SUMIF(Field1:Field3; ">4")

SUM(FILTER(Field1:Field3, Field1:Field3 > 4))SUM(FILTER(Field1:Field3; Field1:Field3 > 4))

Of course, the SUMIF formula is much shorter and is likely easier to read. By combining FILTER with SUM, though, we gain flexibility, and a deeper understanding of how the final result is calculated. Use whichever variant you are most comfortable with.

To explore these functions — and alternatives to using them — be sure to check out our full formula documentation. These functions are available in the Math and Statistical categories.

Feature: Send formula-driven emails

Fri, 12 Nov 2021 16:00:00 +0000

Fully determine the bodies of emails you send using formulas. You can also use formulas to set text that appears before or after field values in reports.

Over the years, we have steadily added features that help you more fully customize the emails sent from your apps. When reports launched in 2016, there were very few report-related options in the inspector. We quickly added the ability to choose whether screen names and blank values should be part of reports, and whether sent fields should be reset afterwards. Towards the end of the year, we added PDF reports.

In early 2017, you got the ability to set the sender of emails, and in 2018 we made it possible to change the subject line, potentially using a formula. Finally, a grab bag of improvements landed in 2019, including the ability to set the Reply-To field and the ability to set the file names of attached files, possibly using a formula.

Setting the email body

It’s 2021, and the time has come to let you set the body of emails sent through your apps using formulas, making all email aspects fully customizable. With this feature, you can finally communicate with your users using plain English (or any other language), instead of sending dry field values in a table.

This feature is enabled by the new Body property of email reports buttons. Consider this formula:

"Dear " & Name & "," & NEWLINE() & NEWLINE() & "The weight is
" & FORMATNUMBER(Weight) & " lbs.""Dear " & Name & "," & NEWLINE() & NEWLINE() & "The weight is
" & FORMATNUMBER(Weight) & " lbs."

The formula above sets the email body to something like the following:

Dear Sally,

The weight is 23.30 lbs.

The new NEWLINE function returns a line break character (and is fully equivalent to CHAR(10)CHAR(10)). It makes it easy to construct email bodies consisting of multiple lines, and multiple paragraphs.

If this property is not set, a default body is used. If the format of the email report button calls for a file to be attached (containing, say, a PDF document), the default body includes instructions in English on how to open the attached file. By setting a body explicitly through this property, you can fully determine the email body yourself.

There is one thing this new feature won’t enable you to do: send emails with images and formatted text. You also can’t send PDF documents containing images and formatted text. For the latter use case, there are lots of great third-party services you can integrate with your apps to realize this functionality. We wrote a blog post walking you through two such services last year.

Refer to our complete documentation to learn more and to access formula examples demonstrating how the new feature can be used.

Setting the text that appears before and after field values

The email body property sets the body of emails you send. If the format of the email is text, field values are included directly in the body, appearing directly after the text set through the Body property.

There is a new property, Prologue, which allows you to set the text that appears before the field values. It is pretty much equivalent to the Body property if the format is set to text (the prologue text appears after the body text). To set the text that appears after field values, use the Epilogue property.

If the format of the email calls for a file to be attached, containing CSV or PDF data, the Body property determines the body of the email itself, while the Prologue and Epilogue properties apply to the attached file. You can even ask Calcapp not to include any field values at all, meaning that you can fully determine the text contents of an attached PDF file using a formula.

The Prologue and Epilogue properties apply not just to email report buttons, but also to open report buttons (which enable files to be downloaded directly to a user’s device).

Refer to the our newly-revamped property documentation to learn more and to access examples demonstrating the new features. Here’s documentation for the Prologue property of email report buttons and open report buttons. Finally, here’s documentation for the Epilogue property of email report buttons and open report buttons.

Calcapp branding and reports

Prior to this release, generated reports differed somewhat depending on if your app was on a White Label plan or not. If your app was on a White Label plan, no mention was made of Calcapp, in any context.

If your app was not on a White Label plan and you sent reports by email, attached PDF files included a blurb before the field values stating the name of your app, the date and the fact that Calcapp had been used to generate the report. Attached CSV files, on the other hand, did not mention Calcapp. Finally, email bodies for apps not on a White Label plan mentioned Calcapp in the footer.

These rules also applied to reports downloaded directly to a user’s device. Downloaded plain text files, or HTML documents, did not mention Calcapp, regardless of what plan your app was on.

If you don’t make use of any of the new properties Body, Prologue and Epilogue and your app is not on a White Label plan, the only change you will see is that generated PDF files look a little different. Specifically, nothing appears before the field values. Rather, a short sentence (“Generated by Calcapp.”) now appears after the field values.

If you want your report to look mostly identical to the way it looked before, complete with the current date and time, associate a formula like the following with the Prologue property of the email report button or the open report button:

"This report has been sent from the ""[your app name]"" app on
" & FORMATDATE(TODAY()) & " " & FORMATTIME(NOW()) & ", courtesy of Calcapp.""This report has been sent from the ""[your app name]"" app on
" & FORMATDATE(TODAY()) & " " & FORMATTIME(NOW()) & ", courtesy of Calcapp."

The formula above uses the new FORMATDATE and FORMATTIME functions to include the current date and time in the report. Writing """" inside of a text string in a formula generates a single quotation mark.

If you do make use of any of the properties Body, Prologue and Epilogue and your app is not on a White Label plan, you will find that the “Generated by Calcapp.” blurb is added to the epilogue — the text that appears after the field values — automatically.

In other words, nothing material changes in terms of branding if you don’t use the new properties. If you do, however, discreet Calcapp branding is added to your reports.

Feature: Use a formula to determine what fields to include in a report

Fri, 12 Nov 2021 15:00:00 +0000

Get full control over your reports. Want to only include fields with values greater than five? Just use FILTER. Also, hidden fields can now be left out of reports.

Three and a half years ago, we had started to lose count of how many times we had been asked one particular question: How can I determine what fields to include in a report?

Calcapp didn’t provide much in the way of customization in that area: you could only include all fields of the screen the button was on or all fields of the app, making for reports with lots of unwanted information. An enterprising user was kind enough to teach us a pretty compelling workaround, which we set out to share in a blog post back in 2018.

The technique described in the post simply asks app authors to put their report buttons on separate screens (configured to only include the fields of that screen), and then add hidden fields. These hidden fields use formulas referencing the fields containing the actual information.

The end result is a single, lone button on a screen. The downside is that you can’t really have any real fields on that screen (they would get included in the report), but the upside is that the button can include an arbitrary set of fields.

The IncludedFields property

With our new release, and a formula engine that supports arrays, that awkward workaround is no longer necessary. Enter the new IncludedFields property of email report buttons and open report buttons, which must be set through a formula.

In order for the formula to be picked up by Calcapp, you must configure your email or open report button to include fields set through a formula. Choose Select fields using formula from the drop-down menu in the inspector when your button is selected, and then on the fx button next to Included fields to edit the formula:

This formula includes Field1, Field2 and Field3:

{ Field1, Field2, Field3 }{ Field1; Field2; Field3 }

Ranges enable a large number of fields to be referenced in a compact way. This formula includes the fields Field1 and Field5, as well as all fields that appear between them:

Field1:Field5Field1:Field5

This formula includes Field1, Field3 and Field5, as well as the fields that appear between Field3 and Field5:

{ Field1, Field3:Field5 }{ Field1; Field3:Field5 }

You can also include all fields of a screen simply by referencing the screen in the array, include all fields of your app by referencing the App object and conditionally include fields using IF. You can even reference all fields of a screen, and only include those whose values are greater than 5 (say) using the FILTER function.

For more on how to use the IncludedFields property, including lots of examples, refer to our newly-expanded property documentation for email report buttons and open report buttons.

Other new report features

There are two other new report features that warrant discussion. First, you can now leave out hidden fields from reports simply by toggling the new Include hidden fields option. Previously, hidden fields were always included.

This option affects what fields are included even if a formula is used to determine the set. In other words, if the IncludedFields formula elects to include Field1, it won’t actually be included if it is hidden and the Include hidden fields option is toggled off.

Second, you can now elect not to present fields belonging to different screens separately by toggling the Separate different screens option.

This is the result when fields are separated by screen:

Screen 1:
Field 1	1
Field 2	2
Field 3	3
Screen 2:
Field 4	4
Field 5	5
Field 6	6

This is the result when fields are not separated by screen:

Field 1	1
Field 2	2
Field 3	3
Field 4	4
Field 5	5
Field 6	6

By not separating fields by screen, you can produce reports that do not mirror the structure of your app. If you determine what fields to include using the IncludedFields property, the report will reflect exactly the fields you include in the array, in the exact order they are specified there.

You can also customize the CSV files sent through your apps and add text before and after field values using formulas.

Feature: Decide the next screen with a formula

Fri, 12 Nov 2021 14:00:00 +0000

Skip straight to the results if the entered data checks out, or collect supplemental information otherwise. Stop copying and pasting screens — now you can make many screens send the user to the same destination.

Since its inception, Calcapp has allowed you define a hierarchy of screens reachable by your users. List screens enable users to select an option (now known as a navigator) and be brought forward to the screen associated with the navigator. Form and text screens enable users to move forward to a single pre-determined screen by pressing Next in the upper-right corner.

Up until now, that hierarchy has been fixed and unchangeable, with no room for making decisions based on formulas. In particular, it has not been possible for multiple screens or navigators to send the user to the same screen, where this screen can take the selection made by the user into account.

Today, all that changes. A new property, NextScreen, has been added to form screens, text screens and navigators. (Refer to the links for detailed documentation.)

This property enables you to do things like send the user to a warning screen if the information filled out by the user does not check out. You can also take a user straight to a results screen if you so choose, or ask for additional information before sending the user to the results screen, all based on formulas.

To send a user to a screen named Screen1, simply associate the following formula with a NextScreen property:

Screen1Screen1

To send a user to Screen1 if Field1 is valid, and to Screen2 otherwise, use this formula:

IF(Field1.Valid, Screen1, Screen2)IF(Field1,Valid; Screen1; Screen2)

To prevent users from moving forward to the next screen, use the pre-existing NextScreenAvailable property of form screens and text screens. (It used to be known as NextPanelAvailable.)

(Returning a blank value from a NextScreen property does not prevent the user from moving forward. Rather, it makes Calcapp use the screen which naturally follows the screen, which you have set in Calcapp Creator.)

Using a drop-down field as a list screen

Up until now, list screens and drop-down fields have had very little in common. List screens and their navigators have sent users forward to pre-defined screens, whereas the selection made from a drop-down field has not had any influence on the screen shown to the user as they move forward.

The NextScreen property changes all that. Let’s say you have a text drop-down field named ScreenSelection with the options “First screen,” “Second screen” and “Third screen.” To move the user forward to Screen1 if “First screen” is selected, to Screen2 if “Second screen” is selected and to Screen3 if “Third screen” is selected, use this formula:

SWITCH(ScreenSelection, "First screen", Screen1, "Second
screen", Screen2, "Third screen", Screen3)SWITCH(ScreenSelection; "First screen"; Screen1; "Second
screen"; Screen2; "Third screen"; Screen3)

(SWITCH is a new function.) The SWITCH formula above can also be written with the IF function:

IF(ScreenSelection = "First screen", Screen1, ScreenSelection = "Second screen", Screen2, ScreenSelection = "Third screen", Screen3)IF(ScreenSelection = "First screen"; Screen1; ScreenSelection = "Second screen"; Screen2; ScreenSelection = "Third screen"; Screen3)

Using a list screen as a drop-down field

Sometimes, you don’t want a list screen to determine what screen is shown next, you want the same screen to be shown regardless of what list screen navigator is chosen. You then want this screen to take into account the selection made by the user.

Achieving the first requirement is easy. Simply associate a formula with the NextScreen property of all navigators of the list screen—let’s say it’s named ProductChoice—and have the formula reference the same screen, named ResultsScreen:

ResultsScreenResultsScreen

The second requirement asks that we have a way of learning what navigator was selected. This is achieved using a new read-only property of list screens, ActiveNavigator.

To make the title of the next screen reflect the choice made by the user, associate this formula with the Label property of the screen:

ProductChoice.ActiveNavigator.LabelProductChoice,ActiveNavigator,Label

The ActiveNavigator property of ProductChoice returns the navigator the user selected. In turn, this navigator has properties of its own that we can access, including Label, reflecting the label of the navigator. (You can associate a formula with the Label property to determine it dynamically.)

You can use the XLOOKUP function to look up a value associated with the selection made by the user. Consider this formula:

XLOOKUP(ProductChoice.ActiveNavigator.Label, { "Product A", "Product B", "Product C" }, { 10, 20, 30 })XLOOKUP(ProductChoice,ActiveNavigator,Label; { "Product A"; "Product B"; "Product C" }; { 10; 20; 30 })

The formula above returns the price of the product represented by the navigator activated by the user. XLOOKUP expects its first parameter to be the value to find in the array given as the second parameter. If found, the array element at the same position in the array given as the third parameter is returned. Here, the value to find is the label of the navigator activated by the user, which is expected to be either “Product A”, “Product B” or “Product C”.

This SWITCH formula is equivalent:

SWITCH(ProductChoice.ActiveNavigator, ProductChoice!ProductA, 10, ProductChoice!ProductB, 20, ProductChoice!ProductC, 30)SWITCH(ProductChoice,ActiveNavigator; ProductChoice!ProductA; 10; ProductChoice!ProductB; 20; ProductChoice!ProductC; 30)

Linking navigators to the same screen versus copying and pasting

In the past, many app authors wanted to achieve the effect described above, that is, multiple navigators all leading to the same screen, with this screen taking the selection into account. This was achievable by liberal use of copy and paste.

If a list screen consisted of 20 navigators, app authors would copy a single screen and paste it 19 times, associating the copies with the other navigators. To make these screens reflect the selection made by the user, authors would make small modifications to each screen copy.

There are several disadvantages to this approach. From an app author’s perspective, making changes to the duplicated screens becomes an arduous process, with each change having to be made multiple times. From Calcapp’s perspective, having screens (and the screens following them) be duplicated many times makes apps very large, which may make them run sluggishly or not at all.

By linking several navigators to the same screen, you reap all the rewards of copying and pasting screens with none of the disadvantages, provided that the screens you would have copied and pasted differ little from one another.

Feature: Decimal commas in formulas

Fri, 12 Nov 2021 13:00:00 +0000

Formulas written with decimal commas are now fully supported. Set your preference the next time you open Calcapp Creator.

Since we launched the first beta version, Calcapp has only recognized decimal points (“.”) as decimal separators and commas (“,”) as parameter separators in formulas. This is in line with how numbers are written in countries like the US, Britain, Australia, New Zeeland, China, Japan, India and parts of Africa.

However, most parts of South America and Europe (including Russia), as well as parts of Africa, use decimal commas, making Calcapp formulas feel foreign in these countries. We often stress that you can frequently carry over formulas from spreadsheets to Calcapp simply by copying and pasting them, but this has sadly not worked well for our European and South American customers.

Apps produced with Calcapp have supported languages other than US English for three and a half years now. Numbers are formatted according to the language of the app and functions like PARSENUMBER and FORMATNUMBER correctly handle the decimal separator of the configured language. In other words, apps have handled decimal commas correctly for years now, but not the app designer.

Programming languages typically use decimal points exclusively. Spreadsheets, however, with very few exceptions either allow the decimal separator to be set manually or follow the conventions of the host operating system. Spreadsheets that use decimal commas as decimal separators use semicolons (“;”) as parameter separators instead of commas.

Ironically, we’re a Swedish business, and decimal commas are exclusively used as decimal separators here. We’re not only Swedish, though, we’re also software developers. As programming languages exclusively support decimal points, it appears that we have grown a little too comfortable with decimal points to realize that this has been a major pain point our customers have experienced.

This issue is now finally resolved. Decimal commas are fully supported, and you will be asked your preference when you sign into Calcapp Creator:

If you set your preference to decimal commas and you open an app you previously authored with decimal points, our server will silently convert all formulas of the app to use decimal commas (and semicolon separators). This process is fast, and it is accurate, so you don’t have to worry about it making a hash of your formulas.

Calcapp Creator will expect you to use decimal commas in other places too, like when you write initial values for number fields and when you author the numbers that are part of a number drop-down field.

This setting does not affect your apps. In order to make them format numbers with decimal commas, ensure that your app is set to use a language that uses a decimal comma as a decimal separator.

Feature: Dramatically improved documentation for formulas and properties

Fri, 12 Nov 2021 12:00:00 +0000

What's got half a million words? The Lord of the Rings trilogy. And our new formula and property documentation, which is now on the web. Thousands of formula examples make getting started with all the new features easy.

When we launched the first beta version in late 2015, Calcapp supported 20 functions. To document them, we had a simple window, with most functions only being afforded a single sentence:

Calcapp went from supporting 20 functions to 244 functions overnight in 2016. The old documentation window would not have scaled to that number of functions, so we introduced the function browser (which later evolved into the reference sidebar). While all functions were documented, the descriptions of how they worked remained as terse as ever, with no examples.

Truth be told, we always wanted our formula documentation to equal the best that spreadsheets offered. We could never justify making that investment with a small team, though, not when fundamental features like copy and paste remained unimplemented.

Making a case for better documentation

Back in 2016, when we went from 20 functions to 244 functions, the only function that was exclusive to Calcapp was BLANK, all the others were standard spreadsheet functions implemented by most spreadsheets. We didn’t consider the function library to be the Calcapp function library as much as we considered it to be simply an implementation of standard spreadsheet functions.

Over the years, we started making additions. We didn’t like Excel’s TEXT function and its convoluted format codes, so we created FORMATNUMBER. We needed regular expressions to create an app for generating CHOOSE formulas in 2018, so we adopted Google Sheets functions like REGEXMATCH and REGEXREPLACE and added our own extensions.

Of the 102 new functions added with our new release, some are exclusive to Calcapp, and others feature Calcapp extensions we have brought over from traditional programming. Examples include the formula fragments you can use with functions like FILTER and SUMIF and the enums you can use with functions like XLOOKUP.

All that is to say that we have taken ownership of Calcapp’s function library. We continue to respect the huge investment in time many app authors have made in learning the standard spreadsheet functions, but we’re not afraid to add flourishes of our own or reject ideas that we don’t think fit our vision.

Not all app authors using Calcapp are well-versed in spreadsheet formulas. To help them get started, and to realize what possibilities a well-thought-out formula language offers, we need documentation that can stand on its own, without relying on readers having any prior knowledge of the topic at hand. To make the documentation easy to digest, we need lots of examples.

Finally, Calcapp doesn’t just feature functions and operators, it also features a wholly-original set of properties which can be used to do everything from setting the recipients of a report to what screen the user is brought to when moving on to the next screen. Properties most definitely need great documentation, because it isn’t to be found anywhere else.

All of that is to say that we decided to invest many months of work into writing better documentation because we couldn’t see another way.

The new documentation

Our new documentation consists of thousands of formula examples and around half a million words, which is equivalent to the entire Lord of the Rings trilogy. (Granted, the trilogy is not as repetitive as our documentation for SUMIF, AVERAGEIF and friends, which are all based on the same template.)

The documentation has moved from the reference sidebar to the web. The reference sidebar was much too narrow to give us the room we needed for the new documentation. Also, by moving it to the web, it is much easier to print, and much easier for search engines to discover and index. (If we’re lucky, spreadsheet users will find our documentation through search engines, gain value from it and learn of our existence.)

Without further ado, here’s our formula documentation (encompassing functions and operators) and here’s our property documentation.

We have de-emphasized the “formal parts” of the documentation, including notes on the parameters to functions, operands to operators as well as return values. It’s still there (and has often been expanded) — just press Details to get access to it.

All formulas exist in two versions, one written with decimal points and one written with decimal commas. Press the button next to all formulas, labeled with a decimal point and a decimal comma, to switch between the two variants. The button next to it copies the formula to the clipboard, enabling you to easily paste it into the formula field in Calcapp Creator.

This documentation has been written by our core development team, which is the same team who answers all your support questions. As a result, we are very much aware of the problems app authors have encountered while using Calcapp, and we have tried to clear up as many formula misconceptions as possible through copious examples.

Some functions come with lengthy documentation and lots of examples — for instance, a hard copy of the documentation for REDUCE would fill 13 pages. Other functions, like the specialized LOGNORM.INV, come with documentation that is every bit as terse as it was in 2016. This mainly reflects a lack of domain expertise on our part.

If you need to use a function where you find the documentation lacking, please write us, and we’ll be sure to prioritize it for the next round of improvements to the documentation.

Behind the scenes

Our efforts to modernize and expand our documentation has not just involved writing, it has also been an engineering effort. Notably, we developed something close to a CMS (a Content Management System — like a plain text version of WordPress) to make the writing process as enjoyable as possible.

Our CMS has close technical ties to Calcapp proper, to ensure that all the thousands of formulas in the documentation are correct, meaning that we know for a fact that they won’t emit any errors if you copy and paste them into Calcapp Creator. (Provided that all referenced fields and other elements are present, of course.)

(A bonus to having deep technical ties to Calcapp proper is that we can write formulas once, using decimal points, and have the version using decimal commas generated automatically, using the same system that is used for converting your formulas from one decimal separator to the other when you change that preference.)

Those technical ties weren’t always in place. The bulk of the documentation was written before we realized that we needed to invest time in that engineering effort. Once those ties were in place, we had to spend weeks sorting out all our formula blunders. Yes, we make lots of mistakes when writing formulas too — and we’re the ones who wrote the entirety of Calcapp.

Just because a formula doesn’t emit any errors in Calcapp Creator doesn’t mean that it’s correct. A computer scientist would say that a syntactically correct formula isn’t necessarily semantically correct, meaning that it doesn’t necessarily do what we need it to do.

Testing thousands of formulas manually, through copy and paste, wasn’t an enticing prospect, so we put on our engineering hats once more. We wrote a program that took our documentation and generated an app for Calcapp, containing the documentation in its entirety, including not only all formulas but also their results, when calculated through Calcapp.

Our program essentially generated tens of thousands of text fields with multiple lines whose formulas read something like this:

"Returns whether a text string ends with another text string.
ENDSWITH(""support@calcapp.net"", ""@calcapp.net"") [" & ENDSWITH("support@calcapp.net", "@calcapp.net") & "] returns TRUE, as
""support@calcapp.net"" ends with ""@calcapp.net"".""Returns whether a text string ends with another text string.
ENDSWITH(""support@calcapp.net"", ""@calcapp.net"") [" & ENDSWITH("support@calcapp.net"; "@calcapp.net") & "] returns TRUE, as
""support@calcapp.net"" ends with ""@calcapp.net""."

Essentially, we got an app containing all formulas immediately followed by the result of evaluating said formula in brackets. The formula above generates the following output in the app:

Returns whether a text string ends with another text string.
ENDSWITH("support@calcapp.net", "@calcapp.net") [TRUE] returns TRUE, as
"support@calcapp.net" ends with "@calcapp.net".

Still, checking this app to ensure that all formulas returned the expected results took weeks. It helped us catch and fix hundreds of errors, not just formula errors in the documentation — and there were plenty of those — but in Calcapp itself. The part of Calcapp that implements our function library already had thousands of automated tests prior to our documentation effort, but those weren’t enough to fully stamp out all bugs. Thanks to this work, our function library is of higher quality.

We think we can be reasonably confident that our documentation is mostly correct. If you find any errors — in terms of formulas or in terms of grammar — we want to hear from you.

With the new tools we built, we are looking forward to documenting all the new properties and functions we are planning for future versions.

Feature: IF without all the parentheses, SWITCH and IFBLANK

Fri, 12 Nov 2021 11:00:00 +0000

Use the IF function with multiple conditions without having to use more than two parentheses. Use SWITCH when you need to test the same value for equality against other values.

Using multiple conditions with the IF function has traditionally required writing lots of parentheses. Here’s a formula which returns 10 if the value of Field1 is 1, 20 if it is 2, 30 if it is 3 and 99 otherwise:

IF(Field1 = 1, 10, IF(Field1 = 2, 20, IF(Field1 = 3, 30, 99)))IF(Field1 = 1; 10; IF(Field1 = 2; 20; IF(Field1 = 3; 30; 99)))

If you need a large number of conditions, you need to write a great many end parentheses, which gets old fast.

Microsoft introduced the IFS function a few years ago, which only requires two parentheses. You’ll be happy to know that we now fully support this function.

This IFS formula is equivalent to the formula above:

IFS(Field1 = 1, 10, Field1 = 2, 20, Field1 = 3, 30, TRUE, 99)IFS(Field1 = 1; 10; Field1 = 2; 20; Field1 = 3; 30; TRUE; 99)

IFS doesn’t have true support for a fallback value, meaning that you need to use the condition TRUE to include a fallback value.

We wanted to have full support for a fallback value, and we saw no need to use a separate function to do so. We simply extended IF, meaning that this formula works just as well:

IF(Field1 = 1, 10, Field1 = 2, 20, Field1 = 3, 30, 99)IF(Field1 = 1; 10; Field1 = 2; 20; Field1 = 3; 30; 99)

We consider IFS to be a compatibility function. If you copy and paste formulas straight from Excel or need to copy formulas from Calcapp to Excel, by all means, use it. If not, we recommend that you stick with IF and simply leave out all the extra parentheses.

SWITCH

When Microsoft introduced IFS, they also introduced SWITCH, which is perfect when you need to test the same value for equality against other values. Here is a formula using SWITCH, which is equivalent to the other formulas above:

SWITCH(Field1, 1, 10, 2, 20, 3, 30, 99)SWITCH(Field1; 1; 10; 2; 20; 3; 30; 99)

Finally, don’t forget about CHOOSE, which we have supported since 2018. If you only need to test for equality against a sequence of numbers starting with 1 (2, 3, 4, …), CHOOSE is perfect.

CHOOSE has no support for a fallback value, but this formula is in all other respects identical to the others on this page:

CHOOSE(Field1, 10, 20, 30)CHOOSE(Field1; 10; 20; 30)

We added support for CHOOSE partly to enable drop-down field values to easily map to table values. We wrote an app to generate CHOOSE formulas from table data. That technique still works well, but you can also use the new XLOOKUP function along with a new app we wrote to do the conversion.

IFBLANK

Spreadsheets provide a number of convenient functions for working with values which may be errors. ISERROR is a straight-forward function which returns whether a value is an error.

This formula returns TRUE, as numbers cannot be divided by zero:

ISERROR(Field1 / 0)ISERROR(Field1 / 0)

If you want to hide an error value, by using a different value if there is an error, using ISERROR is somewhat awkward:

IF(ISERROR(Field1 / 0), 0, Field1 / 0)IF(ISERROR(Field1 / 0); 0; Field1 / 0)

The formula above uses the value derived from dividing the value of Field1 by zero, but only if it doesn’t lead to an error. (Obviously, this example is just for illustrative purposes, as we know for a fact that dividing a number by zero will always produce an error, so there’s no need to check.)

You’ll note that we need to repeat the calculation in the formula above. We could introduce a hidden field to avoid this, but using IFERROR is even better:

IFERROR(Field1 / 0, 0)IFERROR(Field1 / 0; 0)

The formula above is fully equivalent to the IF formula above — and a lot shorter.

We liked using IFERROR so much that we wanted a version that would do for blank values what IFERROR does for errors. Enter IFBLANK.

Just like the name suggests, IFBLANK returns the first parameter unchanged if it is not blank, and returns the second parameter otherwise:

IFBLANK(Field1, 10)IFBLANK(Field1; 10)

Normally, operators like + treat blank values as though they were the value 0. With IFBLANK, we can easily change that behavior, and make a blank value appear as though it was the value 10, with one easy-to-use function.

Feature: More options for CSV and TSV files

Fri, 12 Nov 2021 10:00:00 +0000

CSV files produced by report buttons can now be customized to make them compatible with more apps and services. Change the decimal separator and the delimiter separating values and lay out values vertically instead of horizontally.

Calcapp offers a variety of formats for you to choose between when sharing field values through email or direct download buttons. One of the most useful formats is CSV, which stands for Comma-Separated Values, which we introduced back in 2016.

CSV files are just what the name implies—a number of values separated by commas:

  "Screen 1:"
  "Field 1","Field 2","Field 3"
  1,2,3
  "Screen 2:"
  "Field 4","Field 5","Field 6"
  4,5,6

This simplicity means that an abundance of tools can import data from CSV files, including spreadsheets like Microsoft Excel and databases.

Unfortunately, there is no real CSV standard, meaning that some tools can have trouble working with the CSV data sent from your apps. When we introduced CSV support, our main goal was to enable Microsoft Excel to easily import data sent from your apps. Since then, we have realized that our customers use a variety of tools to work with our CSV files, which does not always go smoothly. With our new release, our goal is to solve these issues.

When you add a new report button and instruct it to use the CSV format, there is a new section in the inspector with all the new options:

Setting the delimiter and decimal separator

The delimiter is the character that separates values in the CSV file. Before this release, Calcapp always used a comma.

You can now set the delimiter to a tab character, in which case the resulting CSV files are often known as TSV files (short for Tab-Separated Values). We have learned that some apps and services can only work with TSV files, and not CSV files, which means that these apps and services can now finally work directly with TSV files produced directly from your apps. You also have the option of using a space character as a delimiter.

Software used outside of the English-speaking world often uses a semicolon to separate fields. The reason is that they typically use a decimal comma as a decimal separator, and not a decimal point. You can now explicitly set the delimiter to a semicolon.

Microsoft Excel uses the language settings of the host operating system to determine how to handle CSV files. That means that a CSV file produced by Excel in Germany (which uses a decimal comma as a decimal separator and a semicolon as a delimiter) may not be readable by a US English version of Excel (at least not without using the Data > Text to Columns feature). That means that you must often be conscious of what software is used to read your CSV files, and the language settings used by these users.

Before this release, Calcapp always used a decimal point as a decimal separator, regardless of the language your app was configured to use. If Excel was configured to use a decimal comma, these values would be interpreted as text strings and not as numbers. Now, you can set the decimal separator explicitly.

CSV files can use a comma as both a delimiter and as a decimal separator. If you go that route, though, decimal numbers will be surrounded by quotes in the CSV file, which increases the file size.

The default delimiter and decimal separator

When you create a new email report button or download report button, you will find that both the delimiter and decimal separator are set to special values known as Default. When default values are used, the actual values used depend on the language settings of your app.

If the decimal separator is set to the default value, it follows the decimal separator used by the language the app is configured to use (a decimal comma for an app in German and a decimal point for an app in English, for instance).

If the delimiter is set to the default value, a semicolon is used if the configured decimal separator is a decimal comma. Otherwise, a comma is used.

We think that these default settings will produce the desired result for most users. Apps in German tend to produce CSV files which will be consumed by users using German language settings. With the new defaults, that scenario—and many like it—will hopefully just work.

Of course, if your app is in German, but files are sent to headquarters in the UK, you can manually set the decimal separator and delimiter to values which will work in the UK.

Existing apps created by older versions of Calcapp will continue to behave like before. In other words, they will continue to use a decimal point for a decimal separator and a comma as a delimiter, regardless of the language settings of the app. This behavior ensures that our new release does not break existing apps. If you want to change the behavior, simply make the desired changes in Calcapp Creator.

Excluding the delimiter line

There is a new option to “exclude the delimiter line.” Older versions of Calcapp always included this line as the first line in a CSV file.

The delimiter line simply specifies what delimiter is used:

  sep=;
  "Screen 1:"
  "Field 1";"Field 2";"Field 3"
  1;2;3
  "Screen 2:"
  "Field 4";"Field 5";"Field 6"
  4;5;6

Microsoft Excel uses it to correctly read CSV files, regardless of the language settings used by the host operating system. In other words, CSV files produced by previous versions of Calcapp were readable even by versions of Excel normally expecting a semicolon to be used as the delimiter.

(Unfortunately, there is no “decimal separator line” which can be used to instruct Excel what decimal separator is used. That means that decimal numbers in CSV files produced by older versions of Calcapp were likely read as text by Excel if the host operating system was configured to use a decimal comma as the decimal separator.)

Only Excel is known to recognize the delimiter line. If you import a CSV file into Google Sheets, for instance, it will show up as part of your data.

For that reason, excluding the delimiter line if Excel is not used to consume the file is the right course of action. You can also safely exclude it if Excel is used and you know that it is configured to use the same delimiter that your CSV files contain.

Finally, excluding the delimiter line often makes the resulting CSV files much smaller. The reason is that Calcapp can use a more space-efficient character encoding for the file if a delimiter line is not used than the character encoding which would otherwise have been used, because of long-standing issues with Microsoft Excel.

Laying out fields values horizontally or vertically

Since its inception, Calcapp has laid out fields and their values horizontally. Consider an app with two screens, Screen1 and Screen2, each containing three fields. Here’s the output when values are laid out horizontally, if all fields are included:

Screen 1:
Field 1	Field 2	Field 3
1	2	3
Screen 2:
Field 4	Field 5	Field 6
4	5	6

To instead lay out values vertically, choose Arrange values from top to bottom in the inspector. This is the result:

Screen 1:
Field 1	1
Field 2	2
Field 3	3
Screen 2:
Field 4	4
Field 5	5
Field 6	6

When you create a new button, values are laid out vertically by default. However, apps created with older versions of Calcapp will continue to lay out values horizontally until you change the option in Calcapp Creator.

Feature: More customizable reset buttons

Fri, 12 Nov 2021 09:00:00 +0000

Use a formula to determine which fields are reset by a reset button. These buttons can now assign blank values to fields.

Reset buttons were added to Calcapp years ago and have changed little since. You have been limited to either resetting all fields of the current screen or resetting all fields of the app. Also, resetting a field has always meant restoring its value to its initial value, never to a blank value.

Today, reset buttons finally become more customizable.

The IncludedFields property

Like email and download buttons, reset buttons now support the IncludedFields property, which you can set through a formula. For a reset button, this property determines which fields to reset.

In order for the formula to be picked up by Calcapp, you must configure your button to determine what fields to reset using a formula. Choose Select fields using formula from the drop-down menu in the inspector when your button is selected, and then on the fx button next to Included fields to edit the formula:

For instance, to reset Field1, Field2 and Field3, associate the following formula with the IncludedFields property:

{ Field1, Field2, Field3 }{ Field1; Field2; Field3 }

Ranges enable a large number of fields to be referenced in a compact way. This formula resets the fields Field1 and Field5, as well as all fields that appear between them:

Field1:Field5Field1:Field5

This formula resets Field1, Field3 and Field5, as well as the fields that appear between Field3 and Field5:

{ Field1, Field3:Field5 }{ Field1; Field3:Field5 }

You can also reset all fields of a screen simply by referencing the screen in the array, reset all fields of your app by referencing the App object and conditionally reset fields using IF. You can even reference all fields of a screen, and only reset those whose values are greater than 5 (say) using the FILTER function.

For more on how to use the IncludedFields property, including lots of examples, refer to our newly-expanded property documentation.

Resetting fields to blank values

What does it mean to reset a field? Up until today, it has meant setting its value to the same value the field had when it was first shown. If no initial value has been assigned, that is a blank value.

Many app authors found it puzzling to see the value revert to a prior value when the field was reset, though. Instead, they expected fields to lose their values, that is, be assigned blank values.

That behavior can now be realized by selecting Assign blank value in the inspector. The default remains Assign initial value.

Feature: Download and start large apps faster

Fri, 12 Nov 2021 08:00:00 +0000

Many under-the-hood improvements make large apps download and start faster and consume less space when stored for offline use.

Making Calcapp perform better with very large apps has been an ongoing project for us for several years now. In 2018, we started compressing apps sent from our server. Later that year, we made navigating such apps much faster and improved the way our server responds to app requests. In 2019, we responded to an influx of users by tripling the memory available to our server, making very large apps run much better.

Our new release further improves our handling of very large apps. When users download such apps, they will find that they download much faster.

For small apps, you probably won’t notice much difference. For very large apps, however, the savings can be huge. We managed to shrink one app from 158 MB to 30 MB (or from 8.9 MB to 1.7 MB with compression turned on).

Such a large app is not only downloaded faster, it is also processed faster when it starts. Also, storing it for offline use doesn’t consume as much storage for your users.

This post is somewhat technical. If you’re not interested in the nitty-gritty, you can safely skip this material, knowing that large apps now work better.

Omitting default values

One technique we used to make apps download faster is that we no longer send “default values.” What that means is that if you add 100 fields to your app, we used to store all values you set in the inspector, even if you never changed the defaults, for all 100 fields.

Number fields are normally formatted with two decimal places, and if you don’t change that setting, we will no longer send that information when an app is downloaded — your app will just assume that number fields should be formatted with two decimal places unless if hears differently.

It turns out that there are lots of values that app authors rarely change, meaning that we can leave them out most of the time. This makes for significant savings.

Making information about your app easily accessible

There is some information about your apps that our server needs to process very often. One of the most important pieces of information is what version of Calcapp is targeted.

From an app author’s perspective, there are no Calcapp versions, it just regularly improves. Behind the scenes, though, we make changes all the time. We make changes to the way your apps are stored in our database and we make changes to how your apps are represented internally. We even rename properties and functions from time to time, which necessitates rewriting your formulas (prior to this release, for instance, the form screen property NextScreenAvailable was named NextPanelAvailable).

In fact, we spend lots of time writing software that you never see, whose only purpose is to move your apps from one Calcapp version to a more current version, which we refer to as our “migration process.” We have spent a lot of time optimizing this process, with a view towards minimizing server downtime. It now takes roughly 24 hours to migrate all your apps to a new version, but our server remains available during all that time, except for around ten minutes when you can’t change any apps (you can still run apps).

The Calcapp version is really important, and it should be stored in a way that makes it fast to access. We also need quick access your decimal separator preference (decimal comma or decimal point?), so that we can convert all the formulas to your chosen decimal separator when necessary.

Collectively, all this “meta” information is stored in your app “header.” It’s supposed to be at the very start of your app (hence the name), but for various technical reasons, it was sometimes located in the middle, or at the very end of your app. That meant that for very large apps, our server had to repeatedly search through hundreds of megabytes of data to locate the information it needed, making it sluggish.

Thankfully, we have now fixed this issue, meaning that large apps should no longer slow down the server in this way.

Compressing dependencies

Our server does a lot of heavy lifting behind the scenes to ensure that your apps run as quickly as possible. One thing it does is that it figures out what properties depend on one another. Let’s say that the value of Field1 is defined as follows:

Field2.Value * 20Field2,Value * 20

When the value of Field2 changes, your app knows that the value of Field1 depends on it and that it needs to be re-calculated, but that it can use old (cached) values for unaffected properties. We say that Field2.ValueField2,Value is a dependency of Field1.ValueField1,Value and that Field1.ValueField1,Value is a dependent of Field2.ValueField2,Value. This makes your app run much faster than if it had to re-calculate everything every time anything changed.

(Have you ever used “trace precedents” in a spreadsheet? It’s the same idea.)

This information used to take up a lot of space. When Field2.ValueField2,Value noted that Field1.ValueField1,Value depended on it, it used the full name of the screen it belonged to, the full name of Field1 and the full name of the Value property. That can take up a lot of space. Now, we assign numerical identifiers to properties (like “232”) and just reference those.

We also stored even indirect dependents (say, if Field3.ValueField3,Value depends on Field2.ValueField2,Value, which depends on Field1.ValueField1,Value, Field1.ValueField1,Value would store both Field2.ValueField2,Value and Field3.ValueField3,Value as dependents). For some large apps, a single key field could have thousands or tens of thousands of indirect dependents. Just storing the dependents of fields could take up hundreds of megabytes of storage for particularly large apps, which is data that would need to be sent and read every time your app was downloaded.

We now only store direct dependents, meaning that your apps need to do a bit more work when run, but it’s well worth it to save a lot of space.

Also, there are a lot of what we call implicit dependencies between properties. The FormattedValue property of number fields has an implicit dependency on the Value property, meaning that even if you refer to a formatted value, your formula will get re-calculated when the value changes.

These implicit dependencies used to be communicated explicitly by our server. Now, we don’t do that anymore, because your apps are smart enough to know about all those implicit dependencies. That also saves a lot of space.

Finally, we no longer reference properties by name in the JavaScript expressions that your Calcapp formulas are converted to by our server. Instead we use — you guessed it — the numerical identifier we now generate. That makes the JavaScript versions of your formulas a lot shorter too.

The road ahead for large apps

We’ve worked hard for years now on improving support for large apps, and we’ll be the first to admit that we still have a lot of work to do.

In the past, we used to advertise our White Label plan as supporting arbitrarily large apps. We no longer do that, because Calcapp can’t handle arbitrarily large apps. We now advertise our best plan as supporting “up to 5,000 fields.” We don’t actually enforce that limit — you’re welcome to go over it if you like — but we can’t in good conscience claim that we do a good job of supporting apps larger than that.

We actually do pretty well, compared to other app builders. Microsoft asks that you don’t add more than 500 controls to apps built with PowerApps, for instance.

We would like to do better, though, and we have a few changes in mind that we want to make part of our next-generation Calcapp 4 project. Stay tuned, we’ll have more to say on this subject in the future.

What you can do to make large apps run better today

One way to make large apps run better today is to not make them as large — at least not as perceived by Calcapp. In the past, many app authors have liberally used copy and paste to duplicate screens, where the duplicates often differ very little from one another.

There are several disadvantages to this approach. From an author’s perspective, making changes to the duplicated screens becomes an arduous process, with each change having to be made multiple times. From Calcapp’s perspective, having screens be duplicated many times makes apps very large, which may make them run sluggishly or not at all.

Fortunately, there is now a better way. The new NextScreen property of form screens, text screens and navigators enables the same screen to be reachable from many different places. You can even use conditional logic to determine which screen the user should be taken to.

If you make a number of list screen navigators all take the user to the same screen, use the ActiveNavigator property of list screens to learn which navigator was selected. You can even plug the label of the selected navigator into an XLOOKUP formula to look up a value based on the selection.

To learn more, read our post about the new properties.

Feature: Include array elements conditionally with IF

Fri, 12 Nov 2021 07:00:00 +0000

Use IF to determine if an element should be part of an array.

The IF function has special behavior when used inside of arrays. Specifically, if its third parameter is not given, it can be used to determine if array elements should be part of the array.

This can be very useful at times. The IncludedFields property of a reset button is used to determine what fields are reset by the button. This formula makes sure that Field1 is always reset, but Field2 is only reset if the value of Field1 is greater than 4:

{ Field1, IF(Field1 > 4, Field2) }{ Field1; IF(Field1 > 4; Field2) }

In other words, the returned array is { Field1 }{ Field1 } if the value of Field1 is not greater than 4. Otherwise, the returned array is { Field1, Field2 }{ Field1; Field2 }.

Not including the third parameter to IF causes it to return a blank value. That means that these formulas are typically equivalent:

IF(Field1 > 4, Field2)IF(Field1 > 4; Field2)

IF(Field1 > 4, Field2, BLANK())IF(Field1 > 4; Field2; BLANK())

However, these formulas are not equivalent:

{ Field1, IF(Field1 > 4, Field2) }{ Field1; IF(Field1 > 4; Field2) }

{ Field1, IF(Field1 > 4, Field2, BLANK()) }{ Field1; IF(Field1 > 4; Field2; BLANK()) }

If the value of Field1 is not greater than 4, the first formula above returns the array { Field1 }{ Field1 } (without Field2). However, the second formula above returns the array { Field1, BLANK() }{ Field1; BLANK() }.

In other words, when you construct an array and use IF to include elements conditionally, only set the third parameter to BLANK()BLANK() if you want a blank value to be part of your array if the condition does not hold. If you want to leave out the element completely, leave out the third IF parameter.

Feature: Join arrays together with |

Fri, 12 Nov 2021 06:00:00 +0000

Use the new operator | to join together arrays with other arrays and values.

We have a brand new operator for joining together arrays with other arrays and values: the array concatenation operator |. It does for arrays what the text concatenation operator & does for text.

These formulas all return the array { 1, 2, 3, 4 }{ 1; 2; 3; 4 }:

{ 1, 2 } | { 3, 4 }{ 1; 2 } | { 3; 4 }

{ 1, 2, 3 } | 4{ 1; 2; 3 } | 4

1 | { 2, 3, 4 }1 | { 2; 3; 4 }

1 | { 2, 3 } | 41 | { 2; 3 } | 4

Let’s say that you have an email report button (which sends an email with field values when pressed) and a download report button (which downloads a file containing field values when pressed). You set the IncludedFields property of the email report button to a complicated formula which includes all the fields you want to email your user.

Now, what if you want the download report button to include the same fields, but also include another one, Field50? Do you need to copy the original formula for the email report button and change it for the download report button?

No, you can simply reference the original array from the download report button formula and use the | operator to add Field50:

EmailReportButton1.IncludedFields | Field50EmailReportButton1,IncludedFields | Field50

Tip: Debug arrays by inspecting their elements

Fri, 12 Nov 2021 05:00:00 +0000

If a function isn't returning the value you expect, you need to look at the parameters it receives by creating new temporary fields visualizing the parameters. To do so with an array, you need to convert it to a text string first using the TEXTJOIN function.

Let’s say that you need the sum of an array, expressed as a range. Let’s also assume that a form screen holds five number fields, Field1, Field2, Field3, Field4 and Field5, in that order.

You write the following formula:

SUM(Field1:Field5)SUM(Field1:Field5)

The resulting sum isn’t what you expect. What to do?

If SUM, or any other function, isn’t returning the value you expect, you need to look at the parameters it receives. Normally, this would be simple — just add temporary fields to your app with its formulas set to the function parameters you want to inspect. When you run the app, you get to see their values, which helps you figure out why the function isn’t returning the result you expect.

In this case, this is the formula we need to inspect:

Field1:Field5Field1:Field5

When given as a parameter to SUM, the formula above returns an array of numbers. However, there isn’t (yet?) a field which can visualize arrays.

To solve this, you need to convert the formula to a text string, which enables you to display the array of numbers using a text field. For this purpose, the TEXTJOIN function is perfect.

Here’s how to use it to visualize Field1:Field5Field1:Field5:

TEXTJOIN(", ", FALSE, Field1:Field5)TEXTJOIN(", "; FALSE; Field1:Field5)

As its name implies, TEXTJOIN takes an array and converts it to a text string. To do so, it joins all elements of the array together, separating them with the first parameter, ", "", ". The second parameter, FALSE, instructs TEXTJOIN to include blank values, which is important when we need to visualize an array.

The formula above produces a text string like the following, if Field4.ValueField4,Value is blank:

1, 2, 3, , 5.

Technically, Field1:Field5Field1:Field5 is an array of number fields. TEXTJOIN only knows how to process arrays of numbers, logical values, text strings or colors, so it asks Field1:Field5Field1:Field5 to convert itself to such an array. Number fields have values which are numbers, meaning that the formula above is equivalent to this formula:

TEXTJOIN(", ", FALSE, { Field1:Field5 }.Value)TEXTJOIN(", "; FALSE; { Field1:Field5 },Value)

While inspecting the actual values is what you want most of the time, you can also inspect the labels of the fields. Doing so is easy:

TEXTJOIN(", ", FALSE, { Field1:Field5 }.Label)TEXTJOIN(", "; FALSE; { Field1:Field5 },Label)

The formula above produces a text string like the following:

Field 1, Field 2, Field 3, Field 4, Field 5.

Use this tip whenever you need to inspect what elements an array holds.

Tip: Avoid gotchas when adding text boxes and buttons in the middle of a range

Fri, 12 Nov 2021 04:00:00 +0000

Arrays are arguably the biggest addition to our latest Calcapp release. They form a core part of the many new functions and properties, and make Calcapp much more powerful.

However, when used with ranges, it’s easy to lose track of what elements are actually included in an array. That can have surprising results, which the topic for this post.

Blank values and ranges

Consider the following formula:

PRODUCT(Field1:Field3)PRODUCT(Field1:Field3)

PRODUCT multiplies its parameters together and returns the result. SUM is similar, but adds numbers together instead.

Remember that the range Field1:Field3Field1:Field3 is equivalent to the array { Field1, Field2, Field3 }{ Field1; Field2; Field3 }, but only if Field2 is the only element that appears between Field1 and Field3. If that is the case, this formula is equivalent to the one above:

PRODUCT({ Field1, Field2, Field3 })PRODUCT({ Field1; Field2; Field3 })

What happens if you add a text box, named Instructions, right underneath Field1?

That change affects the Field1:Field3Field1:Field3 range. Instead of expanding to the array { Field1, Field2, Field3 }{ Field1; Field2; Field3 }, it expands to the array { Field1, Instructions, Field2, Field3 }{ Field1; Instructions; Field2; Field3 }.

In other words, what Calcapp sees is this formula:

PRODUCT({ Field1, Instructions, Field2, Field3 })PRODUCT({ Field1; Instructions; Field2; Field3 })

Calcapp could show an error here, complaining that while Field1, Field2 and Field3 can be treated as numbers (through their Value properties), Instructions cannot, and therefore must not be used with PRODUCT.

Showing an error wouldn’t be helpful, though, because it would mean that formulas like the one above would break the moment you add a text box or button in the middle of a range. Thankfully, Calcapp is forgiving when handling arrays, and no error is shown.

Instead, PRODUCT is given an array, consisting of the values of the fields and a blank value for the text box, as illustrated by this formula:

PRODUCT({ Field1.Value, BLANK(), Field2.Value, Field3.Value })PRODUCT({ Field1,Value; BLANK(); Field2,Value; Field3,Value })

PRODUCT ignores the blank value, and returns the product of the field values, as expected. Had it not ignored the blank value, and instead treated it as zero, the returned value would have been zero.

It would arguably be surprising behavior if adding a text box in the middle of the Field1:Field3Field1:Field3 range caused formulas to seemingly malfunction, so it’s a good thing that PRODUCT ignores blank values.

Blank values are not always ignored

So far, everything works the way we expect it to. However, what happens if we try to add 2 to the elements of an array?

Consider this formula:

PRODUCT(Field1:Field3 + 2)PRODUCT(Field1:Field3 + 2)

The formula above applies the PRODUCT function to the array that results from adding 2 to the Field1:Field3Field1:Field3 range.

When the range is expanded, the following equivalent formula is the result:

PRODUCT({ Field1, Instructions, Field2, Field3 } + 2)PRODUCT({ Field1; Instructions; Field2; Field3 } + 2)

When the value to the left of the + operator is an array and the value to its right is a number — which is the case above — the number is added to each element of the array.

Field1, Field2 and Field3 are number fields. 2 cannot be added directly to them, but can be added to their Value properties. That causes Field1 + 2Field1 + 2 to be expanded to Field1.Value + 2Field1,Value + 2.

Instructions is a text box, though, and it does not have a number property. That causes Calcapp to replace it with a blank value before adding 2 to it: BLANK() + 2BLANK() + 2.

Here’s the fully-expanded formula:

PRODUCT({ Field1.Value + 2, BLANK() + 2, Field2.Value + 2, Field3.Value + 2 })PRODUCT({ Field1,Value + 2; BLANK() + 2; Field2,Value + 2; Field3,Value + 2 })

In BLANK() + 2BLANK() + 2, the + operator treats a blank value as zero, and therefore returns 2. That means that PRODUCT longer ignores the text box that appears in the array, as the second value passed to PRODUCT is 2 and not a blank value, causing the result to be twice the number you might expect.

In other words, if you use a formula like PRODUCT(Field1:Field3 + 2)PRODUCT(Field1:Field3 + 2), you’ll get different results depending on if you add a text box or button in the middle of the range. If your app returns puzzling results and you use ranges, this is important to be aware of.

If you are unsure what array elements are included in a range, create a temporary field whose only purpose is printing the elements of the array. That is the topic for this tip.

Blank array elements and FILTER

Blank values in arrays and ranges can also cause surprising results when used with the FILTER function.

To recap, FILTER accepts an array as its first parameter and returns a version of this array which only contains elements that have passed a test you have supplied.

This formula returns an array of fields whose values are greater than 4:

FILTER(Field1:Field3, Field1:Field3 > 4)FILTER(Field1:Field3; Field1:Field3 > 4)

(The Field1:Field3 > 4Field1:Field3 > 4 formula fragment returns the logical array expected by FILTER. Consult our documentation for the > operator to learn more.)

The formula above expands to this formula, if Field3 directly follows Field2, which directly follows Field1:

FILTER({ Field1, Field2, Field3 }, { Field1, Field2, Field3 } > 4)FILTER({ Field1; Field2; Field3 }; { Field1; Field2; Field3 } > 4)

Now, let’s once more consider what happens when the text box Instructions appears just below Field1. If that is the case, the first formula of this section — using the range Field1:Field3Field1:Field3 — is equivalent to this formula:

FILTER({ Field1, Instructions, Field2, Field3 }, { Field1, Instructions, Field2, Field3 } > 4)FILTER({ Field1; Instructions; Field2; Field3 }; { Field1; Instructions; Field2; Field3 } > 4)

The > operator can only work with numbers, logical values, text strings and colors. The number fields can return their values to satisfy these requirements, but Instructions is a text box and cannot do the same. As a result, it is replaced by a blank value.

The formula above expands to this formula:

FILTER({ Field1, Instructions, Field2, Field3 }, { Field1.Value, BLANK(), Field2.Value, Field3.Value } > 4)FILTER({ Field1; Instructions; Field2; Field3 }; { Field1,Value; BLANK(); Field2,Value; Field3,Value } > 4)

In other words, the first element of the array to filter — Field1 — is only kept if Field1.ValueField1,Value is greater than 4, and likewise for the other fields. The second element of the array to filter — Instructions — is only kept if BLANK()BLANK() is greater than 4 (which it is not, as the > operator treats a blank value as zero).

Therefore, somewhat counter-intuitively, Instructions is not part of the returned array because it is not considered to be greater than 4. Had the condition been < 4< 4 instead, it would have been included, as the < operator would have treated it as the value zero.

FILTER used with formula fragments works differently

There is a variant of FILTER that doesn’t take a logical array as its second parameter, but a formula fragment. This fragment is invoked once per array element, with the element under consideration available as Element, and is expected to return TRUE if the element should be included and FALSE otherwise.

These two formulas are equivalent if the Field1:Field3Field1:Field3 range only contains number fields:

FILTER(Field1:Field3, Field1:Field3 > 4)FILTER(Field1:Field3; Field1:Field3 > 4)

FILTER(Field1:Field3, Element > 4)FILTER(Field1:Field3; Element > 4)

(The version using a formula fragment is a Calcapp extension. It has more in common with JavaScript’s filter() function than with Excel’s FILTER function.)

However, if the Field1:Field3Field1:Field3 range also includes a text box, the first formula above will work, but you will get an error message from the second version in Calcapp Creator, preventing you from sharing your app. The reason is that formula fragments are more strict than arrays.

To get a better feeling for how this works, consider this formula:

FILTER({ SwitchField1, NumberField1 }, Element.Visible)FILTER({ SwitchField1; NumberField1 }; Element,Visible)

This formula returns an array consisting of the fields of the first array which are visible. It works, because both number fields and switch fields support the Visible property.

Now consider this formula:

FILTER({ SwitchField1, NumberField1 }, Element.MinimumValue >= 0)FILTER({ SwitchField1; NumberField1 }; Element,MinimumValue >= 0)

The MinimumValue is a property of number fields. As this property is not supported by switch fields, Calcapp Creator will show an error message.

However, if we use a logical array instead, the formula will work with no errors:

FILTER({ SwitchField1, NumberField1 }, { SwitchField1, NumberField1 }.MinimumValue >= 0)FILTER({ SwitchField1; NumberField1 }; { SwitchField1; NumberField1 },MinimumValue >= 0)

Here is the equivalent formula:

FILTER({ SwitchField1, NumberField1 }, { BLANK(), NumberField1.MinimumValue } >= 0)FILTER({ SwitchField1; NumberField1 }; { BLANK(); NumberField1,MinimumValue } >= 0)

The formula above returns an array containing both SwitchField1 and NumberField1, because the blank value is treated as zero by the >= operator, which passes the >= 0>= 0 test.

Sample app: Convert spreadsheet tables to XLOOKUP formulas

Fri, 12 Nov 2021 03:00:00 +0000

Our latest sample app converts spreadsheet column data to formulas that use the XLOOKUP function. This post explains in detail how it was built.

Create a new app based on this sample app ↗

August 11, 2023 update: We now recommend that you use the data editor to import and edit spreadsheet data. It is significantly easier to use than the method described here.

Original text: We publish sample apps as a means of demonstrating Calcapp features and techniques that you may want to use in your own apps that you distribute to your own users. This sample app is different — the intended user is you, the app author, and it helps you convert spreadsheet data to formulas that use the new XLOOKUP function.

Read this blog post to get a high-level overview of how to use this app to import table data and to learn how XLOOKUP works. This post explains in detail how to use the app converting spreadsheet data and how it was written.

To summarize, Calcapp now supports the XLOOKUP function, which is equivalent to the classic spreadsheet functions VLOOKUP and HLOOKUP. XLOOKUP accepts the sought value and two arrays, one containing values to find (the lookup array) and one containing the values to return (the result array).

This formula returns 300, because the sought value, 30, is the third element in the first array, which causes XLOOKUP to return the third element in the second array, 300:

XLOOKUP(30, { 10, 20, 30 }, { 100, 200, 300 })XLOOKUP(30; { 10; 20; 30 }; { 100; 200; 300 })

As Calcapp does not yet have native support for data tables, the data must be converted to XLOOKUP formulas. That’s the job of this app.

Usage

Here’s an embedded version of the app, which you can also run as a stand-alone app:

For step-by-step instructions on how to use this app, refer to this blog post.

Copy the lookup values from a spreadsheet table and paste them into the Lookup values field. Then, copy the result values and paste them into the Result values field. The generated XLOOKUP formula then becomes available.

Be sure to select the decimal separator you’re using using the Decimal separator field, to ensure that the generated formula works well with Calcapp Creator. If you use a decimal comma as a decimal separator, the app will use semicolons to separate parameters. If you use a decimal point as a decimal separator, the app will use commas to separate parameters.

Also, the app automatically detects if the values are numbers or text. If they are numbers (potentially starting with a currency symbol, such as “$”), the elements of the generated array are not quoted, ensuring that you get numbers — and not text — back when you call the function.

Under the hood

This app makes heavy use of Calcapp’s new formula engine, which we introduced with our November release. Thanks to the new features, this app is considerably simpler than the sample app that generates CHOOSE formulas we wrote in 2018.

You’re encouraged to view the app and its formulas as you read along. It’s available as a template when you create a new app under the Sample: XLOOKUP generator name.

Note: This post explains in detail how the XLOOKUP generator app is implemented. Feel free to skip it altogether if you’re just interested in using the app and not in how it was written.

Handling separators

This app works with both decimal points and decimal commas. It is important for the app to have access to this information, because the generated XLOOKUP formula uses commas as a parameter separator if a decimal point is selected and semicolons otherwise. Also, the app recognizes when users enter numbers as lookup or result values and leaves out quotation marks if that is the case.

There is a text drop-down field named Decimal separator. In order to insulate the rest of the app from having to know about the actual wording of the options available to the user, there are two hidden text fields that expose the chosen decimal separator and parameter separator as text strings.

The first is named DecimalSeparatorText and this is its value formula:

IF(DecimalSeparator = "Decimal point", ".", ",")IF(DecimalSeparator = "Decimal point"; "."; ",")

The second is named ParameterSeparatorText and this is its value formula:

IF(DecimalSeparator = "Decimal point", ",", ";")IF(DecimalSeparator = "Decimal point"; ","; ";")

Detecting numbers with a regular expression

It is important that the app can recognize numbers. To do so, we would normally use a function like PARSENUMBER, which returns an error if the given text string is not a number and the parameter as a number otherwise. This doesn’t work with this app, though, as it needs to be able to work with both decimal points and decimal commas.

PARSENUMBER does not work for this app, as it takes the language of the app into account and its decimal separator (a decimal point for US English and a decimal comma for German, for instance). PARSENUMBER can’t be coaxed into working with decimal commas if the language of the app uses a decimal point, and vice versa.

As a result, we need to detect if a text string is a number using a regular expression. These text strings can be notoriously tricky to get right, and we’ll be the first to admit that writing this sample app required a trip to the excellent regex101.com to make our regular expression work.

(Have you never heard of regular expressions before? They are a powerful tool to work with text. We wrote a lengthy introduction back in 2018 when Calcapp gained support for them. Be sure to read that post first if you want to understand this section. If not, feel free to skip ahead.)

To determine if a text string matches a regular expression, we need to use the REGEXMATCH function. \d matches a single digit, and \d+ matches one or multiple digits.

As a result, both these formulas return TRUE, indicating that both “123” and “123456789” match the regular expression \d+:

REGEXMATCH("123", "\d+")REGEXMATCH("123"; "\d+")

REGEXMATCH("123456789", "\d+")REGEXMATCH("123456789"; "\d+")

The regular expression \d+ can be used to match multiple integers, but what about decimal numbers? If a decimal point is used, \d+\.\d+ matches a decimal number. (The backslash before the period is there because periods are otherwise special characters in regular expressions that match anything. With a backslash, the period in the formula above matches a literal period.)

To make the regular expression work for arbitrary numbers — integers or decimal numbers — we need to make the decimal part optional. Consider this regular expression:

\d+(\.\d+)?

The part in parentheses matches the decimal part of the number. By putting a question mark after the closing parenthesis, the entire decimal part is made optional.

There are five more changes we need to make to make the regular expression complete, though. First, it must accept negative numbers, so we add a leading minus sign, followed by a question mark to make the minus sign optional:

-?\d+(\.\d+)?

Second, it must accept numbers that are preceded by a currency symbol (such as “$”). We don’t want these lines to count as text lines. \p{Sc} matches a currency symbol in a regular expression. It needs to go after the minus sign:

-?\p{Sc}?\d+(\.\d+)?

Third, we need to accept decimal numbers where the zero isn’t spelled out (like in .1). To do so, we must change the first + character, which accepts one or multiple digits, to a * character, which accepts zero or multiple digits:

-?\p{Sc}?\d*(\.\d+)?

Fourth, we only want to accept text strings that only consist of numbers, meaning that “3a” or “a3” should not qualify. To do so, we need to add so-called anchors. ^ represents the beginning of the text string, and is added first, and $ represents the end of the text string, and is added last:

^-?\p{Sc}?\d*(\.\d+)?$

Above, the anchors prevent arbitrary text from appearing between the beginning of the text string and the number, and between the number and the end of the text string.

Finally, we need to accept a decimal comma and not a decimal point if that is the user’s preference. Remember that the symbol the user prefers is stored as the value of the DecimalSeparatorText hidden field. That means that we need to replace \. in the expression with \, if that is the case. (A leading backslash isn’t strictly speaking needed here, as a comma has no special meaning in this context. It does no harm, though, so it stays.) We use the & operator to join together the various pieces of the expression we need.

Putting it all together, this is the formula for the value of the hidden field NumberRegex, which we’ll refer back to from other formulas later:

"^-?\p{Sc}?\d*(\" & DecimalSeparatorText & "\d+)?$""^-?\p{Sc}?\d*(\" & DecimalSeparatorText & "\d+)?$"

Determining if a text field only consists of numeric lines of text

Users are expected to paste their lookup values into the LookupValues text field and their result values into the ResultValues text field. Below each of them, we add two hidden logical fields which determine if the text fields only hold numbers, named LookupValuesAreNumbers and ResultValuesAreNumbers.

It is possible to use the REGEXMATCH function directly with text strings consisting of multiple lines. However, we won’t do that here, instead we’ll use the new TEXTSPLIT function to create an array of text strings (with one line per array element) from the original text string. If you’re interested in the other approach, refer to our write-up for the app producing CHOOSE formulas.

TEXTSPLIT breaks a text string apart and returns the pieces as an array of text strings. This formula returns the array { "1", "2", "3" }{ "1"; "2"; "3" }:

TEXTSPLIT("1-2-3", "-")TEXTSPLIT("1-2-3"; "-")

In the formula above, “-“ is used as the delimiter between the returned array elements. With a text field accepting multiple lines, the delimiter we are looking for is a line break character, which the new NEWLINE function returns.

As such, this formula breaks the text string LookupValues apart, returning an array of the lines of text it consists of:

TEXTSPLIT(LookupValues, NEWLINE())TEXTSPLIT(LookupValues; NEWLINE())

To determine if the individual text lines can be considered numbers, we can invoke the REGEXMATCH function directly on the array:

REGEXMATCH(TEXTSPLIT(LookupValues, NEWLINE()), NumberRegex)REGEXMATCH(TEXTSPLIT(LookupValues; NEWLINE()); NumberRegex)

The second parameter is set to NumberRegex, which is the hidden text field we constructed earlier holding the regular expression which matches numbers.

REGEXMATCH normally accepts two parameters (and a few optional parameters we won’t discuss here). The first one is a text string to match against a regular expression, given as the second parameter. It returns TRUE if the regular expression matches the given text string and FALSE otherwise.

Our new formula engine ensures that REGEXMATCH can also work with arrays. If the first parameter is an array — which it is, in this case — the result is also an array. Specificially, the result is an array of logical values, with the same size as the original text array. If { TRUE, FALSE, TRUE }{ TRUE; FALSE; TRUE } is returned, that means that the array given to REGEXMATCH contains three elements, and that the first and third elements match the regular expression given as the second parameter, while the second element does not.

So how do we go from a logical array, where each element signifies whether a single line can be interpreted as a number, to a single logical value, where TRUE means that all elements can be interpreted as numbers and FALSE indicates that there is at least one element that does not qualify?

Enter AND. This formula returns FALSE, because there is at least one FALSE element:

{ TRUE, TRUE, FALSE, TRUE, TRUE }{ TRUE; TRUE; FALSE; TRUE; TRUE }

AND only returns TRUE if all elements given to it are TRUE. This formula returns TRUE:

{ TRUE, TRUE, TRUE, TRUE, TRUE }{ TRUE; TRUE; TRUE; TRUE; TRUE }

Putting it all together, this is the formula associated with the value of the LookupValuesAreNumbers hidden field:

AND(REGEXMATCH(TEXTSPLIT(LookupValues, NEWLINE()), NumberRegex))AND(REGEXMATCH(TEXTSPLIT(LookupValues; NEWLINE()); NumberRegex))

The formula for the ResultValuesAreNumbers hidden field is similar.

Generating the XLOOKUP formula

The GeneratedXLOOKUPFormula field contains the generated formula. The formula of the value of this field uses the & operator heavily to join text strings together. It makes use of the hidden field ParameterSeparatorText to ensure that it inserts the proper parameter separator (a comma if a decimal point is used and a semicolon otherwise).

There are two final hidden fields we need in order to make the formula for the value of the GeneratedXLOOKUPFormula field more readable. They are named LookupQuoteIfNeeded and ResultQuoteIfNeeded.

The idea is that these hidden fields should contain a single quotation mark (“), but only if the corresponding text field does not exclusively contain lines that can be interpreted as numbers. These hidden text fields can then be referenced from the final formula as an easy means of inserting quotation marks, but only if they are needed.

Here’s the formula for the value property of the LookupQuoteIfNeeded field:

IF(!LookupValuesAreNumbers, """")IF(!LookupValuesAreNumbers; """")

The second parameter to IF may look a bit odd, but that’s actually how a single quotation mark is written in Calcapp (and in spreadsheets). Of the four quotation marks, the first and the last demarcate the text string. To write a single quotation mark, two quotation marks must be written, because a single one would end the text string prematurely.

Before we look at the final formula, let’s look at the expected results from the app. Let’s say that we have a very simple table, consisting of only two rows and two columns. Here it is:

Name	Age
Louise	53
Ahmed	28

The user is expected to paste the contents of the first column into the LookupValues field, and the contents of the second column into the ResultValues field. We then want the app to generate this formula if the preferred decimal separator is a decimal point:

XLOOKUP(SoughtValue, { "Louise", "Ahmed" }, { 53, 28 })XLOOKUP(SoughtValue, { "Louise", "Ahmed" }, { 53, 28 })

We want the app to generate this formula if the preferred decimal separator is a decimal comma:

XLOOKUP(SoughtValue; { "Louise"; "Ahmed" }, { 53; 28 })XLOOKUP(SoughtValue; { "Louise"; "Ahmed" }, { 53; 28 })

Before we move on to the final formula that generates the formulas above, let’s consider what it takes to generate just the arrays to XLOOKUP. We have already concluded that we can convert the value of the LookupValues text field (complete with line breaks) to an array of its constituent lines with this formula:

TEXTSPLIT(LookupValues, NEWLINE())TEXTSPLIT(LookupValues; NEWLINE())

How do we put it back together to form a text string, once more, this time with different delimiters? Remember that the delimiter used above is a line break. This time around, we want the delimiter to be a parameter separator character (a comma or a semicolon), followed by a space for readability.

To achieve this, we use the TEXTJOIN function. This formula does exactly what is described in the preceding paragraph:

TEXTJOIN(ParameterSeparatorText & " ", TRUE, TEXTSPLIT(LookupValues, NEWLINE()))TEXTJOIN(ParameterSeparatorText & " "; TRUE; TEXTSPLIT(LookupValues; NEWLINE()))

(The second parameter, TRUE, instructs TEXTJOIN to ignore blank values.)

Now, what if the lookup values consist of text strings (meaning that the value of the LookupValuesAreNumbers hidden field is FALSE)? Then we need to use not only , or ; as delimiters, but " , " or " ; " (so that the elements of the array end with and start with a quotation mark).

This formula does just that:

TEXTJOIN(LookupQuoteIfNeeded & ParameterSeparatorText & " " & LookupQuoteIfNeeded, TRUE, TEXTSPLIT(LookupValues, NEWLINE()))TEXTJOIN(LookupQuoteIfNeeded & ParameterSeparatorText & " " & LookupQuoteIfNeeded; TRUE; TEXTSPLIT(LookupValues; NEWLINE()))

To truly generate an array, though, we also need the begin and end braces, { and }. Also, we potentially need to add quotation marks to the beginning of the first element and to the end of the last element.

Here’s the formula for a hidden text field named GeneratedLookupArray:

"{ " & LookupQuoteIfNeeded & TEXTJOIN(LookupQuoteIfNeeded & ParameterSeparatorText & " " & LookupQuoteIfNeeded , TRUE, TEXTSPLIT(LookupValues, NEWLINE())) & LookupQuoteIfNeeded & " }""{ " & LookupQuoteIfNeeded & TEXTJOIN(LookupQuoteIfNeeded & ParameterSeparatorText & " " & LookupQuoteIfNeeded ; TRUE; TEXTSPLIT(LookupValues; NEWLINE())) & LookupQuoteIfNeeded & " }"

There is a similar hidden text field named GeneratedResultArray.

Here’s the complete formula, combining the values of GeneratedLookupArray and GeneratedResultArray:

"XLOOKUP(" & SoughtValue & ParameterSeparatorText & " " & GeneratedLookupArray & ", " & GeneratedResultArray & ")""XLOOKUP(" & SoughtValue & ParameterSeparatorText & " " & GeneratedLookupArray & ", " & GeneratedResultArray & ")"

One last thing

At first blush, the complete formula above appears to work very well. It works for plain numbers and it works for text strings.

However, what about numbers that are preceded by currency symbols? The NumberRegex field treats them as numbers, which leads this app to generate an XLOOKUP formula such as this one:

XLOOKUP(SoughtValue, { "Louise", "Ahmed" }, { $53, $28 })XLOOKUP(SoughtValue; { "Louise"; "Ahmed" }; { $53; $28 })

That’s not a valid Calcapp formula — numbers can’t be preceded by currency symbols.

To fix this problem, we need to take steps to remove the currency symbols. To do so, we’ll modify the TEXTSPLIT parts of the formulas for the values of GeneratedLookupArray and GeneratedResultArray. Here is part of the formula for the value of GeneratedResultArray:

TEXTSPLIT(ResultValues, NEWLINE())TEXTSPLIT(ResultValues; NEWLINE())

(We’ll show this exclusively for result values, the formula for the value of GeneratedLookupArray also needs to be modified.)

First off, if the result values are not numbers, the formula above is exactly what we need — no currency symbols should be removed. We’ll achieve this with IF:

IF(ResultValuesAreNumbers, …, TEXTSPLIT(ResultValues, NEWLINE()))IF(ResultValuesAreNumbers; …, TEXTSPLIT(ResultValues; NEWLINE()))

We’ll need to replace … in the formula above with a formula fragment that removes currency symbols.

To achieve this, we’ll rely on another regular expression:

([\P{Sc}]*)\p{Sc}?(.*)

\P{Sc} means “not a currency symbol” and \p{Sc} means “a currency symbol.” What this regular expression does is that it divides a text string into two halves (captured by two capturing groups), one consisting of the text that appears before a currency symbol and one consisting of the text that appears after. The currency symbol itself appears between the two halves and is not part of either capturing group.

(Capturing groups appear between parentheses in regular expressions and capture text, in this case the two halves mentioned above.)

The REGEXEXTRACT function can be used to extract the text captured by a capturing group. To use it, we need to provide the number of the capturing group as the third parameter (1 or 2, in this case, as there are two capturing groups).

Using REGEXEXTRACT would work — but would not be ideal, as we’d then need to repeat the REGEXEXTRACT invocation (once with 1 as the third parameter and once with 2 as the second parameter) and merge together the results using the & operator.

The new REGEXEXTRACTALL function is different from REGEXEXTRACT in that it returns the contents of all capturing groups as an array. That’s perfect, as we can then merge together the two halves (without the currency symbol) not with &, but with TEXTJOIN, with a delimiter set to """".

Here’s the formula with the … part filled in:

IF(ResultValuesAreNumbers, TEXTJOIN("", FALSE, REGEXEXTRACTALL(TEXTSPLIT(ResultValues, NEWLINE()), "([\P{Sc}])\p{Sc}?(.)")), TEXTSPLIT(ResultValues, NEWLINE()))IF(ResultValuesAreNumbers; TEXTJOIN(""; FALSE; REGEXEXTRACTALL(TEXTSPLIT(ResultValues; NEWLINE()); "([\P{Sc}])\p{Sc}?(.)")); TEXTSPLIT(ResultValues; NEWLINE()))

Here’s the complete formula for GeneratedResultArray:

"{ " & ResultQuoteIfNeeded & TEXTJOIN(ResultQuoteIfNeeded & ParameterSeparatorText & " " & ResultQuoteIfNeeded, TRUE, IF(ResultValuesAreNumbers, TEXTJOIN("", FALSE, REGEXEXTRACTALL(TEXTSPLIT(ResultValues, NEWLINE()), "([\P{Sc}])\p{Sc}?(.)")), TEXTSPLIT(ResultValues, NEWLINE()))) & ResultQuoteIfNeeded & " }""{ " & ResultQuoteIfNeeded & TEXTJOIN(ResultQuoteIfNeeded & ParameterSeparatorText & " " & ResultQuoteIfNeeded; TRUE; IF(ResultValuesAreNumbers; TEXTJOIN(""; FALSE; REGEXEXTRACTALL(TEXTSPLIT(ResultValues; NEWLINE()); "([\P{Sc}])\p{Sc}?(.)")); TEXTSPLIT(ResultValues; NEWLINE()))) & ResultQuoteIfNeeded & " }"

Backward compatibility and our new formula engine

Fri, 12 Nov 2021 02:00:00 +0000

We work hard to ensure that your apps continue working, even as we add features to Calcapp. With our new formula engine, we have made some minor changes, but they should not affect your existing apps.

We take backwards compatibility seriously. What that means is that we work hard to ensure that your apps continue working, even as we add features to Calcapp.

We realize that the apps you build with Calcapp are often used in business-critical situations, and the last thing you need is to have — say — a production line grind to a halt just because we made some changes. We also realize that many apps are built by staff members who may no longer be with an organization a year or two down the road, and that making changes to existing apps can be difficult for many organizations. In other words, apps should never break.

This release does bring with it a completely revamped formula engine, though, and there are some rare edge cases where formulas now behave differently.

We don’t think that this will affect your apps, though. We have manually tested most public apps on a paid plan with both the old Calcapp version and the current version, and the apps behave identically. We have also used automated tools to scan your formulas for potential problems and have turned up empty-handed.

Had Calcapp been a conventional desktop application, things would have been different. We wouldn’t have had access to your apps and your formulas, and making any backward-incompatible changes — however minor — would have been unthinkable. We’re glad that we do have access to the apps run on our platform, because that gives us the opportunity to make small changes to the way apps work.

In other words, we don’t think that this new release should cause your apps to perform differently. If that isn’t the case, though, and you do experience issues, please contact us immediately. We’ll work with you to resolve any issues — at no additional cost to you.

Backward-incompatible changes

This is a list of changes that result in formulas behaving differently in edge cases. If you’re not particularly interested in formulas, and your apps seem to work just fine, this is probably dry reading.

Colors

We pride ourselves on being able to detect lots of formula errors at an early stage. What that means is that you get clear error messages directly in Calcapp Creator, instead of getting puzzling behavior when you run your app.

If you, for instance, try to associate the formula "test""test" with the value of a number field, Calcapp Creator would let you know that it expected a number, but unexpectedly found a text string. (It will then offer to convert your number field to a text field.)

Prior to this release, Calcapp supported only numbers, text strings and logical values. You had to express a date or a time as a number, and that was also true for colors.

The problem with using numbers for things that aren’t strictly speaking numbers is that you lose Calcapp’s ability to flag formula errors early. If you set the value of a date and time field to 42, Calcapp won’t complain, as that’s a valid sequential serial number. Likewise, if you set the background color of a screen to Field1 * 100Field1 * 100, an older version of Calcapp would have accepted the formula.

We have seen lots of formulas likely intended for the value properties of number fields erroneously associated with color properties instead. That leads to colors being off and to formulas carefully written by app authors seemingly not having an effect.

To solve this problem, colors are no longer numbers in Calcapp, they are colors (a separate type). Functions like COLOR now return colors and not numbers, and functions like HUE accept color parameters, not number parameters. Any attempt to associate a formula like Field1 * 100Field1 * 100 with a color property will now be flagged as an error.

If you know what you’re doing, treating a color as a number can be useful. For that reason, there is a new function, TOCOLOR, which allows you to convert a number to a color. Use TONUMBER to convert a color to a number.

Truth be told, we undertook this ambitious change with a view towards making dates and times distinct from numbers too. That would have made it illegal to do something like taking the square root of a date and time value, which is never useful.

However, we came to realize that advanced spreadsheet users (some of whom are our valued customers) are very much familiar with how date and time values work. (The integer part of the number represents the number of days that have elapsed since December 31, 1899.) Some advanced users put numeric values representing various dates in formulas directly, without using functions like DATE and TIME. As a result, we abandoned that part of the plan — date and time values will remain numbers.

So what happens if your perfectly-functional app uses colors in a way that Calcapp now considers invalid? They have automatically been rewritten to use the TOCOLOR and TONUMBER functions, meaning that your apps will continue working exactly as they did before.

Renamed properties

This release brings with it various name changes. Notably, panels are now named screens and list panel options are now named navigators. Those name changes affect the naming of two properties.

Specifically, the form screen and text screen property NextScreenAvailable used to be named NextPanelAvailable. Also, the NavigatorLabelColor property of screens used to be named OptionLabelColor.

These properties are rarely referenced from formulas. However, it does happen. This formula could be associated with the Visible property of a text box to only show it if the next screen is not available:

!FormScreen1.NextScreenAvailable!FormScreen1,NextScreenAvailable

(Perhaps the text box has information on how to fill out the form so that the user is allowed to progress to the next screen.)

If you referenced any of these two properties from your formulas, these formulas have automatically been rewritten to use the new names.

The == and != operators

Prior to this release, the = and == operators were identical, as were the <> and != operators.

Our new release makes them behave slightly differently, especially in regards to arrays. These two formulas are not equivalent:

{ 1, 2, 3 } = { 1, 3, 2 }{ 1; 2; 3 } = { 1; 3; 2 }

{ 1, 2, 3 } == { 1, 3, 2 }{ 1; 2; 3 } == { 1; 3; 2 }

The first formula returns the array { TRUE, FALSE, FALSE }{ TRUE; FALSE; FALSE }, indicating that the elements appearing in the first position of both arrays are identical, but that the others are not. To determine if all elements match, you need to wrap the result array with the AND function:

AND({ 1, 2, 3 } = { 1, 3, 2 })AND({ 1; 2; 3 } = { 1; 3; 2 })

An easier way to achieve this is to use ==. The == formula above returns FALSE, indicating that the two arrays are not identical. The == operator does an element-for-element comparison of the two arrays and returns TRUE only if all elements match.

From a backward compatibility perspective, this is not relevant, as prior Calcapp releases did not support arrays. However, = and == differ in one respect that is relevant for existing apps.

Specifically, when these operators are used to compare text strings, = is case-insensitive, meaning that “A” and “a” are considered equal. This is the traditional spreadsheet behavior, necessitating the use of the EXACT function to determine if two text strings are truly identical.

== is now case-sensitive, meaning that “A” and “a” are not considered equal. This would break backward compatibility, which is why we change all formulas so that they use = instead of ==, and <> instead of !=.

Some properties no longer return blank values

Color properties have, since their inception, never returned blank values. If you access the background color of a screen, it returns the background color it uses, even if there is no formula associated with the BackgroundColor property of that screen, or if this formula returns a blank value.

The Visible, Enabled and Valid properties now behave in the same way. That means that if a formula references the Enabled property of a field, the value of this property always reflects whether the field is enabled, even if no formula is associated with that property or if that formula returns a blank value.

This change could theoretically break apps, but we have reason to believe that no app on a paid plan is affected.

Decimal separators and the & operator

When the & operator, which joins text strings together, is used to join a text string together with a number, the decimal separator preference of the language the app has been configured to use is now taken into account.

Consider this formula:

"The answer is: " & NumberField1"The answer is: " & NumberField1

Let’s say that the value of NumberField1 is 1.1. If the language of the app is set to US English, the result is “The answer is: 1.1”. If the language of the app is set to French, the result is “The answer is: 1,1”.

Previously, Calcapp would always use a decimal point in this context. With this change — and the ability to use decimal commas in formulas — decimal commas are now used everywhere if that is your preference (provided that your apps use a language that uses a decimal comma).

This change also applies to functions like CONCATENATE and CONCAT. With these functions and & now converting numbers to text and respecting the decimal separator preference of the app, you may no longed need to use the FORMATNUMBER function, if you don’t need the specialized features offered by that function (like support for thousands separators).

Technically, this change could break your apps, if you explicitly access a textual version of a number and expect to find a decimal point, even if the language of the app uses a decimal comma. We have reason to believe that none of our paid apps do this, though, so this change should be safe.

Feature: No more typos when referencing colors

Fri, 12 Nov 2021 01:00:00 +0000

Colors can now be referenced with no risk of typos, thanks to "enums." XLOOKUP, XMATCH and FORMATDATE also support enums, which help warn you of errors early.

Calcapp gained the ability to customize the colors of apps back in 2017. At that time, we also introduced the COLOR function, which converts a text string to a color.

Using the COLOR function

There are multiple ways to reference the color red using the COLOR function. These formulas are all equivalent:

COLOR("red")COLOR("red")

COLOR("rgb(255, 0, 0)")COLOR("rgb(255, 0, 0)")

COLOR("hsl(0, 100%, 50%)")COLOR("hsl(0, 100%, 50%)")

COLOR("#f00")COLOR("#f00")

COLOR("#ff0000")COLOR("#ff0000")

The first formula refers to the color by its name and the others use text strings which make sense to a web developer (details).

If you make a typo when typing the COLOR parameter, you will get an error when you run your app (or get unexpected behavior, like the wrong color showing up). That’s not ideal — getting an error in Calcapp Creator when you type your formula makes for a much tighter feedback loop, allowing you to correct your formula and move on to the next order of business much faster.

(In fact, we have taken steps to ensure that color formulas entered in the wrong places now generate errors in Calcapp Creator instead of just leading to apps with puzzling behavior.)

Introducing a new way of referencing colors

To eliminate these errors, we are introducing a new way of referencing colors: Simply type Color.Color,, followed by the name of the color.

These two formulas are equivalent:

COLOR("red")COLOR("red")

Color.RedColor,Red

These two formulas are also equivalent:

COLOR("rebeccapurple")COLOR("rebeccapurple")

Color.RebeccaPurpleColor,RebeccaPurple

Our color system supports the color palettes that are part of Google’s Material Design system, which are designed to work well together. You can reference the Material Design colors not just through the COLOR function, but also by writing Color.Color,, followed by the color name.

These formulas reference the same red color from a Material Design color palette:

COLOR("Red 500")COLOR("Red 500")

Color.Red500Color,Red500

These formulas are also equivalent:

COLOR("Blue A700")COLOR("Blue A700")

Color.BlueA700Color,BlueA700

More enums

In traditional programming, Color is known as an enumerated type, or an enum for short. Unlike a text string, which can be anything, there is a finite number of valid enum values. For that reason, you get an early warning if an invalid value is used.

Now that enums are fully supported by our new formula engine, we have taken this opportunity to introduce an additional five enums — with more to come.

We now support the important functions XLOOKUP and XMATCH, pioneered by Microsoft with Excel 2021. These functions support a match mode and a search mode.

The search mode governs the order in which arrays are searched for a value. In Excel, you need to type 1 to search starting with the first element and -1 to search starting with the last element.

This is mainly problematic in Excel because 1 and -1 aren’t very descriptive. It can be easy to lose track of what these numbers mean.

There is an added problem in Calcapp. If you forget what the search mode parameter does in Excel, and put in something like SQRT(16)SQRT(16), Excel will warn you right away, because it evaluates formulas immediately. Calcapp only evaluates formulas when you run your app, meaning that errors are presented much later.

For this reason, we give you a choice. You can either use 1 and -1, which is great if you copy and paste formulas from a spreadsheet or have become very comfortable with these numbers, or you can use enums. 1 can also be written as SearchMode.FirstToLastSearchMode,FirstToLast and -1 can also be written as SearchMode.LastToFirstSearchMode,LastToFirst. These names are more descriptive, and you’ll get an error straight away if you misspell them.

We also have enums for the match mode accepted by these two functions and for the sort order accepted by the functions SORT, RANK.AVG and RANK.EQ.

When we introduced functions like FORMATNUMBER and PARSENUMBER in 2018, we held off on introducing functions which could turn dates and times into text strings and back again. The primary reason was that we felt that we wanted support for enums to enable app authors to specify the format.

Now that we have enum support, we have taken the opportunity to introduce the functions FORMATDATE, FORMATTIME, PARSEDATE and PARSETIME. Here’s how to format a date using a numeric date format, with an enum given as the last parameter:

FORMATDATE(DATE(1981, 11, 14), DateFormat.Numeric)FORMATDATE(DATE(1981; 11; 14); DateFormat,Numeric)

Panels are now known as screens — and other name changes

Fri, 12 Nov 2021 00:00:00 +0000

Panels have been renamed to screens to better reflect the expectations of app authors. There are other name changes, which better reflect how Calcapp is used today and how we expect it to be used tomorrow.

Our latest release changes some of the names that we use:

Panels are now known as screens.
Calculation panels are now known as form screens.
List panels are now known as list screens.
Text panels are now known as text screens.
Calculation panel groups are now known as form groups.
List screen options are now known as navigators.

Why were screens named panels?

Screens used to be called panels for historical reasons. We originally envisioned them — back in 2008 — as horizontal or vertical boxes that could be nestled inside one another, enabling flexible layouts to be built. When the Calcapp you know today was born in 2014, these panels were used to represent screens built in Calcapp Creator.

We resisted renaming panels to screens for some time, though, because a part of our original plan was to automatically put list panels to the left of calculation panels on devices with big screens, like tablets and desktop computers. (Much like the Settings app on iPadOS, in fact.)

However, that feature has been put on the back burner for so long now that we don’t know when it will happen. App authors we talk to are excited about many upcoming features, but apps that adapt better to big screens do not seem to be high on anyone’s list of priorities.

For that reason, we are now renaming panels to the one name that everyone expects them to use — screens. When we do enable apps to work better on large-screen devices, we doubt that anyone will be upset if there is an option that lets multiple “screens” be placed alongside one another on big-screen devices.

The other name changes are about the future

As for the other naming changes, we have picked names that better reflect how app authors are using these constructs today, and how we think you will use them in the future. Many calculation panels perform little in the way of calculations, they merely collect data. Calculations may happen on another screen, or they may not happen at all — perhaps all that collected data is simply sent to a Slack channel through Zapier or sent in a report.

With future versions of Calcapp, which will become better at storing, updating and visualizing data, we expect this trend to continue. Calculations will be the focus of some apps, while others will mostly collect data.

Whether or not these screens are used for calculations, they definitely house forms. Therefore, they are now form screens.

We intend to abolish the distinction between form screens, list screens and text screens in the future. That will enable you to collect data from “list screens” and to enable users to navigate forward to multiple screens from “form screens.”

In a future where you can add whatever you like to a screen, we need a better name for the options that are now only part of list screens (transporting the user to new screens). They are now known as navigators. Finally, following similar reasoning, the form screen groups that house fields are now known as form groups.

We expect a Calcapp with unified screens to ship as part of our Calcapp 4 project.

Are we there yet?

Thu, 01 Jul 2021 00:00:00 +0000

We're hard at work polishing our new formula documentation and getting our new release ready. Action formulas have been pushed to our next release.

Judging by the paucity of blog posts lately, you’d be forgiven for thinking that we’re off on some beach somewhere, sipping margaritas, while essentially letting Calcapp take care of itself.

That’s not true, though. We’ve spent many years working full-time on Calcapp, and this year is no exception. With this blog post, we hereby assert that we are very much alive and that your precious subscription dollars (or euros, kronor, or what have you) are being used to dramatically improve Calcapp, and to lay the foundation for an even better future product.

We have mostly spent our time on the new formula engine we have teased since last year (in March, January and late last year). Calcapp will almost reach parity with the latest version of Microsoft Excel (including its new lifting behavior and functions like XLOOKUP, FILTER and SORT), and will add well-thought-out Calcapp extensions.

Making a case for improving our formula documentation

We first envisioned Calcapp as an app builder for people well-versed in Microsoft Excel and other spreadsheets. As such, the original function documentation was concise to the point of being terse. For a quick refresher on the order of parameters to the PMT financial function, it worked nicely, but if you had no idea how to use this function, our documentation proved inadequate.

It’s been five and a half years since our beta launched, and we’ve learned a great deal since then. One of the things we’ve learned is that while some of our customers indeed are Excel experts, many of you are not. That makes it doubly important that we have formula documentation that can stand on its own, with no prior knowledge of Excel necessary.

Our new formula engine comes with a lot of new formula functions. Like many of our existing functions, they are compatible with Microsoft Excel. What’s different, though, is that these functions are often relatively new, meaning that many of our customers can be expected to be significantly less familiar with them than with functions that hail from the 1980s. (You may be able to write SUMIF formulas in your sleep, but can you say the same for XMATCH?)

We take compatibility with Excel seriously, but at the same time, an app builder isn’t a spreadsheet, and that must be reflected in its function library. Also, we think that there is room for improvement in the set of functions offered by spreadsheets. Our new formula engine offers lots of extensions, with the end goal being that formulas are easier to write, read and maintain, offer clearer error messages and require fewer arcane workarounds.

(For instance, Excel power users typically use the double negative construct with functions like SUMPRODUCT. Calcapp’s new SUMPRODUCT function will work with or without this construct. Also, Excel’s new FILTER function requires you to awkwardly use the + and * operators to express “logical or” and “logical and.” Calcapp will support these operators, but also its own || and && operators.)

A sneak peek at our new formula documentation

For all the reasons outlined above, we’re investing heavily in our formula documentation. We shared a preview of our documentation for FILTER back in March, and since then, a lot of improvements have been made:

Readers are looking for a solution to their problem when consulting the documentation, not an academic treatise. As such, we have reworked it to be easily scannable, with easily-spotted formula examples, more headings and shorter paragraphs.
Our new formula engine will support decimal commas and not just decimal points (enabling the formula SUM(3.14, 2.72) to be written as SUM(3,14; 2,72)). You’ll be able to view all example formulas using either style, making it possible to copy and paste examples directly to Calcapp Creator regardless of your decimal separator preference.
We have written several thousand formula examples. These example formulas range from straight-forward invocations of your favorite functions to advanced function combinations. All examples come with a button for copying the example formulas to the clipboard.
The sidebar of the Learn section of our website has been modernized to work better on mobile devices. It can now be brought up at any point by clicking the menu button in the header.
Function and operator details—like parameters, the return value and their types—are now hidden by default. We think that most readers are better served by being presented with examples before possibly digging into the details later. Also, the types in our documentation (whether a parameter is a number or a text string, for instance) have been simplified.
The new documentation contains a massive number of links. When a formula example makes use of a function or operator that is different from the one you are reading about, simply click the link to be taken to documentation that explains the function or operator.
All formula examples have been carefully proofread, manually and through a special program we wrote that asked Calcapp itself to verify that they are correct. Not only that, we wrote a separate program which automatically turned our documentation into a Calcapp app, including all the calculated results, as calculated by the app. It’s important that you can trust our documentation and our examples to be correct, and we have gone the extra mile to ensure that this is so.

Here’s a screenshot of the documentation for FILTER:

What’s next?

When we completed revamping our function and operator documentation, we realized that we wanted our property documentation to be equally good. (What’s a property? Fields have lots of them, and they represent things like the value of the field, whether it is visible and its color. What sets Calcapp apart is that these properties can be defined through formulas, making for truly dynamic user interfaces adapting to the actions of your users.)

That’s where we are today, moving our existing property documentation to our main website, and expanding it in the process with lots of new formula examples. We expect this process to be faster than writing and copy-editing the function and operator documentation.

Earlier posts have discussed our new support for action formulas. In order to get our new release out the door sooner, we have decided to push this important feature to the next release. All the groundwork for action formulas has already been laid, we just need some extra time to really make this feature shine.

We had wanted to release our new version before the summer holidays. We could probably still make it, but we think it would be ill-advised. We prize stability over everything else, to ensure that your apps continue working, no matter what. We don’t want to jeopardize stability by pushing out an ambitious new release when the core team is on a much-needed break.

Look for our new release in the coming months.

Decimal commas in formulas and better documentation are coming soon

Tue, 16 Mar 2021 00:00:00 +0000

Our next release will add a brand new formula engine, which will support decimal commas in addition to decimal points in formulas. It will also come with much-improved formula documentation and more than 100 new functions.

In our last post in January, we shared an update on our new formula engine, which will support arrays, ranges and lots of new functions. We closed by writing that we hoped that our new release would “see the light of day in March.”

The bad news is that our next release will take a little longer to reach you. The good news is that we’re pushing back the release for a good reason: we want to get two additional features done, which we think will make your day-to-day work with Calcapp easier.

Those features are support for decimal commas in formulas and much-improved formula documentation.

Decimal commas in formulas

Since its inception, Calcapp has only recognized decimal points (“.”) as decimal separators and commas (“,”) as parameter separators in formulas. This is in line with how numbers are written in countries like the US, Britain, Australia, New Zeeland, China, Japan, India and parts of Africa.

Apps produced with Calcapp have supported languages other than US English for more than three years now. Numbers are formatted according to the language of the app and functions like PARSENUMBER and FORMATNUMBER correctly handle the decimal separator of the configured language. In other words, apps have handled decimal commas correctly for years now, but not the app designer.

Programming languages typically use decimal points exclusively. Spreadsheets, however, with very few exceptions either allow the decimal separator to be set manually or follow the conventions of the host operating system. Spreadsheets that use decimal commas as decimal separators typically use semicolons (“;”) as parameter separators instead of commas.

Enough is enough. We’re currently working on supporting decimal commas natively in formulas. There will be a preference you’ll be able to toggle, which will then make all formulas you edit use decimal commas as decimal separators instead of decimal points. This means that you’ll soon be able to write IF(Field1 >= 3.14, 1.23) as IF(Field1 >= 3,14; 1.23).

The Calcapp 4 formula engine actually introduces another separator which is affected by this change, in addition to decimal and parameter separators: statement separators. As mentioned elsewhere, we’ll soon support action formulas, which you’ll be able to associate with buttons. When a button is activated, the formula is run, and these formulas will be able to execute multiple actions (or “statements”), like sending multiple reports and conditionally resetting fields.

To separate actions, or statements, you’ll need to use a statement separator. If Calcapp Creator is configured to use a decimal point, that’s a semicolon:

IF(Field1 >= 3.14, RESET(Field1)); ALERT("Done!")

This example resets Field1 only if its value is greater than or equal to 3.14. It then (unconditionally) displays the message “Done!” in a popup box. The two statements are separated by a semicolon.

If Calcapp is configured to use a decimal point, you instead need to write two semicolons:

IF(Field1 >= 3,14; RESET(Field1));; ALERT("Done!")

Much-improved function documentation

Back in 2016, we overhauled our formula engine, tweaking the way you write formulas slightly—to improve compatibility with spreadsheets—and added support for hundreds of spreadsheet functions. Overnight, we went from supporting around 20 functions to supporting 244. (Today, that number is 281.)

We knew that we needed documentation—for the functions themselves as well as their parameters—but writing high-quality documentation for hundreds of functions is not an easy task, and hard to justify for a product that was then in beta and hadn’t quite found its market yet. As a result, the documentation we did produce was quite terse.

Times have changed. The new functions we are adding can be used in many ways, and there may be alternatives to them that are preferable in some contexts. As a result, they need examples and room for a comprehensive discussion section.

We have re-written or expanded the documentation for most functions. There are exceptions, though. We have done little to change the documentation for most of the specialized statistical and financial functions we offer (like GAMMA.DIST, which still only “calculates values for a Gamma distribution,” with no additional content). All functions, except for compatibility functions, have at least one example, though.

The new documentation is far too voluminous to fit in the old reference sidebar. The plan is to host the documentation on the main website, and only include the first sentence and the parameter documentation in the reference sidebar. The full documentation will then be available from the sidebar through a link.

An added benefit of having the documentation available on the main website will be that you’ll more easily be able to make hard copies of it. Search engines will also have an easier time finding it.

To illustrate our new approach to documentation, the next section is a draft copy of our documentation for the new FILTER function.

A draft version of the new FILTER function documentation

Filters the first array using the second parameter. For instance, FILTER({ 1, 2, 3 }, { FALSE, TRUE, TRUE }) returns { 2, 3 }. 1 is not part of the returned array, as the corresponding element in the second array is FALSE. 2 and 3 are both part of the returned array, as the corresponding elements in the second array are both TRUE.

In other words, the returned array contains an element found in the first array only if the corresponding element in the second array is TRUE. The two arrays must be equal in size.

The second array is often not provided explicitly. Rather, an operation is typically used that returns a logical array. For instance, FILTER(Field1:Field3, Field1:Field3 > 5) returns fields whose values are greater than 5.

(The Field1:Field3 range is a short-hand way of expressing an array containing Field1 and Field3, as well as any fields that appear between them, such as Field2. If only Field2 appears between the other two fields, Field1:Field3 and { Field1, Field2, Field3 } are equivalent.)

The second array does not need to reference the same array as the first array. FILTER({ "Sally", "Ed", "Luke", "Jenny" }, { 90, 62, 91, 82 } > 85), where the first array contains student names and the second array contains their test scores, returns an array of names of the students who scored more than 85.

Use the SIZE function to determine the number of elements returned by FILTER. SIZE(FILTER(Field1:Field100, Item > 5)) returns the number of fields, in the Field1:Field100 range, whose values are greater than 5.

Combining multiple conditions

Use the logical operators || to express “logical or” (disjunction) and && to express “logical and” (conjunction). FILTER(Field1:Field3, (Field1:Field3 > 5) || (Field1:Field3 < 2)) returns those fields whose values are greater than 5 or less than 2. FILTER(Field1:Field3, (Field1:Field3 > 5) && ISODD(Field1:Field3)) returns only those fields whose values are both greater than 5 and are odd numbers.

Traditionally, spreadsheets use the + operator to express “or” and the * operator to express “and.” Calcapp supports these operators too. (The functions OR and AND cannot be used in this context, as they return a single logical value, not a logical array.)

Using a formula fragment to filter elements

Instead of passing a logical array as the second parameter, you can also use a formula fragment which is expected to return TRUE if the element should be included and FALSE otherwise. FILTER({ 1, 2, 3 }, { 1, 2, 3 } > 1) can also be expressed as FILTER({ 1, 2, 3 }, Item > 1).

The formula fragment you supply as the second parameter is run once per element. The element can be accessed as the Item value. Moreover, the index of the element (1 for the first element, 2 for the second element, etc) can be accessed as the Index value and the source array—given as the first parameter to FILTER—as the Source value. Including only the last three elements can be achieved using a formula like this one: FILTER(SEQUENCE(100), Index > SIZE(Source) - 3).

This variant is useful if you need to compare array elements only against themselves. It has the benefit of saving you from having to repeat the source array in the formula. This feature is specific to Calcapp and is not found in spreadsheets.

(Using this variant when you need to examine another array is possible, but is not as convenient. FILTER({ "Sally", "Ed", "Luke", "Jenny" }, { 90, 62, 91, 82 } > 85) would be expressed as FILTER({ "Sally", "Ed", "Luke", "Jenny" }, INDEX({ 90, 62, 91, 82 }, Index) > 85), using the Index value together with the INDEX function to extract the correct value from the other array.)

Using FILTER instead of the *IF functions

When combined with other functions, FILTER can be used as a replacement for functions like AVERAGEIF, COUNTIF and SUMIF. These functions all boil down to filtering an array before applying an additional operation.

SUMIF, for instance, first filters an array based on a condition and then adds the resulting numbers together, returning the result. SUMIF({ 1, 10, 100, 1000 }, ">25") returns 1100, because only 100 and 1000 are greater than 25. SUM(FILTER({ 1, 10, 100, 1000 }, Item > 25)) and SUM(FILTER({ 1, 10, 100, 1000 }, { 1, 10, 100, 1000 } > 25)) return the same result.

Similarly, COUNTIF({ 1, 10, 100, 1000 }, ">25") returns 2, because exactly two array elements are greater than 25. SIZE(FILTER({ 1, 10, 100, 1000 }, Item > 25)) is equivalent—the FILTER invocation returns { 100, 1000 } and SIZE returns the size of that array, 2.

AVERAGEIF({ 1, 10, 100, 1000 }, ">25") returns 550, because that is the average value between 100 and 1000. AVERAGE(FILTER({ 1, 10, 100, 1000 }, Item > 25)) is equivalent.

When given a third parameter, AVERAGEIF, COUNTIF and SUMIF apply the condition to the first array, while applying the operation (averaging, counting and summing) to the first array. SUMIF({ "Dave", "Sally", "Sally" }, "Sally", { 30, 40, 50 }) adds together 40 and 50, but not 30, as these numbers are associated with the text string “Sally”, which the condition stipulates. The equivalent formula using FILTER is SUM(FILTER({ 30, 40, 50 }, { "Dave", "Sally", "Sally" } = "Sally")).

Using FILTER instead of the *IFS functions

AVERAGEIF, COUNTIF and SUMIF also come in versions designed to be used with multiple conditions: AVERAGEIFS, COUNTIFS and SUMIFS. There are also two *IFS functions with no *IF counterpart: MINIFS and MAXIFS, which return the smallest and largest number, respectively, from an array, provided that a number of conditions are met.

AVERAGEIFS({ 90, 62, 91, 82 }, { "F", "M", "M", "F" }, "F", { "CA", "CA", "AZ", "AK" }, "AK") returns an average of the test scores obtained by female students who reside in Arkansas (abbreviated “AK”). Here, only one test score matches (82) and is returned, because while two female students appear in the data, only one of the students resides in Arkansas.

The equivalent formula using FILTER is AVERAGE(FILTER({ 90, 62, 91, 82 }, ({ "F", "M", "M", "F" } = "F") && ({ "CA", "CA", "AZ", "AK" } = "AK"))).

The FILTER version is far more versatile. AVERAGEIFS can only be used with “logical and” and not “logical or” (or any other combination of logical operations). What if we want the average of all test scores associated either with female students or students residing in Arkansas? AVERAGEIFS does not provide this feature, but using FILTER, it’s as easy as turning && into ||: AVERAGE(FILTER({ 90, 62, 91, 82 }, ({ "F", "M", "M", "F" } = "F") || ({ "CA", "CA", "AZ", "AK" } = "AK"))).

FILTER, MAP and REDUCE

FILTER, MAP and REDUCE are commonly used together, as a data processing pipeline to transform data. FILTER is used to remove irrelevant elements from an array, MAP is used to transform the remaining elements and REDUCE, finally, is used to transform the resulting array to a single value.

Instead of REDUCE, a simpler function can be used which reduces an array of values to a single value. The most popular such functions are SUM (which adds all array elements together and returns the result) and AVERAGE (which returns an average of all the array elements).

A single formula can use multiple invocations of MAP and FILTER. For instance, an innermost FILTER invocation can filter the raw array once, and then hand this data to MAP, which transforms the filtered data. This data can then, once more, be given to FILTER, which filters out additional elements, and so.

The formula SUM(FILTER(MAP(FILTER({ "$326.60", "€402.80", "$290.00", "$128", "3002 SEK" }, STARTSWITH(Item, "$")), PARSENUMBER(Item)), Item > 200)) starts off with the text array { "$326.60", "€402.80", "$290.00", "$128", "3002 SEK" }, listing amounts in various currencies. Working our way outwards from the array, FILTER is then applied to the array, and uses the formula fragment STARTSWITH(Item, "$") to only include array elements which start with a dollar sign. That leaves { "$326.60", "$290.00", "$128" }. MAP is applied to this array, with the formula fragment PARSENUMBER(Item), which converts the text array with textual amounts to a number array holding the same amounts: { 326.6, 290, 128 }. FILTER is then applied to this array using this formula fragment, Item > 200, which filters out all elements which are not greater than 200. That leaves the array { 326.6, 290 }. Finally, SUM is applied to this array, returning the grand total 616.60.

Parameters:

values the values to filter.

inclusions either an array or a formula fragment. If this parameter is an array, it should be a logical array with the same size as the array of values to filter. The returned array only contains values where the corresponding element in this array is TRUE. If this parameter is a formula fragment, it is run once per array element and is expected to return TRUE only if the corresponding array element should be included in the returned array. To do its work, it has access to the three named values Item, the array element under consideration, Index, the index of the array element (1 for the first element, 2 for the second element, etc) and finally Source, which is a reference to the array to filter, given as the first parameter to FILTER.

fallbackValues the values to return if no values matched the filter. If there are no fallback values, an empty array is returned.

Result: a filtered version of the given values. If no values match the filter, an empty array is returned, unless the fallbackValues parameter is provided, in which case those values are returned instead.

Examples:

FILTER({ 1, 2, 3 }, { FALSE, TRUE, TRUE })

returns { 2, 3 }. 1 is not part of the returned array, as the corresponding element in the second array is FALSE. 2 and 3 are both part of the returned array, as the corresponding elements in the second array are both TRUE.

FILTER({ 1, 2, 3 }, { 1, 2, 3 } > 1)

returns an array containing the elements which are greater than one, { 2, 3 }. { 1, 2, 3 } > 1 returns the logical array { FALSE, TRUE, TRUE }.

FILTER({ 1, 2, 3 }, Item > 1)

SIZE(FILTER({ 1, 2, 3 }, Item > 1))

returns the number of array elements which are greater than one. As only 2 and 3 are greater than 1, 2 is returned. This variant uses a formula fragment, which is run once per array element to determine whether the element should be part of the result. The formula fragment is expected to return TRUE if that is the case.

FILTER({ 1, 2, 3 }, V -> V > 1)

returns an array containing the elements which are greater than one, { 2, 3 }. This variant uses a formula fragment, which is run once per array element to determine whether the element should be part of the result. The formula fragment is expected to return TRUE if that is the case. This fragment renames the Item value, which references the array element under consideration, to V. For longer formula fragments, renaming a value can make the resulting formula fragment much smaller. Alternatively, renaming a value can be used to give it a name that more accurately describes the value.

FILTER({ 10, 20, 30 }, Index >= 3)

returns { 3 }, as only the last array element has an index greater than or equal to 3. (The first element has an index of 1, the second an index of 2, etc.)

FILTER({ 10, 20, 30 }, (V, I) -> I >= 3)

returns { 3 }, as only the last array element has an index greater than or equal to 3. (The first element has an index of 1, the second an index of 2, etc.) Here, both the Item and Index values are renamed to V and I, respectively. Even if the Item value is not needed, it still needs to be renamed, as it appears before the Index value.

FILTER({ 10, 20, 35 }, MOD(Item, 10) = 0)

returns array elements which are evenly divisible by 10, meaning that { 10, 20 } is returned.

FILTER({ 10, 20, 35 }, MOD(Item, Field1) = 0)

returns all array elements which are evenly divisible by Field1.Value</em>, provided by the user.

FILTER({ 10, 20, 35 }, MOD(Item, 50) = 0)

returns array elements which are evenly divisible by 50. As there are no such array elements, an empty array is returned.

FILTER({ 10, 20, 35 }, MOD(Item, 50) = 0, { -50 })

returns array elements which are evenly divisible by 50. As there are no such array elements, the third parameter is returned, { -50 }.

FILTER({ "Sally", "Luke", "Jenny" }, { 90, 91, 82 } > 85)

returns { "Sally", "Luke" }, which are the names of the students who scored higher than 85, provided that the first array contains student names and the second array contains their scores.

FILTER({ Field1, Field2 }.Color, { Field1, Field2 } > 3)

returns the colors of the fields whose values are greater than 3 as an array.

FILTER(Field1:Field100.Color, Field1:Field100 > 3)

returns the colors of the fields whose values are greater than 3 as an array. Field1:Field100 is short-hand for an array which includes Field1, Field100 and all other fields which appear between them.

FILTER(Field1:Field100.Value, MOD(Index, 5) = 0)

returns the values of every fifth field, among those listed. Field1:Field100 is short-hand for an array which includes Field1, Field100 and all other fields which appear between them.

SORT(UNIQUE(FILTER({ 32, 8, 8, 16, 4, 2, 1 }, Item > 7)))

returns { 8, 16, 32 }, which includes only those elements of the { 32, 8, 8, 16, 4, 2, 1 } array which are greater than 7. UNIQUE ensures that there are no duplicate values, and SORT ensures that the returned array is sorted.

Current status

We’re currently implementing support for commas as decimal separators in formulas. The new formula documentation has already been written. It has not yet been proof-read, though, nor have we written the software which will generate HTML documentation for the main website. (Should there be a search field? Should one page be generated for every function, or one page per category, which would group all text functions together? There are a few questions to resolve here.)

There are also many new button types (which will be able to do things like execute action formulas and open the system map app). They have not yet been implemented, but are not expected to be time-consuming.

We also need to ensure that the migration process is smooth, and that all paid apps will continue to run with no interruptions once the new formula engine is live.

This will be one of the biggest Calcapp upgrades we have ever released, and without a doubt the biggest update our formula engine has ever received. We’re anxious to get it into your hands and we look forward to seeing the amazing apps you’ll create with it.

Array ranges, SUMIF and more are coming soon

Mon, 11 Jan 2021 00:00:00 +0000

Ranges will enable authors to easily and concisely refer to multiple values in formulas. Ranges, combined with the new function SUMIF, will make conditionally summing values much easier than before.

1 + 21 + 2

We have supported formula functions like SUM and PRODUCT for a long time now. What they have in common is that you supply multiple parameters and get a single result back.

These formula functions are used frequently by Calcapp authors, but provide little value beyond adding or multiplying numbers together using + and *. The formulas SUM(Field1, 4) and Field1 + 4 do the exact same thing, which is also true for the formulas PRODUCT(4, 8, 16) and 4 * 8 * 16.

Functions like SUM and PRODUCT are about to become significantly more useful, though, with the introduction of ranges. If you have more than a passing familiarity with spreadsheets like Microsoft Excel, you have definitely encountered ranges (whether or not you know them by that name).

In Excel, if cells A1 through A5 contain values you want to add together, you can easily do so using the formula =SUM(A1:A5). By contrast, Calcapp has historically forced you to enumerate all the values you wanted to add together, by writing something like SUM(A1, A2, A3, A4, A5) or A1 + A2 + A3 + A4 + A5. (Calcapp doesn’t require you to write = before formulas.) Compared to using ranges, that’s a lot more work.

The good news is that our upcoming release will support ranges. If you have five number fields named A1, A2, A3, A4 and A5 (appearing one after another), adding their values together will be as easy as using the formula SUM(A1:A5).

Calcapp authors don’t typically name their fields as though they were cells in a spreadsheet grid. Rather, fields are automatically named using their labels as a guide, so if you use the label “Maximum weight” for a field, the field is assigned the name MaximumWeight automatically. (To break the association between the label and the name, simply type a new name manually in the name field, to the left of the formula bar.) As such, ranges in Calcapp formulas will typically look more like SUM(MaximumWeight:IndividualWeight) than SUM(A1:A5).

The formula SUM(MaximumWeight:IndividualWeight) will add all values together that belong to not only the fields MaximumWeight and IndividualWeight, but all fields that appear between them in the app designer.

Under the hood

In a spreadsheet, the cell reference A1 refers to the cell in the first column and the first row of the spreadsheet grid and A2 refers to the cell in the first column and the second row. The range A1:A2 refers to both of these cells.

Spreadsheets also support something called arrays, which are similar to ranges in that they hold multiple values. An array constant in a spreadsheet is written between curly brackets, like { 2, 4 }, which is a value holding the values 2 and 4. (As we have discussed earlier in this space, we are adding support for arrays to Calcapp.)

Ranges and arrays are subtly different in spreadsheets. In Calcapp, there is no spreadsheet grid, so a range and an array are one and the same. If Field1, Field2 and Field3 appear one after the other in the app designer, the formulas SUM(Field1:Field3) and SUM({ Field1, Field2, Field3 }) not only return the same result, they look roughly identical to Calcapp. As such, a range is simply a more concise way of writing an array.

An example

What if you have five fields (A1 through A5, appearing one after the other) and you want to add their values together, but only those that are greater than two? This has been possible with Calcapp ever since our first release, but you had to use a long and cumbersome formula:

IF(A1 > 2, A1) + IF(A2 > 2, A2) + IF(A3 > 2, A3) + IF(A4 > 2, A4) + IF(A5 > 2, A5)

(This formula would become even more unwieldy if you had, say, 100 fields instead of five.)

Spreadsheets make this considerably easier. The standard way to solve this is through the SUMIF formula function:

SUMIF(A1:A5, ">2")

Calcapp currently supports neither arrays nor ranges, explaining why we haven’t been able to support the SUMIF function earlier. This issue will be rectified by our next release, which will add support for not only SUMIF, but also SUMIFS, COUNTIF, COUNTIFS, AVERAGEIF, AVERAGEIFS, MINIFS and MAXIFS.

As teased earlier, Calcapp will not only support the formula SUMIF(A1:A5, ">2") (where the ">2" condition — determining which values are considered – is expressed as a text string), but also an alternate form which can be written like so:

SUMIF(A1:A5, Item > 2)

The second parameter is technically known as a lambda (or an anonymous function), which returns a logical value (TRUE or FALSE), determining whether a value should be considered. To help this lambda make this decision, the value under consideration is available as Item. (The name can be changed, but that’s a topic for another blog post.)

Lambdas enable you to use complicated logic to determine whether a value should be considered:

SUMIF(A1:A5, (Item > 2) && (Item < 10) && ISODD(Item)

The example above only considers values which are greater than two, are less than ten and are odd. (In other words, only 3, 5, 7 and 9 are considered.)

Modern Excel and dynamic arrays

One of the most exciting changes to come to Microsoft Excel are dynamic arrays, along with a number of new formula functions. Dynamic arrays make it much simpler to perform actions like filtering an array (returning a copy of said array only containing elements satisfying a certain condition with the FILTER function) and removing duplicates from an array (with the UNIQUE function).

We’re happy to announce that we will have full coverage of Microsoft’s new dynamic array functions when our next release becomes available.

Let’s return to the SUMIF(A1:A5, ">2") example above. If you think about it, there are two things going on here. First, the array consisting of the A1:A5 values is filtered to only contain values that are greater than two. Second, these values are added together and returned.

Filtering the array can be accomplished using the new FILTER function, and summing them can be done using the SUM function. Here’s what that looks like:

SUM(FILTER(A1:A5, A1:A5>2))

FILTER is asked to filter the A1:A5 range, passed as the first parameter. The second parameter is also an array, with the same size as the first parameter. However, it is a logical array, consisting of TRUE and FALSE values. A1:A5>2 returns an array consisting of TRUE values where the value is greater than two, and FALSE values elsewhere. That means that { 1, 2, 3, 4 }>2 returns { FALSE, FALSE, TRUE, TRUE }, because only 3 and 4 are greater than two.

SUM(FILTER(A1:A5, A1:A5>2)) may look more cumbersome than SUMIF(A1:A5, ">2") — and it is — but it provides far more flexibility. Which you wind up using depends on your needs and on your preferences.

When will this become available?

We’re in the last stages of our big formula revamp (which is the first step of our next-generation Calcapp 4 project). We hope that our next release, containing these features, will see the light of day in March.

Tip: Share previews of apps

Tue, 20 Oct 2020 00:00:00 +0000

When making changes to an app, you often need to share copies of your changed app with a small circle of users before letting these changes go live for all users. Read this tip to learn how this is done.

To make an app available for others to use, you first need to share it by pressing the Share app button in Calcapp Creator:

By sharing an app, you create a copy of the app you’re currently working on. That means that you can continue to work on the app without affecting the shared version. The shared version will only be updated when you press the button in the top-right corner (labeled Update app when the app has already been shared):

To get an idea of what your app is like to use, without having to update the shared version, use the preview sidebar by pressing the button in the lower-right corner. You can also browse to connect.calcapp.net, on your desktop computer, tablet or cell phone, to use the development version of your app.

This workflow works great if you’re the only person who needs to determine if your app is ready to be updated. However, most of the time, there are others who need to chime in as well. These are people whose feedback you may need in order to determine if the updated version of your app performs well, in terms of its calculations, grammar and layout.

In other words, what you’d like to do is share an app with this close circle of users, without disturbing the app currently being enjoyed by the wider circle of users. This is something we routinely need when developing our healthcare apps, which need to be assessed and tested by doctors before the updates go live.

To achieve this with Calcapp, you need to select Manage apps… from the main menu (reachable by pressing the button in the upper-right corner):

Then, you need to select the app you’d like to share privately. (The app you’re editing will already be selected for you.) You then need to create a duplicate of the app, by pressing the button and selecting Duplicate app.

You’re then given the opportunity to select a new name for the duplicate copy. As you can see in the image above, we like to include the word “copy” in these names, along with the date.

Finally, open the duplicate copy and click Share app. You’ll then get a link to the duplicate you can share with a small circle of users. When you get feedback, be sure to make changes to the original app, as opposed to the copy.

If you need another round of feedback, just repeat this process and create a new duplicate copy, which you then share. You can remove all these copies when you’re ready to publish your app.

Copies of apps are automatically put on a free plan. Apps on a free plan can only be launched a limited number of times per month (typically, ten). If that isn’t sufficient, just create a fresh new copy.

Feature: Reset and change your users' passwords

Tue, 20 Oct 2020 00:00:00 +0000

You can now reset your users' passwords directly from Calcapp Creator. Use this feature if your users have trouble resetting their own passwords or if you'd like to set their passwords for them.

Private apps require users to sign in before gaining access to your app. You add and remove users using the Manage users window:

When you add a new user and share an app with them, a welcome email is sent containing a link which enables the user to set an initial password. If the user forgets their password, they can reset it. That process normally works by sending an email to the user containing a link the user can use to change the password.

Up until now, administrators had no control over this process. An administrator could add and remove users through Calcapp Creator, but could not change their users’ passwords or gain access to password reset links. This changes now.

Why would an administrator need to set a user’s password for them? There are a number of reasons. First, the password reset email may never arrive at the destination due to overzealous spam filters. In that case, having access to the password reset link enables an administrator to send the link to the user through instant messaging or email. Second, some administrators prefer setting an initial password for their users instead of sending an automated welcome email.

Access this new feature by selecting Reset user password from the main menu (reachable by pressing the button in the upper-right corner of Calcapp Creator). You’ll then be presented with this new window:

All your users appear in this window. When you press the Reset password button on the right-hand side, these two buttons appear:

If you press the button, the password reset link which ordinarily would have been sent to a user through email is opened in a separate window, enabling you to set your user’s password directly. If you instead press the button, the password reset link is copied to your clipboard, enabling you to easily send it to your user.

Tip: Generate better PDF documents through Zapier

Mon, 17 Aug 2020 00:00:00 +0000

PDF reports created with Calcapp will only become truly customizable when Calcapp 4 fully arrives. In the meantime, use third-party services through Zapier to enable custom-designed PDF documents today.

Calcapp has native support for generating PDF reports directly from your app. These reports can either be emailed directly to a list of recipients (which can be determined using a formula) or be downloaded directly to your user’s device.

As things stand, you have very few options for customizing the appearance of these reports, though. If your requirements include having your logo be part of the generated report, for instance, or including formatted text, you are currently out of luck. We have pledged to create a PDF report designer as part of our Calcapp 4 project, but this new feature will take time to arrive.

So what do you do if you need this feature today? As luck would have it, Calcapp can integrate with third-party services, which provide features Calcapp lacks natively. We have previously described how you can make your app integrate with the third-party service Zapier to add rows to a Google Sheets spreadsheet when a button in your app is pressed. Other actions supported by Zapier include sending a message to a Slack channel, tweeting or creating a new sales lead in Salesforce (and thousands more).

(We not only support Zapier, but also Microsoft Power Automate — previously known as Microsoft Flow — and Zoho Flow.)

There are competent third-party solutions for creating PDF files that can seamlessly integrate with apps you build with Calcapp. We recently had the opportunity to research this topic and we’ll share our findings in this post.

Generating PDF documents

We have looked at two third-party solutions: Formstack Documents (formerly WebMerge) and Docupilot.

From the perspective of Calcapp and the features we need to create custom reports, both products are fairly similar (though Docupilot is, at the time of this writing, less expensive). Both ask that you create templates using graphical WYSIWYG editors (what you see is what you get), where you insert special tags which are replaced by the values your users enter in your app. For instance, if your template contains the text “Hello and welcome, ${Name}!”, and your app supplies the name Rachel, the generated PDF document will read “Hello and welcome, Rachel!”.

This is the template editor in Formstack Documents:

This is the template editor in Docupilot:

Both Formstack Documents and Docupilot can be instructed to send the generated PDF documents through email, which is likely what you need.

In order to trigger either service from your app when your users press a button, use Zapier. In order for Zapier to receive the event from your app, you need the Webhooks by Zapier app. (For more information on how to set this up, refer to our video tutorial explaining how to use Zapier to integrate your app with Google Sheets.)

Both Formstack Documents and Docupilot are available as apps in Zapier — you just need to search for them by name. Once you have done so, you need to give Zapier permission to talk to either service (by copying and pasting a so-called API key).

What about your template tags, the ones that should be replaced by values your users enter in the app? You’ll use Zapier to determine which app fields go with which tags.

Let’s consider an app with two fields, Name and Email which should be mapped to the template tags Name and Email. This is what this could look like in Zapier, when used with Formstack Documents:

That concludes this whirlwind tour of Formstack Documents and Docupilot, as used with Calcapp through Zapier. We plan to provide this functionality as a built-in Calcapp feature in the future, but until then, both Formstack Documents and Docupilot will get you where you need to go today.

On the road to Calcapp 4

Wed, 12 Aug 2020 00:00:00 +0000

Calcapp 4 is our next-generation version of Calcapp, and it's coming along nicely. Read on to learn more about the progress we've made.

The time has come to update you on the progress we’ve been making with Calcapp 4. Be warned, though — this post is somewhat technical. If you love formulas and what makes them tick, this post is for you. If you’re more interested in our forthcoming support for customizable PDF reports and binding fields to data, feel free to skip past the finer details.

Regardless, rest assured that we’re investing heavily in Calcapp and that we are committed to bringing you major updates with lots of new useful features.

Background

Before we get to what we’ve been up to, we’ll take a moment to shine a light on how Calcapp works. As a Calcapp user, you’re probably familiar with Calcapp Creator, the app designer, and Calcapp Connect, which you use to run your own apps as well as shared apps.

There are other parts of Calcapp, though, which are mostly hidden from view. There’s Calcapp Server, which is what delivers your apps and allows you to make updates. Under the hood, it uses something called Calcapp Compiler.

What’s a compiler? If you’ve ever dabbled in traditional software development, you know that you sometimes need to compile code to make it runnable. (With some languages, such as plain JavaScript, there often isn’t a separate compilation step, at least not one which is visible to you.) Compilers can typically tell you of errors in your code, preventing it from becoming runnable.

Calcapp Compiler does two things. First, it ensures that your app is free of errors, and if it isn’t, it points out the errors to you. (Have you ever tried to subtract a number from a text string in a formula? That’s Calcapp Compiler pointing out the error to you.) Second, it converts (compiles) your Calcapp formulas to JavaScript code which browsers can run directly.

The progress we’ve been making

Calcapp Compiler really is the heart of Calcapp and we have lavished a lot of attention on it lately. We have, essentially, worked full-time on it since November, only taking time off for making your apps qualify as Progressive Web Apps and enabling some miscellaneous features requested by the community.

Calcapp formulas are growing up. We’re enabling them to run in response to events being fired (like a button being pressed). We’re also enabling you to reference elements of your app directly (and not just field values), which will come in handy with certain new properties (like a property enabling a formula to specify which fields to include in a report).

We’re also adding support for around a hundred new formula functions, including SWITCH and IFS. These functions will replace IF for many uses and make formulas significantly easier to read and write (without all the matching parentheses that IF typically requires).

The most important addition, by far, is support for arrays.

Supporting arrays

We’ve long talked about adding support for tabular data, and arrays will be at the heart of this new support. If you’re not familiar with arrays, think of an array as a list of items, that is, a single value referencing multiple values. You can write a literal array in a formula using brackets, like { 2, 4, 6 }, which denotes a single array with the ordered values 2, 4 and 6.

Spreadsheets support both ranges (B12:C14) and arrays ({ 2, 4, 6 }). Some spreadsheet functions accept both ranges and arrays, some accept only arrays and some accept only ranges. We find that confusing, so Calcapp will only support arrays.

We’re adding support for a very large number of new functions, with the vast majority of these expecting arrays to be passed. Most of these will correspond to functions long supported by spreadsheets in general and by Microsoft Excel in particular. We’ll support functions like MATCH and INDEX, but also functions like AVERAGEIF, AVERAGEIFS, COUNTIF, COUNTIFS, SUMIF and SUMIFS as well as lots of new statistical functions.

We’re also leaning heavily on the new array functions introduced by modern versions of Excel (requiring a subscription to Microsoft 365). Those include functions like FILTER, XMATCH and XLOOKUP. (Yes, a true look-up function is coming to Calcapp, although you’ll have to make do with writing the values in the formula itself for the time being.)

The finer points

An extra complication is that we insist on something called static typing. What that means is that we can flag formula errors which traditional spreadsheets simply don’t flag. If you try entering the formula IF(4, "true", "false") in Excel, “true” will be produced, because 4 is assumed to be equivalent to TRUE (this process is known as type coercion). Calcapp will instead present an error and ask you to enter a logical value, potentially saving you from having to make sense of confusing output.

Now, capturing all the nuances of Excel formula functions with static typing is a large undertaking. For instance, SWITCH expects parameters to be given in pairs, which is something we haven’t had to handle before.

Another example is SUMIF, which returns the sum of all values in an array, but only includes values which satisfy a condition. Said condition can be expressed as a value which an array value must be equal to, or it can be expressed in the form of a string like “<4” (an array value must be less than four in order to be considered). In other words, SUMIF({ 2, 2, 10, 4 }, 2) returns 4 (only the first two items are added together, because they need to equal 2), whereas SUMIF({ 2, 2, 10, 4 }, ">2") returns 14 (only the last two items are considered, because they need to be greater than two).

With SUMIF, if you provide an array of numbers, we must therefore allow the condition parameter to be either a number or a text string (enabling more complex conditions like “<4”). That all adds complexity (requiring us to implement something known as union types).

Finally, we also want to support formula snippets (also known as lambdas) in place of the condition parameter, enabling full use of Calcapp formulas to determine whether an array item should be considered. With a formula snippet, you can write SUMIF({ 2, 2, 10, 4 }, ">2") as SUMIF({ 2, 2, 10, 4 }, Item > 2). Full use of Calcapp formulas as the condition parameter means that SUMIF({ 2, 2, 10, 4 }, (Item > 2) && (Item < 10)) will also work.

Referencing fields and not their values

To reference the value of a field, you just write the field name in a formula. In other words, to add the values of Field1 and Field2 together, you just write Field1 + Field2. However, to reference whether Field1 is visible, you need to type the field name, followed by a period, followed by the property name Visible. In other words, to add the values of Field1 and Field2 together, but only if both fields are visible, you need to write something like IF(Field1.Visible && Field2.Visible, Field1 + Field2, 0).

We could easily have asked you to reference the value of a field by writing something like Field1.Value, but that would have been a mouthful and would have made your formulas hard to read. In Calcapp 3 (the current version), we simply assume that you intend to reference the value property if you don’t explicitly write a period followed by a property name.

This becomes more complicated in Calcapp 4, because we now want to enable you to reference not only the value of a field, but also the field directly. The reason for this new requirement is that we are introducing new functions and properties that need to directly reference fields, and not their values. For instance, RESET will be callable from formulas run in response to, say, a button being pressed, and will reset the field to its initial value. RESET(Field1) will reset Field1, and it is important that it is passed the field itself and not its value. (After all, RESET(4) wouldn’t make any sense.)

We don’t want you to have to type either Field1.Value or Field1.Reference (where the latter would get you a reference to the field itself, which would then work with formula functions like RESET). We want you to be able to type just Field1 and then have Calcapp figure out what you’re referring to. In Field1 + Field2, we can be certain that you’re looking to add the values of the two fields together, and in RESET(Field1), we can be certain that you’re looking for a reference to the field itself.

(We’ll actually allow you to write Field1.Value and Field1.Reference to make the call yourself, in the off chance that Calcapp 4 can’t figure out what you mean.)

Our near-term plans

Our Calcapp 4 project encompasses far more than a next-generation formula language, including binding fields to tabular data and a PDF report designer. The new formula capabilities can be considered the base on which the full Calcapp 4 experience will be built.

In the near term, though, we hope to ship many of the formula improvements while keeping the experience identical in all other respects. To that end, we will work to make the new Calcapp Compiler work with the existing Calcapp Creator and Calcapp Connect, creating a sort-of hybrid between Calcapp 4 (the new Calcapp Compiler) and Calcapp 3 (with lightly updated versions of Calcapp Creator and Calcapp Connect).

Then, we’ll commence work on more fully realizing our Calcapp 4 vision.

Feature: Auto-height for AMP

Mon, 11 May 2020 00:00:00 +0000

The auto-height feature enables an app embedded in your web page to adjust its height in response to content changes. This feature is now also supported for AMP, a technology which makes web pages load faster.

AMP is a technology used to create speedy websites, originally introduced by Google in 2015. AMP sites derive their speed advantage from the simpler HTML mandated by AMP and from caching.

AMP pages can embed apps created with Calcapp using the amp-iframe tag. (There are some restrictions, though, including the fact that iframes must not appear close to the top of the document — refer to the AMP documentation for more information.)

However, up until now, AMP pages have not been able to use the auto-height feature we introduced last year. Our auto-height feature resizes the containing iframe so that it matches the height of your app as it changes size, including when users navigate to a new panel and when users cause fields to become visible or invisible.

The issue is that AMP pages cannot include arbitrary scripts, such as our calcapp-iframe.js script, which enables containing iframes to be resized. Instead, AMP requires that their own “AMP runtime” is the only script running on AMP pages.

(This isn’t strictly true — AMP supports running third-party scripts using the amp-script tag. This facility appears to be quite limited, though.)

Luckily, the AMP runtime supports resizing iframes, but only if the iframe in question supports AMP explicitly. Calcapp now emits events when the height changes, both for our own calcapp-iframe.js library (used on regular websites) and — as of today — for AMP.

calcapp-iframe.js supports constraining the height by setting minimum and maximum values. This does not work for AMP. Instead, AMP itself ensures that an iframe is not sized such that it occupies fewer than 100 vertical pixels.

By default, iframes created through AMP use a “sandbox,” which restricts what the iframe can do. As apps created through Calcapp use JavaScript pervasively, you must set a special attribute allowing for scripts to run.

Use this AMP HTML markup to embed an app you have created:

  <amp-iframe width="320"
              height="480"
              sandbox="allow-scripts allow-same-origin"
              layout="responsive"
              frameborder="0"
              src="https://connect.calcapp.net/?app=abc123">
  </amp-iframe>

Calcapp 4 is coming

Thu, 02 Apr 2020 13:00:00 +0000

Calcapp 4 will feature much-improved support for tabular data. Buttons will be able to initiate complex workflows and our formula language will gain many new features. We hope to deliver the first new features in a few months.

Over the past four years, we have incrementally improved Calcapp. Small and large features have been added, bugs have been squashed and the performance has been markedly improved.

We think that the time for incremental change is over. It’s time for revolution.

This isn’t the first time we’ve been down this road — the service you use today is internally called Calcapp 3. Calcapp 1 was created back in 2003 as an easy means of building single-screen calculator applications for Windows using a text file containing formulas. In 2008, mobile was booming and we created Calcapp 2, which was capable of building multi-screen apps for Windows and Android. Calcapp 3, begun in 2014, brought Calcapp into the web era with an app builder available to anyone, producing slick web apps for iPhone, iPad, Android and desktop computers.

It’s 2020, and the time has come to build Calcapp 4. Chiefly, we aim to provide far better support for tabular data and formula-driven automation, which we discuss at greater length below.

You don’t need to worry about your investment in Calcapp, though — all your existing apps will continue to work and the user experience will still feel familiar.

Also, change won’t happen overnight. The new features will be rolled out incrementally, without affecting stability or performance negatively.

Tabular data

The primary innovation Calcapp 4 will bring is much better support for tabular data. While we support importing tabular data for use with drop-downs and exporting data to CSV files or even spreadsheets and databases (through a third-party service), this is a far cry from being able to write apps that can read the data they themselves have written.

Calcapp has excellent support for calculations today. However, calculations often need to be based on not just raw formulas, but on data, which we don’t handle well today.

Also, we think there is a far larger market for apps that can read and write data than there is for pure calculator apps. We’d like to not only serve our existing user base better, but also break into this much larger market.

No-code app builders are exploding in popularity, and what the vast majority of these app builders have in common is that they have robust support for handling data — and poor support for calculations and for using formulas for modeling dynamic behavior in apps. We think that combining Calcapp’s formula prowess with first-class support for data will produce a truly stellar product.

Generally, these data-savvy app builders fall into one of two categories. Either they offer great ease-of-use, but little power (like the slick Glide) or they offer lots of flexibility, but at the expense of a steep learning curve and requiring users to learn lots of new concepts (like the well-engineered Microsoft PowerApps).

We think there is room for an app builder that is both easy to get started with and offers a lot of power through formulas. Further, we think it’s crucial that this product respects the investment users have made in spreadsheets in general and in Microsoft Excel in particular, by offering a similar mental model.

(Others have tried to go down that road in the past, by creating app builders fully integrated with the Microsoft Excel desktop application. We think that’s a mistake, as Excel was never meant to be an app builder. For starters, designing the user interface of an app using Excel’s grid will never yield high-quality user experiences. We think that any product integrating that deeply with Excel is needlessly limiting itself.)

No product on the market meets these criteria today. Our aim is to create it in the form of Calcapp 4.

Formula-driven automation

Apps often need to take complex actions, based on evaluating information entered in an app. For instance, a button, when pressed, should perhaps send an order to a warehouse, make a note of the order in a database and then send a confirmation email to a user. If any of the entered data is not valid, a warning popup may need to be displayed.

Calcapp makes no attempt to realize such workflows today. Buttons can only send or open reports, reset fields or send off data to third-party services. We recognize that this is limiting.

We aim to realize automation through formulas, triggered by events such as a button being pressed. These formulas will be different from regular formulas, in that they will be able to not just calculate values, but take actions through special formula functions.

The current crop of enterprise app builders usually realize automation by enabling workflows to be described graphically. Users essentially have access to a palette of actions, where individual actions can be dragged onto a canvas, allowing multiple steps to be described. There is often special support for describing conditions, enabling different actions to be taken based on whether a formula evaluates to TRUE or FALSE.

Our initial plan calls for using plain Calcapp formulas to realize automation. There is no reason we couldn’t allow these formulas to be represented graphically in the future, enabling users a choice between typing formulas and the graphical approach favored by other app builders. The graphical approach has the advantage of clearly communicating what actions are available and allowing their behavior to be easily customized, without requiring users to remember or look up function names or the order of parameters.

Formula improvements

To support the features listed above, we’ve been hard at work since late last year adding features to Calcapp formulas.

Here’s a small sample of the work we have completed so far:

IF without all the parentheses

Expressing multiple conditions with the IF formula function leads to verbose, hard-to-read formulas, as multiple IF functions need to be nested. IF(X = 1, 10, IF(X = 2, 20, IF(X = 3, 30))) isn’t particularly easy to read, especially if you need a large number of conditions and values.

We’ll fix this problem by allowing the extra conditions and values to be expressed as parameters to the first IF invocation: IF(X = 1, 10, X = 2, 20, X = 3, 30). Much better!

(We’ll also support the new Excel formula function IFS, which does much the same thing.)

Support for the SWITCH formula function

Excel recently gained support for the SWITCH formula function, which Calcapp 4 will also support. Think of SWITCH as a simplified version of IF, provided that you only need to test a single value and you only need to test equality.

The first parameter to SWITCH is the value to test. If this value is equal to the second parameter, the third parameter is returned. Otherwise, SWITCH compares the first parameter to the fourth parameter, and if those values are equal to one another, the fifth parameter is returned, and so on.

Here’s the IF formula above, rewritten to use SWITCH: SWITCH(X, 1, 10, 2, 20, 3, 30).

More types

Every value reachable through a Calcapp formula has traditionally been a number, a logical value or a text string (known as the type of the value). That is unfortunately quite limiting.

We have received many requests for enabling buttons to navigate to various parts of an app, using a formula to determine the target panel. As formulas haven’t been able to reference panels, we haven’t been able to implement that feature.

Also, countless customers have asked us to make which fields are included in reports customizable through formulas. As referencing fields through formulas hasn’t been possible, we’ve had to postpone adding that feature.

Calcapp 4 changes all that, by adding lots of new types, including the aforementioned panels and fields. We look forward to adding new properties and formula functions taking advantage of the new types.

Action formulas

We refer to formulas which can execute actions as action formulas. These formulas will have access to special formula functions, known as action functions, which can execute actions.

Action formulas will also be special in that they will be able to execute multiple actions and thus invoke multiple action functions. You will probably write ; between such invocations.

Here’s an example which sends a report and displays a message if and only if the Result field is valid, and otherwise displays an error message: IF(Result.Valid, SENDREPORT(...); ALERT("Done!"), ALERT("Invalid result!"))

Finally, action formulas will be able to set values, probably by writing something akin to Field1 := Field2 * 2. Note the := symbol — that’s an assignment operator, which assigns the value on the right-hand side to the property on the left-hand side. This will enable buttons to do things like incrementing values, without having to use a stepper, or perform calculations.

(VBA users are used to using = both for assignment and equality. We think that’s confusing, so we’ll probably use := for assignment instead.)

Formula snippets

Some action functions will ask that you supply formula snippets that are executed at a later point in time, snippets which may have access to additional values. (In programming lingo, these snippets are known as lambdas, or anonymous functions.)

For instance, an action function asking the user to enter a value in a popup may make the response available as the Response value: QUERY("What is your name?", ALERT("Your name is " & Response & "!"))

Above, the (fictitious) QUERY formula function takes two parameters: the question to pose to the user and a formula snippet which is provided the response and is executed when the user presses a button.

Naming the values which are provided to these formula snippets may result in easier-to-read formulas. Naming values will be supported using optional so-called arrows (note the -> symbol): QUERY("What is your name?", Name -> ALERT("Your name is " & Name & "!"))

Other changes

We have promised a PDF report designer for the longest time now. We aim to deliver one, but we will deliver better support for tabular data and formula-driven automation first.

We are also aware that many customers want to create apps and upload them to app stores. Some enterprising Calcapp customers have found ways to do so using third-party software, and we expect this process to become easier now that apps produced through Calcapp are true Progressive Web Apps (PWAs). However, supporting app store submissions out-of-the-box would be a complex undertaking and isn’t something we plan to prioritize in the near term.

Finally, we expect Calcapp 4 to deliver myriad smaller improvements. Calcapp 3 was started in early 2014 and the technology landscape has improved markedly since then. We aim to adopt new technology to make maintaining Calcapp easier and to improve performance. We plan to use that opportunity to address long-standing usability problems, including adding support for undo and redo in Calcapp Creator and more robust formula editing.

We hope to deliver the first fruits of our labor in a couple of months. The first features we plan to deliver are the formula improvements discussed above and support for formula-driven automation. Then, we look forward to sinking our teeth into adding support for tabular data.

Release: Our April, 2020 update is here

Thu, 02 Apr 2020 12:00:00 +0000

Apps now work better offline and, as a result, qualify as Progressive Web Apps (PWAs). iPhone users can now easily enter decimal numbers. There are new features for managing users of private apps. Finally, we describe our upcoming project Calcapp 4, with much-improved support for tabular data.

What's new?

Improved offline experience, PWA support. Apps built with Calcapp now qualify as Progressive Web Apps (PWAs), enabling more third-party tools to work with them. We have also made our offline experience more robust, flexible and performant. Learn more »
Easily enter decimal numbers on an iPhone. Apps run on iPhones now use a keypad with a decimal separator button, making it easy to enter decimal numbers. Learn more »
Add users in bulk, download users as CSV. Users who are permitted to access your private apps can now be added in bulk. Also, you can now download the entire list of users, complete with tags, as a CSV file, which can easily be imported into a spreadsheet. Learn more »
Improved email deliverability. We have significantly improved deliverability of email sent from calcapp.net, including reports sent from your apps. We now recommend that you use the Reply-To field, instead of the Sender field, to direct replies to your reports. Learn more »
Download app statistics as a CSV file. You can now download statistics for your app as a CSV file, which you can easily import into your spreadsheet. Use your spreadsheet's formulas to process the data and visualize it through graphs. For private apps, the CSV file has information on how individual users are using your app. Learn more »
Usage statistics on individual users. The Statistics window now enables you to learn how a particular user is using a private app. For such apps, there is a new drop-down menu with a list of all users you have defined in the Statistics window. Learn more »
No more blurry images. When you upload an image, we resize it to a number of lower resolutions so that low-resolution devices don't have to download more than they need. However, we failed to make the original version available, which could lead to blurry images. This issue has been fixed. Learn more »

Calcapp 4 is coming

Feature: Improved offline experience, PWA support

Thu, 02 Apr 2020 11:00:00 +0000

Apps built with Calcapp now qualify as Progressive Web Apps (PWAs), enabling more third-party tools to work with them. We have also made our offline experience more robust, flexible and performant.

Apps created with Calcapp have been able to run offline for years now (provided that you opt for a Business plan or better). Thanks to offline support, an app remains accessible even if a user is on a plane or in a rural area with spotty coverage.

When we built Calcapp’s offline feature in 2016, we used a technology known as appcache. A successor technology, named service workers, was supported by Google on the Android version of Chrome, but Apple’s Safari did not have support. As such, we chose AppCache because it was supported on both Android and on iOS.

Starting in April, Google Chrome will drop support for AppCache, and other browser vendors will likely follow suit. Had we done nothing, apps built with Calcapp would stop working offline in less than a month on Android.

Luckily, we have monitored the situation carefully over the last couple of years, and we were prepared for this development. Calcapp has now been moved fully to service workers, meaning that your apps will continue to work offline.

Progressive Web Apps

Supporting service workers means that your apps now qualify as so-called Progressive Web Apps (PWAs). A PWA can run as a website inside your browser, but can also feature capabilities more in line with what a native app offers. They can be installed on your desktop computer, or they can be added to your Android or iOS home screen. They run offline. There are also provisions for synchronizing and downloading data in the background and for sending push notifications, though Calcapp does not take advantage of those provisions as of today.

Calcapp makers have asked for PWA support for years now. The primary reason is that there are various third-party tools that are able to work with PWAs and not plain websites. For instance, Microsoft allows PWAs to be submitted directly to the Microsoft Store. Also, Google now offers some support for submitting PWAs to Google Play.

(There are smaller improvements as well. Adding a plain website to your home screen on Android adds a small Chrome overlay icon. PWAs added to your home screen get no overlay icon, which arguably looks more professional.)

Getting an app built with Calcapp into an app store still requires quite a bit of work on your part. We’d like to streamline the process, but we currently have a lot of other work that takes priority.

Offline improvements

Now that we have redone Calcapp’s offline support, we have taken the opportunity to subtly improve the offline experience. Here’s a list of the improvements you can expect:

Improved performance. Apps are made available for offline use faster when you first load them. On Android, we have managed to shave a few seconds off the time it takes for the “This app is now ready to be used offline” message to appear. On iOS, the message is now shown as quickly as on Android, which is a dramatic improvement. (Before, users would sometimes need to wait a full minute before the message appeared.)
A more robust experience. Customers sometimes encountered issues with the older offline experience based on AppCache, most often on iOS. Sometimes, the only recourse was to remove a problematic app from the home screen and re-install it. We have a lot more control over the new offline experience, meaning that we think it will prove more robust.
Images and fonts are downloaded in the background. When an app is stored for offline use, images and fonts are stored too. Before, we had to download and store everything before the loading screen of your app would show, which led to a bad experience primarily for apps using lots of images. Thanks to the flexibility of service workers, we now start your app immediately once all the core resources have been loaded and then download fonts and images in the background, leading to a faster experience.
Embedded apps never ask users to update them. When an app is run for the first time, it’s downloaded and stored locally on the device itself. The next time it’s started, that local data is consulted to ensure that the app starts as quickly as a native app. If the user is online, Calcapp checks if there is a newer version available. If there is, the user may be asked to reload the app so that the newest version is run. However, this is not desirable for apps embedded in other websites. Luckily, service workers give us the flexibility to disable the offline experience when apps are embedded, so starting today, users of embedded apps will never be asked to reload an app.
Deferring an app update. As noted above, users are sometimes asked to reload an app when it has been updated. While this message is typically presented only a few seconds after an app has been loaded, it can still be inconvenient to have to reload an app, especially in the rare case that the user has started entering data into the app. For this reason, users can now press the Later button to continue working in the app without reloading it. (The next time the user starts the app, the latest version will be run.)