Something is Happening here at Geist Interactive

Hello there 🙂

 

We have some exciting news to share with you. Geist Interactive has merged with the Proof Group to form Proof+Geist (the + is silent). This is an acceleration of our decades-long mission of empowering people to do great things, a mission we have always shared with the people at the Proof Group. Together, as one team, we are very excited about what’s ahead.

 

Please see the attached press release, and visit us at www.proofgeist.com!

Add-Ons, the Complete (and almost TMI) Guide

The most recent update of Claris FileMaker (19.1.2) includes add-ons. Finally. A calendar, a timer, a kanban board, and much more are part of the actual FileMaker product, built as add-ons.

These add-ons are designed to be fully functional with just a little bit of set up. Each add-on contains layouts, scripts, custom functions, buttons, web viewers, and JavaScript code to give a complete package of functionality. There’s so little to do with each add-on; it’ll just work. Like a portal or a button bar, you need to point the add-on to specific layouts and fields and found set of records. It’s really simple to get these working right away.

And for most people, that is good enough. Anyone can install a kanban board, direct it to find certain records in a table and display those records neatly in one or more columns. No more thought needs to be given to the add-on. It will just work. They’re as close to ‘no-code’ as is possible.

There’s two benefits to the fact that an add-on just works: 1. A lot of functionality value is added to your app within a few minutes, and 2. You can turn your attention to other use cases to complete your work faster.

Just Get Started

In case you want to just get started in using the add-ons, I’d recommend you read these few posts. They’re the quickest way to understand the bare bones workings.

In Case You Want to Learn More . . .

However, there’s a lot inside the add-ons that you might want to know–for your own knowledge and to be able to tinker with and extend the functionality somewhat. So these entirely-optional series of blog posts describes the inner-workings of the add-ons generally. Over the series we’ll also discuss some of the specific add-ons; we’ll give you tips on how to work with it most efficiently.

Here’s the planned list of blog post topics:

How Add-ons Work

View Post

Their universal and self-working functionality, their script and layout structure, and their modularity.

Filtering the Data

View Post

By default, the add-ons return all data, but you can limit the found set by applying a filter. We explain how.

Refining the Find

View Post

The Find Mechanism in each of these add-ons is simple to understand. It does all the work, but you may want to know more about it.

Refreshing the Data

View Post

Sometimes you want to force a refresh of the data, whether after an event such as a find or a record update. Here’s how you can do that.

Using Multiple Instances

View Post

You can use many instances of a single add-on in a file or on the same layout. This guide shows you how that works.

Configuring the Add-ons

View Post

Some add-ons have some complex configurations. Here we point those out and clearly explain how to configure them.

Add-on Events

View Post

All add-ons have events tailored to the experience. Here we talk about those and how you can adjust the Events script.

Required Fields

View Post

Most add-ons require fields both defined in the table and present on the target layout for them to work. Here we list those fields.

Refetching the Data

View Post

Many add-ons are set to automatically re fetch the data, so any changes made by another user will be displayed in the add-on.

Learn All About Add-ons, or Just Use Them

I’ll reiterate, the add-ons are complete in functionality, and most of the time you don’t need to know anything about what I’ve listed above. The add-ons will just work, and the configurations are minimal and done within a user interface rather than in scripting or schema. However, we want to give you all the information. Consider these posts an ‘under-the-hood’ kind of discussions where we talk the nitty-gritty.

Onward

So stay tuned. We’ll release these in small sets so as to not overwhelm you with things to read.

If there’s something else you’d like to know about that isn’t listed above, please shoot us an email at support@proofgeist.com and we’ll get your request written up.

JavaScript at FileMaker DevCon 2019

My username on the FileMaker community is “jeremy_fm_js”, and I’ve been known to advocate using JavaScript in FileMaker for a few years now. It might be interesting to be typecast into ‘the guy that always talks JavaScript’ (I don’t always recommend JS in my posts in the community), but I advocate for many good reasons. Some of them are reasons I’ve stated before, but also, there’s a few new ones I’ve thought of in the past year 🙂 If you need an escape hatch–this is, if you need to build an interface that is more interactive than we can do using ‘idiomatic‘ FileMaker–we can consider JavaScript, and we can consider learning the language. To help you learn JavaScript, JavaScript is part of FileMaker DevCon.

Why JavaScript?

The answer to this question is: why not JavaScript? There’s a lot of innovation we can bring to custom apps using the language native to FileMaker. JavaScript and JavaScript libraries brings thousands of testers to its foundation. I’ve written about all this before.

More reasons

FileMaker itself seems to be giving some weight to JavaScript in the platform (the entire platform, of course). There are two pieces of evidence. First, exploring JavaScript, for the third consecutive year, is part of FileMaker DevCon, the FileMaker conference. Along with APIs and Zapier and microservices, attendees will have the chance to see and experience what JavaScript can do in our apps.

Secondly, JavaScript is specifically mentioned in the product roadmap. In the past it’s been rare to see something so ‘outside’ of FileMaker be mentioned in the FileMaker plans, but there it is. So FileMaker, Inc, and my friends in the product-development team, must have some special plans for it.

The roadmap states: “Within a web viewer, directly call JavaScript from FileMaker scripts and vice versa.” That’s a very amazing idea. We will be able to solve certain web viewer problems with this functionality and give more control to FileMaker interacting with the JavaScript code.

JavaScript at DevCon

All day pre-conference training

This year I have the honor of leading folks in a full-day training of FileMaker & JavaScript. We will work together for six hours to talk about the following objectives and concrete activities.

Learn the basics of the JavaScript language

We’ll work together on exercises that teach us the basics of the language. We’ll talk about JavaScript concepts, and we’ll connect what’s true about JavaScript with what we already know in FileMaker.

Each exercise comes with one or more extra practices. We’ll do those to drive the point home.

Identify the peculiarities of the web viewer object on different devices

The web viewer object in FileMaker is powerful, but it is quirky. We have to understand its needs for each device, so as we practice and exercise, we’ll talk about how the web viewer works differently in different operating systems.

Integrate JavaScript libraries into any custom app

The fun of this day will be to spend time putting charts or data tables or any number of other libraries into our apps. We’ll learn how to do this from scratch. We’ll also review the tools out there that make this part very easy.

Just so you know: In order to work with libraries, we need to know a little JavaScript. We can’t run until we learn to walk.

Learn to communicate between JavaScript and FileMaker easily

The FM WebViewer Bridge framework is an important last-piece of the puzzle. It solves quite a few problems when working with the web viewer, and it provides a less jarring experience for your users. We’ll examine how this framework works.

We will work through examples and practices to learn more about how we can use JavaScript, and it will be a productive day. Attendees will learn a lot about how to use the language. We won’t be JS experts, but we will at least know a bit more of our way around its use in FileMaker. I have two ultimate soft goals:

To be comfortable enough with JavaScript we can look a JavaScript library in the face and not run away screaming in terror.

and

To expand our horizons of what is possible with FileMaker and JavaScript.

The six hours will be more than enough time to get our feet wet. If you haven’t signed up yet for this training time, I encourage you to give it a consideration. JavaScript brings to our fingers much power, and this session can help you see how to harness that power.

Discussions throughout the week

I wish to continue the JavaScript discussion well after the training session ends (after we’ve had a chance to recover from the workshop). Last year I was available to talk shop and sat with a few folks to talk one-on-one about how to integrate a chart or a data table into their in-production apps. That was a blast. So this year I wish to continue that. While at the booth or at food time or in the hallway, I’ll be available to talk with folks about their use of JS in their apps. So feel free to find some time with me and we can continue to discuss this innovative tool.

JavaScript after DevCon

The fun doesn’t end when FileMaker DevCon 2019 ends. Oh no. Energized from that experience, I’ll continue to talk about JavaScript and FileMaker. I’d love to do a follow up training session with interested folks to continue to learn more about the language and how to use it in FileMaker. So stay tuned to this blog and our Twitter page for more information.

Preparing for DevCon

If you do plan (or are thinking about) on joining me for FileMaker & JavaScript, please take a moment to download the file (below) and test your setup (computer, browser security settings, FileMaker version etc) to see if all will go well with your time. Basically click some buttons and confirm you see the web viewer user interface and interactions. Those running macOS will be fine. Windows users should really test it out.

I want you to be successful in the session. The file here contains a small sample of what we will do; all the items you’ll test here we want to make sure work. If you download the file and run thru the tests and all is good, you’ll have no issues with the work we do during the training. If you do have issues, please reach out to me at support@geistinteractive.com and we can work on finding a solution so that you can attend and learn and exercise your innovative spirit.

Don’t worry if your copy ‘fails’. I have a plan in case you can’t view the C3Chart or the DataTables or the PivotTable. The only extremely-vital one is the Code Editor test.

See yah in just a month! And get ready for JavaScript at FileMaker DevCon.

Downloads

The following list of downloads reflects what we did during the FileMaker & JavaScript session. More is coming soon.

JS Test File: test your machine to be ready for the training

Session Slides: The slides we used to talk about JavaScript and FileMaker and the web viewer.

To view all the resources we used and to view tutorial videos walking through each exercise we did during the session, go to this page.

Geist Interactive At FileMaker DevCon 2019

FileMaker DevCon 2019 is fast approaching. There’s less than three months left, and we at Geist Interactive are busy, getting ready for the conference. Todd Geist and myself–Jeremy Brown–will attend (this will be our 20th and 8th time respectively) and spread the good word about JavaScript and the Workplace Innovation platform. We will be busy during the week, but will always make time for chatting about FileMaker or JavaScript or any other tech topic. Read on to see what we will be up to in Orlando, FL.

Conference Sponsor

Geist Interactive is proud to be a sponsor of this year’s FileMaker DevCon. We believe the three-day conference is great for every innovator out there. FileMaker DevCon 2019 will be full of great people, great innovations, and great food. We want to give back in the form of sponsorship so that all developers can learn as much as possible and make great connections.

Training Day

For the second year in a row, I will lead folks in a training session titled “JavaScript for FileMaker Developers“. This full-day session (upgraded from a half-day last year) will focus on how to use JS in our FileMaker apps. Attendees will spend time working on exercises in the JavaScript language. Each person will build a complete integration of a data table or a chart into a custom app. And everyone will learn how to work with the FileMaker Web Viewer object (which can be a bit prickly in some situations). Finally, we will focus on advanced topics like how to communicate to the JavaScript from FileMaker without causing a rude flash of the web viewer.

Our playground for the day.

I am dusting off my teaching skills and pulling out my manipulatives so that everyone–from the JavaScript beginner to the more advanced person–can learn something and walk away with a good set of next steps. Every FileMaker developer can (and should) use JavaScript as another tool in their apps. Join me in this session and learn how to use this powerful tool.

WorkPlace Innovation

Todd Geist is extemely a little obsessed with Workplace Innovation and FileMaker. He’s written about the beginning and the continuation of innovation with each incremental release of the platform. So at FileMaker DevCon 2019, Todd gets to speak about what he sees in the current status and the future trajectory of the Workplace Innovation Platform. Here is a description of his sessions:

Why a Workplace Innovation Platform?

What’s so special about a Workplace Innovation Platform? You’ve seen the videos, you’ve read all the marketing material, but practically speaking what is that makes a Workplace Innovation Platform standout from other options? We are going to look at the current state of business and work group innovation, and learn through a series of examples and mini case studies why FileMaker, as the leading Workplace Innovation Platform, can be so effective in driving business innovation.

What’s Next in Workplace Innovation?

Workplace Innovation doesn’t stop. Neither does the flow of exciting new technology that the FileMaker Workplace Innovation Platform makes available to us. In this session, we are going to look at some of my favorite bleeding-edge techniques, tools, and integrations that really make the FileMaker Workplace Innovation Platform shine. Come and see what the future looks like. There will even be some fun demos you can download and try on your own.

These two sessions are going to be lively and challenging and full, so you may want to show up early to get a spot.

No matter the size of the booth, we’re happy to talk all things Workplace Innovation Platform

Hanging at the Booth

Todd and I along with Tonya (another member of the team) will spend their time at our annual booth in the exhibit hall (though we do wish it were located down by the pool). We always welcome folks to come and stop by and talk anything you want. We’ll demo our products (FMPerception, Otto, WidgetStudio, GoDraw3, and many others) and our custom development offerings. So stop by for a spell and chat us up. Bonus points if you come ready to talk about, A. JavaScript; B. JSON; C. FileMaker Modules; D. Innovation in FileMaker.

Vendor sessions

At FileMaker DevCon 2019 we will feature FMPerception and Otto in two separate vendor sessions. Dave Ramsey will demonstrate the value added to your development using the only Realtime Developer Intelligence tool. He’ll open your eyes to the major features as well as the intricate details that really makes it more intelligent.

Todd will demonstrate what the best Dev Ops tool “Otto” do for you. He’ll walk you through how Otto can help automate the tedious and error-prone process of deploying, migrating, and monitoring solutions.

Check out the schedule as we get closer to DevCon. Stay tuned to us on social media for updates as well.

Packing our Bags (soon)

We’re getting ready for FileMaker DevCon 2019. We’re excited about all the innovations that will be on display and shared throughout the week, and we can’t wait to share a few of our own.

If you’ve never attended, check out my blog post on attending the conference for the first time from last year. Eventually he will post a new one with an updated theme 🙂

See yah in just a few months!

The Context Podcast by Proof+Geist

The Context Podcast: Pause on Production Part 1  — Interviews from PauseOnError Attendees 

Featuring:

  • Martha Zink 
  • Adam Aronson 
  • Barbara Cooney
  • Jonn Howell

Description:

In the scenic mountains of north Georgia, open-minded attendees gathered together to connect, learn, and grow with one another. In this episode, our guests focus on why PauseOnError differs from traditional tech conferences and how it ignites new perspectives. 

Since PauseOnError 2022 ended, we’ve collected attendees’ big learnings and aha moments for The Context Podcast. Listen to their stories and discover why you might want to join them next year.

This is the first of three episodes that feature participants’ stories. 

Available on Transistor.Fm, with full individual interviews available on YouTube.

Links:

Join us October 3-6, 2023 in the same amazing location. We can’t wait to see you there! 

Transactions in FileMaker 19.6: Part 1

What Are Transactions?

We each conduct transactions every day. We transact when we talk with other people, when we buy goods from a store, and when we check out a book from the library. In the database world, transactions have a similar meaning – exchanging this for that, whether it be ideas, encouragement, or money.

Transactions are also a database concept for maintaining data integrity. When working with databases, there are times when you want to make several changes to the data in a single operation. If something happens that prevents one of the changes from completing successfully, you want to undo the other changes and return the database state to where it was before you made the changes.

Consider an online purchasing system. Users can place orders for items In Stock and if an item is Sold Out then it should be marked as unavailable for purchase. The following operations might be part of that purchase:

  1. An invoice for the item gets created, and the user’s account shows a charge for the item
  2. The inventory quantity for the item reduces by 1
  3. If the inventory drops to zero, the item becomes marked as unavailable for purchase in the sales system

If during this process you discover that the inventory quantity is already zero (perhaps because someone else has purchased the last unit), you will want to undo changes you made as part of this sale.

Transactions help you accomplish this goal. They keep all of the changes in a temporary space and then attempt to save those changes to the database. If any one operation fails nothing is written back to the database. This is called an “atomic” transaction.

Understanding the role of Error Trapping is important when working with transactions. FileMaker Pro uses the LastError flag, available via the Get ( LastError ) function, as a means of indicating whether the steps of a transaction succeeded or failed. For example, if our script attempts to decrease the inventory quantity by 1 yet another user has that record locked, our attempt will be blocked. The LastError flag will be set to ‘301’ indicating “Record is in use by another user.” For more on error codes, see the FileMaker Error Codes reference in Claris online help.

Transactions in FileMaker

FileMaker Pro has had transactions for some time now, although they have gone unnoticed by many developers. Whenever you initiate a change in the database, that creates a transaction. Creating a record, editing a record, and deleting a (related) record all open a new database transaction. With the exception of deleting a record, each of these transactions could be rolled back by initiating the Revert Record command. Saving a transaction, however, is less explicit; any action that causes FileMaker to move away from the current record would implicitly attempt to save the transaction. Clicking on a non-interactive background element of a layout would also implicitly attempt to save the record.

Recognizing this behavior, developers created formal patterns to impose structure and regularity around the use of database transactions. Because related records are included in the transaction, patterns arose where an unlimited number of records could be created, modified, and deleted by manipulating record keys and configuring special transaction-focused layouts. These transactions relied on the Relationships Graph, Layouts, and various Script Steps provided in FileMaker Pro for managing transactions.

Script Steps

FileMaker Pro provides several script steps for interacting with transactions. The three primary steps are:

Open Record/Request

Commit Record/Request

Revert Record/Request

The names of these steps show you, historically, they have been based on the current record. In addition to these three, two other steps are critical to the reliable operation of transactions in FileMaker Pro.

Allow User Abort

Set Error Capture

These two steps allow you to better control whether or not a transaction is saved (committed) or discarded (reverted) through user interaction or manually if scripted modifications fail (for example due to a validation error) and determine whether our transaction operations were successful or not.

  • Open Record/Request
    • This step attempts to lock the current record for editing by the current session. If the lock can be obtained a transaction is initiated; if not an error code is written to the LastError flag. This step is optional to the operation of transactions; any attempt to modify a record or related record will implicitly attempt to obtain a lock for the record before allowing the modification.
  • Commit Record/Request
    • This step attempts to save all modifications to the database that have been performed during the transaction. If any modification fails to be written, this operation will be rolled back and an error code will be set in the LastError flag.
  • Revert Record/Request
    • This step will roll back any modifications to the database that have been performed during the transaction.
  • Allow User Abort
    • This step controls whether the script can be canceled by user interaction. While not explicitly about transactions, the Allow User Abort script step can prevent users from inadvertently exiting a script, leaving a transaction open.
  • Set Error Capture
    • This step works in concert with the Allow User Abort script step. Rather than displaying error messages to the user, errors are silently written to the LastError flag and read using the Get ( LastError ) function. By testing for this LastError value after attempting a database operation you can decide whether to attempt to Commit the transaction or Revert it.

Note that any operation that causes the current record to lose focus will result in the database engine attempting to save the transaction. If the transaction can not be saved due to an error, the operation that initiated the save attempt will fail and an error code will be written to the LastError flag. The practice of setting the ErrorCaptureState flag to ON and testing for the presence of a value in the LastError flag is known as “Error Trapping.”

Transaction Scope

Transaction Scope is another important concept when working with transactions. Transaction Scope defines the conditions in which a database operation is included or excluded from the transaction. The scope of a transaction can be inferred to be the current record in the window where the transaction was initiated. Any database modifications to records outside that window are not included in that transaction but may be included in a separate transaction. That is, each open window can have its own transaction independent of the transactions in other windows. Committing or Reverting a transaction in one window will have no effect on open transactions in other windows. However, a record can only be modified in a single transaction; attempting to modify a record in two different windows will result in a record-locking error.

What’s New in 19.6

With an understanding of how transactions have historically worked in FileMaker Pro, you can look at the changes made in FileMaker 19.6. On the surface, FileMaker 19.6 includes additional functionality that makes working with transactions more explicit, extends the number of script steps that can be included in a transaction, and improves the level of Error Trapping available considerably. Where some transaction functionality in prior versions relied heavily on patterns created by individual developers, the new functionality supports their operation more explicitly and makes them more accessible to developers who haven’t used them in the past.

How the new Transactions Work

Transactions in 19.6 work similarly to those in prior releases yet add new steps to open and save the transaction.

New Script Steps and Functions

  • Open Transaction
    • Open Transaction is a new Control step in the FileMaker scripting language. By invoking this step, FileMaker enters a new transactional state for the current window. Within this control block, most record operations (see exceptions) become part of the transaction and can be reversed if the scripting engine encounters an error.
    • Transactions can not be nested; while a Transaction is open the script execution engine will ignore any subsequent Open Transaction steps it encounters.
  • Commit Transaction
    • Commit Transaction is a new Control step that is paired with the Open Transaction script step and signifies the end of the transaction control block. If no errors were encountered during processing, all record changes that occurred during the transaction will be written to the database. If the script execution engine encountered an error during the transaction, the transaction will be reverted and script execution will jump to the step immediately after this one.
  • Revert Transaction
    • Revert Transaction is a new Control step that allows developers to revert a transaction manually. While certain errors will prompt the database engine to automatically revert the transaction, sometimes the transaction will need to be reverted due to errors defined according to business logic. The Revert Transaction step can only be invoked within the script that issued the Open Transaction step; it is ignored by the script execution engine if encountered in any subscripts.

Claris has also provided three new options for the Get () function:

  • Get ( LastErrorDetail )
    • This is an existing function formerly called Get ( LastExternalErrorDetail ) that has been extended to work with the Transaction script steps. It returns more detailed information about the error encountered during the script execution if any. The first value is the name of the script that was executing when the error occurred. The second value is the name of the script step that threw the error. The final value is the line number of the script step that threw the error. If there was no error then this function returns an empty value. If the Transaction is aborted due via the Revert Transaction command the script step name and line number will be those of that Revert Transaction command. Example:
  • Get ( LastErrorLocation )
    • This function is similar to the Get ( LastErrorDetail ) function in that it returns three values indicating the script name, script step, and line number where the error occurred. The principle difference is that this function can be used in contexts other than with Transactions. If no error occurred (as indicated by the value returned by the Get ( LastError ) function) this function will return an empty value. If an error occurred within the Transaction block this function will return the name of the script, the script step “Commit Transaction” and the line number of the Commit Transaction script step.
  • Get ( TransactionOpenState )
    • This function returns a 0 if no Transaction is currently open, and a 1 if a Transaction has been opened. While this function will indicate whether or not a Transaction has been opened, it does not indicate whether any records have been modified as part of that Transaction. For that, the existing Get ( RecordOpenCount ) function will return the number of records open in the current window, with some caveats (see Transaction Scope below).

Benefits of the new Transactions model

Given that transactions have worked reliably since the release of FileMaker 7, it’s easy to question if there’s anything to gain from using the new transaction script steps in FileMaker 19.6. If you have working transaction code in your systems then there is generally no need to change it. If you’re starting a new project, though, or in the midst of development, you might find the new transaction benefits compelling.

Speed

The new transactions script steps are considerably faster than previous methods. In a test of record creation using the legacy and new methods, the new method was 31% faster. While not as dramatic, speed improvements were found with record updates and deletions too.

Simplicity

Complexity is the bane of systems design. Complexity makes systems difficult to maintain, prone to error, and increases the time it takes to bring new developers on board a project. With FileMaker development, complexity often leads to degraded performance as well. In the past you needed to trade off complexity for data integrity. The new transaction model greatly reduces the need for that trade-off.

  • Relationships Graph
    • No single area in FileMaker development lends itself as readily to complexity as the Relationships Graph. Particularly in larger systems, or systems that have been in production for years, updates to those systems have typically resulted in the proliferation of table occurrences as features are added, functionality is changed, data schema has evolved, and developers have adopted the heuristic that “adding new” breaks fewer things than “changing existing” does. To an already complex graph, the legacy Transactions method typically added a whole new set of table occurrences to allow scripts to address all of the data tables from the transaction context. In some scenarios, such as when a script needs to access multiple records in the same table as part of the transaction, multiple copies of the table occurrences may need to appear on the Relationships Graph. With the new Transactions model, none of this is necessary in the vast majority of cases. Record operations can be performed using existing layouts bound to existing table occurrences.
  • Layouts
    • Legacy Transaction methods typically used one or more special layouts for transactional processing. In particular, these layouts were required if you wanted to include any Delete Record commands within the scope of a Transaction. To do so, in addition to the table occurrences required on the Relationships Graph, you also needed to add a portal object for each table in the system from which you might delete records. In addition, each of these portals needs to be named in such a way that your script can reliably target the correct portal before issuing the Delete Portal Row command. In contrast, the new Transaction model allows you to go to any layout based on that table’s context, locate the record in question, and issue a Delete Record command to remove the record.
  • Scripting
    • Scripts using the new Transactions model can be simpler to write as well. Comparing the example above of deleting a record using the legacy and new Transaction models, the scripting required to accomplish that task using both models really highlights the benefits of simpler scripting. Compare the scripting required with the new method
    • to that of the legacy method

More Flexibility

The legacy transaction model in FileMaker 19.5 and earlier allowed you to modify and delete multiple records, all with the ability to revert back if necessary. Because the transaction was limited in scope to the current record in the current window, developers needed to get creative to implement a flexible mechanism for transaction record processing. One limitation of the legacy model exists around record creation. While multiple records could be created via relationships, if the relationship key was modified to access a different record you no longer had access to any records previously created.

The new transactional model in FileMaker 19.6 removes this limitation by expanding the scope to the current window. This gives developers the ability to work with multiple records in a single table or across tables, delete records without specially configured layouts, and access any records previously created within the transaction. The new model allows for more script steps to act on the newly created records, including Replace Record Contents among others. With the new model, far more record modification script steps are available for use within a transaction that can be rolled back at any point.

Prior to FileMaker 19.6, the developer needed to ensure the current record was not inadvertently committed or reverted. With the new transaction model, the developer must explicitly commit or revert the transaction so fewer actions will lead to unexpected transactions. When a transaction is aborted, whether when the scripting engine encounters an error or the Revert Transaction script step is invoked, script execution immediately jumps to the Commit Transaction script step and any steps after the error are skipped. This enhances script readability and reduces the need to guard script steps against execution after encountering an error.

The Pause that Refreshes

“My home office has a full refrigerator, no commute, and a loving dog, yet this place has all of you.” — Pause 2022 attendee

A few weeks ago, I spent time in the North Georgia mountains with over a hundred daring developers and intrepid techies at the tenth annual PauseOnError conference. Brave because the event takes place outdoors in mid-October at a high enough elevation for nights to grow cold and rainy days, some years, to soak clothes through and through. Boundary pushing because it’s not what people expect from a tech event.

This year the sun shone on participants from more than 68 cities across six countries, representing big and small companies alike.

The name PauseOnError comes from a developers’ debugging option in Claris Pro (FileMaker) that pauses when a script runs into an error. Our busy lives follow that same pattern. Better to take a moment (or four days) to pause before f*ing something upperhaps our code, or more likely our health, perspective, and maybe patience with our kids. And if we’re going to pause, let’s make it last.

In 1929, Coca-Cola marketed its new soft drink as, “The Pause that Refreshes.” I prefer time in the woods, amid trees changing colors, people catching up with old friends, and strangers discovering a mutual love for creating systems that can track a violin company’s inventory, a cabinet maker’s special requests, or a university’s students and their grades. I bathed in the conversations and felt a new, more grounded pace echo through the hills. This Pause was less a conference and more a revelatory retreat.

The Buddhist monk, Thích Nhất Hạnh, captured the feeling in his book Being Peace: “We do so much, we run so quickly, the situation is difficult, and many people say, ‘Don’t just sit there, do something.’ But doing more things may make the situation worse. So you should say, ‘Don’t just do something, sit there.’ Sit there, stop, be yourself first, and begin from there.”

From an opening meet-n-greet to late-night bonfires and sing-alongs, we were encouraged to choose our own adventure, so we did. We were amongst people who believe in the power of doing things differently and consistently taught us we’re never alone.

In the closing session, huddled together in a wide open amphitheater, we were reminded that we brought our whole selves to Pause, shared our hearts with others, and would head home reenergized. We reflected on how precious time together feels now, in a world we all saw shut down, and know we’ll never take togetherness for granted again.

At Pause, where the birds cooed, and the trees transformed before us, my head cleared and my mind remembered it could saunter. I found a new peace the inside world doesn’t offer, at least not often enough. This Pause refreshed.

I’ll be back next year. Consider joining me.

Marcia Conner is a former software executive who serves as an advisor to the Proof+Geist leadership team. Find her on the distributed social media platform Mastodon (marciamarcia@follow.proofgeist.com) or wherever you tend to browse.

The Impact of Microsoft Deprecating Direct SMTP Access

What is Happening?

In September 2019, Microsoft announced plans to follow suit with Google and deprecate direct SMTP (Simple Mail Transfer Protocol) access to their services, meaning that unsecured methods, such as sending emails with FileMaker’s ‘Send Mail’ function, would become obsolete. Essentially, users are longer able to log in using only their username and password, as it is not considered a safe method of authentication. As of October 1st, 2022, this plan has been put into action and users are already experiencing issues when sending and receiving mail through FileMaker. 

What Can You Do?

One option is to migrate to a bulk mail or transactional mail provider, of which there are many. 

However, Proof+Geist suggests utilizing transactional emails as APIs. Along with allowing you to look at analytics, utilize templates and models to build HTML, and avoid being marked as a scammer, APIs offer proofing for future changes and deprecation which means you can rest assured that you’ll still be able to send and receive your mail, regardless of whatever updates are to come. 

Some of these APIs include services such as SendGrid (Todd Geist’s personal favorite), MailGun, and Mandrill.

Of course, each API service comes with its own challenges; you may find yourself looking to make modifications to whatever service you choose to better fit your needs. This can be discouraging for users who are already overwhelmed by the changes they need to make due to Microsoft’s updates. 

What Can We Do?

Proof+Geist offers consulting and guidance when it comes to these issues and can assist you with writing functions that will utilize an API to best fit your needs. Our product LedgerLink offers both SendGrid and Microsoft Office 365, enabling you to take emailing to the next level. LedgerLink is free to download and has a variety of email scripts for you to explore. By taking code from LedgerLink and bringing it into FileMaker, you can continue to send and receive mail as usual, without having to worry about being blocked by Microsoft’s updates. 
Interested in learning more about what we can do for you? Proof+Geist offers FileMaker consulting, licensing, and developer tools, including the aforementioned LedgerLink. With our expertise in both Claris FileMaker and web technologies, we are ready to innovate and help support your business.

The Context Podcast: Changes to the Claris Platform

Featuring:

Martha Zink, The Context Podcast Host & Proof+Geist Director of Marketing

Todd Geist, Proof+Geist Co-Founder/CTO 

Matt Navarre, FileMaker Talks Co-Host

Episode Summary: 

Join Martha Zink, Todd Geist, and Matt Navarre from the FileMaker Talks podcast as they discuss changes coming to FileMaker, the Claris Platform, and strategies that businesses can use to benefit from the changes.

Description:

In September, Claris announced that the Claris FileMaker platform would shift to the cloud, making it more accessible and powerful. 

This new platform can be used to create rich UIs and apps for public-facing client and customer portals, which was previously only possible with custom web publishing. This is what we think of as Modern FileMaker. 

For those who need to use previous versions, they’ll be maintained for a while longer.

Learn more in this episode of the Context Podcast. Available on Transistor.FM and Youtube. 

Other Links:

Claris Webinar Recap

Claris Webinar Link

FileMaker Talks Podcast

Faster Development with Claris FileMaker Snippets in Raycast

I love finding new and clever ways to make my computers work better for me. Clipboard manager is a productivity tool I use every day. It saves each bit of text I copy to my clipboard so when I go to paste I’m not limited by only the most recent item saved. 

What if I could take this concept further by storing things I may want to paste again, accessing them easily and putting them back on the clipboard?

While Claris (FileMaker) Pro clipboard doesn’t do this natively, Raycast offers a free and easy way for anyone with a Mac to benefit from a library of Claris-friendly snippets.

What is Raycast?

Think of Raycast as a spotlight-replacement app for your Mac, such as Alfred or LaunchBar. Raycast excels at being keyboard-focused and features a robust developer API so anyone can build their own custom extensions.

Raycast extensions are built with React and TypeScript, which Proof+Geist use when we build web applications.

Getting Started

Download Raycast (for FREE) from https://www.raycast.com, then follow all the setup instructions. Create a keyboard shortcut to search anything or launch commands.Once Raycast is ready to go, visit this page or click the button below and click Install Extension. That’s it! You’re ready to start using Snippets.

Using the Extension

Create a new snippet by copying something from FileMaker and using the Create Snippet command in Raycast. Then name the snippet, give it a description, and add searchable keywords. Press ⌘+return to save the snippet. You can edit later. 

Open the View Snippets command from Raycast to search your snippets, then press return to copy it to your clipboard. You’re now ready to paste into Claris/FileMaker Pro.

By default, all the snippets you create will be stored on your computer in a support folder that Raycast maintains. You can define additional locations for your snippets in Manage Snippet Locations. Share your snippets between computers or with your team by putting them in a synced folder. 

Tips and Tricks

In Raycast, extra actions are hidden behind a searchable menu opened with the ⌘+K shortcut

Assign a global hotkey to launch any specific command, including commands from custom extensions, using ⌘⇧+, (command+shift+comma). 

Search through your snippets using a hotkey that will launch the command directly. Create the hotkey in the Raycast preferences.

Share an individual snippet with someone else using the Reveal in Finder action. That locates the JSON file. Do not rename this file please. It could create duplicates if the snippet is later edited by the extension.

Personally, I’m loving how Raycast Snippets makes my work more efficient and brings some ease to my day, meaning I have more time to focus on development. 

Special thanks to Dan Shockley, author of the FmClipTools AppleScript collection, leveraged by this extension.

Modern FileMaker at Proof+Geist

At Proof+Geist, we see the Claris platform as a key puzzle piece for any business ecosystem. With our world-class hosting platform, professional development tools, and expertise in both Claris FileMaker and web technologies, we are ready to innovate and help support your business now. For questions, comments, or more information, drop us a line at info@proofgeist.com.

The Context Podcast by Proof+Geist

The Context Podcast: Events in the Claris FileMaker Community

Featuring:

  • Martha Zink 
  • Todd Geist 
  • Matt Navarre 

Description

Join Martha Zink, Todd Geist, and Matt Navarre in this episode for a crossover podcast with 1 of the 2 Matts from the FileMaker Chat podcast. They discuss events led by the FileMaker Community, including AutoEnter Live and PauseOnError.

You can listen to this episode on Transistor or Watch it on Youtube.

Other Links:

AutoEnter Live

Rome FileMaker Week

PauseOnError

EngageU

The Context Podcast by Proof+Geist

The Context Podcast : Reinventing the UX/UI Design Process in Modern FileMaker with Mizu

Featuring:

  • Martha Zink, The Context Podcast Host & Proof+Geist Director of Marketing
  • Ernest Koe, Proof+Geist Co-Founder/CEO

In this episode, join Martha and Ernest as they discuss the design thinking methodologies that informed Mizu, how it complements the modern FileMaker concept, and how the context of evolving user interface design and engineering principles will continue to shape Mizu’s iterations. 

What is Mizu (水)? It’s a material-inspired, lightweight FileMaker theme and helper file for FileMaker developers. Mizu is part of an overall design system at Proof+Geist that emphasizes the use of underlying structures (grids), design patterns, and reusable components to enable more consistent, collaborative work.

Join our hosts as they cover topics like: 

  • What is ‘capital D’ Design and how is it foundational to the modern FileMaker concept?
  • How can Mizu make your mental load lighter by taking on the UI, and why does that help development?
  • How can constraints help remove friction in your development process?

Listen to the newest episode of The Context Podcast on Transistor on watch it on Youtube.

Other Links:

FIleMaker as Part of a Bigger Tech Stack

Recap of Claris Webinar: More than Just FileMaker

In today’s webinar, Claris focused on business leaders. Brad Freitag, Claris CEO, removed his Claris hat and played the role of just a CEO. Collectively, the Claris team focused on decision-makers, the Claris Community, and changes in the Claris platform.

Thinking like an executive

Brad Freitag talked about running a business in an agile framework, driven by priorities and a quarter-by-quarter horizon, motivated by the company’s vision and mission. He said an executive focuses on running a “coordinated company, not a clumsy company,” which requires clear communication and a focus on priorities.

A cohesive view of the business is critical for decision-makers and an ever-moving target. What you need one quarter may be different the next. Having technology that can pivot along with the business is a must-have. And having a team to help create and develop that product is a must-have, too.

Working with executives

Claris FileMaker Can Provide Dashboards for Executives

Often, as developers, we focus on what we are delivering or what we’re providing. However, effectively communicating with decision-makers is key to a healthy, long-term relationship with our clients. Brad Freitag focused on the importance of language that unites the development partner/team with executives. He highlighted the five points he learned from Dr. Jeff Sutherland:

  • Goal
  • Reasons
  • Measurements
  • Return on Investment (ROI)
  • Timeline

Freitag believes a commonly understood, working vocabulary is key, as is thinking like an executive, knowing that risk and managing risk are always top of mind to decision-makers. By focusing on the mindset of an executive, technology partners can offer a different perspective on building a successful business.

Modern FileMaker is the Claris platform

Gone are the days of a modern business tech stack made up of a single application. In our lives, we can think of all the apps we use personally (take a glance at your phone!). And at work, we’re juggling email, chat, and virtual meeting tech. But it doesn’t have to be juggling. 

Freitag reminds us that FileMaker has been vital in integration and that, more importantly, it continues to grow. Apps are not silos, and a thriving business continues its success with an integrated chain of software.

Changes to the platform

Claris is creating a distinction between the FileMaker platform to the Claris platform. The Claris platform includes Claris Studio, a cloud-native platform. They continue to broaden the feature set of their existing products and look for ways to integrate with other technologies.

 In an episode of The Context Podcast, we discuss the growing shift toward a more decoupled, lightweight approach to development. Ernest Koe and Todd Geist share how a new set of ideas, skills, and technologies directly inform how we build value with the tools we have, including FileMaker and the Claris Platform.

Keep in mind that FileMaker is consistently updated. In other words, Claris FileMaker and Claris Pro (the latter being part of the Claris Platform bundle) will live in parity for the foreseeable future. This FileMaker/Pro part of the platform continues to improve as the rest of the platform grows. Recently, we covered the changes in version 19.5 during an episode of The Context Podcast, and we expect 19.6 to bring a slew of new, exciting features.

Before today, access to Claris Studio was limited to Partners and members of the Problem Solvers Circle program. Starting today, Claris released licensing for the Claris platform for the general public.

The Claris Community

PauseOnError: The Claris FileMaker Community

Peter Nelson, VP of Engineering, spoke to the developer community, reiterating that our job as developers is different today than before. Customers expect products to be accessible and for the technology to grow along with the company. 

With the shift to the Claris platform and its growing suite of tools, developers now have more capabilities than before. Both Peter Nelson and Andrew LeCates, Director of Platform Evangelism, highlighted the importance of keeping up with modern security practices. As an Apple Company, Claris follows and audits against current best practices, including ISO certification and SOC audits.

Claris proudly shared that their delivery cadence has been every 4-6 weeks with Claris Studio. Robert Holsey, Product Manager, echoed the value of delivering quickly and listening to feedback. In other words, what the community shares with Claris matters.

Gianine Campbell, Community Relations, talked about the community as a critical part of the Claris ecosystem. She emphasized that the company continues to look for ways to increase engagement, provide valuable content to existing developers, and attract new developers. They are actively looking for ways to support the community at large (like AutoEnter Live and PauseOnError) and highlight the importance of community-building and community engagement.

Proof+Geist takeaways

What we know of the FileMaker platform is not lost or gone. FileMaker is part of the greater Claris Platform. It is actually the secret sauce. It makes Claris capable of hybrid business operating system strategies—which makes Claris challenging to replicate in value. It offers a suite of capabilities that remain incredibly relevant today. 

In the future, as Studio continues to gain features and capabilities, that gap will likely close. Today, FileMaker will continue to play an essential role for many businesses. But we are excited about the opportunities to do so much more.

Just like we suggest to customers that newer versions of FileMaker Pro bring better security, tools, and features, we feel that the Claris platform will do that at a larger scale.

Many of us in the FileMaker developer community have been playing the modern FileMaker game for a while. We saw more than 5 years ago that the game had fundamentally shifted to the cloud. We noticed that for FileMaker and the Claris platform to make this move, they would have to do several things:

  • Include cURL and JSON: We asked FileMaker to add these and provided working examples of JSON functions
  • Choose JSON over XML: We started using Node JS to create JSON APIs
    • Claris Added a RESTful JSON API
  • Embrace JavaScript:  Not just for Node-based APIs, but for web viewers. We worked with Claris to create the Javascript-based add-ons for FileMaker 19
  • Embrace the Software Development Life Cycle: We created Otto to help developers (including ourselves) create and manage a dev/prod environment
  • Shift the center of innovation from the File to the Server: We created Ottomatic, a world-class hosting platform with more locations than AWS. It’s modern, optimized, and constantly evolving

We are thrilled to hear Claris embrace the language of a “Modern FileMaker Revolution”.

An evolution would make FileMaker incrementally better. A revolution is a shift from an app development strategy to a platform strategy.

The Context Podcast by Proof+Geist

The Context Podcast: Expanding the Possibilities of Modular & Decoupled Development with OData

Featuring:

  • Martha Zink, The Context Podcast Host & Proof+Geist Director of Marketing
  • Todd Geist, Proof+Geist Co-Founder/CTO
  • John Renfrew, Independent Developer & Owner

Episode Summary: 

The recent release of FileMaker 19.5 introduced a new feature for those with FileMaker Server for Mac and Windows: OData (Open Data Protocol). Originally created by Microsoft, OData is an open protocol that allows for the creation and consumption of queryable and interoperable REST APIs in a simple and standard way.

Description:

The recent release of FileMaker 19.5 introduced a new feature for those with FileMaker Server for Mac and Windows: OData (Open Data Protocol). Originally created by Microsoft, OData is an open protocol that allows for the creation and consumption of queryable and interoperable REST APIs in a simple and standard way.

In this episode, join Martha, Todd, and John as they explore OData and its many wide-ranging impacts: What benefits – efficiency gains, programming ergonomics, and scalability – does OData offer? How does OData compare to and improve upon other methodologies like the Data API, ODBC, and PSOS? Before diving into OData, what are some tradeoffs and cautions we should consider? And perhaps most centrally, how does OData open a door to new ways of modular and decoupled development in modern FileMaker?

You can listen to this episode here or watch on Youtube

Other Links:

OData Documentation

FileMaker 19.5 Release

The Context Podcast: New Features in FileMaker 19.5