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: https://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.
Interesting tidbit of history: Unix creator's passwords, cracked by modern hardware https://fossbytes.com/unix-co-founder-ken-thompsons-bsd-password-cracked/
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: http://money.com/money/5652229/when-should-i-pay-my-bill-google/
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.
"Free as in Sausage Making: Thoughts on Freedom within the Debian Project" by Sam Hartman https://hartmans.livejournal.com/99077.html
Even if you don't do large-scale logging, read this. The strong engineering vibes will make it a pleasure, I promise. https://apenwarr.ca/log/20190216
This closing keynote describes how widely different runtimes—#Rustlang, 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.
https://www.youtube.com/watch?v=YZomx3Jt4Xs is ostensibly about #Rustlang and #Cpp 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: https://github.com/slurps-mad-rips/rustconf-2019/blob/master/content/_index.md#standards-vs-specifications
They invited people to tweet questions under hashtag 123GottaCPP.
Right now, compile-time evaluation (`const fn`s) in #Rustlang 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.
https://crates.io/crates/moxie is a #Rustlang 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.
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.
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.
This is a success story of using #Rustlang 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).
Contributing to #Rustlang 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 :)
https://crates.io/crates/tracing (formerly tokio-trace) is a #Rustlang 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.
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.
The point about scripting languages is not novel though. I first read about it in ESR's blog titled "The long goodbye to C": http://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.
functional.cafe is an instance for people interested in functional programming and languages.