One of the nice thing about having an underlying structured representation of those texts is that I can also render them to e.g. Markdown[1].

I've experimented about generating the Markdown files corresponding to multiple versions (archives) of a given text and committing them to the same Git repository to be able to see diffs or blames[2].

I would like to assign the proper dates to each commit, but given there are texts in e.g. 1791, it's not possible.

0: https://refli.be/fr/lex 1: https://github.com/hypered/iterata-md 2: https://github.com/hypered/iterata-archive

I've started the Slab templating language[0] to be able to define reusable HTML fragments. It means using a dedicated tool but hopefully not needing to resort to a real programming language.

0: https://slab-lang.org/

Two, although it's possible to introspect a blaze-html -generated tree, you can't easily have tooling to, say, list HTML fragments, where they are used, which one are full HTML documents (i.e. starting with a doctype)... One of my goal with Slab is to have a "refactorable" language to write "large" HTML code bases (I'm mainly thinking of design systems reference implementations). Having a tool that can "see" the tree structure, the fragment calls, the list of files, ... opens new tooling opportunities.

I'm one of those people that says syntax doesn't matter; we should talk about semantic instead (and thus just adopt s-expressions for syntax). Yet, in this case, I think that a very lightweight syntax that maps clearly to HTML, in particular for non-programmers (e.g. designers), is very valuable.

Note also that I make available a statically-linked `slab` binary that makes super easy to start using Slab. You don't need a programming environment with a compiler and so on. (I'd like to try to create a Cosmopolitan[2] binary in the future.)

The `slab` binary also has a "watch" feature that rebuilds pages and reload the browse as you edit `.slab` files. I guess I mean that having an integrated tool can offer a very good developer (or designer ?) experience.

[1]: https://github.com/hypered/slab/blob/main/content/reference....

[2]: https://github.com/jart/cosmopolitan

In particular, I tried to respect a principle often found in programming languages: user-defined elements (fragments) are no different than builtin ones. For example notice how `page` (which is user-defined) is used in the same way as as `body` (which is builtin) in the first code snippet of the introduction[1].

(In the future, I hope that instead of providing builtins, Slab will instead use libraries of elements. There is an undocumented feature to define elements[2].)

In Pug, to reuse bits of HTML, you can define mixins, but they are called with a `+` sign in front of their name. I also believe mixins can have expression arguments, but not other blocks of HTML. To pass blocks of HTML as "arguments", Pug provides the `extends` keyword, but I think it can only be used at the toplevel of a template. In Slab, the concept of fragments is a bit more uniform: a fragment can be used with expression arguments, and block arguments.

[1]: https://slab-lang.org/reference.html#introduction

[2]: https://github.com/hypered/slab/blob/main/examples/el.slab

Comments URL: https://news.ycombinator.com/item?id=41047502

Points: 39

# Comments: 8

+15 years of professional experience mainly with Python

+4 years of hands-on technical leadership

I'd love to work with Haskell and Nix (my side projects use them), although I've been using Python professionally for about 10 years. I like to get my hands dirty and have always worked with things like CI/CD pipelines, provisioning VMs, and so on (for example, I've been using Docker since 2013). I'm used to complicated code bases that need serious improvement.

I've got a lot of side projects visible on GitHub at https://github.com/noteed/ and https://github.com/hypered/. One of them is https://slab-lang.org/.

Please contact me at noteed at gmail.com.

Comments URL: https://news.ycombinator.com/item?id=40583072

Points: 2

# Comments: 0

    1 + if true then 1 else a b + c

    ⟨+ 1 ⟨if␣then␣else␣ true 1 ⟨+ ⟨a b⟩ c⟩⟩⟩

[1]: https://github.com/noteed/syntactical

I believe it looks exactly the same since 1997, when that site was originally introduced, and wanted to share it. The text can be searched using a form where you have to first click the "Search" button, then the "List" button to actually go to the result page. On a given result, you can download its PDF version by clicking the "Image" button.

It looks like the site is a bunch of Perl CGI scripts but I have no idea how documents are authored, or how the PDF generation is done.

It's available only in French, Dutch, and German. While German is an official language in Belgium, the German version is only a translation, not an official text.

Comments URL: https://news.ycombinator.com/item?id=34115515

Points: 1

# Comments: 1

What prompted me to do so was that the Wikipedia page in french mentioned a VM running multiple threads, which I thought was very interesting for 1989.

[1]: https://github.com/noteed/exploring

I read it a year or two ago, and I was revisiting it these days, hoping to write some RISC-V assembly when I found the repository you just submitted.

    jonesforth.S:540: Error: illegal operands `addi fp,fp,-8'

For those interested, I'm using the nixpkgs cross-toolchain. Some documentation is here[0]. Here is a possible `shell.nix` file content:

    { pkgs ? import  {} }:
    let
      riscv64-pkgs = import  {
        crossSystem = (import ).systems.examples.riscv64;
      };
    in
    {
      riscv64 = riscv64-pkgs.mkShell {
        buildInputs = [
        ];
        nativeBuildInputs = [
          riscv64-pkgs.buildPackages.gdb
        ];
      };
    }

[0]: https://nixos.wiki/wiki/Cross_Compiling

[1]: https://github.com/noteed/riscv-hello-asm

The separate entity would provide the "raw" service (where there wouldn't be much to open source) to Amazon, possibly running MongoDB directly on their infrastructure, then Amazon would turn it into a full-fledged SaaS offer.