1. 9

    I’ve noticed the same issue with Electron apps on my low RAM devices. Anything with 4GB or less of RAM doesn’t allow you to run more than 2 instances of the programs, without chugging into swap space or worse, oom-killing.

    Particularly worrying is most of my messaging apps are exactly like that: Riot/Element, FB Messenger, WhatsApp, Telegram (this last one is actually pretty optimized and doesn’t eat too much). Long gone are the days where an XMPP bridge would solve the issue, as most of the content is now images, audio messages, animated GIFs, emojis and other rich content.

    Thanks for the article, at least I know that i can replace one of the culprits with a daemonized, non-Electron app and just use the phone as a remote control.

    1. 9

      As far as I am aware, Telegram is not Electron, it is actually a Qt based app.

      1. 7

        Long gone are the days where an XMPP bridge would solve the issue, as most of the content is now images, audio messages, animated GIFs, emojis and other rich content.

        I’m not sure what you mean. Most XMPP clients today (like Conversations, Dino, etc.) gracefully handle all of the items you mentioned, and with much less resources than a full web browser would require. I definitely recommend XMPP bridges when possible where the only alternative is an “app” that is really a full web browser.

        1. 4

          Of those listed, I think Riot will maybe disappear at some point. Riot has (amazingly) managed to have native desktop clients pop up, Quarternion, gomatrix and nheko are all packaged for my Linux distribution.

          1. 3

            I understand the desire to use something browser-ish and cross-platform. I don’t fully understand why Electron (hundreds of mb footprint) is so popular over Sciter (5mb footprint).

            1. 1

              Electron is fully free, Sciter is closed-source with a Kickstarter campaign in progress to open-source it.

              For the large companies, the price of something like Sciter should be a non-issue. If I were reviewing a proposal to use it, though, I’d be asking about security review and liability: HTML/CSS/JS have proven to be hard to get secure, Electron leverages the sugar-daddy of Google maintaining Chrome with security fixes, what is the situation with Sciter like?

              Ideally, the internal review would go “okay, but if we only connect to our servers, and we make sure we’re not messing up TLS/HTTPS, then the only attack model is around user-data from other users being rendered in these contexts, and we have to have corner-case testing there no matter which engine we use, to make sure there are no leaks, so this is all manageable”. But I can see that “manageable” might not be enough to overcome the initial knee-jerk reactions.

            2. 2

              Long gone are the days where an XMPP bridge would solve the issue

              I use Dino on desktop to replace the bloated Discord & WhatsApp clients, and it works fine (with inline images, file sharing, etc working too).

              Disclaimer: I did, however, write the WhatsApp bridge :p

              1. 1

                Isn’t the reason that XMPP isn’t useful more to do with these services wanting to maintain walled gardens? And further, isn’t that a result of the incentives in a world of “free” services?

              1. 1

                I stumbled across this when an implementation was created for clojure.

                I’m curious to look further into Branca to see to their suitability as a JWT replacement, due to the many well known issues with JWT.

                1. 1

                  this is only for symmetric encryption

                1. 6

                  I found that, for me, the most important thing was simple. I obsessed over all sorts of tools, vimwiki, org mode, etc. In the end I realized the most important thing to focus on was portability. I need a system that works anywhere, and I can trust will be around for a long time.

                  My basic system is .md files in SyncThing. On my desktop I edit them with Vim, on my phone I edit them with Markor. I don’t organize particularly. I group some things into top level pieces (e.g. technology, home, etc.) but there’s no real system.

                  1. 1

                    That’s more or less what I do. I have been planning to add them to SyncThing too as currently they are spread between different systems. I just have a directory with a bunch of plain text files. Once a file gets beyond a paragraph or two, or just a collection of links, I start writing it in Markdown. At various points I’ve felt like I should be doing more, but every alternative system I’ve looked at feels too complicated. The important thing for me is writing, and there should be as little friction as possible (so it doesn’t get much easier than simply opening my text editor) and with plain text I’m free to format it however I like (though I do try to keep it organised). Whenever I want to look something up I just grep the directory.

                    I saw the other post about ‘just forgetting things’, but I don’t think that would ever work for me. A lot of my notes are on how I solved a problem, or compiling a bunch of separate material into something concise and coherent. I can’t just ‘look that up’ again next time I run into it, unless I want to repeat the whole process again. And really, the whole point of writing notes for me is to get things out of my head so that I can focus on other things. I don’t refer back to my notes often, but when I do they’re a life saver.

                    I do often write paper notes too, but generally only for quick to do tasks or temporary lists, and sometimes while I’m trying to conceptualise an issue. I think they’re great for that. Ultimately, the less specific tools I have, the better. Otherwise I might need to start writing notes on how I use my note taking tools!

                  1. 4

                    In before someone claims they’ve got special eyes which are different from everyone else’s.

                    1. 3

                      The most common complaint I hear is headaches. I’m sure there’s plenty of people who are very light sensitive and do get headaches, but most people should try turning the brightness down before putting themselves into that category.

                      1. 6

                        Newer monitors are bright AF.

                        My wife was able to buy a monitor with someone else’s money, so I recommended she get the LG Ultrafine 5k. It’s an amazing monitor, and way too bright at default settings. We both would get headaches from using it until we knocked the brightness down a notch or two.

                        1. 3

                          yeah I also discovered that with my new monitor, it actually improved a bunch when I changed to backlight color from cold to warm, but it skews color correctness on it.

                          1. 3

                            Every time I have tried adjusting a modern monitor for comfort, I’ve put the brightness setting the lowest value offered by the firmware and it’s still too bright.

                        2. 3

                          its not that someone does or does not have “special eyes” its a what are you optimizing for as always, because if you go look at the stats in a different direction using a cool colored backlight, light themes increase eyestrain and mess with your sleep cycles due to artificial blue light exposure, dark schemes reduce that. Light schemes are less power efficient on modern display panels so if you are optimizing for battery life guess what dark theme wins. Then when you get to “special eyes” there are a lot of people who have Myopia or Astigmatism, which dark themes can produce halation, chances are light themes are better for you there. If you are trying to present on a large screen having a theme that is somewhere in the middle, and a little darker for dark rooms and a little lighter for light rooms wins.

                          My point is more or less there is a ton of nuance here where saying “SEE SEE SEE SEE SEE SCIENCE PROVES MY PERSONAL PREFERENCES RIGHT” is wrong, and the author honestly skips over all of that to justify their own preferences for some reason.

                          1. 6

                            My point is more or less there is a ton of nuance here where saying “SEE SEE SEE SEE SEE SCIENCE PROVES MY PERSONAL PREFERENCES RIGHT” is wrong, and the author honestly skips over all of that to justify their own preferences for some reason.

                            “I’m right because science” is a tactic to insulate against criticism, it preemptively accuses you of “denying science” if you dare to disagree.

                        1. 3

                          This appears to be the same idea as https://github.com/x-motemen/ghq, which is written in go. I believe it also supports svn and darcs.

                          1. 2

                            It’s very similar indeed, and I had not discovered it prior to writing git-cu! I went with a slightly different design in that it’s “dumber” and passes options directly through to git, and doesn’t offer any management beyond cloning.

                            1. 2

                              This tool looks very promising.

                              I oftentimes found myself very confused of my $HOME/git structure. At $WORK we use three version control systems so it was hard to consistently clone repositories with proper names. Later on it turned out to be a mixture of guessing and ripgrep.

                            1. 8

                              The output is distinctly like that of https://github.com/lambdaisland/deep-diff2 which uses An O(NP) Sequence Comparison Algorithm via clj-diff.

                              The algorithms in Clojure libraries got a serious comparison & benchmark in https://juji.io/blog/comparing-clojure-diff-libraries/ which was thorough. It seems that O(NP) Wu et al. 1990 is a winner for speed.

                              I’d love to know how Graphtage’s algorithm compares with the existing literature, the description sounds novel.

                              1. 3

                                Until reading this, I hadn’t grasped why LISP was considered a good message-passing system by Alan Kay. Obviously you can do anything in LISP, but as the article mentioned, Python does that too.

                                Now I understand it’s referring specifically to the fact that this is perfectly normal Clojure: ((foo obj) list element x). Although in this case, the message isn’t being dispatched to the list, it’s the function. In Clojure this is less clear due it’s protocol support, so maybe it would invoke a method controlled by the list type, and maybe it wouldn’t.

                                1. 1

                                  This is not quite right. Kay wants dynamic late binding. That means:

                                  (+ 42 69)
                                  

                                  being a message isn’t interesting unless:

                                  (define (+ x y) ...)
                                  

                                  (or similar) is also a message that could be sent independently as part of some other event.

                                1. 1

                                  There’s some overlap here with Rich Hickey’s Spec-ulation talk: https://www.youtube.com/watch?v=oyLBGkS5ICk

                                  Particularly

                                  dont break your API. Make a new thing, name it something else, figure out the migration that makes sense for you and your users.

                                  Most Clojure core projects were on 0.xxx until recently, where they bumped to 1.xxx due to the perception issues associated from a world which is mostly SemVer. Most of them haven’t broken API for many years.

                                  1. 1

                                    I think co-streaming is accurate. I’d consider remote control a fairly important aspect of remote pair programming, which this tool appears to lack. That’s OK, it’ll work for some uses but not others.

                                    1. 12

                                      This is tangentially related, but this is the first project in a long time that I’ve seen that uses Darcs, and I’m really happy to see it still getting used! It still feels like it was closer to “how it should be” than either Git or Mercurial.

                                      1. 4

                                        The author of hikari has also created a video where they talk about how & why they use Darcs: https://hikari.acmelabs.space/videos/hikari-darcs.mp4

                                        1. 1

                                          Not just a video! They wrote an entire book about Darcs: https://darcsbook.acmelabs.space/

                                        2. 2

                                          I heard that Darcs has bad performance. Do you think it is unlikely to become an issue for a project of this size?

                                          1. 3

                                            Hard to know without diving in a bit more. The issue isn’t that Darcs can’t scale as such; it’s that performance degrades exponentially with the number of merge conflicts. If they’re resolving those as they go, they could theoretically scale to a very large repo. But I’ll be blunt I haven’t actually kept up with development terribly well, so I don’t know how much this has (or hasn’t) been meaningfully rectified.

                                        1. 1

                                          This is really cool, I’ve never been able to move myself from bspwm for X. But I’m actively searching for new WMs, particularly ones that borrow from cwm’s tagging feature. I tried AwesomeWM, but it just didn’t have the lightweight “Unix” feel that bspwm has.

                                          1. 3

                                            Try dwm. I use it because I never use any of the features of any of the other tiling WMs anyway, but with dwm I can easily change stuff because it’s written <2k LOC of very simple C.

                                            Not sure what cwm’s tagging is but dwm has something called tagging.

                                          1. 2

                                            I used literate programming for a while, and literate was the best tool I could find which would allow me to swap blocks around. My use case was for my init.vim/vimrc. In particular I wanted to place my plugins close to the configuration for them, but sometimes that configuration would need specific ordering:

                                            • Plugin definitions need to go between plug#start() and plug#end()
                                            • Configuration might go in vimrc (if it’s g:foo)
                                            • Some calls or maps might go in an ftplugin file

                                            Scattering it around made it much more difficult to track down everything I’d changed about a particular plugin to remove or fix something.

                                            The massive downside was that the compilation process didn’t feel very portable. I just had this binary blob I lumped around and couldn’t get to work in unusual environments. I eventually solved this problem by using Dein’s hook functions to put configuration in callback functions, but my ftplugins are a mess again.

                                            1. 2

                                              I vastly prefer the approach that lit.sh takes over this. Literate seems to allow for defining arbitrary blocks wherever and then providing primitives for assembling, which is flexible but seems confusing. A more inline, top down approach, like that from org-mode + Babel or lit.sh is the sweet spot for me.

                                              1. 3

                                                This is a feature from the original literate programming tools. Wikipedia has a section on it: https://en.wikipedia.org/wiki/Literate_programming#Order_of_human_logic,_not_that_of_the_compiler. In fact, I think it was the whole point of literate programming. The examples Knuth gave were great, he’d say something like:

                                                The outline of the program is
                                                
                                                --- somefile
                                                @{Includes}
                                                @{Globals}
                                                @{Functions}
                                                @{Main}
                                                ---
                                                
                                                The first part of the problem we will tackle is outputting the information to the screen.
                                                We would first need to include stdio.h in order to write to the screen
                                                
                                                --- Includes+=
                                                #include <stdio.h>
                                                ---
                                                
                                                We should also name the variables we will store the word count in
                                                
                                                --- Globals+=
                                                int bytes = 0;
                                                int words = 0;
                                                int lines = 0;
                                                ---
                                                
                                                Then finally we can write a function to print these out
                                                
                                                --- Functions+=
                                                void print_result() {
                                                  …
                                                }
                                                

                                                Nothing too exciting so far right? But the real kicker comes when we start working on the input to the system, we can go back and append to includes/globals/functions. We’re not using the order the program is written, but the order we want to explain the problem in. This is more relevant in certain runtimes/languages (I’m thinking of (require 'foo) in Cljs or #include in C).

                                                1. 2

                                                  I hadn’t thought about it that way, but I can see how it makes sense. You can tell the story in a way that is separated from the flow of code. I guess I’d argue that in most languages you can (at least) forward declare functions that aren’t being used yet, making it possible to do this by writing a program from top to bottom in whatever order the functions make sense to introduce them in?

                                                  It seems like a mental gymnastics exercise to piece together the program in the Literate source form, otherwise…? Perhaps I should give it a try and see. I could be completely wrong.

                                                  1. 2

                                                    The given point seems worth taking on its face. I used lit.sh to design literate code support for Monte, and looking at the module where I first developed and used that support, the very beginning of the file starts with a bunch of imports and then an apology for the fact that some things will be declared in an awkward order because we don’t detangle.

                                              1. 21

                                                Yeah, 72 is much more reasonable. We need hard limits, or at least ‘annnoying’ conventions to keep the horrors at bay. The human eye scans lines best at around 72 characters wide, and we should put human readability of our code before other concerns. I have worked on projects that had huge long lines and there is no excuse. If a language or tool or whatever can’t deal with human limits, find or make another tool. Linus’ current workstation should not be the standard.

                                                That being said, I think Racket has made a reasonable compromise:

                                                A line in a Racket file is at most 102 characters wide.

                                                If you prefer a narrower width than 102, and if you stick to this width “religiously,” add a note to the top of the file—right below the purpose statement—that nobody should violate your file-local rule.

                                                This number is a compromise. People used to recommend a line width of 80 or 72 column. The number is a historical artifact. It is also a good number for several different reasons: printing code in text mode, displaying code at reasonable font sizes, comparing several different pieces of code on a monitor, and possibly more. So age doesn’t make it incorrect. We regularly read code on monitors that accommodate close to 250 columns, and on occasion, our monitors are even wider. It is time to allow for somewhat more width in exchange for meaningful identifiers.

                                                https://docs.racket-lang.org/style/Textual_Matters.html

                                                1. 25

                                                  The human eye scans lines best at around 72 characters wide

                                                  I would like to have 72 chars wide line but with ignored indentation. It would make nested block readable on its own.

                                                  Example with 40 chars width ignoring indentation white space

                                                  Lorem ipsum dolor sit amet, consectetur
                                                  adipiscing elit. Donec sit amet augue
                                                  felis. Suspendisse a ipsum et sem auctor
                                                  porttitor in ac lacus. 
                                                  
                                                      Curabitur condimentum augue diam, ut
                                                      molestie nibh faucibus nec. Aliquam
                                                      lacinia volutpat tellus, non
                                                      sollicitudin nulla luctus sit amet.
                                                  
                                                          Aenean consequat ipsum sem, ac rutrum
                                                          leo dictum at. Suspendisse purus dolor,
                                                          condimentum in ultrices vel, egestas vel
                                                          ipsum.
                                                  

                                                  Versus 40 chars width including indentation

                                                  Lorem ipsum dolor sit amet, consectetur
                                                  adipiscing elit. Donec sit amet augue
                                                  felis. Suspendisse a ipsum et sem auctor
                                                  porttitor in ac lacus. 
                                                  
                                                      Curabitur condimentum augue diam, ut
                                                      molestie nibh faucibus nec. Aliquam
                                                      lacinia volutpat tellus, non
                                                      sollicitudin nulla luctus sit amet.
                                                  
                                                          Aenean consequat ipsum sem, ac
                                                          rutrum leo dictum at.
                                                          Suspendisse purus dolor,
                                                          condimentum in ultrices vel,
                                                          egestas vel ipsum.
                                                  
                                                  1. 18

                                                    The human eye scans lines best at around 72 characters wide

                                                    With monospace fonts? Or proportional ones? With large text or small?

                                                    With English prose, poetry, or with C code? With hyphenation? Indentation?

                                                    I’ve found that recommendation is pretty good for English text with a middle size proportional font. I do not find it works as well for code.

                                                    1. 5

                                                      100% agreed. As I argued in the comments above, people don’t read code the same way that they read prose, and so I would not try to generalize a heuristic meant for prose to code.

                                                      1. 3

                                                        I agree. Reading written text involves repeatedly shifting your focus to the line below. A consistent and short line length in that case is very important. Code is not the same. It’s far more common reading code to study a single line or small block, and in that case, I find that arbitrarily wrapping a line to stay within 80 characters usually breaks consistency and harms readability. I used to subscribe to the 80 character limit until I realised this difference. We don’t read code like we read written text.

                                                        Terminal/editor windows side by side is a fine point, but in general the vast majority of lines of code are short anyway, often well under 80 characters. If a few lines happen to wrap on your display, I hardly think that’s going to completely kill readability, and it’s certainly a trade-off I’m willing to make. If many lines are wrapping then yes, you probably have a problem with your code formatting (or your code in general). It’s the hard limit that I take issue with. Back when I wrote my own code like this, all too often I would find myself renaming identifiers (usually for the worse) among other arbitrary and unhelpful things, just to fit some code within a line without wrapping. I wouldn’t be surprised if more often than not this is the outcome for many others who attempt this, and it’s almost certainly a net negative for readability. Dropping the idea entirely has been a huge relief. One less thing to think about. Most of my code still consists of short lines, as it always did, and as most code naturally does. But when I need to, and it makes sense to write a longer line, I don’t spend a second agonising over whether it fits within some special number of characters, and instead focus entirely on whether it in itself is clear and understandable.

                                                      2. 10

                                                        I want to reinforce your comment that

                                                        The human eye scans lines best at around 72 characters wide, and we should put human readability of our code before other concerns.

                                                        Recently, I have been trying to optimise my on-screen experience and I found a series of peer-reviewed articles with recommendations that improved my experience.

                                                        In one of those, it is claimed, indeed, that more than 72 and less than 80 characters (precisely, 77) is the optimal number for clear readability.

                                                        The study is for dyslexic people, and I was never diagnosed as so. But it works for me, and I tend to believe it works for most people as well.

                                                        1. 1

                                                          Yeah what I’ve read confirms this, I think the width of the text column can vary based on the character width. For example in CSS I typically set something like:

                                                           p { max-width: 32em; }
                                                          
                                                          1. 4

                                                            You can also use 72ch to set it based on width of the 0 character (which will approximate it)

                                                      1. 1

                                                        Are there some release notes or a changelog available?

                                                        1. 9

                                                          I wrote an application that did the right thing. It was targetted at a German audience, but as the product team (including devs) were English we wrote it in English and had translations provided to us from the German team. When you requested the SPA we negotiated using the Accept-Language header, so if you had “en-us” as a preferred language, you’d get the “en” version of the site.

                                                          When they went to demo it in Germany and 2/5 people saw the site in English we got a message to disable the English version of the site in production. This was in a corporate setting, where the laptops were presumably setup by the company that employed them. This wasn’t the kind of corporation that allowed access to install your own software, we couldn’t even access the AWS Console due to firewalls.

                                                          Since then I’ve been slightly more sympathetic when some site (including Google!) shows me Swedish or Indian while I curse at my computer (I’m still very angry!). I think browsers don’t make this anywhere near clear enough, it’s quite a lot of digging to change this preference in Firefox on Linux. The other side of this problem is users who are get frustrated that every website in the world seems to be in English all the time, “Isn’t it obvious?! I’m in Germany! Give me German!”.

                                                          It would be really interesting to perform some analysis on GeoIP vs Accept-Language headers to figure out if my experience was anomalous or there’s a real problem on the web that companies are compensating for.

                                                          1. 3

                                                            I think if the user makes it obvious that the preferred language header has been changed – such as by using en-au or en-gb, then one should respect that setting, and show the user English. It can solve the problem with clueless users complaining about default language and for people stuck in foreign lands. I also think that browsers should query and use the language setting from the operating system itself.

                                                            1. 3

                                                              In my experience trying to answer business questions based on logs analysis, I’ve found that, basically, this is the kind of question the data can’t answer. Suppose you, or a market research firm you hired, had access to the entire world’s logs. Suppose you query that data and find that, say, 0.2% of all traffic has an explicit, non-English Accept-Language header which disagrees with the language that GeoIP would tell you to use.

                                                              Is that a real problem? It’s a very small percentage, and I suspect most businesses would conclude that the data justifies their decision to keep the status quo. I would personally take the opposite view: If you consider 0.2% as a fraction of all internet traffic everywhere, it means that millions of people every single day are having this problem. I do think that the fraction is not going to be something overwhelming like 20% or anything like that, so the data on this question is never going to lead you to a clear conclusion. There will always be a debate. So I’d suggest that it doesn’t make sense to frame this as a question of what the data says.

                                                              I’ll elaborate on my belief that even a small percentage of traffic is significant for this decision. Even if you make the assumption - which I suspect is false - that the problem is easily resolved or only a minor annoyance for all of the people hitting it… well, at some point surely anyone would have to agree that five minutes of nuisance times a million, is worth at least a couple hours of engineer time.

                                                              There’s a possible counter-argument: That’s fine if you’re Google or Amazon or Apple, who should know better. But our website is so small, and will be used by so few people, that we don’t need to worry about it. To anyone advancing that argument, I will say: Why do you want to intentionally limit your audience? If you’re a business, you should know that a lot of people who might otherwise buy from you will look for a local place that doesn’t create this pain point for them. If you’re a non-profit, you should be trying to get your message out to the broadest possible set of people. Either way, you don’t want your belief that your site is too small, to turn into a self-fulfilling prophecy that keeps your audience small.

                                                              As an aside, I should say that at Google, I very frequently found myself the one calling to do the responsible, inclusive thing with regard to localization among other concerns. I developed the rhetoric you see above, in part, through those conversations. Not to speak ill of anyone, but I think when you’re focused on completing a specific task that you are emotionally invested in - launching a new feature - it can be difficult to hear that there is a concern you hadn’t thought about that you need to spend time on.

                                                              1. 3

                                                                I think browsers don’t make this anywhere near clear enough, it’s quite a lot of digging to change this preference in Firefox on Linux. The other side of this problem is users who are get frustrated that every website in the world seems to be in English all the time, “Isn’t it obvious?! I’m in Germany! Give me German!”.

                                                                This is only an issue if you’re using an OS in English, I think? I’d wager that if your OS is in English, then most of the time you’d prefer your webpages and web services in English, too (I do, anyway).

                                                                I agree browsers’ UI sucks on this; it’s one of the downsides of “let’s provide as few options as possible”-philosophy which seems present in all (mainstream) browsers.

                                                                I agree much depends on your site’s intended audience and quality of translation. For international sites and services like Spotify, Netflix, Wikipedia, etc. it makes much more sense to just look at the Accept-Language header and be done with it, whereas for very German-specific stuff like a government website looking at the location makes more sense. I think this table would make the most sense:

                                                                                         | International site | German-specific site
                                                                                         | ------------------ | --------------------
                                                                de-DE from Germany       | German             | German
                                                                de-DE from anywhere else | German             | German 
                                                                
                                                                en-US from Germany       | English            | German
                                                                en-US from anywhere else | English            | English
                                                                
                                                                1. 2

                                                                  I do too and your table is fine for Germany, but I also live in a country where macOS is not translated to the language we speak (Slovenian). English is a weak signal in countries as it is effectively the default second option for a large part of the planet.

                                                              1. 6

                                                                Today I’ve spent installing Jitsi on a new VPS in a datacenter nearby, run by a small company I trust more than any corporation from Silicon Valley. Just had the first multi-hour conversation with a close relative and while the video had some dips now and then, the audio was good 99% of the time. I’m quite happy that this traffic isn’t available for analysis by Facebook, Google or Amazon. It was quite easy to setup and I can recommend anyone interested to check it out: https://github.com/jitsi/jitsi-meet

                                                                1. 3

                                                                  I can recommend Talky as a trustworthy zero-setup WebRTC video chat solution, for those who don’t want to put the effort into hosting their own. QoS has always been fine for me. Here’s their privacy policy – it’s pretty straightforward.

                                                                  1. 2

                                                                    I’ve been using Nextcloud Talk for the same reason and purpose for a while now. If you happen to have a Nextcloud server around this option is worth a try, it works wonders for us here to keep in contact with out spread-out family in these times of isolation and quarantine. I first installed it last year after my father died so I could make daily video calls with my mother - I live in Sweden, she lives in the Netherlands - without having to feed Suckerberg, Apple, Google or Microsoft in the process. Once SARS2 hit the use has been expanded to my wife’s mother and brother and some others.

                                                                    1. 1

                                                                      Did anyone try to use jitsi with LDAP ? Because I could only find sprase information or unresolved threads and failed to do so. The idea is to limit the creation of rooms to LDAP authenticated users, otherwise this is a possible DDoS problem.

                                                                      1. 1

                                                                        Would you say it’s a reasonable approach for hosting business meetings?

                                                                        1. 1

                                                                          I’ve been using the hosted version at https://meet.jit.si with a group of four to six people for two years now, and apart from last summer it really is good enough. You can easily give it try it before deciding on setting up your own instance.

                                                                          1. 1

                                                                            I wouldn’t self host jitsi for business, I’d use meet.jitsi. The killer feature over at meet.jitsi is the SIP integration they’ve setup in a large number of countries. When your mic just isn’t being picked up today, you always have the dial-in.

                                                                          2. 1

                                                                            I’m quite happy that this traffic isn’t available for analysis by Facebook, Google or Amazon

                                                                            It’s not like they’re sending all their data to Facebook; what is probably going on is that they’re just using a Facebook API, by the sound of it for Facebook logins.

                                                                            What is most certainly not going on is sending all your data to Facebook “for analysis”. I’m not saying that makes it fine or that it’s great, but there is a nuance to these things, and I find it disappointing that whenever these kind of topics come up, the nuance goes out the window at the speed of light pretty much every single time :-/

                                                                            1. 1

                                                                              It’s not like they’re sending all their data to Facebook; what is probably going on is that they’re just using a Facebook API, by the sound of it for Facebook logins.

                                                                              Of course, and re-reading my comment one could easily conclude that, sorry for being sloppy. That said, I’d argue this is not so much about the actual content of a conversation as much as about the fact that I’m talking to a close relative, at that moment in time, for a certain period. It is just one data sample that in itself is insignificant, but combined with all the other small data points gives a quite accurate view of what keeps me busy and who’s around me. So I still stand by my comment but please interpret “this traffic” as “the meta-data” ;)

                                                                              As a side-note, https://meet.jit.si does forward all traffic through Amazon.

                                                                          1. 5

                                                                            This week I started a project to implement a DVCS for relational data and it’s going pretty good, I’m eagerly awaiting working on it on the weekend :) I’m still a little surprised that this seems to not have been done yet, if anybody knows of prior work in this area, hints would be much appreciated.

                                                                            1. 2

                                                                              Sounds fascinating! What is the use case you have in mind?

                                                                              Reminiscent of Clojure’s Datomic in that it would keep all history of mutations.

                                                                              1. 1

                                                                                Reliable, efficient and private synchronization of application data between devices and people, it can be anything really. I saw Datomic before but it seems to be proprietary, right? That would be a no-go for me.

                                                                                1. 2

                                                                                  Yep, proprietary, Datomic seems to be another path to revenue for R. Hickey and other clojure folk.

                                                                                  Love this idea. Two weeks ago on vacation I fantasized about this concept for personal ‘human-scale’ data - an encrypted (at rest?) syncthing + git storage backend for email, contacts, etc.. My personal org file setup almost achieves this: an encrypted filesystem in a file (cryptomator) synchronized via syncthing. Please post notable progress!

                                                                                  1. 1

                                                                                    Yeah I personally like working with Git and use it for all my projects and I thought “why doesn’t my calendar/contacts/nutrition tracking work like this?”. But the problem with Git is that it’s text-based and thus not a good database backend for graphical applications. And with Git it’s not easy to provide a good UI/UX for syncing that regular users can use, especially if there are merge conflicts.

                                                                                    1. 2

                                                                                      What are you imagining for UI/UX? Planning to support mobile? Syncthing drops a “.conflict” file with alternate versions and lets you sort it out.

                                                                                      1. 1

                                                                                        Conflict resolution is the thing I want to make better than in Git or Syncthing. Because I version relational data, there is much more structure to work with when conflicts arise and some conflicts like whitespace/formatting-related problems don’t arise at all. The user will have to choose between two (or more) conflicting data sets, but it will be much easier than fixing a Git merge conflict or dealing with Syncthing’s .conflict-files. Everything will be graphical, so yeah mobile will be supported, too.

                                                                              2. 1

                                                                                https://github.com/39aldo39/DecSync uses the file-system in a conflict way, and therefore can be used with syncthing to sync k/v data between devices. There’s RSS/Contact support right now.

                                                                              1. 4

                                                                                In line with the other comments, GNU has recutils for text-based databases. https://www.gnu.org/software/recutils/

                                                                                1. 2

                                                                                  I really like the philosophy/motivation for GNU recutils, but it’s unfortunate that there aren’t bindings for languages other than C/C++. The folks in the GNU Recutils IRC said the closest they’ve seen is a Python implementation, and even that one isn’t completely compliant with the specification; it implements just the core functions, but none of the advanced features (like distributed database support). I would love a Go implementation.

                                                                                  1. 3

                                                                                    Good opportunity to write one.

                                                                                    1. 2

                                                                                      I’ve looked into it, and I have higher priorities at the moment. Not opposed to revisiting it

                                                                                      1. 2

                                                                                        There are several attempts both, bindings and translations

                                                                                        https://github.com/search?q=recutils

                                                                                        I recall vaguely using recutils from within Delphi of all things… I do not think it had (at least back then), anything like a merge function (which is why I thought the OP was looking for)

                                                                                1. 2

                                                                                  I’ll be caring for my partner who seems to have a cough. Quite nervous about it being COVID19 as she’d fall into the vulnerable group as she has a compromised immune system. I’ll cook her some crepes for breakfast, and generally take care of her.

                                                                                  As she’ll be sick, that usually buys me some time to myself while she rests. I’ve been working on a static site generator in Clojure called “Anansi” which I’ll probably be boosting, I’ve had some ideas about how themes should feed back into HTML generation so need to work on that. I’ve started writing my first blog post on the internals of figwheel and what features it’s actually providing and how they work. I’ve always wondered this, ClojureScript is something of a magical black box.

                                                                                  If partner is up for it we’ll try and finish Unravel or something, also dependent on how close I feel safe being. If I’m sick, I can’t go out and get necessary supplies!