jbackus

    # 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.

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/

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

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.

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!