Jan Vlnas

Depends on what options and technologies you have available, and how do you deploy your website.

There are CMSs which update existing static pages through FTP: You provide access credentials, mark editable parts of your HTML in a markup, and then edit the content through the hosted CMS. I know two systems which work like that: Cushy CMS and Surreal CMS.

If the source of your site is versioned through Git (and hosted on GitHub), you have other options, like Netlify CMS, Spinal CMS, Siteleaf, Forestry, or CloudCannon. Some of these also need you to use static site generator (like 11ty, Jekyll, or Hugo).

If you have some server-side scripting support available (typically PHP) you can also consider some flat-file based, server-side systems, like Kirby CMS or Lektor, which are usually simpler to retrofit into an existing template than “traditional” CMSs (WordPress, Drupal).

Finally, you could also use a desktop-based static site generator which provides a user-friendly GUI, and then locally generates and uploads the website. For example Publii, YouDoCMS, Agit CMS.

From my point of view, both OpenRefine and Apache Hive serve completely different purposes. OpenRefine is intended for interactive cleaning of messy data locally. You could work with their libraries to use some of OpenRefine features as part of your data pipeline (there are pointers in FAQ), but OpenRefine in general is intended for a single-user local operation.

I can't recommend a particular alternative without better understanding of your use case. But if you are looking for an interactive tool to work with big data at scale, take a look at notebook environments like Jupyter, Databricks, or Deepnote. If you are building a data processing pipeline, consider also Apache Spark.

Edit: Fixed references from Hadoop to Hive, which is actually closer to Spark.

If you already use Elasticsearch, take a look at percolators or percolate queries:

…instead of storing documents and running queries against it, percolation requires to store queries and run documents against it. This is the reason why it is often referred as flipping around query and documents.

In fact, this post by Alexander Reelsen works with your exact use case, but you will find many more articles on the topic.

Out of these three frameworks, I'd recommend NestJS – it's by far the most popular and actively developed. However it's mostly inspired by Angular 2 so its take on MVC is a bit different from what you may be used to with Rails, with heavy reliance on decorators and dependency injection (and generally being more “ceremonial”). Nest is also intended to be used with TypeScript which I personally consider a plus. While you can use it with vanilla JavaScript the developer experience is more basic.

WebSocket is a low-level transport protocol which provides bidirectional communication channel between client and server. HTTP is only used for establishing the connection.

gRPC is a higher-level RPC framework which builds on top of HTTP/2. Bidirectional communication channel is provided by HTTP/2.

So the comparison here should be either between WebSocket and HTTP/2, or gRPC and some WebSocket framework, for example Socket.IO. WebSocket can be seen as obsolete technology compared to HTTP/2 for majority of use cases (exception being handling of binary data on JavaScript client). With emergence of HTTP/3 (aka QUIC) there's also a new web technology WebTransport.

Few years ago we were building a Next.js site with a few simple forms. This required handling forms validation and submission, but instead of picking some forms library, we went with plain JavaScript and constraint validation API in HTML5. This shaved off a few KBs of dependencies and gave us full control over the validation behavior and look. I describe this approach, with its pros and cons, in a blog post.