randomThoughts9

You might be able to give up control over something, but never the responsibility that comes with it. So in this particular case, we are free to let the algorithm decide for us, but we should all be aware who will suffer when the algorithm goes haywire. It's that simple.

Comment · 9 years ago

Someone posted this link on reddit today.

https://think.ing.com/uploads/reports/171218_Why_Bitcoin_to_...

Comment · 9 years ago

This is a very recent interpretation. It is legally true, but it goes against the true meaning of the word.

When you work for a charity, do you ask for a raise? Do you get a bonus if you collect more money? How much to you get to keep?

Not even mentioning that sometimes the money goes through a chain of charities, all making a living out of it, but leaving almost nothing for the final beneficiary.

Comment · 9 years ago

Not trying to defend Roger Ver, but that is an awful interpretation. He wasn't shaming anybody for being poor.

He was just trying to emphasize, what in his view is a discrepancy between what some people preach and what they do.

Comment · 9 years ago

> This is unprecedented.

Don't get me wrong, I like Kotlin, but Ceylon did the multi platform thing much better.

They have real platform modules, built into the language (not just a build tool trick), and a language specification that was written from the start with multiple platforms in mind.

But it never took off (yet), and Kotlin's support is good enough, so it will have to do I guess :).

Comment · 9 years ago

That's not entirely true. Only in the blockchain world there are two Rust projects I know of:

- the parity ethereum client: https://github.com/paritytech/parity

- the exonum framework: https://exonum.com/

Comment · 9 years ago

I agree and I appreciate what they are trying to do.

But just as a counter-argument, look how a simple lock looks like in Rust [1]:

  fn main() {
      let counter = Arc::new(Mutex::new(0));
      let mut handles = vec![];

      for _ in 0..10 {
          let counter = counter.clone();
          let handle = thread::spawn(move || {
              let mut num = counter.lock().unwrap();

              *num += 1;
          });
          handles.push(handle);
      }

      //...
  }

[1] https://doc.rust-lang.org/book/second-edition/ch16-03-shared...

----- edit: Just to clarify my point. The ownership model is a beautiful solution to the resource management problem. And as the parent pointed out, some concepts can be cleanly borrowed/reused in other languages.

But now, in Rust, in practice, you realize that this model requires a lot of boilerplate code just to make the borrow checker happy, even for simple things like using a lock: create Arc(Mutex(data)); clone the arc reference; move the new Arc reference to the new thread.

Comment · 9 years ago

Well, a fun fact: there is nothing funny about that list :). It should have been called "Some facts about Rust's growing popularity".

Now, my predicament: I love Rust's type system and tooling, but it's really hard to justify to myself the pain of writing correct Rust code (borrowing, lifetimes, etc.) when I know I can get almost the same effect by using a GC language + immutable messages.

And I don't need that last drop of performance either.

So if you just want a native language with a good type system and a growing ecosystem, where do you go? Still Rust or something else?

Comment · 9 years ago

> Inequity doesn't mean much wrt Bitcoin IMO.

I'm sorry, but you can't brush that subject off with a single sentence. It's a huge problem. If you want a real currency, that is.

You might hope that the free market will fix this problem, but I have my doubts. The current whales don't have a real incentive to sell.

And if Bitcoin would reach its goal, we would have some new, anonymous and untouchable overlords that would make the feudal ones look like amateurs. No thanks.