Marmelab Blog

Depends on what "look great" means.

And I've seen Delphi apps; I recently worked on one. In my experience they don't look great. Maybe you've done a lot of work to theme the controls; if so, wonderful. But what I'm familiar with just brought up Windows dialogs, and ... well, that's functional but I wouldn't say it looks great.

But here are a few examples of ways you could create 150 fields in a day on a web app and have them look great:

Arrays of control types: https://formik.org/docs/examples/field-arrays for simplicity of creating the controls plus something like https://chakra-ui.com/docs/components/input to make them pretty.

Spreadsheet look (with spreadsheet functionality!) in one control: https://www.npmjs.com/package/react-spreadsheet

Want to build the form by hand and customize it? https://www.form.io/

Form should follow a database schema and automatically display database records? https://marmelab.com/react-admin/ (I used this approach to bring up an admin panel for more than 150 fields, though spread over a couple dozen pages, because of course that looks better than trying to bring up 150 fields on one page.)

The standard way to create a large form (or any data table on a page) today is to iterate over the fields you want and add them to a page. There are frameworks like Chakra that can help you make everything look attractive--and you can theme the result in whatever color scheme or styles you like.

I really don't want to have to touch Delphi ever again;…

So what's the answer then? Before the internet almost all journalism was "paywalled." You either bought a subscription or an individual copy of what the organization has to offer.

Ad-supported journalism is a joke in a society that abuses advertising so thoroughly. Using an ad blocker is more than a convenience, it's a security measure. Arguably it's also better for the environment [1] [2].

One article [3] argues for "non-reformist reforms," which try to mitigate the commercial pressures on journalism. However the article's solution seems to be to switch to public media models and/or government funding. As the article puts it:

"Therefore, any initiative that erodes the commercial and anti-democratic design of existing media institutions—by transitioning them into nonprofit outlets, facilitating public media partnerships, unionizing newsrooms, and establishing media cooperatives—can help radicalize news workers and engage communities while laying the groundwork for more transformative change in the future."

I honestly don't know how well that'll work, but it's also basically what the article suggests to pay for journalism for a year:

"They can enlist foundations or other sponsors to underwrite their work. They can turn to readers who are willing to subscribe, renew their subscriptions, or make added donations to subsidize important coverage during a crucial election."

Stengel's article also says, "A large percentage of these Americans see media as being biased. Well,…

PostgREST: https://github.com/PostgREST/postgrest and http://postgrest.org/en/v6.0/

Sample PostgREST apps: http://postgrest.org/en/v6.0/ecosystem.html

React-admin: https://marmelab.com/react-admin/ and https://github.com/marmelab/react-admin

React.js: https://reactjs.org/

Combinations:

- https://github.com/tsingson/ra-postgrest-client
- https://github.com/raphiniert-com/ra-data-postgrest
- https://reactjsexample.com/a-react-web-application-to-query-and-share-any-postgresql-database/
- https://github.com/tomberek/aor-postgrest-client
- https://github.com/priyank-purohit/PostGUI
- https://awesomeopensource.com/project/priyank-purohit/PostGUI?categoryPage=9
- https://www.reddit.com/r/learnpython/comments/bzrr1c/how_to_create_dynamic_dashboard_on_top_of/

More links:

- https://github.com/topics/postgrest
- https://duckduckgo.com/?q=%22postgrest%22+%22react%22&t=ffab&ia=software
- https://duckduckgo.com/?q=%22postgrest%22+%22react-admin%22&t=ffab&ia=software
- https://react-admin.com/docs/en/ecosystem.html

I'm sure you can find more!

Yeah, there's not one solution. There are many. Many are open source. PostgREST is amazing. The rest is up to you, but there's tons of tools out there.

Thanks!

> Can you elaborate how this compares to some open source solutions, for example react-admin?

I would say that ...

React-Admin is a programming framework that a skilled React programmer can use to produce an application with great features that are limited only by the skills, drive, and dev time of the programmer. It looks like a very impressive and powerful programming framework to me.

DataSpeeder, on the other hand, is not a programming framework. It is a finished application that is ready to run immediately, can be deployed by a non-programmer, and has intentionally simple features that were designed to solve a specific problem ... Providing an instant end-user web GUI for MySQL.

To see the differences in how the tools are used, you can take a look at this (very nice!) React-Admin tutorial ...

https://marmelab.com/react-admin/Tutorial.html

And then take a look at the DataSpeeder "Create an Application" video tutorials ...

https://www.dataspeeder.com/support

I hope that helps!

Your technical stack should not be frozen. During years, it will probably evolve, either to use some promising features of new technologies, or to still be able to hire. For instance, hiring some Cobol developers is really hard (and then expensive) these days.

More important than technologies is testing. If your whole app is well tested (with both unit and E2E tests), you won't be reluctant to upgrade some part of your system because it doesn't answer your needs. Moreover, it would bring a lot of reliability and would be self-documented. That's the biggest point IMO.

For nowadays mood, we are really glad using React, Node, GraphQL and PostGreSQL for all our apps.

Note: we wrote a blog post about one of our long running customer story, which may interest you: https://marmelab.com/blog/2018/03/28/1859.html

I've been using the free, open-source React Admin https://marmelab.com/react-admin/ framework for this use case, and I really like how it works and how little code I need to write. I used it to quickly build an internal CMS, and it handles relational stuff well. For instance, if I have pieces of content, each of which can have multiple tags, it handles all the tag lookups using typical REST API calls. Also integrates well with our existing auth system (AWS Cognito).

There are some other low-code tools that have similar premises and offer things like ETL tools. We evaluated one called Retool https://retool.com and it seemed pretty cool, but because it's a per-user pricing model, the costs can be pretty substantial when you have a lot of people using the tool.