flyx86

Has anyone had success running video calls over Matrix without Element?

fwiw if you use the Jitsi widget, you can share the URL to your Jitsi room with anyone and they do not need Element or Matrix to join.

The whole voice/video thing is a design problem as protocols like Matrix or XMPP are designed for non-realtime communication, while voice/video is very much realtime. You cannot possibly federate a video stream, so Matrix or XMPP can, by design, only supply the routing (i.e. connecting the people who want to participate in a realtime chat) and the participants then need to agree on some server/software combo that provides the actual video conferencing.

Okay so I wondered whether we can leverage XSLT in order to render the JSON without quirks mode. The idea is:

* We have an XSL stylesheet that ignores input and renders out the HTML contained in "#render"

* Along with the JSON file, we send a header `Link </stylesheet.xsl>; rel="stylesheet"; type="text/xsl"`

* We send the JSON with `Content-Type application/xml`

* Browser renders the HTML via the stylesheet and then the JavaScript takes over and renders the page without quirks mode

Sadly, this doesn't work because when the browser can't parse the JSON as XML, it stops processing and doesn't call the stylesheet :(

I needed some time to figure out you're not talking about multithreading in JavaScript/electron, but about this

https://github.com/vector-im/element-web/issues/2349

:)

Matrix bridges do that for me today! Currently using IRC and Telegram bridges, thinking about adding Slack.

Sadly, Electron-based Element is still the best Matrix client by far.

It's very handy to have shared calendars across multiple devices.

CalDAV should have you covered there. While the need for a server may be a bit inconvenient, I doubt that usability would be on par with it when you just copy the files instead (think of alerts, sharing calendars with others, etc). Also, there is no iOS Syncthing client when your phone probably is the most important device to have your calendars on.

This whole page is basically insulting the intelligence of users.

It's about time you try Linux

implying that while you did have heard of Linux, you misjudged it.

Unlike Windows and MacOS Linux gives you options

This is factually wrong, anyone knows that both Windows and macOS give you a lot of options.

The major operating systems put their users in a box, while Linux allows you to choose an OS that fits your needs and skill level.

implying that you can't run macOS or Windows by choice. No, obviously zombie Steve Jobs forced you to buy a Mac for a lot of money.

and "free" here refers not to the cost of the software but to its liberty—as no one entity owns the software it essentially belongs to everyone, without restriction

This is factually wrong but okay, copyright law is a complicated thing and it wouldn't make much sense to discuss that here.

So, in part, making the switch to Linux is an ethical decision about the software you use on a daily basis, and the rights you and others have to the information and things you use.

implying that if I choose to buy a software for money to support its developers because I think they're doing a good job, this is somehow unethical. Actually, there were no ethics discussed in the previous paragraph, so this is a conclusion without foundation.

Most open source operating systems are completely free both in price & licensing. There are typically no upfront fees, lengthy legal agreements, or restrictive copyright protections.

Um, did they ever see the GNU GPL?

Free software is developed completely transparently which means the source code is out there in the open for anyone to look at. This means, if you wanted to, you can have a meaningful influence over the software development process.

That is not generally true. If you look for example at SQlite, you'll find that while this is a piece of free software used by millions, they generally don't accept patches or any other kind of influence.

There are thousands of free software applications available to install without the need to browse the web. All this software undergoes scrutinous review before it reaches you, so you can find and use what you like with confidence.

implying that either non-free software isn't reviewed or that somehow I should trust people I don't know that review free software, but not people I don't know that review non-free software.

With LibreOffice, you can also open and edit any Word, Powerpoint, or Excel files you may already have.

Anyone who ever tried opening a non-trivial Excel sheet with LibreOffice would disagree on that.

On other platforms, the creative field is dominated by proprietary applications, but there are several capable free and open source alternatives.

… which also run on Windows and macOS.

---

There are a lot of good arguments you can make in favor for Linux. This page totally botches it.

Parking is not allowed on direction lanes (this one is a turn-right lane). You may halt your car there, but you may not leave it (thus park it). So while you can do this, you will also block yourself from doing much else.

Of course, a DDoS attack would be possible by having a couple of friends and switching the driver every once in a while.

A witty state lawyer may also try to sue you based on StVO §30 (1), though winning that trial won't be very likely, because you can simply stop the engine (allowed at traffic lights).

So I still cannot send a voice message in the chat (like Android users can), but I am now able to do video calls. Shouldn't a feature be fully completed before moving on to the next one?

And it still frequently happens that I get the same text message from Android users six times. Where are the priorities of this project?

UML would be handy at places where you would have drawn some kind of diagram anyway. Like an overview of components in a distributed system. Or a processing pipeline. Or an overview of a deployment environment. If UML delivered a useful set of constructs for those, it would be useful. Sadly, it focuses on class diagrams which I have never seen used anywhere. Sequence diagrams are somewhat used, but they are too complex and do not fit the average use-case well. (distinction between classes and objects? what about threads? loops have no break statement. Fragments are horrible. wtf.)

There are diagrams for component overview and such, but they are so strange that you just end up with drawing your own diagram type.

But yeah, the software engineering department still teaches UML.

Interfacing with C is actually a lot of work. Not that it is not possible, but if you write a light wrapper, you end up with all the low-levelness that makes up C.

If you want to use a C library „the Ada way“, you need to wrap almost every C function with an Ada function that transforms C pointers into Ada arrays (remember, [] in C is just a pointer with no dope), C defines into Ada enumerations, C function pointers to Ada subprogramm access types and so on.

This amounts to a lot of work. For example, my OpenGL Ada wrapper is roughly 10,000 lines of code. But it does do extension loading and resource management automatically (in contrast with the raw C API) and all defines have been translated to enum values so you can call functions only with values they can handle.

For safe resource finalization, Ada provides `Ada.Finalization.Controlled`. This enables you to implement RAII, smart pointers, and other ways of safe finalization. `Ada.Unchecked_Deallocation` is just the bare-metal tool you can implement more intelligent finalization with (because in the end, someone needs to deallocate the memory).

NixOS, because it fixes the problems Docker tries to build a workaround for.

but it’s the first language I’ve experimented with that has made them a first-class feature

It is a feature of ALGOL68, Pascal, Ada and quite some newer languages:

https://en.wikipedia.org/wiki/Tagged_union

Now see, that's much clearer. From the perspective of someone who knows Lisp, perhaps. I find it very confusing. Moreover, you are using an example from a tutorial, which is meant to explain how things work, not to show what the best way to write some macro is.

You can write the same macro with less verbosity:

    macro debug(n: varargs[typed]): typed =
      result = newNimNode(nnkStmtList, n)
      for x in n:
        let xRepr = toStrLit(x)
        result.add(quote do: writeLine(stdout, `xRepr` & ": " & $`x`))

Some tasks, especially around generic programming, can be very easily expressed in a dynamic language, but require more machinery in a static language.

I think this is not generally true and not a point against static typing, but rather against statically typed languages with poor support for generics. Java stands out as the poorest implementation of generics I have ever seen.

For instance, a generic serialization library can be written in a dynamic language, without anything fancy, but providing the same thing in a static language requires more machinery, and is sometimes more complicated to use.

As a counterexample, have a look at NimYAML (my work):

    http://flyx.github.io/NimYAML/