aeberhart

Interesting analysis! Do you also have insights into which JSON Schema constructs are used most often in that dataset?

We wrote an article on this: "JQ vs. JSONata: Language and Tooling Compared". https://dashjoin.medium.com/jq-vs-jsonata-language-and-tooli...

In a way it's a very basic question, but I really had to search a while...

* multiple documents in a single stream * any node type can be used as a mapping key * pointers via &anchor and *alias

Disclaimer: I'm the creator of Dashjoin (https://github.com/dashjoin/platform)

Implementing the features you mentioned:

Once you connect your SQL / NoSQL database, you're immediately able to view, query, search, and edit the data. Every record implicitly has a "homepage". On this page, you can add active elements to automate tasks via REST services. We do this using JSONata (jsonata.org) which is a super expressive and concise transformation and query language. You can find some samples in our demo application (https://github.com/dashjoin/dashjoin-demo).

The core philosophy is to get immediate results and refine from there, depending on your cost / benefit calculation.

SDLC:

I think this is a very important point! Even though you're working with low code, it is still a development project with testing, staging, and production, issues, tickets, etc. We allow you to manage the software development lifecycle using GIT. You can view a sample project here: https://github.com/dashjoin/dashjoin-demo. It contains of the DB connectivity information, custom page layouts, queries, and REST function adapters. A developer commits changes to the repository. The production can be configured to pull a certain QAed version.

Great post and really worth reading. Quite shocking insights, for example on the e-waste of BTC: "an average of one whole MacBook Air of e-waste per "economically meaningful" transaction".

> What do you mean by automate tests? What exactly do you want to test?

One of our customers in the public sector builds a Low Code app that performs automated plausibility checks on forms submitted by clients. These checks can be quite complex since they reflect legislation. In this case it is crucial that you can mock form input and validate the checks against expected results.

I agree that once a project gets a bit more complex, these points are very important.

In our low code platform (https://github.com/dashjoin/platform), you end up writing several JSONata (https://jsonata.org/) snippets for ETL, actions, and visualizations.

These can be tested using junit. All changes to the app can be managed and deployed via GitHub. You can check out our sample app:

GitHub: https://github.com/dashjoin/dashjoin-demo Live: https://demo.my.dashjoin.com/

I think so too. JSON Schema enables very useful tooling such as validation, Swagger-style UIs for interacting with services, or declarative web forms that people would have to build again and again.

There certainly are some similarities, but I think JSON-LD and and JSON Schema solve different problems. You might find this article helpful (I ended up writing this after being confused by the various standards in this space): https://dashjoin.medium.com/json-schema-schema-org-json-ld-w...

A question that can only be answered with "it depends..." :)

You might be able to simplify some of the queries using recursive SQL: https://en.wikipedia.org/wiki/Hierarchical_and_recursive_que...

Neo4J is a very popular DB (ranks #18 here https://db-engines.com/en/ranking) so should be mature.

Side by side would allow you to formulate queries depending on the use case, but of course this comes with quite some cost (keeping data in sync, having another system to take care of).

Neo4J allows you to store properties, so you certainly could model all your info (also the relational aspects) in it.

Hope this helps!

Thanks! No, $doc2data is not a standard function. JSONata allows you to define your own functions (https://docs.jsonata.org/embedding-extending#expressionregis...). JSONata is great for transformation and we added functions for loading data.

Dashjoin is an open source platform that allows you to easily extract, load, and transform (ETL) data into a database of your choice. We use JSONata, a powerful JSON query and mapping language, in conjunction with a graphical mapping editor for this task. The platform also allows you to visualize and query the resulting data in the database.

Would love to hear your feedback! Github: https://github.com/dashjoin/platform

We scan the DB schema and suggest possible joins. The platform also supports basic CRUD operations using forms powered by JSON Schema. Would love to hear your feedback! Github: https://github.com/dashjoin/platform

Here's the Wikipedia definition: A low-code development platform (LCDP) provides a development environment used to create application software through a graphical user interface instead of traditional hand-coded computer programming.

So a Low Code platform can help you in cases where there is no off the shelf solution available for your task.

Thanks for the link to the discussion on Github. I don't think it is a good idea to rely on inference (owl:sameAs) for something as basic as foaf:name vs. rdfs:label vs. schema:name, ...

I have not used JSON API yet but it is cool to see the "follow your nose" approach be applied to REST APIs.

With your first point, you are talking about versioning (switching to a new IRI while keeping the old one for compatibility)?

I agree that there probably is no value in using JSON-LD for an application that was built without LD in mind.

Regarding your last statement about APIs. JSON API (https://jsonapi.org/) looks interesting. Have you worked with that?

The problem is the support matrix which is crazy in this area. I think ServiceNow did pretty well without having too many adapters (of course now they have quite a few - https://docs.servicenow.com/bundle/orlando-it-operations-man...). So if the product is easy to use, reasonably priced, and has the ability to schedule data imports, why not?

Not the first of its kind but it is lightweight (<1000 loc), renders compact forms, and supports Draft 06