Interesting synchronicity: I've written a patent-drafting DSL which exactly parallels this – and which is now shaping up into an "IDE" for patent drafting...
Patent texts read as prose, but are actually precisely structured legal documents. The latest developments in this domain involve LLMs to create and modify patent documents, but even though the legal profession seems to have fallen all in on it, it's essentially rather fragile and error-prone.
I've gone the deterministic direction, which has opened up some very cool, previously unexplored, possibilities!
A few months ago, for the first time in my life, I had to write a patent document. It was very complicated – too complicated. Noting the structure, I searched for tools, but found only LLMs. So I wrote my own tool.
The amusing thing is, LLMs prefer the DSL-structured document!
(My impression: various approaches; mostly academic; some small companies in the space; judging from a loose assessment wrt my career choices as a freelancer: no real business opportunity yet)
Patents are a much smaller space than the vast legal one in the article, so it's tractable for a human. The raw DSL spec length is roughly comparable to Lua or Go. It's a genuine grammar, with types and an AST; but no conditionals, control flow, expressions, etc. like a regular programming language.
A patent document can be represented in a graph. That opens it up to various transformations, refactoring, and validation – all mathematically rigorous! This is far more reliable than asking an LLM to check a document.
Using git enables not only regular diffs, but also structural diffs, which compare legal elements rather than just lines.
The LSP (yes, that too!) makes drafting much easier, with autocomplete and validation as I type.
I plan to open-source the DSL, and the tool that processes its files and outputs jurisdiction-aware, nicely formatted documents...
I went into this imagining something like Synfig Studio (https://www.synfig.org/) or Moho (https://moho.lostmarble.com/). "Studio" here is quite far from what it actually is: lip-syncing in static characters.
I get that you're using AI to boost capability with less effort, but at the moment, I think the more specialized tools are still a better avenue for this.
Lastly, I followed the link to Jellypod (https://www.jellypod.com/). It's pretty good, but falls into a vocal "uncanny valley". Even a human reading from a script wouldn't sound that perfect; the enunciations immediately come across as artificial.
Now, if this was an extension to Synfig (also open source!), it would be a much more interesting venture...
Unfortunately, I never got around to using it! I bought it with high hopes, but my Zip disks turned out to be so convenient and spacious that the VHS-backup need never arose.
That said, it's not too late... I still have my Amiga system in storage, and a VHS recorder.
>I bought it with high hopes, but my Zip disks turned out to be so convenient and spacious that the VHS-backup need never arose.
It's good to hear, in retrospect, that you were able to use a storage medium that did not even exist when Amiga were discontinued. Which type of interface for the Zip drive works with it?
(It occurs to me that Zip disks presumably offer the great virtue, otherwise absent as I understand it for Amigans, of PC compatibility.)
This is a famous "killer" feature from WordPerfect: the ability to view and edit the low-level formatting for a document. It's invaluable for fixing weird bugs.
However, it works only because WP uses the "text-stream" paradigm, where a document comprises a linear stream of text with formatting codes (Bold, Font, Hard Return, etc.) embedded directly at the point at which they're applied.
In contrast, Word uses the "nested containers" model (characters inside words, words inside paragraphs, paragraphs inside sections, etc.), where this feature can't be replicated.
I didn't look closely at your code, but just thought to mention this feature.
I don't see why the "nested containers" model would prevent this feature to be replicated, it's just a tree of nodes. Not edit-this-as-plain-text-simple but almost.
Just last week I needed to output a formatted document, and my choices were constrained to: HTML+CSS, Markdown, docx (OOXML), or odt (ODF).
The formatting had to be manipulable in code; the first two options were unsuitable for my use case. That left OOXML and ODF.
Both docx and odt are zip files, with XML content. Any guess which one turned out to be the better choice? I was left wondering why docx even exists in the first place.
Anyone using OOXML can rightly be regarded as stupid. There are far superior formats, and we should insist on their usage.
It's a fascinating paradigm – as though it dropped here out of some future.
However, I'd never use it. Reason: having everything dynamically created JIT means there's a trade-off somewhere else; in this case, it's energy consumption. I'd rather "cache" applications (ie. have them as installable software, which has been built just once) than endlessly recreate software from scratch each time, with all the energy usage that entails.
Thanks for the great feedback. That's why there is an app store in pneuma. You can upload and download pneuma generated apps from others. Give it a try!
The computer doesn't "enjoy" books – it assimilates them as data. That data isn't stored verbatim; it's used to train a system. In return, ChatGPT is made freely available, and millions of people benefit from it.
My dog bit me accidentally while playing, a few times. Every time, he apologized. (That is: he stopped playing, made a characteristic sound, and licked me to make sure I was OK.)
I remember when I was a kid one of the cats we had - who at that point was very much not a kitten and blind to boot - had gotten into a tussle with some strange cat. I just reached in to the melee and grabbed our cat. He promptly bit my and - or rather he started to. Didn't even break the skin. Just immediately stopped and I swear to God if a cat could say, "Oh, I'm sorry I thought you were someone else" that's what he would have said.
Patent texts read as prose, but are actually precisely structured legal documents. The latest developments in this domain involve LLMs to create and modify patent documents, but even though the legal profession seems to have fallen all in on it, it's essentially rather fragile and error-prone.
I've gone the deterministic direction, which has opened up some very cool, previously unexplored, possibilities!
reply