1. 3

    Nextcloud may be a good solution. It has a calendar and a WYSIWYG document editor. It seems to have a graphical installer too, or a Docker image that uses SQLite by default.

    I couldn’t find a marketplace app, though I guess you could make one if you wanted to.

    I haven’t explored it much to be honest, and wouldn’t host it myself as I’m not the target audience, but it seems to cover most of what you need.

    1.  

      I suppose the visitors will have to make accounts in order to see those documents then? I’d prefer the static pages/documents to be publicly open. But thanks!

    1. 25

      Go gives you the tools for concurrency, but doesn’t make them terribly easy - except to misuse.

      Compare Erlang, which does make concurrency an essential part of its worldview, and makes building those systems less hassle-prone than Go.

      1. 9

        They use different models for concurrency, with different tradeoffs and different expressive power, but I don’t think Erlang or Go is generally better or worse than the other with regards to concurrency.

        1. 5

          Could you give us an example? I’m not familiar with Erlang

          1. 5

            Erlang concurrency is in two models: a low-level process (green thread, no shared state) that can send and receive messages using imperative code, and one of several high-level behaviors that encapsulate the error-prone sending and receiving semantics so the developer only has to implement a handful of callbacks that handle incoming messages that may or may not change the server’s state and may or may not expect a reply.

            In a chat server, you’d model a connection as a gen_server or gen_statem that receives outgoing messages from TCP and incoming messages as a cast from a channel, and a channel as a gen_server that relays incoming messages to channel members.

            http://erlang.org/doc/design_principles/gen_server_concepts.html has some specific information about behaviors.

            https://learnyousomeerlang.com/the-hitchhikers-guide-to-concurrency is the first of several chapters in Fred Hébert’s excellent book about the low-level concurrency, and https://learnyousomeerlang.com/what-is-otp is the first of several about the high-level behavior-based model that I’m most familiar with.

        1. 17

          I wrote an IRC bot in Go (nearly a year ago… Time flies) that would randomly respond to people saying “bitcoin” in the channel with “More like buttcoin, am I rite?!”

          It has since evolved to do other stupid shit for no reason other than me finding it somewhat funny in the context of the channel. Oh… And it previews links, because why not…

          1. 9

            Bitcoin trolling sounds like a valid utility to me :)

            1. 3

              Please make a Lobsters version /s

              1. 3

                Please make a Lobsters version

                Well, it’s mostly tailored to the ##crustaceans channel on Freenode. Source code here if you want to do anything to it: https://github.com/Brekkjern/buttsbot

                It’s an absolute mess, but(t) it’s there.

              2. 2

                I wrote an IRC bot in Go (nearly a year ago… Time flies) that would randomly respond to people saying “bitcoin”

                More like buttcoin, am I rite?!

              1. 2

                Writing a typechecked function macro for Janet and exploring SuperCollider in the hopes of making a live music coding environment using Janet. SuperCollider is not for the impatient (if you know a synth server with an easier API or want to join in, please tell me)

                1. 2

                  I made a little toy script to make fzf descend directories when I pressed Ctrl-R, instead of automatically. It made me yearn for a real programming language:

                  #!/bin/sh
                  
                  export counter=$(mktemp -u /tmp/fzfc-XXXX)
                  echo "1" >$counter
                  workbinds='enter:execute(cd {};nvim .)+unix-line-discard,tab:execute(lf {})+unix-line-discard,`:execute(cd {};zsh -i)+unix-line-discard,#:execute(cd {}; edwood -f /usr/lib/plan9/font/luc/latin1CW.10.font)'
                  
                  find -maxdepth 1 -type d | fzf --bind 'ctrl-r:reload#expr $(cat $counter) + 1 > $counter && find -maxdepth $(cat $counter) -type d#' --bind "$workbinds"
                  

                  Maybe not a toy, since I used it for a bit. But certainly ugly and prone to various data races.

                  I also used Go to script Go once: https://skuz.xyz/go-in-go.html I didn’t dig that deep but it’s not ready for use yet.

                  1. 2

                    Reading this with a ligature font somewhat undermines the author’s point. I’ll stick to my old-fashioned keyboard :)

                    https://skuz.xyz/stash/get/1d771f4ddd0ca81029c6d0f96aa7cb5fb4c1cb1364d8a50820e4ab2b07d5229d

                    That aside, I really hope no-one makes a programming language with number agreement and English-like sentence flow and that requires a charpicker to write. Many people learn programming languages long after they can quickly learn new languages (childhood). If the author’s dream programming language came true, it would either be exclusive to English speakers or take years to learn. A small language that can be written with few symbols is more accesible.

                    Look at SQL for example. SQL is English-like but making it more “natural” would incur a lot of complexity and ambiguity.

                    Plaintext just happens to work well for code, but many tools that can aid with expressivity can be stacked on top (ligature fonts for example). The author talks about his students finding <=unintuitive, but that’s hardly a problem if you do more than an hour of programming.

                    1. 3

                      Even after thirty years of programming, and five years of professional programming, I find using a ligature font helps me distinguish between >= and =>. It’s a digraph like any other, and should be treated just as other old digraphs and trigraphs.

                      1. 1

                        Huh! I will use an archive link, thanks for the note.

                      1. 3

                        As noted at the top, feel free to add projects to one of these pages, depending on whether it’s a DSL embedded in another language (Python, etc.) or a stand-alone shell language:

                        https://github.com/oilshell/oil/wiki/Alternative-Shells

                        https://github.com/oilshell/oil/wiki/Internal-DSLs-for-Shell

                        1. 5

                          I just added janetsh and janet-sh to the first and second pages respectively

                          1. 3

                            there’s also closh

                            1. 1

                              Though slightly off-topic, I find babashka has a better philosophy of combining bash and clojure (ie. it doesn’t mix the two nor try to be a shell).

                        1. 4

                          The fact that 2 words can be replaced in this and it being indistinguishable shows how much substance there was in the original

                          1. 4

                            An interesting feature to implement if you want to avoid browsers is create-on-push like Sourcehut has. If you push to a non-existent SSH remote URL under your account, the repo will be created (you will have to go to the browser to set a description and visibility though). See https://geoff.tuxpup.com/posts/cool_sr_ht_feature/

                            1. 3

                              Yeah, that’s definitely something I’d like to do. Right now, creating a repo is only doable via the command line, but it’s a separate step (rcpu -h shithub.us newrepo reponame)

                              But it would be nice to just push. Since I control both ends of the protocol, I can add a git9-mkrepo capability that the server respects, and a flag in the client to handle it. I just need a bit of time to implement it. The only real sticking point is that right now, the server sandboxes itself within the repository before it starts processing user commands – which is hard to do if the repository doesn’t yet exist.

                            1. 4

                              Previous threads:

                              Perhaps a merge is appropriate if these threads happen every few months, with similar points being made.

                              Some have suggested a “reproducible” tag for hermes and such. What do you make of this?

                              1. 6

                                The architechture.md file mentioned is quite long imo. I wonder whether documenting the code like a library would work (easier in some languages than others), and providing a list of entry points/interactions in a short architechture.md (I often struggle with finding where the work actually starts). In-source docs have much less chance of going stale.

                                Also, for those not bothered to check what exa -TD does, it prints a tree of the directories at .. Funny the author didn’t just say tree

                                1. 5

                                  The architechture.md file mentioned is quite long imo.

                                  Mea culpa :) In my defense, rust-analyzer is a deep and complex project which sits closer to the 200k limit, so there’s a lot of ground to cover. And yes, pointing out entry points explicitly is a good idea, I’ve added separate section for them, thank you!

                                  I don’t think that in-source docs are a substitute for architecture.md though. They are good for explaining what are you looking at, but bad at helping to find where to look in the first place. In my experience, the central document is also, counter-intuitively, easier to keep up to date. I still forget to update the docs even if they are next to code, but with a single document I at least have a workflow to check if the docs are up to date. Finally, with inline docs you probably want to get an “atlas of fine grained maps” rather than a “coarse grained map”. An interesting idea to bridge the tho approaches is to auto-generate codemap out of specially-marked doc comments.

                                  That being said, rust-analyzer also enforces “each module has a docstring” property, and you write about providing a list of entry points to find where the work actually starts, so I expect that we are more in agreement than not :)

                                  1. 4

                                    I agree with this!

                                    In my Dinit project, it’s called DESIGN. It’s pretty brief and only succintly covers a few things, but importantly points where to look in the source for various things; then there are large chunks of comments within various sources files which give the details relevant to that particular source. The DESIGN file also spells out the design considerations and philosophy, and gives very high-level information as to how the software is put together.

                                    It’s really hard to build up a picture of a how a project is put together. An overview like this can save hours of having to slowly piece it together by trawling source more-or-less at random. But, a lot of information can still live in the form of comments within the source code. (Of course, they need to exist, and to be kept up to date).

                                  1. 5

                                    I’ve always had problems with RSS because I always found the list of “unread articles” stressful. I know you don’t need to read everything, but somehow my mind doesn’t cope well with the concept of “letting unread things remain unread” 🤷

                                    I find that Lobsters/HN/Reddit works fairly well.

                                    1. 2

                                      I’m in the same boat. When I used newsboat, a while ago, I had to mark everything as “read” weekly to keep out noise.

                                      I decided to make my own feed reader a few months ago. It ended up becoming a CLI that I pipe into fzf to read feeds. No read/unread, no complex navigation, and notifications on new items. It’s worked really well for me. If read/unread is overwhelming, you may consider it.

                                      1. 1

                                        Same, so I made my own that doesn’t have that.

                                        1. 1

                                          list of “unread articles”

                                          That’s for the “main news” sites, where I also find RSS doesn’t work so well. But it works great for following low-traffic blogs from people where I want to see everything they post.

                                        1. 4

                                          Why not have a hide function for comments, as we do for stories? Threads hidden by more users could be moved further down (don’t know whether this is done with stories). New replies on these threads wouldn’t clutter your view up if you hid them.

                                          Aside from that, a voluntary meta section for discussing on-topic-ness and tags would be interesting

                                          1. 3

                                            Writing an initial, hacky, regex-based parser in Go for typeup, a document format optimized for typing (preliminary example document). I’ll probably rewrite it using Janet’s PEG Module though, because regex-based parsing is pretty rough, even from the beginning. Also hope to write an optimized Zig stream parser when I have a spec. Hopefully it’ll be tidy enough to make public by next week.

                                            Also messing around with Zig, Kakoune and river, and collecting enough coffee grinds to grow some Oyster Mushrooms in spring.

                                            1. 12

                                              Some more interesting articles on the website, including: http://jehanne.io/2018/11/15/simplicity-awakes.html

                                              I wonder why GCC and not e.g. tcc, if simplicity is stated as the primary goal?

                                              The author ponders package management in one place, I’m curious if they’d like https://github.com/andrewchambers/hermes

                                              1. 4

                                                I think the answer to this question is that much software relies on a (GNU) C standard not fully supported by tcc. As far as I know tcc only supports C89 fully (maybe even GNU89 although I am not sure)

                                                1. 1

                                                  Is there an alternative minimal C toolchain that supports C11?

                                                  1. 7

                                                    cproc? The vast majority of packages in Oasis Linux are compiled with it

                                                    1. 1

                                                      Even if it supports C11, that wouldn’t be sufficient. Many applications use so called GNU C extensions (Linux for example) which are only fully supported by clang and gcc.

                                                1. 13

                                                  I suspect these “nothing’s happened since 19XX” articles are just strawman arguments. Humans build on old technology. Technology isn’t made in a vacuum. To some degree, “nothing new has happened here” can be said about anything. For example, humans have basically discovered every place on the surface of Earth, does that mean that archaeologists and explorers are useless?

                                                  1. 28

                                                    Thermionic tubes are made in a vacuum.

                                                    1. 2

                                                      Thank you for brightening my day :)

                                                  1. -1

                                                    Another advertisement post…

                                                    1. 6

                                                      …Not really? They’re just sharing a link to the documentation of their favorite language.

                                                      Of course, if the only thing OP did was shill about Janet, that would be a different issue.

                                                      1. 1

                                                        Exactly, just a link to a tool.

                                                        1. 1

                                                          Or rather, a link to a tool’s documentation. That does not make it an advertisement.

                                                      2. 5

                                                        It’s a bit antisocial for you to comment on every post you consider suitable for the tools tag, adding nothing to the conversation.

                                                        1. 2

                                                          Tag is not there, so I add to the conversation that in my opinion this is just a link to a tool, not a conversation starter.

                                                      1. 1

                                                        This looks really cool and I have to admit I wanted to explore 9plan for a while now. Is there a good entry-level guide to what plan9 is all about and how it works?

                                                        1. 3

                                                          Higher level overview: https://thedorkweb.substack.com/p/a-week-with-plan-9

                                                          cat-v has all the manuals and papers: http://doc.cat-v.org/plan_9/

                                                        1. 4

                                                          I’m dreaming up a markdown-like document format optimized for quick notes, with no line prefixes and avoiding the Shift key whenever possible. Also planning what to grow this year (oyster mushrooms and bulb fennel being priorities).