skysight-inc/HackerNews huggingface dataset:
> They are nestable

trycatch is nestable as well.

> they can store arbitrary values, timers

Nice. I am currently decoupling trycatch's hooking layer to allow for this arbitrarily[1]. The continuation-local-storage library[2] allows for this functionality as well.

> intercept microtasks

Care to elaborate?

> wrap closures to be associated with the Zone

Yup, similar to domains, though I do wonder when this is necessary? One use case that came up with trycatch was finally support, or the need to exit the current domain/trycatch context.[3]

Lastly, there's one consistent failure I see in all these domain-like, async listener-like, long-stack-trace, event-source modules and that's long-lived resources or how they incorrectly handle EventEmitter handler's context[4], with the core issue being the boundary at which the hook is applied (From Trevor Norris' comment):

After thinking this over, it occurred to me that trycatch is a top down approach. Whereas AsyncListener is bottom up.

Long story short, things like keep-alive sockets will retain a domain/context/zone(?) and their handlers will be called with the incorrect context.

Do you fix this in your zone.js implementation?

[1] https://github.com/CrabDude/trycatch/issues/38

[2] https://github.com/othiym23/node-continuation-local-storage

[3] https://github.com/CrabDude/trycatch/issues/37

[4] https://github.com/CrabDude/trycatch/issues/32
> I may be wrong, but my misunderstanding is that Groklaw shut down because there is no way of knowing whether or not the privacy has been compromised.

And that was true since POP3 was invented. When you're sending the digital equivalent of postcards to each other then you can never know if your privacy has been compromised.

It's unclear to me what PJ really thought about the privacy of email before Levison, but what is clear is that Levison and SilentCircle's hysterical actions are what convinced PJ to close up shop.
Livefyre Sidenotes brings annotations to the rest of the web. Genius.
That's why you put your opening curly-braces on the same line as the if-statement, like the good lord intended!

if(expr){
expr;
}
Reread the original comment to which you're effectively replying for what I think is a complete rebuttal to this comment, and, again, let me remind you that your comparison of Cryptocat and this book is unfavorable to the book's author.
Go and Rust make the braces mandatory. Hugely more popular curly-braces languages such as Java, Javascript, or C#, don't.
That's up to the CA. It seems that StartSSL doesn't automatically revoke an old one even with rekeying.
Hacker charged in CRA Heartbleed breach
Show HN: Node.js library for HN API
Lightning Fast Prototyping With Harp
OK, I see now

I missed that because all of my cabling needs are easily met by manual assembly: most custom cables I make are for CPC (Circular Plastic Connector) "Cannon" type connectors and the Series III contacts are still doable by hand (although machines do a much better job of crimping). 2mm pitch connectors are the limit of my ability.

My biggest problem is doing a good job in volume. Thankfully I've found a wire processor with very low setup fees.
Reddit mods are censoring dozens of words from r/technology posts
Six Lessons Learned The Hard Way About Scaling A Million User System
This "use the right tool for the job" reasoning is just as flawed, though.

Switching between programming languages when you need explicit memory management vs. garbage collection or high performance vs. rapid development incurs a huge cost in interoperability. Should an English speaking person switch to French when they want to discuss love, since that's the right tool for the job? Of course not. If one (natural) language has words or idioms that are useful, they get incorporated into the languages that don't have them.

As the field of programming languages matures, we most certainly will want to pick languages that can rule them all. Languages will be adaptable to support different tradeoffs in the various dimensions you mentioned, without making a bunch of arbitrary ad hoc changes to all of the other dimensions.

Whether there will actually be just one is another question. I'd guess "probably not" for the same reasons that there's not a single natural language. Probably we'll have fragmentation, instead. But it won't be because people are choosing "the right tool for the job" and it won't be a good thing.
I see this as a cautionary tale about the limits of cloud-storage of anything. If you really care and you're facing an adversary with subpoena power over your ISP, the only solution is to ensure the ISP simply never sees the plaintext. Thus PGP, S/MIME, etc.
That assertion is difficult to square with actual statistics: http://www.uscourts.gov/uscourts/Statistics/StatisticalTable...

Remember that by the time a case reaches a court of appeals, with the government as a party, the U.S. itself must first decide its position is meritorious (it almost always has discretion to bring or defend a case). Then a district court also rules on it. So, for the district court to be reversed against the government, both the government lawyers and the district court must have been incorrect. This will not be an especially common occurrence even without the improper influence that you are insinuating. Given this posture, I find it remarkable, frankly, that the government loses appeals as frequently as it does. While it usually wins, it is hardly rare for them to lose.
This is amazing, and I really intend to use it. I am a developer but I just suck at front-end (CSS, mostly) and I have a much easier time learning back-end stacks. I haven't used WebFlow yet but is it fairly easy to use it to create bits and pieces to put into my entirely separate website?

Also for a person like me, it would be great if there was some sort of "explain" feature where Webflow would give me a peek at what's going on so i could slowly learn. For example: "This fade-in was achieved using the CSS3 fade animation with the following line of code: ...". I know that's a niche feature, but I think there are a lot of design-challenged coders out there who would like it.
Can Government Play Moneyball?
There are such lists, and compilers do generate warnings when you use a construct in it. Most of the problems is with people ignoring warnings.

But then, once in a while you have an example of bugs being inserted because the right construct was one that generated warnings. The Debian SSH bug is quite a clear example.
Nah man, you are contributing to the problem. Less training wheels, the world is a better place without them.

Drink your kool aid all you want, coding will never be replaced by a solution like this. It will simply allow someone to get closer to what they want before they grow frustrated by unforeseen limitations they will eventually run into; then they need to hire a real coder to fix everything, and likely replace it all, costing them more money and worse lost time.
Lavabit held in contempt of court for printing crypto key in tiny font
Looking for retailers using Bitcoin
I want to organize a pop-up shop with vendors that accept bitcoin in San Francisco. Targeting the middle to end of May.

Feel free to post here or email me at matt@thestorefront.com.
A book renting/borrowing app, which can be used to discover people(May be in a integrated map) who are willing to rent the book for a few days.
Built on pre-existing foundation. No kitchen nor bathroom in evidence. So for 2nd-world poor housing, maybe.
Hackonomics: Street prices for black market bugs
One of the goals behind the primitives NaCl selected was per-packet public key crypto.
That was a long way to go to insult C and brag about Eiffel. Ada doesn't have this problem either but nobody is jumping up and down saying how its the one true language. Back when I was looking at Phd topics (I ended up jumping into work instead) "provably correct" code was all the rage. Lots of folks at USC-ISI were looking into proving the code expressed the specification, and the resulting executable faithfully expressed the intent of the code. End to end correctness as it were.

What struck me about that work was that invariably there was some tool you ran over the specification and the code and it implemented some algorithm for doing the work. And yet if you went that far, then you should at least be willing to run something like lint(1) and had anyone at Apple run it, or made warnings fatal (always good practice), the repeated goto would never have escaped into the wild (useless code is useless, its a warn in both GCC and Clang, and always flagged by lint).

So is the challenge the language? Or the processes? I tend to favor the latter.
Bitcoin Creator ‘Satoshi Nakamoto’ Unmasked as Nick Szabo
This looks like exactly what I've been hoping to find after taking an OS course last semester! Thank you very much for sharing this link!
Nokia has NFC for payments as well AFAIK.
Hm. Is there provision for, "Gee, it sure looks like important investigation may not have occurred in this case, perhaps it should be revisited"?

catch( DefenseDidNotDoSomethingImportantException e ){
Case.Retrial();
}

As a defendant (or coder), you don't want to have to rely on exception-handling to save you from error, but as a citizen, I'd like to prevent technicalities from blinding our judicial system to proper consideration of major issues. Technicalities are often there for a reason (as this one is), but that shouldn't stop us from getting at the heart of an issue.
Even in Haskell you can fairly easily get non-reachable code:

if a == a then
...
else
-- unreachable

Combine this with the unfortunate habit (which I'm also guilty of) of allowing variables to be called a' and you'll an easy-to-miss bug.
Are managers the biggest problem with webinars?
Raise your hand if you bought an "upgradable" mother board in the 286 and 386 days.... Do you still have it?

I have a computer that still uses some of the same screws that my 486 used. For a long time I kept the original hard disk spinning even though I didn't store stuff on it... But when IDE connectors went away I stopped bothering with keeping it for nostalgia.

Even my case is no longer compatible, the power supply stopped being compatible long ago.

Some of this is "advancements" some of it is just that manufactures want to sell you new stuff.

Houses are about the only thing that are modular and you can say you will only need to buy one... The house I grew up in is nearly 200 years old. So far it hasn't needed to be replaced to do incompatibility.
Normalizing Sexual Violence: Young Women Account for Harassment and Abuse
As DJB noted in the very presentation he introduced NaCl, public key crypto for all data is in fact very feasible on todays hardware.
I really don't see how enforcing {} syntax on all conditionals is going to make us so much safer.

Yes, people make mistakes, but this is a pretty huge screw-up. If you are modifying an unbraced if-statement and aren't paying attention to scoping, then you are being woefully negligent at your job. Especially when you are working on cryptographic code used by millions of people to protect their most valuable information.

So let's say we force more red tape to make sure this doesn't happen. Those of us who pay attention to scoping probably won't mind too much, it's good practice to do this anyway.

But what about the mediocre programmer? He may decide that now his if/else if/else three-liner, when adding new lines for {}, should really just turn into a switch/case. And now he neglects a fall-through case, or adds an unconditional break; before important code. And we're right back where we started.

It doesn't matter how much we safeguard and dumb down languages. We can load our languages full of red-tape: extra braces, no jumping or breaking, no fall-throughs, always requiring explicit conversions, no pointers, no null types ... all we'll end up with is code that is much harder to read (and possibly write), while the mediocre programmers will find new and inventive ways to screw things up. It's just as likely to make them even more lax, and attract even less disciplined programmers into important development roles. You know, since it's presumed to be so much safer now.

The real problem is the amount of poor programmers out there, and the lack of repercussions for these sorts of things. A doctor that leaves a scalpel in a patient is (rightly) ruined for negligence. Do you think the "goto fail;" writer even received a written warning? Why not?

I'm not saying people can't make mistakes, but I think your pay scale and the importance of what you do should come with some actual responsibility for your errors. Just like in every other profession out there.

Yes, sometimes you can blame the tool. But there are also times when you need to blame the user.
Yet, some tools are objectively worse than others. And there is such thing as the right tool for the job.

You can't just push the problem into lack of discipline. People make mistakes, if you stubbornly ignore that fact, you'll get defective products.
Correct. Nor are they interested in having their name tied to the transaction either I guess!
Hasn't this been tried multiple times already by other vendors? It's a cool idea, but I'm not sure why this will succeed where other attempts failed.
> It's pretty common to want to write something like [. . .] without wanting to destructure a list or use the call-values hack.

This makes no sense. You want feature X (the ability to return multiple values) without having to either (a) pick apart a simple structure containing those values or (b) assign names to those values, letting the runtime system pick them apart (or never stick them together, its choice) for you.
So what more do you want?!

You want an option type, right? Well what's an option type? Let's consider Haskell:

data Maybe a = Nothing | Just a

No matter what kind of cleverness you do in memory or whatever, in the end this type is a tuple of two values: (constructor, data). The only special thing going on is that the type system makes sure that (a) constructor == Maybe or constructor == Just, and (b) if constructor == Maybe the data field is meaningless (has no type, can't be read, does not effect equality, whatever).

But it's still a tuple. The cons cell is the exact same thing in the absence of a strict compile-time type system, except for your code example we have it flipped: (data, constructor) (well, actually you seem to have a flipped 'Either String a' going on there, but let's stick with option for now) where data is actual data or nil when meaningless, and constructor is like Just when nil and like Nothing when true (btw, lisp convention is the other way around; second value is true like Just and false/nil like Nothing).

Just like the original linked article, what your complaint boils down to is "non-compile-time-typed systems allow you to do things which would break compile-time-typed systems"—and while I love compile-time typing as much as the next Haskell aficionado, I don't demand compile-time typing in a language [family] whose very essence is its absence.

EDIT: if you could reply and explain what would resolve this "shortcoming of the language", maybe I could understand better what you're trying to say...
Nifty looking tool!

The home page is missing a link to pricing. I couldn't find pricing until clicking through to the Features page.
Sure but you could just as easily add this as a compiler flag to any language. For example, I think gofmt will auto-brace your conditionals and other such things. I'm all for interesting language design but this isn't a very powerful example.
GCC has this, you turn it on by appending "-pedantic -Wall" to the compiler invocation. Sadly, many people don't know about it or care enough to use it.
The biggest Canadian corporate disaster this century swamps this hiccough from BlackBerry. Nortel was worth almost $400B in 2000 and is now worth $4M, essentially losing $400B of shareholder value this century.

This bodes ill for the rest of the article ...
Interesting, I'll take a look if it happens again.
Check out http://ycombinator.com/whynot.html
Ask HN: A startup centered around gamification
A lot of sites use gamification techniques to encourage activities that they want to see on the site, such as Stack Exchange, Khan Academy, and even game platforms such as Xbox and PlayStation.

My question is, would it be possible to take advantage of this trend by gamifying things that users are already doing? For example, gamify your actions on Twitter and Facebook? What would be a good way to do this and what problem would this solve?
I don't know that it's true, but it's certainly plausible that these hosts used OpenSSL versions prior to 1.0.1. Many other sites were in the same position.
This is cool, it does seem unfortunate that Behrokh Khoshnevis and the University of Southern California haven't gone and done this already given how long they have been developing contour crafting, moon bases are great and all, but cheap housing is immediately practical and in dire need in California.
Replacement? Does it talk OpenVPN protocol? No. It is not a replacement.
I'm very impressed with how short and clean the code. I did a very quick code review, and things appear to be implemented sanely (eg, they drop permissions and chroot properly). There aren't many comments, but most of the code is readable enough without it. I don't care much for their coding style (little whitespace, long lines) but that's just aesthetics.

More importantly, QuickTun might have some usability issues. Port numbers are hard-coded, and most configuration options seem to be set as environment variables. This should be expected though, as a result of trying to keep the code as small as possible.

I'd recommend it, but only to someone who's willing to read the source to figure out what's going on. If someone wanted to write their own VPN, it would be an excellent reference. It's definitely not for everyone.
Ask HN: Compard to GitHub, is Bitbucket enterprise oriented?
You don't use the "take me (home|target location)" direction feature? I use that all the time.

Other very useful Siri phrases - "Find a {cuisine} restaurant near my house" to setup takeout on my commute home - or "call my {relation}".

Proper nouns esp. restaurant names (e.g. "Sent sovi") are still pretty tough to get understood no matter what voice engine I use.
This code is as simple as the project owners say it is, but a couple things about it that I wish were different:

* The "nacltai" protocol driver uses C VLAs to store attacker-controlled numbers of bytes; a VLA is morally the same as an "alloca" call. I have no clue if this is exploitable but reading it gives me a painful burning itching sensation.

* I sort of wish the authors didn't parse strings to recover crypto parameters from the packets, but instead just used a straightforward binary encoding that would require less use of C's terrible string functions.

I'm still a lot more comfortable with this codebase than with OpenVPN. :)
What attracted me to Eiffel, in the mid nineties, was the whole concept of design by contract, better OO than C++, compilation to native code, GC and belonging to the Pascal family of languages.

What putted me off was Eiffel Studio's price as university student, without knowing if the language would have any industry influence.
Not sure why this is currently front page. They could have built even better houses had they used what is referred to around here as 'tilt-up' construction. You pour a concrete foundation, You stake out four wall forms around that foundation and pour in the walls, when they cure you tilt them up and tie the tops together with steel. Boom, "instant" building with windows and doors.
There's another tunnel implementation that's based on NaCl called fastd. It seems to be production ready, however some thousands of Freifunk participants use it to connect their Access Points.

https://projects.universe-factory.net/projects/fastd/wiki
> Always put brackets after your conditionals (for languages where you can)

That's the point. The programmer shouldn't have to remember to write code the Right Way, rather the language should be designed to avoid these ambiguities.
Agree 100%. If there's one rule the history teaches us over and over again in every aspect of our lives, is that you should never count on human discipline. You build your systems to work in spite of, not thanks to, human behaviour.
Will you post the results?
This is one of my most loathed developments in "best practices" lately. I see it everywhere and it just adds noise, since it doesn't change the functionality of the code. It's like adding a comment on every flow control statement. A concrete example is try/catch, which forces the user to add superfluous curly brackets.

In fairness, I have hit the "goto" style of bug he talks about in switch commands, when I forgot to add a break statement. But I can't remember a single time in my programming career when I added a line to an if/for/while and broke something.

I think people are wasting their energies on subjective topics like telling people to use spaces instead of tabs, or putting { on the same line as the flow control statement, or even telling people how much whitespace to use between () and where.

What we really need is a standardized formatter for any language that works like Google's Go Format. Programmers should not be spending time refactoring code just for looks. If anyone knows of a utility that does this and is easily configurable for personal taste, I would sure appreciate it. Being able to convert /* */ comments to // and back again would be a plus.
I know you think it's unfavorable to compare the two, but that's the entire problem.
Hi, thanks for sharing your experience. I think when proposing anything, it helps to be able to clearly express your idea in such a way that anyone including non-technical people like myself can understand and relate to. I think this aspect could be improved. Other things:
(1) I don't have a strong idea what pain point you are addressing. You mention features extensively, but could say more about the problem you are solving.
(2) You mention 50$/mo but no idea how many potential users/market size.
(3) The way you've described it, your idea seems more like a research project suited for a university than an actual product that can be sold to consumers. Need to make it easier for people without expertise in the area to understand what exactly your product is.
I don't understand the argument for using a hash-table for kw-args. Hash tables only win against plists when you don't need to read every single element; when you always need to read every single element, then it's a losing proposition to use a hash-table instead of a plist.

Yes I agree with your later comment about syntactic blessing and all, but I think you picked a terrible example by choosing the single place in lisp where plists make more sense than hash tables.
We invest a lot emotionally in our businesses too, but yes, at most we'd have to make those taxes conditional. But then of course, if homeowners get a break and business owners do not, most businesses will move out of cities and other urban areas after a while, and that's not good for society in general.
This design actually seems pretty interesting - one of the advantages of additive manufacturing by printing is that the resultant parts can be made with a strong internal structure (triangles, honeycombs, etc.) while still being made of mostly air, an outcome that's difficult to achieve using molding/casting, forging, or subtractive manufacturing (milling).

I also suspect that the mostly-hollow walls have a decent R-value on their own.

I do wonder how this competes with straw bale / rammed earth, shipping containers, and other recycled, rapid prefab building manufacturing.

"Making cheap houses for the poor" seems to be a common design+architecture firm/student theme - does anyone know of any success/failure stories where these "cheap house" designs were applied in real life?