tav

Thanks for being so generous! Here's $500 from me:

https://imgur.com/gallery/qGBGwXc

Great work — the functional spin on top of Rebol's clean syntax is really nicely done!

Any chance you'll be adding something like the parse function? The ability to have domain-specific dialects was one of the best things about Rebol and would be great to see in a modern language.

And speaking of functions, could you make the "Function Reference" that's on the homepage, be available on a standalone page too? It's a very useful reference and would be great to access it easily. Thanks!

Over the last decade, Redis has been my go-to example of beautifully written code. Thank you for such an amazing creation @antirez, and best of luck for whatever you do next.

Could you elaborate on the "fundamental, serious limitations" by any chance?

In the off chance that some Rust developers are looking at this thread, I'd like to put forward a counter-proposal:

1. Use a postfix ?! instead of .await

2. Use a postfix ?? instead of .await?

3. Use the await keyword only in the "for await" construct

Then the common case becomes:

    let resp = http::get(url)??.to_string()

Which, imo, is a bit easier to parse than:

    let resp = http::get(url).await?.to_string()

This would make it easier to follow the core logic in async code, the same way that ? made error handling so much cleaner in Rust.

We'll be limiting it to open source projects — but not just software ones, whether it's an open hardware project, or an open source book, it'll all be welcome.

As someone who was a "child prodigy", people making a big deal of my age only made me feel good about myself and wanting to achieve more. Of course, this may not be a universal experience, but has certainly been common among the other child prodigies that I've since met.

Any chance the Smart Routing would be available as a TCP/UDP proxy service? It would be great to take advantage of Cloudflare's network without having to hand over your SSL keys.

No, but it is available as part of Google's cloud services [0]. Particularly noteworthy is the fact that they offer an SLA with 99.99% availability. Even crazier is their pending multi-region version due later this year which will come with a 99.999% SLA!!

[0] https://cloud.google.com/spanner/

Yes, that was actually the original plan. It all seemed so easy! Let developers connect their standalone Stripe accounts and have sponsors pay directly into those accounts. But this proved problematic for a few reasons, e.g.

* Most developers didn't want to handle matters like global VAT reporting individually, so ideally the money would flow through a central entity which took care of that for them so that they only have to deal with a single source of income.

* The need to support ad-hoc transfer of funds between standalone accounts when maintainers approved transfers to other developers they are collaborating with.

Stripe Connect with managed accounts helps to solve some of these issues, e.g. by creating charges on the platform account and then creating individual transfers to connected accounts. But according to https://stripe.com/docs/connect/charges-transfers:

"This approach is only fully supported when both your platform and the connected account are in the U.S. If your platform or the connected account is outside of the U.S., you can only use this approach for less than 10% of your total volume."

So, is there some other method that's available? Because right now, I'm looking at handling the payouts myself and using Stripe to handle just the incoming payment processing. And it'd be great to use Stripe for both instead!

(P.S. Congrats on the new job!)

This is the exact thing that I've been working on for the last year and a half. The biggest hurdle is actually handling the flow of money.

Because, unlike say Kickstarter/Patreon, where the money goes to a single entity/person, open source collaborations tend to be distributed and dynamic. So you effectively need to build a payments company and handle all of the headache that goes along with it.

But, having said that, I very much believe that something like this is needed — and thus why I'm still persevering with the project. Happy to chat further if cperciva/others are interested.

I wonder how much work it would be to add support for this to Raph's pure Rust CommonMark parser [0]. Pull parsing lends itself quite nicely to the AST-based output that GitHub prefer and Rust should help to minimise some of the security issues.

For those interested, here is the direct link to the new GFM spec: https://github.github.com/gfm/

[0] https://github.com/google/pulldown-cmark

That's basically what App Engine Flexible [0] is. It's yet to reach General Availability, but all you have to do is define a bunch of containers and a dispatch.yaml file [1], and App Engine then takes care of deploying/routing/scheduling it for you.

[0] https://cloud.google.com/appengine/docs/flexible/

[1] https://cloud.google.com/appengine/docs/flexible/python/how-...

If anyone from GitHub reads this, it would be great if you could use Task Lists [1] within Notes, e.g.

    Note Title.

    - [ ] Some subtask.
    - [x] Another subtask.

You could then group subtasks within a single note and tick them off as you go without having to edit the note every time. Cheers and thank you for the fantastic new features!

[1] https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-...

Congrats to everyone at CloudFlare who made this happen!

Is there a list of TLDs which are supported somewhere? When I last looked (years ago), only Verisign provided registry locking and the other registries weren't showing any signs of coming out with similar products.

Great work! But is there any reason that you didn't build on top of the really nice V8 binding https://github.com/ry/v8worker instead of Duktape?

No worries. All forgiven :)

Thank you ever so much for the hard work done by yourself and the rest of the Rust developer community. It has been an absolute pleasure seeing the language evolve, and now that it's hit 1.0, I look forward to the incredible opportunities it makes possible.

It takes great courage to go against the grain in terms of the core language (e.g. abandoning GC, M:N scheduling, etc. as core parts of the language), but the end result promises some truly exciting times. Thank you again and thank you also to you and the others for commenting here on HN despite the heavy criticism at times and being ever so helpful for those of us on IRC. It's been a fantastic ride and I look forward to it getting even better.

That would be pretty awesome! Also, do you happen to know if your current patch is safe to apply on top of OpenSSL 1.0.2a?

Nice work! Do you guys also have a similar implementation of ChaCha20-Poly1305 for Go? If so, any chance you could share that too?

I'vs been obsessively checking too, but for React Relay :(

Does this mean that those who hacked Target could have just added the card details to their own Stripe account and waited for Stripe to update the data once the banks got around to replacing the customer cards?

At least with my banks, when they send me updated cards, only a handful of the digits actually change and most of those changes have tended to be in the last 4 digits — which Stripe lets you see, along with the updated expiry month/year.

At this point, it's just a matter of brute forcing the remaining permutations. Am I misunderstanding something or are there countermeasures to protect against such attacks?

Click refresh (ctrl/cmd+R in many browsers) and then press cancel in the dialog box that pops up asking if you want to leave the page.

Whilst the concept of setImmediate is nice, the current implementation in IE isn't properly integrated with the rest of the event loop — resulting in broken behaviour when you use it in combination with setTimeout [1], DOM events, etc.

In contrast, using MutationObserver results in correct behaviour on all modern browsers and relatively minimal delays — between 0.002ms and 0.007ms according to an OS X only micro-benchmark I did last month [2].

And, yes, it would be great if we could call a builtin instead of hacking on top of MutationObserver, but it isn't that ugly:

  if MutationObserver
    $div = root.document.createElement 'div'
    observer = new MutationObserver tick
    observer.observe $div, attributes: true
    scheduleTick = ->
      $div.setAttribute 'class', 'tick'
      return
  else
    scheduleTick = ->
      setTimeout tick, 0
      return

In conclusion, I agree that a feature like setImmediate would be great. But given IE's broken implementation and a viable workaround in modern browsers, I see no need to rush it. I'd rather they focused on: new features like Object.observe; improving the performance of old features like Object.seal; and finalising some of the ES7 ideas like exposing the event loop!

[1] http://codeforhire.com/2013/09/21/setimmediate-and-messagech...

[2] https://gist.github.com/tav/9719011

A bunch of ZeroDivisionErrors doesn't look so pretty :)

For anyone who wants this for themselves, here's a Python script [0] that generates similar output [1]. It doesn't have the nice Google Cache feature from ajani's version, but it does produce static HTML which some may prefer.

[0] https://gist.github.com/tav/5545779

[1] http://tav.espians.com/temp/hacker-news-top-1000.html