@juliobiason There are two levels of instance moderation.
The first level just hides an instance from the public global timeline, but messages are still exchanged.
The second level is a defederation: messages from the blocked instance are rejected and messages from your instance are not sent to the blocked instance.
However, I don't know if messages from your instance and boosted by a non-blocked instance are visible from the blocked instance.
@minoru A stable ABI is important when you are distributing binary software. If you update the runtime libraries provided by the language/OS, ideally, this shouldn't break software compiled against an older version of the runtime.
For free/open-source, it's less important as you can recompile the software to fix this. Though this means distributions won't integrate a new version of the language until the next stable version of the distribution.
@juliobiason From the ActivityPub point of view, other actors sends you messages by posting (http POST) to your inbox URL (server to server protocol), and you retrieve those messages by getting (http GET) from your inbox URL (client to server protocol).
Nothing is said about keeping messages in the inbox after getting them or other interactions like patch/put/delete. The ActivtyPub Remove activity could be used to remove messages from your inbox (the inbox is a collection, and you can Add or Remove objects them from collections).
You could move messages from the inbox to a collection to keep them or to a trash collection to remove them after some time. You could also define rules to automatically move things posted to your inbox into collections.
I will find the fediverse easier to follow if it used an interface like a feed reader (I'm thinking of Akregator notably) than the Twitter-like interface of Mastodon and Pleroma. Notably when following bots accounts as they tend to spam timelines.
Using different languages for describing, theming, and coding the logic of a UI is somewhat better than mixing everything into a single language. Reusing the rendering engine of a web browser to draw the UI is not a bad idea.
Using node.js as the backend is more questionnable though, as you could have achieved something similar by extending or changing the web browser bindings for local pages.
re: Mastodon -> Pleroma
@mdallastella I set up a Pleroma instance when I broke my Mastodon instance while trying to update it (I was on a fork that became somewhat unmaintained, and I couldn't easily switch back, nor run it because of system updates).
Easier to update, and to theme (no need to fork to change things like icons, background, or colors). So I wouldn't mind if functional.cafe migrate to Pleroma.
@rose I prefer the story of Black/White to the one of Black2/White2.
re: Guile, complaining
@MutoShack The function read does not evaluate the content of the file. It just parses it as a s-expression. So it's normal to see quasiquote and unquote in the resulting xml. Keep in mind that REPL means "read, eval, print, loop", so read and eval are different phases.
In your case, you need to use local-eval after reading, or replace (read (open-input-file ...)) by (include ...).
@erkin Maybe because of dependencies (like make requiring guile). Though, there are already guile-2.0 and guile-1.8 packages for a few softwares with dependencies on older versions of guile. I wonder why there isn't a guile-2.2 package for this.
@rose I already played and finished the original on GBA years ago (and could play it again since I have the cartridge and a DSLite), so I already know the story. I played the demo, and while it looks nice, it doesn't appeal me enough to play it on Switch.
@philipwhite Without any knowledge on the language you are using, I answered both.
The "return copy" are easier to read than in-place updates if your language allow definition or overloading of operators, as you can write formulas in a more natural way. Also, if you are writing your library in a functionnal language, the "return copy" is often the way of thinking operations (operation without side effect), not the "in-place update" (operation with side effect).
Though in a functional language, you would also prefer map-like operations instead of separate add/scale where you can give a function that is applied on every item (potentially combining several input vectors of the same size, like map in lisps), a model similar to OpenCL kernels or OpenGL compute shaders that you run on a graphic processors.
re: hot take, software
@amiloradovsky Sometimes, the config file is only present for development purpose, in order to be able to play with parameters before fixing them after testing the soft (notably when you have hardware coupling). So there are configurable values, but the soft should be able to start without any config file at all.
@jk In the first pokémon games, there are two ways involving money.
If you run out of money (and ways to get money) while you haven't got two mandatory key items located in the Safari Zone, you can't finish the game, as you need to pay a fee to enter the zone, and the number of steps you can walk there is limited. There is a similar problem for entering Saffron city (visiting the city is mandatory), as you need to buy a drink and give it to a NPC to be authorized to enter the city.
In the pokémon games, you get money by beating trainers and selling items. However, in the first games, there is no renewable items, and you can't repeat battles you won (outside the elite 4, but that's after those areas, and beating them is finishing the game anyway).
You loose money when all your pokémons are KO (even against wild pokémons). Also you sell items for half the price you buy them, so you loose money if you repeatingly sell and buy the same item. So if you are very bad at the game, you can reach an unwinnable state (no money and no way to get some, while needing some for getting into mandatory places), and you can save in that state.
The problem is not present in the other games of the series (nor in the remakes of the first games), as there is always a way to get money.
@amiloradovsky The different tools uses similar but slightly different way of expressing regexes, sometimes incompatible (notably if there is a possibility to extract and not just match).
I've just looked at the Racket page on regexes, and there are two kind of regexes defined there...
There's a game jam starting tomorrow centered on lisp (any dialect).
@erkin if your dictionnary is more like a table of a database (and notably if the functions you provide to work on the collection are like database operations), the second option is better, as you are not abstracting a collection of key-value pairs, but a collection of objects.
Also, the association list should only be a serialized representation of your collection, not the actual data you work on in code (as structures / classes provide better abstractions than lists, and are easier to refactor).
@erkin It's also more consistant if your dictionnary also has values that are not lists, because you have to write the dot for those.
@erkin Although both are equivalent in code, I find that the first option convey better the idea of a key-value pair.
(let ((cnx (make-mastodon "email@example.com"))) (set-profile cnx "Someone haunting the Internet maze.") (toot cnx "Hello World!"))
The social network of the future: No ads, no corporate surveillance, ethical design, and decentralization! Own your data with Mastodon!