Maybe you could hack something together with an embedded https://www.google.co.uk/forms/about/? Or some other form as a service provider

I unironically agree with Mariano Guerra. As somebody who went straight from managed hosting (cpanel) to aws, now that I've started managing a site by sshing into a box running apache, I've hit far fewer roadblocks, and the ones I've hit have been simpler to sort out.

That being said, I recently made a google sheet act as a basic cms for a site. So that could be an option too.

@Tak Tran I’m intrigued by your suggestion! I think you can trigger AWS Lambda or Github Action via Zapier/etc based on entries to Google Forms/Airtable. And presumably you can force people to log-in with their google identity for auth purposes & record that.

I wish I thought of that two days ago 😛

Only thing I’m not sure about is how do you enforce “unique per user field” (e.g. username)

I’m not convinced by “forego static+serverless” requirement & just spin up the server 🙂

Looked up what it’d take to do that in Python+Flask (as I’d go there given my background vs php). And while I think is/can be/ conceptually simpler, There is a lot more code to write & infra to properly setup. & more complexity lurks around the corner..

I think Netlify functions could be/are nice, but I’m still getting https://futureofcoding.slack.com/archives/C01932BJGE8/p1610868785005700?thread_ts=1610844320.005100&cid=C01932BJGE8

which is either bad ux (in case it’s me doing something wrong) or horrible infrastructure management (in case it’s been down for 3 days)

There is also a rust version (called stretch) from Visly which is more embeddeable. I prefer the flutter/swiftui layout model which is much easier to use in a visual programming context - the druid toolkit has an interesting implementation. Figma also has a pretty nice autolayout plus constraint system which can be used to build live UI -- see https://github.com/treeform/fidget

https://youtu.be/421gU482xFE

https://youtu.be/dBJLmYjfcbU

"Flashfill is not dynamic." 😢 So close to brilliant. (Gharani's tutorial is remarkably clear by the way.)

MS released it as an SDK: https://github.com/microsoft/prose

@William Taysom – looks like Google's clone ("Smart Fill") generates a spreadsheet formula & exposes it, so it is dynamic. (I can't get it to trigger at all though, so no hands-on experimentation yet.)

https://www.youtube.com/watch?v=jz690myEAsw

found another more detailed video: the prose group seems do be doing awesome stuff! https://youtu.be/X1YXge3C8RI

And yes, coding this up earlier today fizzed my buzz: 34 lines, half an hour, several mistakes.

relaxng (XML validator) has an https://relaxng.org/compact-tutorial-20030326.html#id2815185 operator for this sort of thing. Its been a while since I last wrote a gramamr but I think it would look something like this:

grammar {

  start = element house { room*}

  room = element room { box & ((red & blue?) | (blue & red?)) }

  box = elem box { "box" }

  red = elem ball { "red"}

  blue = elem ball { "blue" }

}

or else any other grammar would help (ANTLR, PEG, etc):

grammar = "house" room*

room = "box" ("red ball" "blue ball"? | "blue ball" "red ball"?)

I think it is useful to think in terms of grammars because then becomes obvious when the thing you are trying to validate is not context free

in XML world, once you need to validate something were a context free grammar is not enough, you reach for https://en.wikipedia.org/wiki/Schematron#Sample_rule.

hah had to edit my grammars. Not sure if they match your requirements exactly but you get the idea 😛

+1 Emmanuel Oga's suggestion of grammars, to which I'd add any other automata generating-abstractions. For example, regular expressions over the domain of toys (as opposed to the domain of characters).

This writeup expresses the cleanest approach I know of: https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/

the trickiest part of this is the “report all rooms that have the wrong toys and exactly what’s wrong”—i’d be tempted to reach for the really dynamic grammars that let you pretty easily insert whatever side effects/logic you want, like OMeta/ohm or rebol/red’s parse dialect. do you just want console output or structured data about the errors?

After someone asked in private what I was on about up above, I offer as an example this "regular expressions over sequences" library in Clojure: https://github.com/cgrand/seqexp The relationship between https://en.wikipedia.org/wiki/Introduction_to_Automata_Theory,_Languages,_and_Computation is a worthwhile area of computer science study for practical minded practitioners. 🙂

Wouldnt a datalog or mini-kanren style approach be useful?

Ah Garth Goldwater, OMeta haven't heard that in a while! Yes friends, an important part here is the detailed error reporting. I'll need to read Parse, don't validate @Don Abrams. Seems many non-trivial programming problems have a parsing (state machine) feel, and at one level we have good parsing tools though they seem to be underutilized in practice. One interesting thing here that counts matter and order does not. (Of course, one quick fix is to sort the list of toys in a room and then match on that sequence.)

As for error reporting, here's an idea. Imagine an interactive grammar generating tool. We start with golden path of validity (imagine a sorted list), something like:

Room = "box" ("blue ball" "red ball" | Color " ball")

Then the tool would propose invalid sequences for which we have to generate error description productions. That would be neat. I suppose other perennial parsing problems are tokenizing nicely so that you can operate on higher-level constructs, and I mean once you are acting on tree-ish data rather than streams, it begins to feel like regular functional programming...