karlding

There isn't any steganography (at least for the flag that I found). They have a bot that actually "reads" your post, which you can verify for yourself. This is alluded to in the message that you get when submitting a post:

> Your post was submitted for review. Administator will take a look shortly.

Threads as first class citizens is something that Zulip [0] focuses on, which makes it much easier to have multiple conversations within the same space. It also makes it easier to ignore any conversations you don't care about.

This avoids the problem with Slack where some people might use the threading features, while others ignore it. Personally I'm a huge fan of Zulip, having used HipChat, Slack, Mattermost, Skype for Business, and Discord in the past.

[0] http://zulip.org

I believe they have migrated most (if not all) of their storage off AWS to their own infrastructure [0].

[0] https://techcrunch.com/2017/09/15/why-dropbox-decided-to-dro...

You mentioned EV certificates, but are those actually still meaningful? Troy Hunt wrote a series of articles [0][1][2] about the perceived value of Extended Validation certificates, and concluded that they were essentially useless.

Does anyone else have additional data for/against EV certs nowadays?

[0] https://www.troyhunt.com/on-the-perceived-value-ev-certs-cas...

[1] https://www.troyhunt.com/extended-validation-certificates-ar...

[2] https://www.troyhunt.com/paypals-beautiful-demonstration-of-...

I don't work as an SRE, but isn't that covered by providing engineers physical access to secure facilities in the absolute worst case?

The article states:

> The defense in depth philosophy means we have robust backup plans for handling failure of such tools, but use of these backup plans (including engineers travelling to secure facilities designed to withstand the most catastrophic failures, and a reduction in priority of less critical network traffic classes to reduce congestion) added to the time spent debugging.

> For example: It seems ridiculous now, but at one point authors were significantly squeezed by commercial distros offering support and feature work directly to customers for their packages.

Something similar was discussed a few weeks ago with respect to procps [0] and the struggles of maintaining Open Source projects.

[0] https://news.ycombinator.com/item?id=19936320

Maybe you should use BikeshedDB [0] instead?

[0] https://github.com/tschottdorf/bikesheddb

What if you simply worked on the AST/token level and converted that into pseudocode, assuming you either annotated your functions with a description or named them following some sort of convention? Then you could write your code and then "compile" your source files to pseudocode.

Seems like this could be useful for writing specification documents or anything safety critical..

18650 describes the form factor of the cell (18 mm in diameter and 65 mm in height), much like you have AAA batteries.

According to Apple's MacBook Pro marketing page [0], their SSD supports sequential read speeds of up to 3.2GB/s. So this isn't as far-fetched as you imply, even if we're discounting other factors like the filesystem cache.

[0] https://www.apple.com/macbook-pro/

> Their self driving tech is built on top of Baidu's open source platform and another open source platform with only 1 year of development with a huge team. A recipe for disaster.

I assume you're talking about Apollo [0]. Out of curiosity, what's the other open source platform you've mentioned? Do you have any sources?

[0] https://github.com/ApolloAuto/apollo

Isn't that situation only possible if config.push is set to matching? As far as I know, it's been set to simple by default since Git 2.0 [0].

[0] https://git-scm.com/docs/git-config#Documentation/git-config...

Yeah, there's quite a few companies that are working on a similar product, including PlayStation Now (Sony) [0], GeForce Now (NVIDIA) [1], and Shadow [2].

[0] https://www.playstation.com/en-gb/explore/playstation-now/ps...

[1] https://www.nvidia.com/en-us/geforce/products/geforce-now/

[2] https://shadow.tech/int

For what it's worth, North recently laid off 150 of their employees [0] and the Canadian government is pulling their 18 million investment [1] in the company. There's some discussion about this on the /r/uwaterloo subreddit [2], as well as the regional /r/waterloo reddit.

[0] https://www.theverge.com/2019/2/22/18236253/north-focals-sma...

[1] https://www.theverge.com/2019/2/22/18236695/north-focals-lay...

[2] https://www.reddit.com/r/uwaterloo/comments/aubwpm/north_tha...

The Chromecast Audio also supports Optical Out via TOSLINK, allowing you to bypass the built-in DAC and use your own, if you so desire.

Sounds like what you want is fuzzy searching (say fzf [0]) over autocomplete suggestion results. You could type the prefix, and then fuzzy search by typing the suffix to get your desired word (while letting autocomplete fill in the middle of the word).

[0] https://github.com/junegunn/fzf

This [0] one about Twitter? Not a security breach, but users' passwords were being written to a log file before hashing.

[0] https://news.ycombinator.com/item?id=16989534

On bash, this assumes that $HISTCONTROL is set to ignoreboth [0]. This is in the default ~/.bashrc on Ubuntu, but I can't speak about other distros.

I don't use zsh, but I believe the equivalent is $HIST_IGNORE_SPACE [1].

[0] https://linux.die.net/man/1/bash

[1] https://unix.stackexchange.com/questions/6094/is-there-any-w...

Peter Buhr also teaches CS 343: Concurrent and Parallel Programming [0] at the University of Waterloo in a dialect of C++ that he has been working on [1], called uC++ [2].

[0] https://www.student.cs.uwaterloo.ca/~cs343/

[1] https://github.com/pabuhr/uCPP

[2] https://en.wikipedia.org/wiki/%CE%9CC%2B%2B

You may want to tell your CIO to check out BikeshedDB [0], which is built exactly for this use case.

[0] https://github.com/tschottdorf/bikesheddb

The main problem was that they ran out of runway while waiting for manufacturers and suppliers to line up and meet their demand. The software was solid, but for hardware products, that's less than half the picture. You need to worry about coordinating with suppliers, factories, and all these other logistical issues to produce a product a scale. If a supplier is unwilling to meet your demand, you're basically screwed and are left waiting indefinitely, unless you immediately pivot on your hardware design.

They're taking the multiset [0].

So it's \binom{2^4 + 4 - 1}{4} = 3876

In other words, there are 3876 multisets of cardinality 4 with elements taken from the set containing all 4 bit values.

[0] https://en.wikipedia.org/wiki/Multiset

Out of curiosity, how is the embedded story (for both bare-metal and RTOS) in Rust nowadays? I took a look early last year, and I remember feeling that the ecosystem still wasn't as mature as I liked.

There's svd2rust [0] and dslite2svd [1], which is basically "bindgen for hardware". Please do correct me if I'm wrong, but from what I understood [2], most SVD files leave out a lot of information so a lot of what svd2rust generates is unsafe. Seems like the only way around that is to patch the SVD files. Is this still the case?

In addition, what about compiling with no stdlib? And how does that interop with existing Crates (ie. do new "embedded-specific" Crates need to be created?)

Super excited to see Rust gain traction! I'll definitely take another shot in my free time and see how the ecosystem has matured.

[0] https://github.com/japaric/svd2rust

[1] https://github.com/m-labs/dslite2svd

[2] https://www.reddit.com/r/rust/comments/687b3l/embedded_in_ru...

An example of when you might use this is when you're cutting over to a new service, and you want to validate that the new service behaves the same way as the old one before transitioning all the traffic to the new service. In order to build confidence in the new service, you can assert that the expected output is the same, and raise alerts when there is an inconsistency. This incremental rewrite approach allows you to slowly replace pieces of an application with a new service and helps prevent regressions in behaviour.

Or consider when you're performing a database migration (on large databases) with 0 downtime. Typically this involves something like:

1. Dual Writing: Create 2 tables and write to both and keep them in sync (by duplicating new data, and back-filling old data)

2. Update read paths: Change all code to read from the new table, and validate that the data being read is consistent with the old table. You can use a library like Scientist [0] to validate that the reads are the same.

3. Update write paths: Change all code to write to the new table (and raise alerts if the old path is exercised)

4. Deleting old data: Remove code and data that relies on the old data model

[0] https://github.com/github/scientist

For bash users, that assumes that the HISTCONTROL [0] environment variable is set to ignorespace (or ignoreboth).

[0] https://www.gnu.org/software/bash/manual/html_node/Bash-Vari...

That's basically what postmortems are! For those unfamiliar with the term, postmortems are a written account of an incident, its impact, the actions taken to resolve resolve it, root causes, and identifying any follow-up actions to prevent the incident from recurring.

I think postmortems should be a valuable learning opportunity for the entire company, and are by no means a punishment. In an organization that fosters "blameless culture," this allows the organization to grow and to identify and fix a weakness.

Google's SRE book [0] also talks a bit about this in the chapter about Postmortems.

[0] https://landing.google.com/sre/book

A quick and dirty way of doing it, assuming the currently active pane is the one you want to copy text from:

1. Enable pane zoom (<prefix> z)

2. Enter copy mode (<prefix> [)

3. Select and copy text

You can also look into the tmux-yank [0] plugin, which copies to the native system clipboard.

[0] https://github.com/tmux-plugins/tmux-yank

You may want to check out BikeshedDB [0], which is built exactly for this use case.

[0] https://github.com/tschottdorf/bikesheddb

I've always found "A Painless Guide to CRC Error Detection Algorithms" [1] from the zlib site pretty useful and easy to understand. Once you understand polynomial division, things start making a lot more sense.

[1] https://zlib.net/crc_v3.txt

Safari still does not support WebRTC, and users must enable Flash on sites that require it. They've merged in a few commits [1], but their implementation is still lacking [2].

[1] https://trac.webkit.org/changeset/210942 [2] http://caniuse.com/#search=webrtc