HNHacker News
TopNewBestAskShowJobs

Blaisorblade0

43 karma · joined June 24, 2016

submissionscomments
Blaisorblade0··on A Solution of the P versus NP Problem?
I mostly agree but there is a small effect: "Claims spectacular proofs with flawed arguments" might still be reason to doubt his future proofs more until verified. And mathematicians do use such criterions before reading unverified claimed proofs of hundreds of pages (not uncommon). And since some proofs target tens or hundreds of persons, that can be a problem. I've read such stories, though I don't have a reference at hand.
Blaisorblade0··on A Solution of the P versus NP Problem?
That's only obvious in a vacuous sense.

As a PhD student in Programming Languages, can I request a reference?* Nobody managed to provide one on MathOverflow, and that's the StackExchange for professional mathematicians:

https://mathoverflow.net/q/226966/36016

Of course, your claim is vacuously true, since you can add a trace of all steps of a proof verifier. It's also vacuously true because you can add a dump of the Internet to the proof. Neither thing is insightful.

> what we normally think of as an "honest proof" is a series of steps each of which follows from the previous by application of one of a finite number of axioms or rules of deduction, and such an "honest" proof is thus checkable in linear time by checking each step

Also, for the record: actual formal proofs for (say) standard ZFC are exponentially bigger than anything you want to work with.

EDIT: To clarify, I didn't mean to imply I'm some authority, just to suggest I'm not so obviously* an idiot. Which was maybe stupid anyway.

Blaisorblade0··on Automated Verification of a Type-Safe Operating System [pdf]
Until recently, MSR was also very disconnected from product development. There was a distinct change last year.

Also, in general most papers are more useful for writing further papers to improve on their limitations (until something's great), than to be adopted right away. This one is pretty cool, but both the conclusion and the benchmarks set out significant challenges for further research. After all, this is the first OS using automated verification, not the last.

> a lack of software developers inside Microsoft willing to replace their existing code and learn new tools and languages.

I'm sure research on the topic hasn't ended, so should they switch now or wait for more research? Or wait for research on verifying existing code? And if a new paper comes out, should they switch again? Also, do universities train enough developers to use such technology?

Blaisorblade0··on Automated Verification of a Type-Safe Operating System [pdf]
> So, we have numerous secure and high-uptime systems deployed whose methods were published even if source wasn't. He or others can always build on these if they want to replicate the results.

I know that's technically true, but not helpful, and that's why this line of thinking is becoming unfashionable.

As a researcher in Programming Languages, who publishes and has reviewed code: By that argument, there's no need to publish CompCert or Coq, which seems ridiculous. Publishing code can help adoption even if the code gets rewritten.

Publications without code often fail replication for many reasons (not necessarily involving foul play or even errors). I can't document all tricks needed to get the performance results in 20 pages. And replication in another scenario might show the results don't generalize easily (and nobody knew). So having sources provides the extra confidence you need before bothering.

And compared to other publications without code, the needed expertise seems much less common.

OTOH, papers do get used by the research community, possibly steering it in some direction (including then wrong one). And a few papers matter enough that people will attempt replication anyway (and learn if they work).

When the results of a paper are "here's what we tried and got, new ideas are needed" (honestly, many papers on hard problems) then maybe sources don't matter.

Blaisorblade0··on Reflex: a new programming language for reactive programming by Facebook
Is there some website with some more info to read, for all those like me who dislike videos? I already googled "reflex facebook programming language" and found very little.

Quoting the talk abstract (http://www.curry-on.org/2017/sessions/reflex-reactive-progra...):

> Reflex is a new programming language for reactive programming developed at Facebook. It has many interesting characteristics, mixing OO and functional programming, it allows rapid development of applications with “spreadsheet semantics.

EDIT: to clarify: that's literally all I found. (I dislike videos so much I had missed that abstract is also on Youtube).

Blaisorblade0··on Let’s Stop Bashing C
Knowing assembly won't teach you the difference between legal overflows and ones triggering undefined behavior, or why you might need -fno-strict-aliasing to cast your pointers, and many more things. Does anybody know any correct nontrivial C programs beyond the ones by DJB? Or anything close? And it's not like, once bug-free, those are evolving much...
Blaisorblade0··on How Dropbox Hacks Your Mac
You're talking past each other — other, more fundamental features used to require hacking OS X. See for instance https://news.ycombinator.com/item?id=12467149. IIRC ArsTechnica wrote at some point that monkey-patching Mac OS/Mac OS X was standard on the platform.
Blaisorblade0··on How Dropbox Hacks Your Mac
Many app stores (even for smartphone) have sandboxes where you can grant additional privileges. Of course the user (who else) has to decide whether they trust the app or not. But I'd be happier trusting a sandboxed Dropbox, especially because it couldn't have hidden its use of Accessibility.
Blaisorblade0··on Smaller and faster data compression with Zstandard
https://en.wikipedia.org/wiki/Godwin%27s_law ? :-D
Blaisorblade0··on Why is Python slow
Are you the OP author, or working on Pyston? I have basically two questions/curiosities — I'm not asking adversarially: 1) For which code is the C runtime most expensive? Typical Python code tries to leave heavy-lifting in libraries, but what if you write your inner loop in Python? Enabling that is (arguably) one goal of JIT compilation, so that you don't need to write code in C. 2) What about using Python ports of performance-sensitive libraries?

In more detail: I arrived at https://lwn.net/Articles/691243/, but I'm not sure I'm convinced. Or rather: with a JIT compiler you probably want to rewrite (parts of) C runtime code into Python so you can JIT it with the rest (PyPy has already replaced C code in their implementation, so maybe there's work to reuse). For instance, an optimizing compiler should ideally remove abstractions from here:

  import itertools
  sum(itertools.repeat(1.0, 100000000))
Optimizing that code is not so easy, especially if that involves inlining C code (I wouldn't try, if possible), but an easier step is to optimize the same code written as a plain while loop. Does Pyston achieve that? I guess the question applies to the LLVM-based tier, not otherwise.

Yes, Python semantics allow for lots of introspection, and that's expensive — but so did Smalltalk to a large extent. Yet people managed, for instance, to not allocate stack frames on the heap unless needed (I'm pointing vaguely in the direction of JIT compilers for Smalltalk and Self, though by now I forgot those details).

Blaisorblade0··on Dotty: a next generation compiler for Scala
Unlike Scala, you can't figure out what Python code means correctly and statically — you have little idea what will be called by a function without running the code up to that point, so it's hard to do semantics-preserving refactorings.

But Python changed Strings to use Unicode, and that's something everybody uses and that is insanely hard to refactor automatically even with types.

For Dotty, instead, there are some hard-to-refactor-for changes, but they're in really advanced Scala things, so I expect they'll affect fewer users — mostly the kind of users who can write shapeless-like stuff.

Blaisorblade0··on Dotty: a next generation compiler for Scala
For anybody curious, I think he's hinting at modern effect systems, on which there's lots of research these days. He advised for instance Lukas Rytz PhD thesis at EPFL (and Lukas Rytz is still working on Scala, now at Lightbend).
Blaisorblade0··on Dotty: a next generation compiler for Scala
Assuming I get him correctly, that's bad sarcasm. I'd recommend instead this joke on JavaScript toolchain: http://cube-drone.com/comics/c/relentless-persistence

Compilers are huge beasts, but good ones are worthwhile, and Dotty is a better Scala compiler, so this criticism seems misdirected.

← PreviousPage 2 of 2