From j3s at c3f.net  Fri Jan  1 18:16:43 2021
From: j3s at c3f.net (Jes)
Date: Fri, 01 Jan 2021 18:16:43 GMT
Subject: Home network
In-Reply-To: <46ce024841d015737df0484903a20cebc98aaf61.camel@gmx.com>
References: <7e9e0ebb-ef9f-d4fb-99a0-27b65bb6c2aa@sysmatrix.net>
 <ac2a9509-d08a-bd36-286c-83b7105579b5@saloits.com>
 <9fb5d949-68b7-1835-982b-9019e22b911b@sysmatrix.net>
 <af3e2e92-99c0-e027-237b-1f715d45e9da@saloits.com>
 <46ce024841d015737df0484903a20cebc98aaf61.camel@gmx.com>
Message-ID: <0A6C0859-D106-4648-BC59-B9CAC052A33A@c3f.net>

On December 16, 2020 6:25:21 PM CST, paul <pstelzig at gmx.com> wrote:
>A warning about Virtual Box, it's owned by Oracle and they have a
>reputation about licensing.

I just wanted to mention that qemu+kvm
is an excellent alternative. I've been using
it exclusively for many years. Here's my favorite (if a little inflammatory) "get 
started quickly" guide:
https://drewdevault.com/2018/09/10/Getting-started-with-qemu.html

From joe at begriffs.com  Fri Jan  1 18:32:58 2021
From: joe at begriffs.com (Joe Nelson)
Date: Fri, 1 Jan 2021 12:32:58 -0600
Subject: DMARC problem with the friends list?
In-Reply-To: <20201217133500.GQ10321@begriffs.com>
References: <20201217133500.GQ10321@begriffs.com>
Message-ID: <20210101183258.GH58277@begriffs.com>

Joe Nelson wrote:
> Looks like there's a problem with the friends list when relaying
> Andrew's messages. Robbie's mailserver bounced a message, and the
> bounce notice email is attached below.

Robbie's mailserver just bounced another one, this time from Jes:
* https://talk.begriffs.com/pipermail/friends/2021-January/001248.html
* Message-ID: <0A6C0859-D106-4648-BC59-B9CAC052A33A at c3f.net>

When I was experimenting with mimedown perhaps I changed a mailing list
setting to have it strip parts from messages or something. I better
review the config.

From prenticedarren at gmail.com  Wed Jan  6 18:37:04 2021
From: prenticedarren at gmail.com (Darren Prentice)
Date: Wed, 6 Jan 2021 12:37:04 -0600
Subject: Soft Skills
Message-ID: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>

There's an old-timer <http://blesser.net> at my company that I meet with
every week who offers his own sort of brand of career counseling / life
coaching / psychoanalysis type thing. He's a highly accomplished engineer
overflowing with wisdom and insight for fellow geeks.

I wanted to share some takeaways I've learned from him. And I figure some
of you might get something out of it during these remote times.


   1. Seek motivation through genuine human connection.
   Core to everyone's motivation is the inner child's desire for love,
   understanding, and feeling seen. Most of us don't have these needs very
   well fulfilled in our youth. So we develop coping mechanisms to protect us
   from potentially being hurt, and we look to other sources for this
   fulfillment such as career success and recognition. These secondary sources
   are not inherently bad, but it is important to recognize that they are
   fleeting and insufficient. Github stars alone will not keep you going. I've
   been struggling with motivation lately, and I can't tell you how much of an
   improvement I've noticed by just making an effort to connect with other
   people at a genuine human level. When I'm having trouble starting some task
   or dreading configuring some tool I'm not familiar with, I reach out to a
   coworker and have them pair with me on it. All the bad feelings go away
   instantly by having someone else there. I ask about their day, how they're
   feeling. I noticed I have all these silly excuses not to do so, but they're
   all overblown. There's literally no risk. Don't just sit on your anxieties
   alone, reach out.

   As I invest more in other people emotionally, I find I'm more motivated
   and relaxed in all areas. I'm currently working to dismantle this filter I
   built up over the years where I sort people into categories of safe/unsafe,
   interesting/boring or not worth talking to. Everyone is interesting and
   worth your time. By showing openness and vulnerability they in turn will
   open up and show interesting sides of themself. Even if you don't like your
   job, this will make you feel more connected and invested. It will also help
   difficult people be more trusting and receptive of your ideas.


   2. Pay attention to your feelings and emotions while you work.
   Us geeks are a lot worse at understanding our feelings than we're ready
   to admit. When starting on a certain task do you find yourself feeling
   anxious? worried? pressured? disgusted? embarrassed? inadequate? Dig deeper
   into those feelings and ask yourself why they're there. Think back to the
   earliest times you've felt that feeling, probably as a kid. Make peace with
   that memory.

   Feelings are not logical. You can't wish them away. There will always be
   those voices from your childhood telling you that you're nothing or that
   you have to do XYZ to gain approval. You have to make friends with those
   feelings so they don't control you. Discussing them in the presence of
   someone else can also help a ton in making those feelings feel safe to
   feel. It takes years to upgrade your mental processes, so be patient.

   These feelings can also be important indicators. They can tell us if
   something is worth our time or not. They can tell us some code needs to be
   refactored. That we need to ask for help. That we need to step away from
   the computer for a bit. Go for a walk. Meditate. Let racing disordered
   thoughts die down.


Feel free to share any soft skills that you find useful.


Oh and if anyone's interested, he does offer his services privately at
~$70/hr, reach out to me if interested.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://talk.begriffs.com/pipermail/friends/attachments/20210106/23cc28d4/attachment.html>

From palotai.robin at gmail.com  Wed Jan  6 19:28:08 2021
From: palotai.robin at gmail.com (Robin Palotai)
Date: Wed, 6 Jan 2021 20:28:08 +0100
Subject: Soft Skills
In-Reply-To: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
References: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
Message-ID: <CANiLjA2RO3=im_T6Tz+dYcf1Y9NQDU2qSBSn9GzT=pTvjgSuZA@mail.gmail.com>

Hi guys,

First post on the list, was lurking for a few months (?). I joined due to
some nostalgy (or rather anemoia
<https://www.youtube.com/watch?app=desktop&v=wH6ZCIRjI14>) for a simpler
development experience, when stacks were shallow, the tools are unified and
releases infrequent. But more on that maybe some other time. I guess it is
mostly a mirage.

Interesting point on involving colleagues. Especially about setting to a
task, there are two extremes I observed:

-  The task which is so trivial that involving others will just waste their
time and slow me down. But whenever I actually involve others, I'm very
positively surprised. Small details get fleshed out, aspects which I never
thought about emerge.

-  The task which seems dauntingly impossible. Having some discussions
unlocks quite some alternatives.

Every now and then I work on my ebook
https://treetide.com/book/programming-without-anxiety.html, which discusses
what I found useful in removing anxiety and writers block during work.
There's a free preview - if you like it but want to spare the money, ping
me for a coupon.

About the feelings and observing their source - makes me remember Gerald
Weinberg's communication model. The basic model goes something like:
1) intake - Physical reception of the message through some channel.
Sometimes we outright discard a message without interpreting further.
2) interpretation - Depends on our relation to the sender of the message.
We assign assumed intent to the message.
3) significance - We develop a significance based on the interpretation.
Manifests in a feeling.
4) response - The action triggered based on the interpretation and the
significance.

Now, this is the basic model. Where it gets really related and interesting
is that there can be recursion plugged in between 3 and 4, significance and
response. We observe what significance that message generates, and based on
primed-in models (form childhood etc) we react to our own feelings, maybe
with different feelings. For example, a tall guy says in a meeting that a
spec is not deliverable on time. You agree internally, but due to a tall
guy beat you as a child you get angry that he is right, and out of that
anger you object his statement. (Probably bad example, this is what I could
come up with)

Weinberg asserts what makes communication hard is that when we observe a
response, we should debug this hidden recursive process to get to the real
causes and motivations.

In fact I discovered Weinberg quite late, after he died. Look at the
bundles at the bottom of https://leanpub.com/u/jerryweinberg . Especially
https://leanpub.com/b/peopleskillssoftbutdifficult can be relevant.

BR
Robin

Darren Prentice <prenticedarren at gmail.com> ezt ?rta (id?pont: 2021. jan.
6., Sze, 19:44):

> There's an old-timer <http://blesser.net> at my company that I meet with
> every week who offers his own sort of brand of career counseling / life
> coaching / psychoanalysis type thing. He's a highly accomplished engineer
> overflowing with wisdom and insight for fellow geeks.
>
> I wanted to share some takeaways I've learned from him. And I figure some
> of you might get something out of it during these remote times.
>
>
>    1. Seek motivation through genuine human connection.
>    Core to everyone's motivation is the inner child's desire for love,
>    understanding, and feeling seen. Most of us don't have these needs very
>    well fulfilled in our youth. So we develop coping mechanisms to protect us
>    from potentially being hurt, and we look to other sources for this
>    fulfillment such as career success and recognition. These secondary sources
>    are not inherently bad, but it is important to recognize that they are
>    fleeting and insufficient. Github stars alone will not keep you going. I've
>    been struggling with motivation lately, and I can't tell you how much of an
>    improvement I've noticed by just making an effort to connect with other
>    people at a genuine human level. When I'm having trouble starting some task
>    or dreading configuring some tool I'm not familiar with, I reach out to a
>    coworker and have them pair with me on it. All the bad feelings go away
>    instantly by having someone else there. I ask about their day, how they're
>    feeling. I noticed I have all these silly excuses not to do so, but they're
>    all overblown. There's literally no risk. Don't just sit on your anxieties
>    alone, reach out.
>
>    As I invest more in other people emotionally, I find I'm more
>    motivated and relaxed in all areas. I'm currently working to dismantle this
>    filter I built up over the years where I sort people into categories of
>    safe/unsafe, interesting/boring or not worth talking to. Everyone is
>    interesting and worth your time. By showing openness and vulnerability they
>    in turn will open up and show interesting sides of themself. Even if you
>    don't like your job, this will make you feel more connected and invested.
>    It will also help difficult people be more trusting and receptive of your
>    ideas.
>
>
>    2. Pay attention to your feelings and emotions while you work.
>    Us geeks are a lot worse at understanding our feelings than we're
>    ready to admit. When starting on a certain task do you find yourself
>    feeling anxious? worried? pressured? disgusted? embarrassed? inadequate?
>    Dig deeper into those feelings and ask yourself why they're there. Think
>    back to the earliest times you've felt that feeling, probably as a kid.
>    Make peace with that memory.
>
>    Feelings are not logical. You can't wish them away. There will always
>    be those voices from your childhood telling you that you're nothing or that
>    you have to do XYZ to gain approval. You have to make friends with those
>    feelings so they don't control you. Discussing them in the presence of
>    someone else can also help a ton in making those feelings feel safe to
>    feel. It takes years to upgrade your mental processes, so be patient.
>
>    These feelings can also be important indicators. They can tell us if
>    something is worth our time or not. They can tell us some code needs to be
>    refactored. That we need to ask for help. That we need to step away from
>    the computer for a bit. Go for a walk. Meditate. Let racing disordered
>    thoughts die down.
>
>
> Feel free to share any soft skills that you find useful.
>
>
> Oh and if anyone's interested, he does offer his services privately at
> ~$70/hr, reach out to me if interested.
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://talk.begriffs.com/pipermail/friends/attachments/20210106/9a208066/attachment.html>

From dklann at grunch.org  Wed Jan  6 19:31:54 2021
From: dklann at grunch.org (David Klann)
Date: Wed, 6 Jan 2021 13:31:54 -0600
Subject: Soft Skills
In-Reply-To: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
References: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
Message-ID: <51fb1ce6-d78c-b508-b8c6-7b592fd69cb4@grunch.org>

Wow. Just. Wow.

On 1/6/21 12:37 PM, Darren Prentice wrote:
> There's an old-timer at my company that I meet with 
> every week who offers his own sort of brand of career counseling / life 
> coaching / psychoanalysis type thing. He's a highly accomplished 
> engineer overflowing with wisdom and insight for?fellow geeks.
> 
> I wanted to share some takeaways I've learned from him. And I figure 
> some of you might get something out of it during these remote times.

I saw the Subject line (not the From line), and thought, "Ah, spam." I 
was ready to mark it as Junk and move on. I'm glad I actually read your 
note!

I too am a bit of an old-timer, but maybe not as old and certainly 
nowhere near as accomplished as your mentor. I too have found that 
connecting with people is *WAY* more important than I thought even only 
15 years ago. I even moved out "to the country" to become a hermit and 
focus my time and efforts on my craft. Well, my partner and I are back 
in the city because we started feeling like that missing human 
connection was actually diminishing our intellectual capacities!

Thanks Darren, for sharing your thoughts and experiences, and for taking 
the chance to be vulnerable publicly on the list!

I'm looking forward to meeting up in person with folks again!

Original note trimmed, but no less important...

   ~David Klann
-------------- next part --------------
A non-text attachment was scrubbed...
Name: OpenPGP_0x745A93D6286EC7BC.asc
Type: application/pgp-keys
Size: 48654 bytes
Desc: not available
URL: <http://talk.begriffs.com/pipermail/friends/attachments/20210106/7a7a869c/attachment.bin>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: OpenPGP_signature
Type: application/pgp-signature
Size: 236 bytes
Desc: OpenPGP digital signature
URL: <http://talk.begriffs.com/pipermail/friends/attachments/20210106/7a7a869c/attachment-0001.bin>

From joe at begriffs.com  Sun Jan 10 17:30:36 2021
From: joe at begriffs.com (Joe Nelson)
Date: Sun, 10 Jan 2021 11:30:36 -0600
Subject: Real man pages for POSIX reference?
In-Reply-To: <20201023032810.GG53936@begriffs.com>
References: <20201021032548.GA53936@begriffs.com>
 <0F7C5B3C-BFA8-40BD-84D2-9C0B6BDE8550@causal.agency>
 <20201022030734.GE53936@begriffs.com>
 <20201023032810.GG53936@begriffs.com>
Message-ID: <20210110173036.GA10546@begriffs.com>

By the way, does anyone know if the internet RFCs are available in man
page format somewhere?

From joe at begriffs.com  Sun Jan 10 18:07:44 2021
From: joe at begriffs.com (Joe Nelson)
Date: Sun, 10 Jan 2021 12:07:44 -0600
Subject: Soft Skills
In-Reply-To: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
References: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
Message-ID: <20210110180744.GB10546@begriffs.com>

Darren Prentice wrote:
> I've been struggling with motivation lately, and I can't tell you how
> much of an improvement I've noticed by just making an effort to
> connect with other people at a genuine human level. ... I reach out to
> a coworker and have them pair with me on it. All the bad feelings go
> away instantly by having someone else there.

Totally agree, same here. That's why I wanted someone to pair with on
the parsing experiments. Chris Wilson has joined me on the frostbyte
server several times now to work through it and it's been very
motivating.

Is anyone interested in doing a remote group hacknight? Same format as
our meetups in the Before Times, but using Cyberia's Jitsi server?

From june at causal.agency  Sun Jan 10 18:19:17 2021
From: june at causal.agency (June Bug)
Date: Sun, 10 Jan 2021 13:19:17 -0500
Subject: Real man pages for POSIX reference?
In-Reply-To: <20210110173036.GA10546@begriffs.com>
References: <20201021032548.GA53936@begriffs.com>
 <0F7C5B3C-BFA8-40BD-84D2-9C0B6BDE8550@causal.agency>
 <20201022030734.GE53936@begriffs.com> <20201023032810.GG53936@begriffs.com>
 <20210110173036.GA10546@begriffs.com>
Message-ID: <9E846A63-61DE-4E7C-9DAC-1B4D5F0B55F5@causal.agency>

> On Jan 10, 2021, at 12:30, Joe Nelson <joe at begriffs.com> wrote:
> 
> By the way, does anyone know if the internet RFCs are available in man
> page format somewhere?

I don?t believe so, but I wrote some scripts to achieve a similar
experience: <https://git.causal.agency/src/tree/doc/rfc>. It downloads
all of them in text form and compresses them, generates a tags file
and implements a :RFC vim command. nvim +RFC1459 opens the RFC, gO
jumps to the table of contents, ^] jumps to a section heading or a
reference, and K opens another RFC number. I use this with neovim;
for vim I believe the install path and default g:rfc_path would
need to be modified.

From joe at begriffs.com  Sun Jan 10 23:00:27 2021
From: joe at begriffs.com (Joe Nelson)
Date: Sun, 10 Jan 2021 17:00:27 -0600
Subject: Real man pages for POSIX reference?
In-Reply-To: <9E846A63-61DE-4E7C-9DAC-1B4D5F0B55F5@causal.agency>
References: <20201021032548.GA53936@begriffs.com>
 <0F7C5B3C-BFA8-40BD-84D2-9C0B6BDE8550@causal.agency>
 <20201022030734.GE53936@begriffs.com>
 <20201023032810.GG53936@begriffs.com>
 <20210110173036.GA10546@begriffs.com>
 <9E846A63-61DE-4E7C-9DAC-1B4D5F0B55F5@causal.agency>
Message-ID: <20210110230027.GI49511@begriffs.com>

June Bug wrote:
> > By the way, does anyone know if the internet RFCs are available in man
> > page format somewhere?
> 
> I don?t believe so, but I wrote some scripts to achieve a similar
> experience: <https://git.causal.agency/src/tree/doc/rfc>.

Leave it to June...amazing as always! :)

> It downloads all of them in text form and compresses them, generates a
> tags file and implements a :RFC vim command. nvim +RFC1459 opens the
> RFC, gO jumps to the table of contents, ^] jumps to a section heading
> or a reference, and K opens another RFC number. I use this with
> neovim; for vim I believe the install path and default g:rfc_path
> would need to be modified.

Very interesting way to leverage the editor. Makes me think, what if you
use Vim's help system itself, rather than having to generate a tags
file? Basically make a plugin that has no real functionality other than
including all the RFCs as its help files.

Then you could use vim's built-in :helptags command to index them. In
:help help-writing it says,

	To define a help tag, place the name between asterisks (*tag-name*).
	The tag-name should be different from all the Vim help tag names and
	ideally should begin with the name of the Vim plugin.  The tag name
	is usually right aligned on a line.

	When referring to an existing help tag and to create a hot-link,
	place the name between two bars (|) eg. |help-writing|.

By processing the RFCs in this way, creating links, they would become
indexable help files. To open one, do :he RFC<foo> where it can even
autocomplete.

From nicholasdrozd at gmail.com  Sun Jan 10 23:33:50 2021
From: nicholasdrozd at gmail.com (Nicholas Drozd)
Date: Sun, 10 Jan 2021 17:33:50 -0600
Subject: Soft Skills
In-Reply-To: <20210110180744.GB10546@begriffs.com>
References: <CACfWeO4-qGM3UVfKE3TzKuGo9fc59xoeRos2bfWKr9wi54h0gA@mail.gmail.com>
 <20210110180744.GB10546@begriffs.com>
Message-ID: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>

> Totally agree, same here. That's why I wanted someone to pair with
> on the parsing experiments. Chris Wilson has joined me on the
> frostbyte server several times now to work through it and it's been
> very motivating.

I don't know how much this is worth for motivation, but I for one
would definitely read a Begriffs post about parsing. lex and yacc are
things that I feel like I ought to know, but the barrier to entry is
high enough that I've never even really looked into it. So if you
wrote a post about it, it would be of great use to at least one
person. (My previous offer to look over rough drafts and verify code
samples remains in effect.)

From drewbenson at netjack.com  Mon Jan 11 00:08:33 2021
From: drewbenson at netjack.com (Andrew Benson)
Date: Mon, 11 Jan 2021 00:08:33 GMT
Subject: Soft Skills
In-Reply-To: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>
References: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>
Message-ID: <CE16B2CC-5F3A-4329-A7A5-DC296E357A71@netjack.com>

Does anyone know ? are lex and yacc still in common use today?  I learned about them at college around 1990 ? about 30 years ago now (hard to imagine!).  With that much time having passed, I?d think there?s probably a newer ?state of the art? library or something for defining and parsing a grammar.  ? just curious!

On Jan 10, 2021, at 5:34 PM, Nicholas Drozd <nicholasdrozd at gmail.com> wrote:

?
> 
> Totally agree, same here. That's why I wanted someone to pair with
> on the parsing experiments. Chris Wilson has joined me on the
> frostbyte server several times now to work through it and it's been
> very motivating.

I don't know how much this is worth for motivation, but I for one
would definitely read a Begriffs post about parsing. lex and yacc are
things that I feel like I ought to know, but the barrier to entry is
high enough that I've never even really looked into it. So if you
wrote a post about it, it would be of great use to at least one
person. (My previous offer to look over rough drafts and verify code
samples remains in effect.)

From remexre at protonmail.com  Mon Jan 11 00:36:36 2021
From: remexre at protonmail.com (remexre)
Date: Mon, 11 Jan 2021 00:36:36 +0000
Subject: Soft Skills
In-Reply-To: <CE16B2CC-5F3A-4329-A7A5-DC296E357A71@netjack.com>
References: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>
 <CE16B2CC-5F3A-4329-A7A5-DC296E357A71@netjack.com>
Message-ID: <HImQmljfhMniVI5rOuw4A75WvCKq1omnfJoiP8VlK4Bc1aJu92Jf-CH8GFWYYwwlMzFM9AHqRnjJfefZY22oO8Biz9DlYPqd03rDdlVEV0M=@protonmail.com>

> Does anyone know ? are lex and yacc still in common use
> today? I learned about them at college around 1990 ? about 30 years
> ago now (hard to imagine!). With that much time having passed, I?d
> think there?s probably a newer ?state of the art? library or something
> for defining and parsing a grammar. ? just curious!

There are a lot of newer parsing techniques outside of the LALR family;
my shortlist would be:

- Parsing Expression Grammars (PEGs): _very_ easy to write a parser
  generator, but the grammar is structured differently from the
  LR-family, there are left-recursion issues (and workarounds), there's
  little error checking.

- Packrat Parsing: A technique to ensure a PEG executes in linear time,
  but blows up in space usage; imo this isn't practically useful yet.

- Monadic Parser Combinators: You can encode a (typically LL) parser as
  a monadic value. If you're in a language with do notation (e.g.
  Haskell, Idris, Scala), these can be very elegant, and pretty easy to
  implement. Megaparsec [0] and Attoparsec [1] are the two parser
  combinator implementations I've used in Haskell.

- Parsing with Derivatives (aka "Yacc is Dead" parsing, after the paper
  they were introduced in [2, 3]): easy to write a parser generator in a
  functional language (with memoization and laziness). Handles all CFGs,
  so you get back a parse forest, not a single parse tree.

- Generalized LR (GLR): Based on LR, but supports all CFGs. Resultingly,
  you get back a parse forest, but you can disambiguate locally, so
  "often" you end up with only one parse tree at the end. Used in lots
  of places, including tree-sitter [4].

- Lane Table: As general as LR parsing (simpler and more permissive, but
  less efficient than LALR, so relatively shunned in the 80s-90s),
  performs the LALR transformation as an optimization only. This is
  being worked on in lalrpop [5], which can otherwise do LR and LALR.

The lab I work in at UMN has been doing research on extending LALR for
extensible languages (where you can import new language features, with
their own syntax and everything). Our parser generator, Copper [6, 7],
uses LALR plus contextful scanning, where the LALR parser tells the
lexer which tokens are valid at a given point. This actually increases
the expressivity of LALR quite a bit.

In my opinion, LR/LALR still wins for "serious things" because they can
warn you about problems with your grammar, e.g. "this nonterminal isn't
actually reachable," "there's no finite sequence of tokens that parses
to this nonterminal," etc. Good compiler errors and error recovery are
still somewhat hard, especially versus a hand-written recursive descent
parser, though.

For quick hacks though, I like PEGs; I'll often write a PEG on paper,
and can write a parser corresponding to it fairly easily in anything
from Prolog to Haskell to ARM assembly.

In terms of tools, lalrpop [5] is the friendliest I've used, hands-down.
They've put a lot of effort into having good error messages for people
who have never heard of LR parsing before, and in my opinion they mostly
succeed. Menhir [8] is another LR parser generator from the OCaml world
that has a lot of advanced features in the user-interface side.

[0]: https://hackage.haskell.org/package/megaparsec
[1]: https://hackage.haskell.org/package/attoparsec
[2]: https://arxiv.org/abs/1010.5023
[3]: http://matt.might.net/articles/parsing-with-derivatives/
[4]: https://tree-sitter.github.io/tree-sitter/
[5]: https://github.com/lalrpop/lalrpop
[6]: http://melt.cs.umn.edu/copper/
[7]: https://github.com/melt-umn/copper
[8]: http://gallium.inria.fr/~fpottier/menhir/


From joe at begriffs.com  Wed Jan 13 23:35:04 2021
From: joe at begriffs.com (Joe Nelson)
Date: Wed, 13 Jan 2021 17:35:04 -0600
Subject: Soft Skills
In-Reply-To: <HImQmljfhMniVI5rOuw4A75WvCKq1omnfJoiP8VlK4Bc1aJu92Jf-CH8GFWYYwwlMzFM9AHqRnjJfefZY22oO8Biz9DlYPqd03rDdlVEV0M=@protonmail.com>
References: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>
 <CE16B2CC-5F3A-4329-A7A5-DC296E357A71@netjack.com>
 <HImQmljfhMniVI5rOuw4A75WvCKq1omnfJoiP8VlK4Bc1aJu92Jf-CH8GFWYYwwlMzFM9AHqRnjJfefZY22oO8Biz9DlYPqd03rDdlVEV0M=@protonmail.com>
Message-ID: <20210113233504.GN49511@begriffs.com>

Andrew BensonA wrote:
> > Does anyone know ? are lex and yacc still in common use today? I
> > learned about them at college around 1990 ? about 30 years ago now
> > (hard to imagine!). With that much time having passed, I?d think
> > there?s probably a newer ?state of the art? library or something for
> > defining and parsing a grammar. ? just curious!

I picked Lex/Yacc (Flex/Bison) precisely because they're old and stable.
Also looked at ANTLR, but it doesn't seem to value stability. For
instance, it dropped C as a target language from v3 to v4:

* https://theantlrguy.atlassian.net/wiki/spaces/ANTLR3/pages/2687352/Code+Generation+Targets
* https://github.com/antlr/antlr4/blob/master/doc/targets.md

remexre wrote:
> There are a lot of newer parsing techniques outside of the LALR family;
> my shortlist would be:
> 
> - Parsing Expression Grammars (PEGs)
> - Packrat Parsing
> - Monadic Parser Combinators
> - Parsing with Derivatives
> - Generalized LR (GLR)
> - Lane Table

Interesting, I tried Bison's standard mode and its GLR mode, and in my
Haskell days used a parser combinator library, but I don't know about
the others. Can you give some examples of (preferably not too esoteric)
languages that are especially hard to parse with Bison but become easier
with the other approaches?

From remexre at protonmail.com  Thu Jan 14 00:15:58 2021
From: remexre at protonmail.com (remexre)
Date: Thu, 14 Jan 2021 00:15:58 +0000
Subject: Soft Skills
In-Reply-To: <20210113233504.GN49511@begriffs.com>
References: <CABAiW0p-GC-pXpgd=J0PG-qtv+r5625BXVdzGOtBcewZDVFv8g@mail.gmail.com>
 <CE16B2CC-5F3A-4329-A7A5-DC296E357A71@netjack.com>
 <HImQmljfhMniVI5rOuw4A75WvCKq1omnfJoiP8VlK4Bc1aJu92Jf-CH8GFWYYwwlMzFM9AHqRnjJfefZY22oO8Biz9DlYPqd03rDdlVEV0M=@protonmail.com>
 <20210113233504.GN49511@begriffs.com>
Message-ID: <qw4DTpNJoxHk0Dtd_cN6Qc0Z0K3hJjDFZKz7HyH3VS6tAjzbSR8ceawHg5275z2HmKw9pJtZBxCZih2n65uJltni1dlgQO0Gp_xoIZmpM9o=@protonmail.com>

> Interesting, I tried Bison's standard mode and its GLR mode, and in my
> Haskell days used a parser combinator library, but I don't know about
> the others. Can you give some examples of (preferably not too esoteric)
> languages that are especially hard to parse with Bison but become easier
> with the other approaches?

I'd say PEGs/Packrat, monadic parser combinators, and to some degree
parsing with derivatives are about trying to write a parser without
having to put a lot of effort into the parser generator (and for PEGs,
you don't _really_ need a parser generator; to some degree, PEGs are
just a formalization of recursive-descent parsing, and writing a parser
generator is pretty trivial).

Parsing with Derivatives and GLR have the advantage that they handle
_all_ context-free grammars, so languages like C and C++ can be parsed
much easily than e.g. with LALR in Bison.

Lane Table is as expressive as LR(1), while having the efficiency of
LALR(1); the cases where a grammar is LR(1) but not LALR(1) are kinda
esoteric, but I have one here (reproduced from [0]):

    G1 = "a" X "d"
       | "a" Y "c"
       | "b" X "c"
       | "b" Y "d"
    X  = "e" X
       | "e"
    Y  = "e" Y
       | "e"

There's a reduce-reduce conflict here, when seeing a sequence of input
tokens like:

    a e e e c

With the conflict affecting it occurring between the last "e" and the
"c." Essentially, we need to remember whether "a" or "b" is initially
accepted, but the basis for LALR's smaller tables is throwing away that
information. LR(1) and the lane table algorithm both allow this grammar,
since they don't throw away this information.

[0]: https://smallcultfollowing.com/babysteps/blog/2017/03/17/the-lane-table-algorithm/


From chris at sencjw.com  Mon Jan 25 16:42:15 2021
From: chris at sencjw.com (Chris Wilson)
Date: Mon, 25 Jan 2021 10:42:15 -0600
Subject: Article on `volatile` C Keyword
Message-ID: <a1c3fa05-95ac-46f1-9e4b-fcbb065f8601@www.fastmail.com>

I thought that this was an interesting article. In it, the author explains how C is described with reference to an abstract machine (something that Joe's explained to me in the past). I thought others here may enjoy it:

https://blog.regehr.org/archives/28