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 for 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!

Building a modular picker with an OnTimer Script

It’s common in Claris FileMaker to create picker windows. Imagine selecting a customer for many different parts of your app: Invoices, Work Orders, Sales Orders. How can you reuse the same customer picker and have the result from the picker target different tables?

One technique that we use here at Proof+Geist is to use the Install OnTimer script step along with a handler script. 

The components are:

  • Calling script, with context-dependency
  • Handler script, with context-dependency
  • Picker window
  • Picker select script
  • Global field to store selection results

To preview this technique, check out this video where I am able to use the same picker window for selecting a customer for any target context.

1. Create the picker

I usually start by building the picker card. Most often, I use a list view, which makes adding find capabilities or filtering more straightforward.

The scripts that support the picker include:

  • Reveal the Picker, which sets up the picker environment and will:
    • Create a New Window set as a Card.
    • Stop any inherited OnTimers.
    • Clear the global field that stores the picker result.
  • Select Item, which sets the picker result in a global
    • Depending on your needs, you can return one primary key, a list of keys, a JSON object, or an array of JSON objects. Most often, it’s a simple primary key of the selected record.

Step 2: Create the Calling “Button” Script

This script has two jobs: install the OnTimer handler and call the script that reveals the picker card.

Step 3: Write the handler script

This script will run as soon as the picker window card closes. It stops the OnTimer and then processes the picker result if any. It may set the picker result into a field and commit.

Install OnTimer

This is an interesting FileMaker script step, and it’s often used in pickers to trigger a QuickFind after the user pauses typing in a Search global field. However, here we are using it to define a callback. Think of it as “here’s what I want to happen after the picker closes.” It allows us to avoid looping pauses in our picker window which would complicate the picker’s QuickFind.

In a single-file solution, a card window will inherit any OnTimer running in its parent window. Therefore, you need to stop the OnTimer in the Reveal Picker script. In a solution that separates out Picker functionality into its own file, you do not need to do that, because card windows created from a separate file do not inherit the parent OnTimer. 

Taking it Up a Notch: Suggestions

The Picker

Add a global for search criteria that runs a QuickFind, add filters to constrain the find, pass into the Reveal Picker script any window dimensions, positions, default find criteria, global filter defaults.

The Selection

Allow for multiple selections, show items are selected with a button bar icon, show selected items in a popup portal based on a virtual list (ideal for long lists where the user loses track of what’s selected). Allow the user to create a new item if none are found.

The Handler

Rather than simply setting the target field directly, perhaps pass the picker result to an API that creates or edits records and includes any required validations. For example, you cannot change a customer on a posted invoice. Yes, you’d probably hide or show a disabled “Select Customer” button, but the edit Invoice API would also trap for the invoice status before it would allow the customer ID to be edited.

Conclusion

Modular pickers in FileMaker are incredibly useful – they allow you to create a picker window once and use it from any context in your FileMaker solution. I hope that this tutorial outlining the technique we use here at Proof+Geist was helpful! For questions, comments, or more information, feel free to drop us a line at info@proofgeist.com.

Claris Joins AutoEnter Live as Premier Sponsor

Proof+Geist and Soliant Consulting are excited to announce that Claris will be joining us as a Premier Sponsor of AutoEnter Live!

Attendees will see some familiar faces from Claris during the two-day virtual event on July 19 and July 20, including the keynote and several under-the-hood sessions. Attendees can also connect with Claris directly at their virtual booth in AutoEnter Live’s vendor showcase.

We’re excited to welcome Claris to our list of exceptional sponsors and look forward to the insights they will bring to our sessions.

If you haven’t signed up for AutoEnter Live yet, register for this free event today!

Proof+Geist Web Authentication for Claris FileMaker

Managing authentication for FileMaker-backed web apps

One of the wonderful things about Claris FileMaker is its ability to power web apps. However, doing so brings up questions about authentication. For instance, how do you allow a user to securely log into a web app? Once they’ve logged in, how can information about the user be easily collected, displayed, and changed according to the user’s role and permission set in that web app?

For Next.js there is a great library to handle secure authentication: NextAuth. Because NextAuth is open-source and extensible, we built a FileMaker database adapter—Next-Auth FileMaker Adapter—that can connect directly to your existing solution and access various attributes that you are already storing about your users. In the tutorial below, you will learn how to configure a Next.js project with NextAuth and FileMaker.

To best follow along, you should be familiar with npm or yarn, the basics of Next.js, and how to enable the FileMaker Data API on FileMaker Server. Prefer to watch me do it? Feel free to follow along with this video!

Project Setup

For this tutorial, start with the example provided by NextAuth: https://github.com/nextauthjs/next-auth-example

NOTE: This example repo uses TypeScript, but there are no TypeScript-specific features required for this tutorial. It should look and function very similar to a standard JavaScript project.

1. Clone the repository to your computer.

git clone https://github.com/nextauthjs/next-auth-example.git
cd next-auth-example
npm install

2. Configure your local environment.

cp .env.local.example .env.local

Start by editing this file with some API keys to connect to whichever login provider you’ll want to use. You can learn more about all the available login providers and how to configure each one in the NextAuth documentation. If you go the Email provider route—a great option for password-less login links—you’ll also need to install the nodemailer package to your project npm install nodemailer. While you’re in the file, add credentials for connecting to your FileMaker server—you’ll use them later. If you’re using my sample file, add the credentials below to the .env.local file. This account has the fmrest privilege set enabled, and the file should be hosted on a server with the FileMaker Data API enabled.

FM_USERNAME=fmrest
FM_PASSWORD=fmrest
FM_DATABASE=next_auth_demo.fmp12
FM_SERVER=https://myfmserver.com

Remember to change the FM_SERVER value to your own FileMaker server, where this file is hosted!

If you have Otto installed on your FileMaker server, you can also use the Data API proxy feature instead of username/password.

3. Install the FileMaker Adapter.

Run the following command to add Next-Auth FileMaker Adapter to your project.

npm install next-auth-adapter-filemaker

4. Run the website locally.

This step ensures that you’ve got the initial setup working properly. If this step fails, go back and double-check all the configuration settings.

npm run dev

NextAuth Setup

With this project in your favorite code editor (I like VSCode), navigate to /pages/api/auth/[…nextauth].ts. Within the providers array, add or remove the login providers that you want to expose to your app, depending on which ones you set up in the previous step. Add the following code to the top of the [...nextauth].ts file (before the export statement):

import { FilemakerAdapter } from "next-auth-adapter-filemaker";
const fmAdapter = FilemakerAdapter({
  auth: {
		username: process.env.FM_USERNAME,
		password: process.env.FM_PASSWORD
	},
  // or, if you have Otto on your FM Server
  // auth: { apiKey: process.env.OTTO_API_KEY },
  db: "FM_DATABASE",
  server: "https://myfmserver.com",
});

Then, add an adapter key to the NextAuth export that references the adapter we just created:

export default NextAuth({
    ...
    adapter: fmAdapter.Adapter,
	providers: [...]
    ...
});

And that’s it! Run the dev server (npm run dev) and check out the example in your browser. When you log in, you’ll see your user account created in your FileMaker file.

Usage

One of the major benefits of this setup is that you can now easily access other custom attributes about your users as defined in your FileMaker file. Now that NextAuth can access your user table, you can inject that information into the session object that is returned. Within your NextAuth configuration object, add the callback function for session and inject the user object into session.user, then return the session object like so:

export default NextAuth({
    ...
    callbacks: {
      session({ session, user }) {
        session.user = user
        return session
      }
    },
    ...
});

By default, the user object that’s returned from the session is very bare-bones, but with this technique, the entire use object returned from your FileMaker database will be present in the front-end of your web app. Now, go to the nextauth_user layout in your FileMaker file, and change up the fields that you see there. You can remove any of the optional fields that you don’t need or add your own! After making those changes you can go back to the web app and re-fetch your session on the API example page to see all of those fields come through.

To see all of this in action, check out my video tutorial.

Optimizations

If you’d like to implement this in production, there are a couple more things to consider. The default configuration will make at least 1 Data API call to your FileMaker server each time that a new page is loaded, sometimes even more frequently. To counteract this, you have 2 options which I can describe briefly.

Option 1: JSON Web Token

If you change your session strategy to JWT in the NextAuth config, it will only use the adapter for login, but not sessions. To remain logged in, the user will store this special token in their browser. The primary downside to this approach is that you cannot force a user to log out by deleting their session on your server, but it is the simplest way to configure a production-ready app.

Option 2: Redis Cache

This package supports caching sessions in a Redis database so you can still get the benefit of database sessions without the load on your FileMaker server. At this time, we have tested support with the Upstash Redis host, as they have great serverless support and work well with Next.js

The primary downside to this option is that you’re now dealing with a cache, and that requires a bit more thought about how you might want to update user data since the web app will no longer hit your FileMaker database directly to check for the latest changes. The cache is automatically updated when a user logs in, but if you want to update any part of their user object while they are logged in, you may need to have FileMaker update the Redis cache directly.

Proof+Geist: Supporting Your FileMaker Ecosystem

At Proof+Geist, we know that the Claris platform is a key puzzle piece to 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. For questions, comments, or more information, drop us a line at info@proofgeist.com.

The Context Podcast by Proof+Geist

The Context Podcast: Protecting Your Data Hosted with FileMaker Server

  • Martha Zink, The Context Podcast Host & Proof+Geist Director of Marketing
  • Angelo Luchi, Proof+Geist Director of Infrastructure
  • Todd Geist, Proof+Geist Co-Founder/CTO

From the outside, hosting with FileMaker Server can seem simple and straightforward. But behind the scenes, there’s a whole lot more going on! Whether you’re hosting your FileMaker solution on-premise or in the cloud, on your own or through a hosting provider, it’s important to keep a few things in mind to protect your data and your business from risks. Ransomware or malware attacks, accidental or intentional internal threats, file corruption, and various data center, network, or internet issues can jeopardize not only your mission-critical data, but potentially your business as a whole. Join Martha, Angelo, and Todd in this episode as they share their experiences and recommendations around backups, monitoring, documentation, and access/user management that can help safeguard against costly risks to your data and your business.

This podcast episode is also available on YouTube: https://youtu.be/BBgV7OG27T0

General Links:

S3-compatible immutable offsite backup providers/services:

Network/infrastructure monitoring tools/platforms:

Deployment platforms:

Documentation tools:

The Context Podcast by Proof+Geist

The Context Podcast: The Evolving Claris Platform

  • Peter Nelson, Claris Vice President of Engineering
  • Andrew LeCates, Claris Director of Platform Evangelism
  • Martha Zink, The Context Podcast Host & Proof+Geist Director of Marketing
  • Ernest Koe, Proof+Geist Co-Founder/CEO
  • Todd Geist, Proof+Geist Co-Founder/CTO

On April 26, 2022, Claris hosted a webinar on the future of their technology and platform. In this episode of The Context Podcast, Martha, Ernest, and Todd are joined by special guests Peter Nelson and Andrew LeCates from Claris. They focused on their upcoming offering, Claris Studio, their shift toward unified licensing, the Problem Solvers Circle Program, and the focus that Claris has on the growing and expanding platform.

A huge thanks to Claris for spending time with Proof+Geist to talk about the future of the platform. And make sure you listen until the end — Todd may have talked about an upcoming event planned for this summer!

Claris Updates Webinar – April 26, 2022: https://www.youtube.com/watch?v=7qMZFzrGQI4
The Context Podcast on the Modern FileMaker Revolution: https://www.thecontextpodcast.com/78
Problem Solvers Circle: https://content.claris.com/problem-solvers-circle/developer/partner-podcast-Proof-Geist
PauseOnError: https://www.pauseonerror.com
AutoEnter Live: https://www.autoenter.live

This podcast episode is also available on YouTube: https://youtu.be/yRL47nNLH6Y

The Context Podcast by Proof+Geist

The Context Podcast: Multi-File Solutions

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

In this episode, Martha, Todd, and John explore multi-file solutions from a broader perspective. Deciding on a single or multi-file FileMaker solution is not a good proxy for how complex the system is – a complex system can comprise one file, just as a simple system can comprise multiple files. Both Todd and John discuss optimizing systems and workflows using multi-file solutions. They suggest that breaking free from the ‘everything-in-one-file’ mindset allows for an iterative approach to development. With that, a Claris FileMaker developer can measurably improve and rebuild systems with new models over time.

Join Martha, Todd, and John in this episode as they re-envision best practices and delve into how multi-file solutions and the FileMaker platform can help us build value in new and better ways.

This podcast is also available on YouTube: https://youtu.be/RQQcA5T8R-k

Claris announces exciting changes to its platform

Focusing on Problem Solvers

In today’s Claris webinar, CEO Brad Freitag started by saying that “Problem solvers are our ecosystem,” giving a shout out to the all-in Claris community of developers and consulting businesses. He and his team detailed a new licensing program, shared additions to the platform, and discussed the future. Here are three notable takeaways:

Claris Studio: The next piece of the puzzle

First, Claris is releasing a new product. Peter Nelson, VP of Engineering, referred to his webinar from 8 months ago, where he talked about “New Stuff.” Today, they announced its official name: Claris Studio, available this fall. What we know as Connect today will be folded into Studio. Claris Studio promises to be a modern web experience designed to work with the current Claris products. In this first release, Studio will feature User Views, dashboards, and centralized log-ins. 

Hubs are a collection of views grouped to complete a workflow. You can think of a hub as a curated way to fill out a sales order or navigate a user through a process to submit a work order.

Dashboards will help show data from both Pro and Studio, meaning that the platform is connected and not just disconnected pieces under a single umbrella. In other words, Claris is focused on a unified, cohesive platform.

Anonymous views will allow companies to collect data from a larger, non-licensed audience. This is one of the biggest differentiators for Claris Studio and something more challenging to do in FileMaker in its current state. Hopefully, this addition better guides users through workflows like collecting repair orders from tenants or service requests from customers.

Centralized identity management is a big win coming out of this announcement. Having a single-stop location for user management will be a time saver and modernizes development.

The Claris team mentioned their focus on delivering, and Day 1 of Claris Studio will be cloud-only. Their focus is on getting out to data centers across the globe. However, on-premise deployment is not lost on them and is likely part of their more extensive roadmap.

A developer preview of Claris Studio is coming soon!

Claris: one platform, one license.

Second, Claris is continuing to evolve and lean into its brand. Claris Studio will join other existing products under a unified Claris banner. Existing products will be renamed as Claris Pro, Claris Go, and Claris Server. Along with this platform vision, Claris will be moving from licensing their ‘binaries’ to licensing for usage — a subscription licensing model based on deployments. In short, Claris wants to make it free to use and create, and charge for what you share with the world.

Along with this new platform strategy and vision, Claris announced a new program for customers and developers. They call it the Claris Problem Solvers Circle. This program involves a two-year agreement to allow time to try, deploy, and benefit from the entire platform. After two years, customer pricing will increase, but the goal is that the technology will prove its value within businesses.

This program will be available for 500 existing customers at a 30% pricing increase from their current licensing. If you’re interested and want to learn more, check out the information on Claris’ website. Reach out to us at Proof+Geist to discuss what this might look like for you, both short-term and long-term.

Andrew LeCates, Director of Platform Evangelism, says the program is an experiment that they are excited to try, and quite frankly, so are we. This program is a great way to prove how strong, creative, and flexible this technology really is. We are excited to help define the value proposition of the Claris platform.

What about FileMaker Pro?

Third, Claris continues to invest heavily in FileMaker Pro (Claris Pro). FileMaker 19.5 is coming soon, and Peter Nelson shared his excitement about its release. It’ll have significant features for Pro and Server. We will post more on these new features once they’re released.

FileMaker 19.6 is also in the works with exciting features, like scripted transactions (Todd Geist has an extraordinary level of joy for this) and user group management with OAuth.

Pro soon to include a freemium version

Claris is focusing on new adopters, offering a freemium version of Claris Pro. This also includes access to Claris Studio. A paid license will be required to deploy a solution to multiple users, but the free version opens the door to try out the software. 

We will share as we know more about getting your hands on the freemium version.

What’s Proof+Geist’s take on it?

We’re all in.

This webinar made it clear that Claris is focusing on delivering a modern platform that brings existing technology in line with the future of the platform. We recently waxed philosophical on The Context Podcast about just this topic: what makes for Modern FileMaker and how it fits into modern businesses. 

Is Fortune 500 the goal for the Claris platform? Maybe adjacently. Strategically, the Claris platform is best suited for small to medium-sized companies, along with government and school entities. But are they in Fortune 500 companies? Absolutely. This platform is alive and growing and finds itself in businesses across the globe.

“Build, test, and iterate” — a mantra at the core of our practice at Proof+Geist — is a mission for Claris, so they will share more as they make progress on these changes. And we’re here for it. We hope you’ll join us for the ride!


You can find the announcement in the Claris community here.

The Context Podcast by Proof+Geist

The Context Podcast: The Modern FileMaker Revolution

The podcast is back!

The Claris platform has both depth and breadth, and we want to continue to share our excitement for the platform. With that in mind, we are excited to bring back The Context Podcast with a new host and new content. Martha Zink will host the podcast, continuing the tradition of interviewing the Claris community on various topics. Have some ideas or want to be on the podcast? Drop us a line and let us know! We want it all, including technical deep dives, customer stories, conceptual chats, and other topics that benefit the people in our community (and help spread the word on how awesome this community is).

The Modern FileMaker Revolution

In this episode, Martha, Ernest, and Todd discuss how Proof+Geist is redefining FileMaker in the context of today’s business needs, modern development practices, and a rapidly changing technical landscape.

What is the ‘modern FileMaker revolution’? How can vast networks of apps, tools, persistence layers, databases, experiences, workflows, and more be leveraged to create value using Claris FileMaker, the platform we love?

Highlighting the growing shift toward a more decoupled, lightweight approach to development, Ernest and Todd share how a new set of ideas, skills, and technologies directly informs how we build value using FileMaker today.

Introducing Otto 3

Today, we are proud and excited to release Otto 3 into the world and share it with the Claris FileMaker Community.

You can read all about it on Otto’s new home: www.ottofms.com. Also, you can read Todd’s introduction to Otto 3 here.

 

Towards A Better JavaScript Development Environment

Writing JavaScript in FileMaker is hard. Sure, the path is easy to see and clear to follow, but the actual writing of the code is hard. I have tried to find a way to write JS code that makes it fairly easy. And by “easy,” I mean “make it so that FileMaker developers don’t have to learn a hundred skills to get JS to work in FM – other than the JS itself.” I’m striving for a better JavaScript Development Environment.

An Okay JS Development Environment

My first attempt was writing or placing code in FileMaker fields. That worked…and it didn’t. There’s a lot of advantages to this method, but there are as many disadvantages (a fact I was reminded of in session feedback comments and emails about the demos I’ve released). We’re just writing in a text field – there’s no automatic formatting of the code, and there’s not any helpful type-ahead or auto complete features. There’s a lot wrong with this. Even my attempts to use a code editor JavaScript library to render the code from a text field proved only marginally better.

I continued doing this method many times (here, here, and here) always knowing that this isn’t ideal.

But recently, Kevin Frank approached me about a JS project. Working with him on this JSON-parsing library, I took it as an opportunity to finally come up with a better way of developing JavaScript in FileMaker. Kevin has written about it in his post FileMaker 19 + JSONata. Check out the details of the origin and use. We also recorded a podcast episode about it – check that out.

Towards a Better JS Development Environment

After all of our work with JavaScript in FileMaker, we’ve come to our current definition of a better JS development environment. To be effective with our coding time, here’s what a ‘better development method’ must include:

  1. Using a proper HTML/JS code editor.
  2. Immediate rendering or performing of the code in the FileMaker web viewer object.
  3. Using data from the FileMaker app.
  4. Using the result of the JavaScript processing in FileMaker.

Let’s tackle each one of these and use my work with Kevin as illustration.

A Proper Editor

Writing JavaScript is a piece of cake when one has an integrated development environment (IDE) that catches all the mistakes and properly formats the code immediately. And my previous methods (e.g., typing into a text field) failed on both those fronts. Sure, I could use a JS code-editing library (I’ve done that). It works decently, but there’s always a catch or two that frustrated users (including me).

So this trend toward the better includes using a proper IDE to write the JS outside of a FileMaker field.

Working with a proper editor brings up a whole host of challenges; one has to actually pick a platform to use and then learn to use that platform. That takes time. I use VSCode for all my JS work now (and from that app will come screenshots). It’s complex and I don’t know all of it. But what I do know is that it makes writing JS so much easier. 

With this project, I set up a small web-based file structure inside a project folder. There are two simple files in which I do all my writing: index.html and index.js. That’s manageable. I can write my simple JavaScript code here and (eventually) get it into FileMaker.

index.html
index.html
index.js
index.js

I can’t get into all that VSCode does here in this post, but if you’re going to explore writing JavaScript, VSCode is a great choice to use. I’ll share more about how to use VSCode in the near future.

See the Fruits of My Coding

The FileMaker developer is used to seeing what she is developing appear or work before her eyes – if not in scripts, at least in what’s on the layout. So too must she be able to see the code work (or not) in the web viewer right away. Additionally, since we’re using the web viewer inside FIleMaker, it’s essential to get the JS code inside FileMaker as soon as possible.

Todd figured out a way to see the JavaScript work immediately in a FileMaker file’s web viewer object. We use it in our projects here at Proof+Geist, we used the technique in the add-ons, and I’m using it for this demonstration file.

Essentially, when I am developing the JavaScript code, I can run a development server that serves the code I’m writing. This development server is picked up by the web viewer and shows the results of my JavaScript coding. Whether the code works or doesn’t, I see how my code is turning out immediately.

By starting up a development server in VSCode, whatever I write in the code will be picked up by the web viewer.
The Development Server in Action

The mechanics behind this are a bit complex. It involves Node.js and some JavaScript libraries to run a development server. Hopefully, very soon, we will have a template project you can use that has all this already set up.  So be on the lookout for that.

Using the web viewer inside of FileMaker to render the code is one part of a better JavaScript development environment.

Using FileMaker Data

A hallmark of a better JavaScript development environment is to use real data inside FileMaker. Since we’re working inside a FileMaker app, it follows that we could use the data already in there. I don’t want to develop with fake data that may not have the same performance considerations as the real data. If my goal is to show 1000 records in a data table, then I want to make sure the whole process works with 1000 real records. 

In our development, we use data from FileMaker, and we do this using the Perform JavaScript in a Web Viewer step.

For this JSONata example, I’m using this script step to load data into the web viewer. The web viewer already contains the JS code, and the work will happen when it receives the JSON data and the query. Here’s my code.

This pattern is pretty standard:

  1. The web viewer on the layout is named. I write the name into a variable (line 1).
  2. I give the name to the global function inside the JavaScript in a variable (line 2).
  3. I pick up the query data in a variable (line 3).
  4. I pick up the JSON data in a variable (line 4).
  5. I then call the script step with the above pieces (line 8).

Notice that I’m pausing in line 7. In all of our work with the web viewer, we’ve found this to be essential. Since I’m using a new window (line 5) where the web viewer is located, I need to wait a small amount of time for the web viewer to load. And this has to happen so that the JS function “simpleQuery” is loaded and ready. Between Kevin and myself, we’ve tested it to be around ½ to 2 seconds. 

Getting the Data into the Web Viewer

The JavaScript function itself is pretty simple, but it has one part that is vital: it has to parse the incoming JSON data into something JavaScript can read. Line 4 here shows that I’m taking the JSON that comes in and parsing it.

The simple function called from FileMaker

We have template scripts written to help us remember the pattern. I use those all the time. 

Returning Results

Many times the point of a JavaScript library is to return results to FileMaker. This is the case in the work Kevin Frank and I did together. He found this cool library called JSONata that parsed JSON using a query language (one designed for this library). The idea is to pass the web viewer some JSON and a query and then get the result of the query back. So we have to work with FileMaker’s ability to get the result out.

In this example, we’re getting the results back in two ways: 1) we’re setting the data into a field, and 2) we’re getting the data back to use inside the script itself.

You can examine each script to see what they’re doing. They’re pretty simple:

Get Result Into the Field

This script simply shows what happens in the normal use case: One script calls the JavaScript. The JavaScript does the work and calls a FileMaker script – in this case, “Get Result” to return the result back to FileMaker. The original calling script finishes its run before the “Get Result” function runs. And that’s a fine progress of steps. The callback script gets the result and places the result into a field. End scene.

Get Result Into the Script

This script is built differently and uses the newer FileMaker.PerformScriptWithOption() function (documented here). In this case, I want to use the result in the original script. So I call this the function simpleQueryInScript(). The function processes the JSon using the query and calls back to FileMaker a script called “Get Result In Script”. This script interrupts the original script, gets the result from the JS and, in this case, sends it back to the original script.

I know this is a lot to take in, so study the scripting and examine the JS code provided here and see how it all works together.

This is a better environment for JavaScript in FileMaker development. It’s pretty close to all we can do to make it easy enough to write JS and see it render out in the web viewer while developing.

One more thing

We’ve been talking here about writing JavaScript. But there’s one more step: actually using the code you’ve written in an actual production. Don’t worry. We’ve got that covered. After I’ve finished with the code, I can run a small command and the JavaScript is put into the correct field inside of the app for the web viewer to pick up.

Uploading new code to FileMaker

Onward

Finding a better JavaScript development environment for FileMaker has been something we’ve explored for many years. We’re interested in making using JavaScript even more accessible by providing easy tools to get the job done. This FileMaker 19 + JSONATA exercise gave me the opportunity to flesh out what is really necessary to easily develop the code. Thank you to Kevin Frank of FileMaker Hacks for his proposal, his collaboration, and his support.

We’re not done; in future posts, we can point out how we work with VSCode and other tools to make this work.

The demo file is found here and at Kevin’s site.