Custom development is a complex and expensive business, which is why we created BBWT – to try to reduce the cost of development through automation and thereby streamline the development process.
Real-Time Editor
Developing a custom web application is a complex process, which is normally broken down into several development stages. As the application moves from one development phase to the next, each phase will invariably require changes or fixes to improve the completed parts of the system, usually via feedback requests received by the development team.
Considering that a change request may involve multiple people – the Customer, Project Manager (PM), Tester and Developer – the process can be time-consuming and increase the cost of the project. It therefore makes sense to try to minimise the cost of development by automating this process as much as possible.
BBWT’s Real-Time Editor (RTE) feature provides a way for just one person to directly edit the source code mark-ups (HTML) in an application’s pages, so removing the need for feedback requests to go through many hands before being implemented. The RTE feature enables edits or new elements to be applied directly to test pages, which automatically updates the source code in real-time too.
The editor is activated by a pen icon in the top menu and remains active until the user closes it from the menu or logs off. Page’s reloading doesn’t cause the edits made to be lost or change the editor’s on/off state.
The highlighted pen button in the screenshot below demonstrates the edits counter. The counter indicator is a ratio of the number of edits made during the current editing session (“2” in the screenshot) to the number of total edits being applied to the GitLab repository’s code (“5” in the screenshot).
![RTE]()
The menu items available in the RTE are:
- Submit to PM: this sends edits made during the current editing session to GitLab as a commit, then the CI/CD job is immediately triggered, processes the edits and applies them to the repository’s code. After submitting, the editor remains active.
- Close Editor: this closes the editor without losing the edits made during the current editing session.
- Cancel New Changes: this cancels the edits made during the current editing session, stored locally in the browser. It’s possible to undo them with this menu item.
For cases where fixes are related to static page content, RTE has the potential for delivering huge savings in time.
For example, the UI part of the real-time editor provides these options:
- Adding a tooltip message to an element (input, label etc).
- Adding/changing a phrase of a container element (like <p>, <div> etc).
- Fixing labels. For example, title/sentence cases’ fixes.
- Fixing control’s attributes (like input’s placeholder etc).
- Fixing a URL of a link element (<a>).
Based on this approach of directly editing mark-ups within the running application, the RTE feature has the potential for even further improvement in development automation.
For example:
- Integration with localisation.
- Automatic validation/correction of page content by the RTE script (for example, the script can automatically correct title/sentence cases for all headers/labels/buttons).
- Adding comments to the mark-up with instructions for a developer (for example, the PM/customer adds a comment near the submit button of a form with a request to show a special ‘toast message’ on saving).
- Changing mark-up element’s styling.
- Adding custom elements to the mark-up (for example, the PM can add a button to a form and then the developer implements the button’s behaviour).
Why is this useful? Page content generally needs to be specified by the customer, because it is the customer’s system, and they have the domain knowledge. In previous systems, customers needed to write a long list of fixes to send to us to include in the next iteration. This was a time-consuming process. By automating this process, we save a lot of time and make it easier to ensure that we have correct content in place.
Database Explorer
At the heart of most modern systems is an SQL Database – which to the non-developer is effectively a collection of Excel tables, holding all the data the system works with. The structure of the database is known as the schema – this is the list of tables and fields, and the relationships between them.
Knowledge of the database schema used by a complex application can be very useful, particularly when a customer has technical staff who might be working directly with data exports or reports themselves. But documenting the DB schema is often a challenge – the structure evolves rapidly during development, and the tools that exist for DB documentation are complex.
To address this problem, Blueberry has built into BBWT a database schema exploration / documentation tool. This feature is obviously only accessible to administrators (and can be removed from the system if not required).
This tool allows Blueberry staff to add notes / comments to all tables and fields, and keep this documentation even as the fields and tables change over time. It also provides a simplified view of the DB structure – hiding unnecessary tables – which make it easier for customer technical staff to understand the system.
But why reinvent the wheel? By integrating this functionality into BBWT, it is always to hand, and immediately available. No need to install SQL tools, nothing to learn. In our view, this makes all the difference.
Data Anonymization
With GDPR, there is often a requirement to generate an anonymised version of a live system for testing purposes. Blueberry makes use of a tool called Anonimatron to assist with this – see anonimatron.
We are working to integrate this tool into BBWT. The database explorer module includes support for labelling fields with a “type” – e.g. email, DOB, Name. This type is used to specify the anonymization rules that should apply to the field – the system then generates an XML which Anonimatron can use to make an anonymised copy of the live system database. In future, we’ll have the option to do this as part of our build systems, so every time we release a new version to live, we can automatically copy an anonymised backup to the test system.
Data Dictionary
This feature allows the database schema to be marked-up with additional meta-data, such as types, typical field widths and validation rules. This meta-data information is then made available to the GUI code where it can be used to automatically deliver client-side validation.
For example, perhaps a system has a “Person” record with an “email” field. In the DB Browser, we set the type of this field to email, and in the GUI code we link the GUI control to the correct field. The GUI code then automatically applies Angular validation rules suitable for an email field (these rules are defined interactively within the DB Browser – there’s an admin page to set the rules for anything of type ‘email’).
This mechanism allows core developers to focus on the hard parts of the system – the effort of getting the validation rules right for each field can be left to testers and technical project managers – and customer staff.
Of course, the built-in logic can be overridden where specific application requirements need more specialised behaviour.