YanTheFawn

Want to preface this with some info - I have been a big fan of Ethereum since I deep dove into it in Jan 2021. I became captivated by al of the beautiful concepts proposed by the new tech:
1) smart contracts (integrity by auditable code), 
2)stable coins (so that transactions could happen stably),
3) transparent transactions ("cant be evil > dont be evil"),
4) ability to own one's own data
5) the breaking of siloed databases
6) digital identity backpacks to potentially remove friction such as constantly filling out forms with the same information each time we go to the doctor's office or sign up for a new platform by housing it on a 
7) credibly neutral substrate (with presumable privacy components when armed with ZKP's),
8) true provenance in the form of NFTs, and a potential world of building true online identities via attestations. 
That said, this past year has shown me some painful realities of the landscape as it is:

YanTheFawn

My criticisms of crypto as it is today, Nov 2022:

1) There isn't much product market fit to date - aside from price speculation and fascination with the tech itself, ask yourself, do I actually use this tech for a daily need? To get coffee, to pay a friend, for social media, for streaming services
2) The UX is, generally speaking, terrible - I think we can all agree that the most common products (i.e. Metamask) are terrible to use
3) The space has many centralization vectors - proof of stake (look at the largest staking services and the % of the network they represent), wallet services, RPC services (the degree of which they are hosting nodes on Amazon cloud), NFTs largely pointing to centralized servers, centralized UI's, stable coin companies being centralized and being vectors for fraud/government freezes. Even DAI's collateral is heavily backed by centralized stables.
4) The space feels incredibly circular - i.e. Defi is the act of trading one speculative token for another speculative token.
5) The space

YanTheFawn

 rough draft idea for a crypto weapon that uses game theory to overthrow Putin.

Assuming Putin doesn’t want to negotiate - the next least catastrophic solution to ending the war would arguably be an internal majority uprising. Why this isn’t already happening could be modeled in the following game theory game:

Take a game of 101 participants that models an autocracy. Let’s say these are the rules:
* You have two actor types: 1) a king 2) the subjects
* The game goes in rounds - first the subjects act, then the king acts.
* The subjects are allowed to object, but cannot coordinate in advance. If 50 or more of the subjects object the king “loses”, and the subjects “win”, and the game is over.
* The subjects have to write their choice on a private card, and then show their cards all at once. The collective utility points gained from the objecting subjects is (n^2), where n is the number of objecting subjects. Each individual experience the collective utility points. So if 50 subjects object, they all experienc

YanTheFawn

How Google works:

Phase 1 - Discovery
Google needs to first discover all the webpages that exists.
In order to discover new webpages, there are two ways Google would generally do this:
  1. They work with major web hosts (e.g. GoDaddy, Amazon Web Services, Wix, etc), and get informed of new webpages uploaded to the host by people like you and me. 
  (if you’ve ever made a website before, to actually put it on the internet you know you’d have to upload it to a host company)

   2. Using software programs called “bots”, they scan previously identified webpages (perhaps from step 1) regularly, searching for possible links to new pages.

YanTheFawn

public class App 
{
    public static void main( String[] args )
    {
        foo("testing");
      
    }

    public static void foo (String string)
    {

YanTheFawn

class Range
  def oscillate(num_times: 1)

    previous_value = nil

    num_times.times do |index|
      first.upto(last) do |value|
        #protect against repeat values, since 
        #each oscillation directions don't know
        #about the other, and will otherwise

YanTheFawn

I'm using the SC api, and I just had a question for you guys!
I'm noticing from the example in the docs that one has to instantiate a player every time one streams a new track: 

e.g. 
SC.stream('/tracks/293').then(function(player){
  player.play();
});

In my current implementation, I'm invoking the above every time a new track is played (with the new url stream replacing the old)
- is this the intended use, or is there a way of pulling in the next stream without the overhead of reinitializing the player all over again? If not, it seems like I would have to re-attach all my event handlers to the new player instance every time a user clicks to a new track, which

YanTheFawn

irb(main):001:0> module Dog
irb(main):002:1> def bark
irb(main):003:2> puts 'woof'
irb(main):004:2> end
irb(main):005:1> end
=> :bark
irb(main):006:0> module Yanik
irb(main):007:1> include Dog
irb(main):008:1> end
=> Yanik

YanTheFawn

class NumberThing
  def return_number
   return 12
  end
  
  def test(new_number:true)
    if new_number
      return_number = 5
    else 
      return_number

YanTheFawn

var bulletinApp = angular.module('bulletinApp', ['ngResource']);


bulletinApp.controller('PostsCtrl', ['$scope', 'Post', function($scope, Post){
  this.heading = 'Bulletin Board';
  this.posts = Post.query();
  
  var PostsCtrl = this;

  this.create = function(){