mindB

What you're describing sounds a lot like the indieweb movement. Worth checking out although they're getting significantly less momentum than activity-pub or any other number of protocol-first social networking projects.

https://indieweb.org

Fair enough. :) I guess my stronger wording is because I don't understand workflows where being able to dump vast quantities of text to the terminal quickly is important. In general, a terminal emulator is for use by a human, and humans can't really process info at the throughput rate of other terminal emulators, much less the faster alacritty.

All that said, I'm glad to hear there's a plan on the latency front.

These benchmarks miss the point in my opinion. When I'm choosing a terminal emulator, beyond features, the one "performance" metric that I'm interested in is latency; nothing else really affects my workflow (positively or negatively). In the benchmarks I've seen of alacritty wrt latency[1][2], it doesn't come out so well.

[1]: https://danluu.com/term-latency/

[2]: https://lwn.net/Articles/751763/

I think you're probably right. The impressive thing here and the competitive advantage is probably the organizational ability and supervisional manpower to make effective use of extra manpower.

That's interesting that the 40 hour thing came from OR. Will have to look into that. I'm working on my MS in OR right now. I had always just thought that it was based on the undeniable fact that work just kind of sucks after 40 hours in a week.

The way he drives his workers is very different than a common orthodoxy I see around here:

He demands 12 hour days, and he gets more efficiency than other contractors; definitely different than the view that there's some optimum level of work <=40 hours/week after which returns diminish so much as to not be worth it. Maybe the game industry's perpetual crunch time isn't as insane from a strictly financial perspective as it seems at first blush?

Is this true? As far as I know, even in rooms with m.room.encryption, you can still send normal m.room.messages. Or does the config option you're describing automatically setup room PLs such that m.room.message can't be sent?

For the record, E2E is currently in libpurple master (only decryption not encryption) and in PR on matrix-python-sdk. Just a slight flip there.

Plots.jl is a pretty darn good plotting library. If you prefer something more along the lines of grammar of graphics, checkout VegaLite.jl or Gadfly.jl. For dplyr, I just saw a presentation by Dr. David Anthoff on his QueryVerse.jl family of packages, and it's probably just what you're looking for.

That said, I do not recommend the linked article for learning Julia as it's highly out-of-date.

- pandas :: your choice of DataFrames or JuliaDB

- scikitlearn :: no single package since skl is a meta-package of sorts, but most of the stuff is there spread across the eco-system

- Keras :: checkout Flux or Mocha

Welcome to Julia! Also take a look here [1] for more package that might be to your interest.

[1] https://github.com/svaksha/Julia.jl/blob/e305195ab60e6859e78...

matrix.org is federated rather than p2p, but it's e2e implementation has some very nice features (group chat, multiple devices, forward secrecy, etc.).

Not saying that python great for this, but this exact use case is literally what matlab was created for. I'd take python over matlab any day, but people have been writing crappy matlab scripts for their dissertations for a long time now.

I did a brief search because I was curious who was remembering correctly here. There have been several studies correlating "long" sleeping with mortality, but the study I found that attempted to control for confounding variables[1] seems to suggest that most of the differences in mortality in the populations studied can be explained by "depression and low socioeconomic status". It seems like a lot more study has been devoted to undersleeping than oversleeping, and I can't find anything convincing as far as maximum healthy sleep time and effects of over-sleeping. One study I still want to look at but haven't gotten around to yet is the stuff the NSF produced in 2015 when making its recommendations about sleep duration.

[1] https://academic.oup.com/sleep/article/29/7/881/2708387

You have evidence for that claim? No study I've seen seems to suggest there's any problem with sleeping more up to something like 12 hrs/night I think. National Sleep Foundation recommends 7-9 hours for adults, and I think I've seen studies suggesting that's on the low side. When you also account for natural variations within a population, a need for 10 hours of sleep doesn't seem ridiculous.

Pony is a programming language, so I take consistency to be about how consistent the pony programming language feels to the user (principle of least surprise, etc.). That said, I'm not part of the pony core team; if you really want an answer, you could stop by #ponylang on irc and ask.

Interesting that he hit on the top three points in the pony philosophy[1] but in a very different order than they chose. For pony, the order is:

1. Correctness

2. Performance

3. Simplicity

4. Consistency

5. Completeness

I think I tend to agree with that order more. While simplicity tends to be helpful with performance and correctness, there are very few cases where you'd sacrifice correctness/performance for simplicity if implementation time/cost were not a factor. Let's not confuse a way of getting to the goal with the goal itself.

> Incorrectness is simply not allowed. It’s pointless to try to get stuff done if you can’t guarantee the result is correct.

[1] https://www.ponylang.org/discover/

I had a brief dalliance with pony last year, though I wasn't coming at it from a systems perspective. At the time, it was the "lowest level" programming language I had used.

Maybe the author's perspective is just that much different from mine (he's used to things like C++ and Rust), but "simple" is just about the last word I'd use to describe pony. Don't get me wrong: Pony is a pleasure to work with, and it is no more complicated than necessary for the problem it's trying to solve, but adding the capabilities layer to the normal type system makes for a language that has a lot going on. I'd expect that the amount of fighting newcomers do with the capabilities system is similar to how people fight Rust's borrow checker. Maybe the author just didn't have enough actors that wanted to share state/communicate where it wasn't an issue for him.

In any case, I highly recommend anyone thinking about picking up a new programming language to give pony a look, especially if problems you're trying to solve are amenable to high levels of concurrency and need to run fast. The pony capability system basically eliminates data race bugs (within pony), and also guarantees against runtime crashes. It's got a bit of a learning curve, and the package ecosystem around it isn't great yet, but it's doing unique things to solve problems many languages aren't attempting to address.

What do you use to bridge sms to matrix? I've seen a couple projects people were working on, but some were very hacky, and the rest were lacking features.

I'm not super familiar with it, but ATS[1] might fit the bill in having dependent types and linear types but supporting both functional and imperative paradigms. It's pretty darn obscure, though.

[1] http://www.ats-lang.org/

You have a source on Gosling trying to get people not to use Emacs (not calling you out; just genuinely curious)?

Julia actually has that, though polishing is still ongoing. Checkout JuliaDB [0]. It works well for noodling around in a REPL but can also smoothly deal with huge data and processing distributed across multiple computers, all while leveraging the native Julia ecosystem which is much nicer than numpy and with lower overhead.

[0] https://juliadb.org

I'm pretty sure most Americans on first blush would see this as legal absurdity as well. Very biased sample size of 3, but everyone I've mentioned it to so far has seen it as such.

Isn't that exactly what v3 of the GPL does?

But the article was making a strong claim that this was the provably optimal solution. In this case it is, because the objective function (in the way I'm assuming they formulated the problem) is convex.

I thought the solution set had to be convex or concave for branch and bound to work as an optimization algorithm, and this one clearly isn't?

EDIT: Nope. It's just the objective function that needs to be convex, not the constraints.

The E2EE in matrix is actually based on the double ratchet from the Signal protocol. So you could think of the E2E in matrix as just a federated version of Signal. :)

When you add in queues for passing things back and forth between the async functions, I think this boils down to an Actor model. The nursery would be equivalent to supervisors in Erlang.

The REPL opened with org-babel-switch-to-session has been really buggy for me. Has it worked for you? Could just be because I'm using it with non-python kernels, which isn't well supported yet in general as far as I can tell.

Looks like that just calls make-comint-in-buffer eventually[1] with some fancy stuff to make sure it connects to the same jupyter server as being used for ein. Not sure I see a lot of utility there if I'm just wanting to run a jupyter REPL next to a regular code buffer or e.g. org-mode.

[1] https://github.com/millejoh/emacs-ipython-notebook/blob/cfd0...

What do you use for running the jupyter REPL in emacs? I haven't found a great way of doing so yet. Just running it in a comint buffer?