I manage a task app that is used by many people in our company. However, for some time now, I’ve been frequently updating the app, and users have been experiencing sync errors. When they can’t sync the app, they still try to update tasks, which causes other users to miss these updates. At the end of the day, they come to me, and I have to suggest they to discard changes, and sync the app.
Is there a solution for this? Ideally, when users encounter a sync error, I’d like them to see a notification preventing them from making further changes until the error is resolved. We’ve even made an announcement in the company asking everyone to resolve sync errors before making any updates, but it still happens.
Normally, when developing an application, developers have their own branches. They pull the latest version of the application to their local environment, make updates, and after ensuring everything works correctly, they push the changes. What is the closest development approach to this in AppSheet?
There is a process to using these options, one need to have a copy app made to upgrade from…
Here is Appster response from the link I sent..
Appster
You said:
Normally, when developing an application, developers have their own branches. They pull the latest version of the application to their local environment, make updates, and after ensuring everything works correctly, they push the changes. What is the closest development approach to this in AppSheet?
In AppSheet, the closest approach to a development workflow similar to branching, as seen in traditional software development, is the use of app versions combined with careful deployment practices. Here’s how it aligns:
App Versions and Backups:
AppSheet allows you to maintain version history through backups. You can take a snapshot of your app before making changes, which acts as a “branch.”
Developers can save multiple versions of the app under different names, treating these as isolated branches for testing purposes.
Testing in Isolated Environments:
Utilize test users or testing environments by leveraging user roles or custom filters. This allows you to simulate changes for specific users without affecting others.
Deployment Process:
AppSheet uses a deployment check process where you can make changes in the editor, test them in a “test mode,” and only push them live when you’re confident. You can also restrict updates to specific groups during testing.
I removed the answer from the accepted solutions because if there are another tricks about sync issues, I’d like to hear about them from another users too. Thanks again
Thanks for the kind words! I’m glad that the lite version of Appster is making a difference! (^_^)
The answer provided by Appster-lite (the free version inside ChatGPT) was kinda weak; it was in the right spirit, headed in the right direction, but not quite what I would want for the answer.
If we were playing darts, it hit outside the middle ring.
I was curious to see what the version of Appster in the Answer Portal would say about this, as there are more detailed resources in there for it to pull from when answering. Here is what it had to say:
Question
Normally, when developing an application, developers have their own branches. They pull the latest version of the application to their local environment, make updates, and after ensuring everything works correctly, they push the changes. What is the closest development approach to this in AppSheet?
Answer
In AppSheet, while there isn’t a direct equivalent to traditional version control systems like Git, you can employ a similar development approach through the use of development copies and planned updates.
Closest Development Approach in AppSheet:
1. Create a Development Copy: - Make a duplicate of your live app specifically for development purposes. This allows you to experiment, develop, and test new features without disrupting the live app that users interact with. This is essential for uninterrupted user experience and safe testing. You can refer to the detailed explanation in the “Development Copy” resource.
2. Parallel Data Sources: - Link your development app to the same data sources as your live app. This ensures that any new features or changes you test are compatible with the actual data structures your live app uses.
3. Testing Environment: - Utilize the development copy as a sandbox for testing new features, tracking bugs, and making updates. Resolve any issues in this isolated environment to ensure stability before pushing changes to the live version.
4. Streamlined Update Process: - Once your updates in the development app are finalized and thoroughly tested, use AppSheet’s “App Update” feature to seamlessly integrate these changes into the live app. This minimizes service interruptions.
5. Regular Updates and Communication: - Schedule updates at convenient times for users and communicate any potential downtime or changes in advance to ensure transparency. Referencing resources like “How to manage Major Version Updates” can provide additional insights into this process.
This approach mimics a branching strategy where the development copy acts as a separate branch, offering a controlled and planned method for updating your app. For a more detailed walkthrough, you can explore the resources provided in the ‘Resources & Tools’ section of the Answer Portal.
That’s more like it! Inner ring, if not a bullseye.
The only thing it didn’t touch on, was the “Stable Version” feature for enterprise licenses; this is a much easier way to manage this sort of thing, but it requires the expensive license that most wouldn’t have. (So i guess kinda makes sense.)
Happy Apping!
PS: For anyone interested, here is the answer provided by vanilla chatGPT (I’ve got an automatic comparison thing built into the Answer Portal)
Vanilla ChatGPT Answer
In AppSheet, the development process is a bit different from traditional software development with version control systems like Git. However, you can simulate a similar workflow using the following approach:
App Copying for Branching: Since AppSheet does not have a built-in branching system, you can create a copy of your app to simulate a personal development branch. This allows you to work on changes independently without affecting the main app used by users.
Go to the AppSheet editor, click on the app you want to work on.
Click on the “Manage” tab.
Use the “Copy” option to create a duplicate of your app. Name it appropriately to indicate it is a development version (e.g., “MyApp - Dev”).
Development and Testing: In this copied version, make the necessary changes and additions. Test thoroughly to ensure everything is working as expected. AppSheet provides a “Preview” mode to test the app’s functionality.
Change Management and Documentation: Keep a record of changes you make and why, which can help when merging changes back into the main app. This documentation could be simple notes or a shared document outlining the modifications.
Syncing Changes Back: Once you are satisfied with the changes:
Note down all the changes you have made.
Open the main app in the AppSheet editor.
Manually implement the changes you made in the development copy into the main app.
Test the main app thoroughly to ensure that the changes did not break any existing functionality.
Publish Updates: Once the main app is updated and tested, you can make these changes live by deploying the updated app version to your users.
Version Control: AppSheet provides a version history feature. Each time you save changes in the AppSheet editor, it creates a new version. You can view and revert to previous versions if needed, which provides a basic form of version control.
While this process is somewhat manual compared to a traditional branching strategy, it allows you to isolate and test changes before deploying them to your main application used by end-users.
So number 4 there is crap, and a perfect example why you should at least use Appster-lite in ChatGPT over vanilla chatGPT.
