KajMagnus

Aren't there lots of new forum software?

Discourse, Flarum,

and Lemmy, open source and reminds of HackerNews/Reddit: https://join-lemmy.org (it's quite alive over at GitHub :-) https://github.com/LemmyNet/lemmy/graphs/contributors)

And I'm developing another one, Talkyard, which reminds of HN/Reddit as well: https://www.talkyard.io (also: https://www.talkyard.io/-32/how-hacker-news-can-be-improved-...)

It seems to me that companies often want forum software, sometimes internally, sometimes for customer support — on their own domain, rather than over at Reddit.

But for consumers, maybe, like others here write, it's mostly Reddit (for English speakers)?

More about algorithm questions vs system modeling:

I'm thinking that

1) getting good at algorithms takes less time, than getting good at system modeling. — One will see one's mistakes sooner, within minutes, compared to system modeling, in which case one would need to stay at a workplace for months or years, to see how a system design eventually turned out to be a mistake?

But 2) it's also harder to get good at hard algorithm questions — most people won't get that good at it, also with weeks and months of practice. And they still wouldn't have any real chance in a Google coding interview.

And in that way, algorithm questions make sense?

They give more information about the person's ability to think and learn — good for the company —

and takes less time for the candidate to get good at (weeks or months — compared to working for years?), good for the candidate?

(I'm someone else than GP)

PS. I wonder what the electrician was up to? :- ) and the other one

What's happening to Meta/Facebook and Instagram? Are they destroying themselves from inside, when they cannot get their stuff together enough to fix their bugs preventing new people from joining?

My years old Instagram blocked, although I had never posted anything, just looked at other people's posts some years ago.

There was an error message about me having violated their terms of service. Although it worked the last time I used it, and thereafter I did nothing for many years.

So I tried to create a new account. First I got "Internal Error, try again". And then, (I tried again), after having chosen a password and verified my email (a new address for a new account), there was an error like "Seems you're using an open proxy. If you think this is not the case ... blah blah".

Is there anything like Fossil — with a built in ticket tracker — but that does not remember exactly what I did? But instead focuses on a nice looking history?

Hmm but after having websearched for "fossil ticket site:news.ycombinator.com", not sure if I really want a built in ticket tracker. Also, seems Fossil remembers and redistributes all old revisions of tickets and comments — including typos and angry words or ... accidentally copyrighted material? someone might have added, not sure if I like that

Any thougts about Fossil's ticket tracker? (Anyone has used it?)

I was just looking for something like Fossil/Git but that focused on a clean history :- )

jj's Automatic Rebase and rewriting history support look lovely ( https://github.com/martinvonz/jj#comprehensive-support-for-r... )

and "Conflicts can be recorded in commits", e.g. for starting resolving a merge at home, continuing in the afternoon at the co-working space, a different laptop.

`jj edit` and `describe` looks like things I'd use a lot.

Nice with Rust and Nix (Hi Martin I'm Magnus from Gbg btw :- ))

`jj st` — nice naming. I've named my scripts directory just 's', since, typing is not that fun

> I just redeploy the application with the new state.

How long does that take? From clicking Deploy until the app got updated? ... and until it's restarted and the new state is available?

Could this depend a bit on how far away a data center is? Maybe 200ms longer for some?

Let's say you have a Git repo. Now, what if your laptop and all your mobile phones disappear? (Maybe you're travelling and your car takes a turn down into a river.)

Then, remembering a trusted hash of your Git repo, might be convenient (depending on where the Git repo mirrors are kept and who has access).

Or maybe for some reason you'd like to save a hash of a text you wrote, or something.

Dt: 20b968d95bbc605e0aff4c214e1cc3a110eec746

> maybe have English as your mother tongue

Or Swedish :- ) Semicolon works in the same way, in Swedish. I think I didn't know much about the semicolon, though, until I had read a few books (in Swedish) about writing books (in Swedish).

Maybe most Latin languages? Oh not Greek. Hmm interesting how it works in Arabic, https://en.wikipedia.org/wiki/Semicolon

When writing the first line in a new project,

one in an instant adds thousands of bugs :- )

> convey a specific representation ... is the "public document" you have access to, not the raw data

Seems you're saying it might be illegal to convert a HTML file to PDF format, or to use a screen reader to read the text.

I wonder in which country you are (where apparently there can be laws like that)

> We have quoted a fixed sum per month for that service and we plan to use that money to reimburse everyone sending PR:s we merge

How interesting :- ) I wonder how you'll distribute the thanks-for-the-feature (PR) money — e.g. per PR, or per lines (hmm I guess not) or maybe some impact / "severity" system like for bug bounties? (but this time "feature bounties")

(From Sweden me too. How nice that you built the app and that apparently things seem to end in a good way :- ) I felt a bit upset when reading the article)

> "all in one" ... create a single bundle

That's nice. (I too think it's simpler to get everything okay well tested, when it's all in one place, rather than different software, possibly from different vendors, that's supposed to integrate with each other to accomplish the same thing.)

Also nice that it's written in Rust. And that you've chosen the MPL 2.0 license.

And that Kanidm is an OIDC Identity Provider, I've been looking for that :- ) And WebAuthn

(Keycloak is nice, however it's Java and thus a bit resource intensive (RAM), and some other things.)

Thanks, interesting reading, and some from there linked topics as well

Does this indicate that by not fixing the fake reviews problem, Amazon can, whenever it wants, get rid of a troublesome competitor?

(since the competitors are sort of forced to use fake reviews)

> assuming that you actually read the code

How large percent of the development time, would you say you spend on reading the code in the dependencies?

If you would be ok with posting a link to any online repo of yours,

then, it'd be interesting to have a look at how many lines of code there are, in the vendored dependencies, and compare with num lines in the actual program. Maybe I'd run `cloc`

I've also been looking for a Ryzen that can be upgraded to 32 or 64 RAM :- )

Interesting question.

Maybe one answer can be 1) a public automatic tests repository, 2) release channels, 3) incompatibility auto warnings, and 4) organization internal tests.

1: (for plugin developers) The plugin developers could write automatic tests of their plugins, save them in a plugin-auto-tests source code repository, which the Talkyard developers then would run as part of the Continuous Integration builds (which happens many times more often than new version releases).

The plugin developers would get notified about plugins getting broken, before new Talkyard versions had been released. And could either fix those problems, or tell the Talkyard developers to "please don't do that change at least not now".

2: (for plugin users) Talkyard has release channels (inspired by Kubernetes [1]) — there's a Rapid, a Regular and a Stable channel. (Currently only a Regular channel.) One's Talkyard site could stay on the Stable channel, meaning, there'd be about half a year between the day when a plugin problem got noticed, and a new Talkyard version had been promoted to the Stable channel. That ought to be enough time to have done something about plugin breakage. (Security bug fixes, though, would get added to the Stable release channel, as soon as sensible.)

[1]: https://cloud.google.com/kubernetes-engine/docs/concepts/rel...

3: (for both developers and users) There's an automatic notices system in Talkyard. If a plugin uses deprecated functionality, Talkyard can show a warning to the Talkyard forum admins, and then they can decide what to do. Maybe contact the plugin developers? If they don't reply in a month, try finding a new plugin? Contact Talkyard and ask them to take over mainenance of the plugin? (These incompatibility auto warnings are less-noise than subscribing to new-releases-announcement emails, because these warnings would inform you about only the deprecated functionality the plugins on your site use.)

4: If it's super important that a plugin won't break, then the organization could setup a test environment with at a Rapid release channel version of Talkyard. Then they could do their own internal private tests of new versions, about half a year before they'd appear in the Stable channel.

If all these (at least 1-2-3) were in place, I'd think that theoretically, yes plugins could still break. But maybe it would no longer be the right thing to "worry" about. (Auto upgrades are optional, b.t.w., and enabled by default.)

> > after few months I can't update to a new version

> forum owners often won't upgrade their website ... plugins that likely will break

Maybe then it'd make sense if I mentioned Talkyard https://github.com/debiki/talkyard — it's forum software with automatic upgrades. I'm developing it. There's not yet any plugin system, instead currently "everything" is built-in, and there are (unfortunately) fewer features.

> did it in our company

How much time did it take? (for one person to do it)

> Maybe someone would like to buy an NFT

Assuming the story is interesting enough for people to bid for an NFT, then:

What about writing a book instead / as well?

(Can one do both? or maybe things included in an NFT cannot also be in a book?)

Or what about finding [other people who were involved in the early Internet and came up with technologies and ideas that nowadays 20 - 25 years later are "taken for granted"], and write a book together? Or maybe (some of) them would be interested in getting interviewed and having their stories included in a book, together with your story. Maybe a bit similar to the book "Founders at Work", but about well known early Internet technologies instead of early software / Internet companies? (At the same time, maybe that's way more work than what you originally had in mind)

(I think you meant `calixa .io` not `.com` — the latter gives a Chrome security warning.)

Amazing! That's the word that popped up in my mind too.

Scala 3 is my on shared 1st place favorite language

Union/intersection types — indeed, I use all the time, in Typescript.

And Opaque Types looks lovely too. All across my code base, I have type aliases like "UserId" or "PageId" or "PostNr" or "DraftNr" etc, and it'll be nice that this can now be type safe for real, not just type aliases. (Just waiting for opaque types to arrive to Typescript too.)

> Every time you enter a folder that direnv hasn't seen before, or the file in there changes, you have to run `direnv allow` for it to be taken up.

That sounds great, just like I would have hoped that it'd work. And, because of this: "or the file in there changes", in a way it's even safer than a Makefile — in that Make wouldn't notify me if the Makefile got changed, but Direnv does (and people might not remember to look at any Makefile diff after pulling from the repo). — Now I'm starting slightly thinking about if Direnv makes sense somewhere in my own project(s).

Thanks for the reply & all info :- )

Actually, this: `USER=my_name make psql` and this: `make psql USER=my_name` I don't like that much: No command line completion of `USER=my_name`.

Makefile targets like `mycluster-kubie` are nice, although they can result in a combinatorial explosion (if one needs two or more parameters).

It seems to me that after all, it'll be Deno or maybe Rust "scripts" that I'll want to use, combined with Make — Make for building, and Deno for running things.

(Running = often, nice with command line completion. Building = less often.)

Thanks for the extra pieces of software :- ) Direnv looks nice, makes me nervous about security exploits though (seems it automatically parses a file in the current directory, sometimes provided by strangers, via a Git repo that maybe I just wanted to look at). Hmm, https://github.com/direnv/direnv/issues/23 "security considerations"

Git-crypt seems like a nice way to maybe distribute secrets for accessing one's CI environment :- )

Didn't know about entr. Currently I use inotifywait (from package inotify-tools in Debian)

Yes it's powerful, I agree about that. At the same time, it's not type safe (but Deno + Typescript would be), and the syntax is a bit funny, like the differences between `( (( [ [[` which I annoyingly often forget. One day, when I saw code like this:

    if [[ ${1:0:1} = '-' ]]; then
      ...
      set --

I got a bit annoyed, and said to myself that Bash scripts almost should be forbidden. I didn't know that syntax `${1:0:1}` and there wasn't really anything to websearch for — just different symbols.

Websearching for "bash bracket colon colon" something actually worked but it took a while. In a typed language, I'd just clicked a function and would have seen the docs, in an instant.

> from zero to a script that's production ready in like an hour with option support, help text, man pages, shell completion, signal handling that's portable to any system.

It seems you've been used Bash for quite a while. Then I'm guessing in your case, it's a good choice. Agreed that dependencies for Python or Deno or whatever else is annoying to have to include (the Deno runtime is sth like 50 - 60 MB if I remember correctly)

I wrote "or are security-dangerous like C" actually,

— that's easy to measure, if it's written in C or not (or some other memory unsafe language)

> Shouldn't that be completely opaque to the user?

That would have been nice indeed. However many languages use lots of memory and are a bit slow, or are security-dangerous like C. It's nice to know, then, that this app likely uses barely any memory at all, and is as fast & keyboard-responsive as it can be, and harder to hack — Rust. (Assuming it is implemented in a good way :- ))

Yes! I logged in just to mention HOCON, then I noticed you have mentioned it already :- )

So, the project you linked to is Java / Scala: https://github.com/lightbend/config

And there're also (basic? complete?) HOCON parsers in Javascript and Rust — I investigated this a while ago, because I want to use HOCON everywhere in my projects:

https://docs.rs/hocon/0.5.1/hocon/ (Rust)

https://www.google.com/search?q=hocon+javascript (Js, a few different)

The Rust version:

> This implementation goal is to be as permissive as possible, returning a valid document with all errors wrapped in `Hocon::BadValue` when a correct value cannot be computed

How nice :- ) (it seems to me)

I have in mind to use Deno instead of both Node and Bash scripts :- )