jbackus

Very nice. I've been using https://screenotate.com/ for years in part because of the nice OCR support

Having your business beholden to any app store is a bit scary, but Google's chrome web store is probably the most precarious. As far as I can tell, almost every negative action taken against you is done in an automated fashion, with basically no human recourse beyond knowing someone on the inside or hoping for a negative PR cycle.

At least with the mobile app stores, a good review process with some human recourse is baked into the incentives of the platform, since lots of money is involved.

With the Chrome web store, you get the feeling it is just there because Google capitulated in the past, acknowledging that browser extensions are necessary to be a mainstream browser. Beyond that, it seems to be moderated with two goals: reduce overhead cost and mitigate any security threats.

The result is the complaints you hear from every extension developer:

* Google arbitrarily blocks a decent % of updates, because of automated flagging

* Google removes extensions with basically no recourse, often for unclear reasons

* Google itself (if I remember correctly) even recommends using a Google account separate from your personal/work email, since often these automated suspensions take down the account connected to it too

Don't get me wrong, browser extensions have a lot of power and that's often an issue (malware, browser history collection, phishing, etc). Still, building an extension for Chrome involves the constant reminder that you are under the thumb of a big monolith organization that is indifferent to you.

Nope. If you read the post, you'll see he mentions that it isn't related to uglification. It's a definition of unicode characters

Another cool way you could do this: Ruby methods can ask for their caller_locations. They work like this:

    # Source

    $ cat example_for_hn.rb
    def foo
      bar
    end

    def bar
      baz
    end

    def baz
      (c1, c2) = caller_locations.first(2)
      puts "Parent caller:      '#{c1.label}' in '#{c1.path}'"
      puts "Grandparent caller: '#{c2.label}' in '#{c2.path}'"
    end

    foo

    # Demo

    $ ruby example_for_hn.rb
    Parent caller:      'bar' in 'example_for_hn.rb'
    Grandparent caller: 'foo' in 'example_for_hn.rb'

    module Shitlist
      def shitlist(method_name, whitelist)
        original_method = instance_method(method_name)
        undef_method(method_name)

        define_method(method_name) do |*args, &block|
          call = caller_locations.first
          passes_whitelist = whitelist.any? do |label, file_pattern|
            call.label == label && call.absolute_path.end_with?(file_pattern)
          end

          unless passes_whitelist
            fail "Shitlisted method! Permitted callers: #{whitelist}"
          end

          original_method.bind(self).call(*args, &block)
        end
      end
    end

    class Example
      extend Shitlist

      def not_on_shitlist
        qux
      end

      def baz
        qux
      end

      def qux
        puts 'Only some methods can call me :)'
      end
      shitlist :qux, 'baz' => 'shitlist.rb'
    end

    $ ruby shitlist.rb
    Only some methods can call me :)
    Traceback (most recent call last):
      2: from shitlist.rb:44:in `<main>'
      1: from shitlist.rb:25:in `not_on_shitlist'
    shitlist.rb:13:in `block in shitlist': Shitlisted method! Permitted callers: {"baz"=>"shitlist.rb"} (RuntimeError)

Of course, you might not want this hijacked method with tracing inside something performance critical. You could always configure the implementation to be a no-op in production.

I had the privilege of seeing Jeffrey do multiple live performances of his software (demoed @ 9:20) at different Internet Archive events while he was the artist in residence.

Each time, I got the delightful feeling that I was witnessing something special (and, of course, very weird in a good way). The performance is legitimately "live" in that he's creating new images from scratch, and it seems clear that he's able to build up this rich imagery from what seem like a handful of solid composable building blocks in his software.

I always found those performances inspiring in a similar way to how I feel the times I have visited DynamicLand. A wonderful blend of the physical medium and alternative ways of thinking about computers that produce such an interesting result, making me glad people like this exist in the world.

Yeah, I don't remember any of the Ruby tooling ecosystem maintainers having nice things to say about the various syntax changes they've added over the years. I don't blame them.

These changes are always justified with a hand wave and a reference to "developer happiness" and ergonomics. I think that justification is seen as insulting when all the static/dynamic analysis tools obviously actually deliver a lot of value to Ruby devs, and yet the basic tooling to support this ecosystem (robustly parsing, traversing, annotating, rewriting, and unparsing an AST) is not provided by the language.

Yeah. Been years since I even played with it, but even in 2016 I remember Ripper being completely unusable, failing to parse plenty of normal Ruby syntax. The Parser gem also maintains a separate parser for every Ruby version, so you can a program using Ruby 2.5 but tell it to parse code according to Ruby 2.2 syntax. It's also just way better built, tested, and has other nice features like tools for rewriting ASTs.

Ruby's parser is notoriously complex; if I remember correctly, only a few members of the core team even know how to maintain it without introducing regressions.

The craziest part of this is that Ruby does not provide a full featured Ruby parser, so its entire static and dynamic analysis ecosystem depends on a (actually very high quality) 3rd party parser, begrudgingly maintained by someone who (AFAIK) doesn't even write Ruby anymore: https://github.com/whitequark/parser

When I see new language features like this, I think of how Ruby's entire tooling ecosystem depends on the dramatically underfunded (and therefore primarily goodwill) efforts of high output maintainers like whitequark and a few others. Ruby's highly dynamic and untyped nature means these tools are all the non-runtime guarantees you can get, basically. Epitome of digital infrastructure.

Consider asking your company to fund some of these people:

* https://github.com/whitequark (maintains parser)

* https://github.com/sponsors/bbatsov (maintains RuboCop)

* https://github.com/sponsors/mbj (maintains unparser and mutant)

---

As context, I know this stuff intimately because I used to contribute heavily to most static and dynamic analysis tools in the Ruby ecosystem (https://github.com/backus?tab=overview&from=2017-12-01&to=20...) and used to track new ruby changes really closely: https://cognitohq.com/new-features-in-ruby-2-4/

I'm building Jam (https://jam.link/) to tackle this problem. You can think of it as a consumer password manager built specifically for sharing.

It's fully frontend encrypted, so Jam doesn't know what logins you save and it can't read your secret credentials. The cryptography is based on 1Password's design (https://1password.com/files/1Password-White-Paper.pdf). I'd be happy to share details if people are curious.

Jam's focus on sharing comes through, right now, in the UI and default behavior. For example, when you save a new login, your friends in the system can proactively request access. To visually illustrate that: If I save a new login to Jam (like so https://i.imgur.com/syM2bep.png) then my friend gets a notification about that account, can see what it is (https://i.imgur.com/ZUKwfBB.png) and can request access (https://i.imgur.com/3SCcBm5.png).

It's in private beta right now, it's free to use, and I'm looking for as much feedback as possible. I'm happy to add people from HN right away, just email me at john at jam dot link

Author here, thanks for reading!

Regarding "decentralization can only exist to circumvent the law", I don't think that in the long term (>5 years out). I touched on this a bit in another comment: https://news.ycombinator.com/item?id=17641098

Regarding privacy, I'm with you there, but I'm very skeptical that very fuzzy privacy concerns can switch enough people away centralized systems with network effects (FB, Twitter, Reddit, YouTube). I think these systems will see adoption from a few groups:

- Privacy advocates and people otherwise interested in the tech by itself - Ostracized groups. For example, see how Voat (not a decentralized system, but an example of a Reddit clone with a ideological mission) wound up as a hub for the alt-right. - The most extreme people trying to boycott platforms like Twitter. For example, people demanding way more censorship from Twitter that are trying to make Mastodon happen because it has content warning stuff and other anti-harassment stuff from what I've heard - Communities that are forced out by the law, like r/DarknetMarkets moving to Dread: https://medium.com/@jbackus/minimum-viable-decentralization-...

So, subcommunities definitely will exit I think but whether they go to other centralized systems depends on UX (which is harder with decentralization) unless a legal reason makes decentralization the only option.

Author here. I'm mainly writing about decentralization that is supposed to be mainstream while also looking for historical examples. With that in mind, I've looked at:

- Dozens of file sharing apps and their protocols (focus on Napster, Gnutella, FastTrack, and BitTorrent) - Tor, I2P - Tor hidden services - Original p2p Skype

If we generalize "decentralization" into "creative uses of distributed systems and/or cryptography for the sake of privacy and resilience" then we can include a bit more:

- PGP - Willfully blind centralized systems like mega.nz

Then finally if I dip into older attempts that IMO didn't get real adoption, we can include some other interesting examples:

- Freenet - Tribler - Mojonation

There are systems like Diaspora and Mastodon, but they're too close to the present IMO to use as historical examples. There are also obviously decentralized/distributed systems that serve as the backbone of the internet and I do want to allocate more time to learning these deeper, but they don't feel the same.

---

Anyways, I'm not even really disagreeing with you but mainly trying to point out that I'm trying to draw from as much as possible. The original Skype stands out as a case where it seems to have no relationship with the law (https://twitter.com/backus/status/1014726515592818688).

If you have examples (failed or successful) that you recommend looking into, I'm all ears. As I've pointed out in a few other places, my point regarding the law isn't to say that this is all decentralization will ever be for. Instead, I'm saying this seems like the main point in the past for mainstream applications. Maybe decentralized apps will work as well as centralized apps in the future, but it seems like this might be far enough out that it would be incredibly risky for a startup to decentralize today when it doesn't need to.

I could say more, but this is already a lot. Thanks for reading my article!

Another interesting project is RDL: https://github.com/plum-umd/rdl

Both Diamondback and RDL come out of UMD. I'm curious what drives this research there. From what I can tell, Ruby is barely touched otherwise by academia.

First of all that is an interesting point. Given that it isn't as potentially dangerous I'll agree that it is less bad than I initially thought.

I'll respond to your question by asking you a question. Which of the following expressions evaluate to "truthy"?

    'truthy' if (a, b = [])              # =>
    'truthy' if (a, b = nil)             # =>
    'truthy' if (a, b = [nil])           # =>
    'truthy' if (a, b = [nil, nil])      # =>
    'truthy' if (a, b = [false])         # =>
    'truthy' if (a, b = [false, false])  # =>
    'truthy' if (a, b = [true, false])   # =>
    'truthy' if (a, b = [false, true])   # =>
    'truthy' if (a, b = *[])             # =>
    'truthy' if (a, b = *nil)            # =>
    'truthy' if (a, b = *[nil])          # =>
    'truthy' if (a, b = *[nil, nil])     # =>
    'truthy' if (a, b = *[false])        # =>
    'truthy' if (a, b = *[false, false]) # =>
    'truthy' if (a, b = *[true, false])  # =>
    'truthy' if (a, b = *[false, true])  # =>

Ah well "You probably shouldn’t do that though" is just my opinion as the author. I didn't play a part in these changes. I just like Ruby enough to dig into their changelog :)

I don't know if he has written about it beyond the docs and various commits. He has talked about it many times on his podcast (which I highly recommend). Here is an episode that talks about the attributes API as well as his Relation#or work: http://bikeshed.fm/8

Definitely also checkout the episodes where he talks about Diesel.

I feel bad for Sean Griffin. He spent over a year overhauling the internals of ActiveRecord to add this attributes API. His work dramatically improves coercion and type enforcement for ActiveRecord users. Seems weird for this to only get a non-descriptive bullet point in "other highlights."

Here are the docs if anyone is interested: http://edgeapi.rubyonrails.org/classes/ActiveRecord/Attribut...

Author's other projects are pretty interesting too: https://rsnous.com/

This is very common across most psychology studies from what I understand.

In the Journal of Personality and Social Psychology, the premier journal in social psychology – the subdiscipline of psychology that should (arguably) be the most attentive to questions about the subjects’ backgrounds – 67% of the American samples (and 80% of the samples from other countries) were composed solely of undergraduates in psychology courses (Arnett 2008). In other words, a randomly selected American undergraduate is more than 4,000 times more likely to be a research participant than is a randomly selected person from outside of the West.

Source: http://hci.ucsd.edu/102b/readings/WeirdestPeople.pdf

This is a great post. I'd love to hear more about multistage zaps people use. I'd also enjoy a post that talked about different zaps that zapier uses in house.

We use blazer[1] which is open source and lets you share queries just like this video demonstrates. It also has other nice features like composing results into charts and allowing interpolated values for generating queries with variable inputs. The demo[2] has examples for the features I mentioned.

1: https://github.com/ankane/blazer

2: https://blazerme.herokuapp.com/

He taught statistics at Stanford for a few years. He also taught startup engineering (CS184) before doing the MOOC.

too many brains and dollars have been shoveled into resolving what I call ‘anti-problems’ – interests usually centered about food or fashion or ‘social’or gaming

A few things come to mind when I hear people say things like this:

1. This type of complaint usually indicates observer bias. People don't read about, or share, news about boring industries. Go look at the last 25 investments on https://twitter.com/VCdelta and see how many are truly "anti-problems."

2. People who look down their nose at entrepreneurs who don't pursue "Big Problems" probably don't realize how hard the "Small Problems" actually are.

3. If you think smart people are missing out by not pursuing some massive task, like helping veterans, then I have good news for you: that means you believe there is an opportunity for someone to improve society and make a lot of money in the process. Go invest your time and/or money, improve the world, and reap the rewards. If you don't know how to fix the problem then maybe things aren't as simple as people choosing not to make the world better. If you know how to fix these issues, but you don't know how to make money doing so, then you are really just saying that investors should instead be philanthropists. If you don't think you're smart enough/strong enough to solve these problems then maybe you shouldn't be telling others you know what is best.

How close is this fork to the original source? The folks behind the Open Crypto Audit Project[1] have done a fantastic job auditing the security of Truecrypt and they're now doing the cryptanalysis. While an actively maintained fork is desirable, changes to the core dependencies will eliminate the benefits of the audit.

[1] https://opencryptoaudit.org/

Dynamic finders in Rails 3.1's ActiveRecord: http://git.io/hdb0QA

This is great. Thank you.

Can we get the source for this extension? It gets access to all website data so there really should be some verifiable source included.

Yes, I'm glad he isn't dismissing them. I'm just saying that it isn't as simple as returning profits to the producer.

Don’t concert ticket re-sale sites like StubHub encourage and take a cut from scalping? Yes, and I’m not a big fan of them for that reason. If the demand for a band’s ticket is high, they’re the ones that should be making the mark-up, not some sleazy guy with 20 computers who bought 40 tickets the second they went on sale to turn around and flip them. But at least that guy has to bet his own money that he can resell a private commodity he bought.

This is a weird opinion. This kind of resale is common in markets where producers would rather guarantee selling their entire product at a certain price as opposed to risking overpricing. Same reason many farmers sell off crops immediately to middlemen instead of trying to maximize price selling directly. They aren't being exploited, they're hedging risk. I would imagine that centralized ticket websites like StubHub also improve the venue's distribution in this case. If venues don't like resellers, they can follow Louis CK's actions[1].

[1] http://thenextweb.com/media/2012/07/03/louis-c-k-sees-ticket...

How funny you find it is mostly a function of how much hair you've pulled out working with systems.

It depends on the drugs. There are a lot of cases of producers selling on these market places. Look at a lot of the marijuana vendors, the vetted LSD vendors, the mushroom vendors, etc. Beyond that, there is violence involved in later steps of the drug trade: smuggling, gang turf wars.