thu

I've started to learn touch typing many times, but don't use it. The main problem is that as soon as I want to touch type while working (e.g. coding), I only know the letters, but not the symbols, numbers or even uppercase letters. I think I can force keybr to add those, but they are not part of real world examples, while the words are natural enough. Is there any progressive way to introduce those just like keybr introduces 1 letter at a time ?

I maintain a web site where I re-render to HTML a scrapped version of the (consolidated version of) the Official Belgian Journal[0].

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

you must copy and paste content

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/

What do you mean by "jj clone" ? I assumed it was possible to start using jj on an existing Git repository, and continue using Git (and jj) afterwards. Isn't this the case ?

(OP here.) This is true to a good extend but a library such as blaze-html can't offer at least two things I've in mind. One is the very lightweight syntax. You can for instance have a look at the reference page source code[1]. Writing that in blaze-html is a lot more verbose.

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

(OP here.) Indeed, Slab is a templating language, just like Pug or Haml are. Slab was initially a reimplementation of Pug, but it evolved a bit.

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

SEEKING WORK | Belgium | Remote & On-Site in Belgium

+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.

I've used that algorithm and extended it to handle distfix expressions[1]. For instance it can parse the expression

    1 + if true then 1 else a b + c

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

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

Maybe you did while it was still called PLT Scheme (supported in DrScheme), although it's called Racket since 13 years.

20 years ago, on December 24, 2002, it was decided to replace the paper version of the Belgian official journal by its online version, starting in 2003. Here is how Belgian citizens can access theirs laws and other official texts: http://www.ejustice.just.fgov.be. (It's also available in HTTPS.)

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.

I'm looking for a Markdown editor that can save directly to GitHub, with the ability to make drafts (feature branches and possibly PRs) and reviews (accept the PR or merge to main) directly from the editor and hide as much as possible the complexity of Git. The idea is this could be used by non-technical persons to edit Markdown files in a Git repository that is turned into a static site by whatever means technical people could come up with (Jekyll, Pandoc, whatever).

I have started to write some notes[1], and even some code to try to better understand how the game was created (I'm pretty sure I've made some mistakes though). I have listed some additional references there if you like this.

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

Thanks a lot for your answer!

May I ask why you want to switch out of zendesk ? I'm reluctant to use it where I am (we have so many badly integrated third party software already...) but some people are pushing a lot for it.

BTW, thanks a lot for writing jonesforth.S, it's a joy to read !

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.

What a coincidence, I was trying to compile it yesterday but for instance, the `fp` register is not recognized. I can rename it to `s0` (a synonym) but I'm wondering what should I do to avoid this error:

    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 <nixpkgs> {} }:
    let
      riscv64-pkgs = import <nixpkgs> {
        crossSystem = (import <nixpkgs/lib>).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

Wouldn't it be possible for an entity such as Amazon to establish a separate legal entity and thus circumvent MongoDB's Server Side Public License ?

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.

Thanks a lot. It seems this remains quite a challenge to turn those into working code though !

Maybe someone here can help.

A few years ago I tried to implement what is shown on that page but without using something like SC, i.e. I was generating list of samples directly. I recall I was stuck trying to find how the 2nd order resonant Low Pass Filter (BLowPass [1]) was working.

Any good pointer to help me write it would be appreciated. I didn't spent much time reading SC source but I think it was not very clear for me without much sound synthesis knowledge.

1. http://doc.sccode.org/Classes/BLowPass.html

This sounds like Aboriginal Linux: http://landley.net/aboriginal/about.html

I think they use GHC frontend to parse Haskell sources.

Did you compare the disk usage vs. whisper ?

It is possible to know how far they are into having enough pre-order ?

There was this article[0] where they explain that light electric motors allow for new interesting design (e.g. in motor placement, and number of them).

[0] http://spectrum.ieee.org/aerospace/aviation/how-i-designed-a...

I wouldn't say the "writers" are endorsing the old website, or not endorsing the new one, but whois is pretty telling:

    $ whois haskell-lang.org | grep ' Name:'
    Domain Name: HASKELL-LANG.ORG
    Registrant Name: FP Complete Corporation
    Admin Name: FP Complete Corporation
    Tech Name: FP Complete Corporation

    $ whois haskell.org | grep ' Name:'
    Domain Name: HASKELL.ORG
    Registrant Name: YaleUniversityComputer Science Department Haskell Group
    Admin Name: Galois Hostmaster
    Tech Name: Galois Hostmaster

This is the same design. And the person who donated it to haskell.org asked them to stop using it[0]

[0] https://mail.haskell.org/pipermail/haskell-community/2016-Ap...

a new community based on better principles

Like stating the "old" community is based on worse principles ?

The link to the CHG (which I confused with IHG) is using HTTPS but it seems the redirect to GitHub works only in HTTP.

I'm not sure what stating CHG sponsors the new site means.

I still don't understand why new subreddit or IRC channel are necessary. They could be used strictly to talk about the new site, but it seems they will be targeted to all things Haskell, exactly like the existing places.

Otherwise I'm all for some form of competition and moving things forwards, so props for the initiative.

Have you heard about Mars One ?