Pinned toot

Did you know that "toot" sounds just like Russian word for "here"?

I'm Alexander Batischev a.k.a. Minoru; you might've seen me on GitHub: github.com/Minoru I've been dabbling in functional programming for 7 years now. Mostly Haskell, but interested to learn from other languages as well. Hobbies for when I'm AFK: reading, cycling, pretending to learn how to draw.

Toot!

Minoru boosted

By default Gmail is scanning your bills for use in Google Search when you type in 'when should I pay a bill'

@ourmaninjapan says, “if they’re collecting this, what else are they collecting...?" @alixlangone on how to turn it off: money.com/money/5652229/when-s

Minoru boosted

Genie: You have ONE WISH.

Me: Alright, I have one, but it's very detailed.
Genie: As long as it is only one wish, you're allowed to spend as much time as you want detailing it.

Me: Alright, here we go. *Grabs notebook and takes a deep breath* The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL are to be interpreted as described in [RFC2119].

Genie: Wait, is that...?

Me: *Flips notebook* Chapter 1. Preamble.

Minoru boosted

When computers are involved in the inputs you experience, the outputs you produce, and your reasoning process, the distinction between those computers and you blurs considerably.

Increasingly, not having user freedom means not having agency. This work is critical.

2.17 had two regressions:
1. couldn't update feeds if `max-items` is set;
2. couldn't load configs if you have `#` in the middle of a command (*not* as a start of a comment).

Both are fixed with 2.17.1, please update: newsboat.org

Minoru boosted
Minoru boosted

"Free as in Sausage Making: Thoughts on Freedom within the Debian Project" by Sam Hartman hartmans.livejournal.com/99077

Time for your regularly scheduled update! 2.17 is available now: newsboat.org

There's a new feature that lets you save *all* the articles in the feed to text files. Plus a few bugfixes, and a little performance improvement.

Even if you don't do large-scale logging, read this. The strong engineering vibes will make it a pleasure, I promise. apenwarr.ca/log/20190216

This closing keynote describes how widely different runtimes—, Python, Node and more—can interoperate via WASM. There's a bit of history, and a demo that shows how easy it is to write a function in Rust and call it from, say, Python.

youtube.com/watch?v=KFpU30xlux

youtube.com/watch?v=YZomx3Jt4X is ostensibly about and co-existing, but the real point of the talk is what Rust can learn from C++ in terms of standardization. ISO owns C++ spec, and charges people to vote. ECMA is no better. The speaker urges Rust community to try and avoid this pitfall. They ran out of time, so check out the slides: github.com/slurps-mad-rips/rus

They invited people to tweet questions under hashtag 123GottaCPP.

Right now, compile-time evaluation (`const fn`s) in are *very* limited in what they can do, but the work is underway to fix some of it. The talk goes in-depth, explaining which limitations are here to stay and which ones will be lifted eventually.

The speaker asks to open an issue if:

1. you want something in std to be `const fn`, since it's often easy to fix;

2. something doesn't work as `const fn` and you think it should.

youtube.com/watch?v=wkXNm_qo8a

crates.io/crates/moxie is a UI toolkit. I admit I didn't follow too closely, but it seems like it's following in the steps of virtual DOM approaches popularized by Elm, React and such.

The author points out that existing UI frameworks (not just for Rust) are huge beasts, doing far more than putting pixels on the screen. So don't expect to see a full-fledged Rust UI framework anytime soon.

youtube.com/watch?v=tmM756XZt2

A member of Rust-embedded WG gives a short recap of Rust on embedded platforms (think STM micros and kilobytes of memory, not RPi). Then explains how they went about displaying stuff on a VGA monitor (not as trivial as it might seem! E.g. four clock cycles per pixel, not enough memory, synchronization woes). Interesting tidbits.

And of course there is a demo. The live-demoing gods were kind to this one, and everything went smoothly.

youtube.com/watch?v=PXaSUiGgyE

There is a dashboard for MongoDB called Compass. The speaker rewrote one of the tabs in the dashboard to speed it up; on 10k documents, JS took 121 seconds and (via ) took 3.

It's a quite in-depth talk on what problems transpired in the process, both inside Rust and on the boundary with JS.

If you aren't interested in Wasm, you won't loose anything if you skip this talk.

youtube.com/watch?v=lLzFJenzBn

This is a success story of using at Facebook. To be introduced at the company, new language "has to be 10x better at *something*, and no worse on everything else".

They wrote a high-perf Mercurial backend as their test project. Then expanded into other teams. Python programmers are the most enthusiastic adopters so far; Node/JS devs follow.

Closes with reflection on how to expand to non-fans (same as mentioned in the keynote).

youtube.com/watch?v=kylqq8pEgR

Contributing to compiler sounds like a daunting task, but this talk shows how it's not as complicated as might seem. In 18 short minutes, you'd see how one might progress from finding an issue, to figuring out where the code is, to implementing a fix, and finally submitting a pull request.

This is as much a performance as it's a talk; you might watch it just for the fun of it. (And maybe you'll end up working on Rustc :)

youtube.com/watch?v=KJ-V2BOtZn

crates.io/crates/tracing (formerly tokio-trace) is a crate for structured logging, especially in asynchronous code. Logging in async is challenging because context and cause-effect chains are less obvious than in serial code. It also provides as alternative interface equivalent to "log", so you can move to "tracing" easily and then start exploring the niceties it provides.

youtube.com/watch?v=JjItsfqFId

The speaker wanted a hobby that's unrelated to work. Trying out pottery taught them they wanted something physical, yet with short feedback cycle and preferably with an "undo" button. Enter generative art with pen-plotting.

The rest of the talk is a mix of images with some commentary of how adding constraints, getting inspiration from other mediums, and improving your tooling really helps create something beautiful.

youtube.com/watch?v=Ho3xr4b60Z

The point about scripting languages is not novel though. I first read about it in ESR's blog titled "The long goodbye to C": esr.ibiblio.org/?p=7711 There, the author notes how despite his decades of C experience, he prefers to write new software in Python if he can (with a lot more factual arguments than I can fit here). Regardless of your opinion of ESR, that post (and the other two in the series) are worth a read IMHO.

Show more
Functional Café

functional.cafe is an instance for people interested in functional programming and languages.