skysight-inc/HackerNews huggingface dataset:
> "whatever you come up with will have a higher likelihood of failure"

This is where you are simply wrong.

> "the authoritative copy goes into the cloud"

This we agree on.

So, where you are wrong is this: you are only considering technical failure modes but there are many others besides and so any comparison between 'the cloud' and 'your get-out-jail-free-card-backup' would have to be in terms taking into account all modes of failure, not just the technical ones and then on top of that you'd have to consider the likelihood of the backup failing to restore at the same time that the primary system goes down for whatever reason (including technical ones).

That's why I call it a blind spot, even after being told in 20 different ways that the uptime of Amazon does not come into play here you are still clinging to that. It is simply not relevant because that's not the scenario a back-up will most likely prevent against. It will also prevent against that scenario, on top of the ones where someone incapacitated by drugs, anger, depression or any one of another set of circumstances decides to take it out on your company. Or maybe someone makes an honest mistake (I've been called out twice in my career to restore data for companies that had been wiped out because of simple mistakes that should have never ever happened).

So back-ups are not a luxury, they are a necessity and the degree to which Amazon can outperform your back-up in terms of availability is not a factor in the whole discussion.
The compiler for this language will be too slow to be useful. Contrary to this author's belief, crypto people really do care about performance.

Anyway, what the author wants isn't a "boring C" compiler, it's a compiler for a new language that doesn't actually have undefined behavior.
Even a few generations ago, 4+ year olds wandered the neighborhood with the other 4+ year olds lightly supervised and played games in the woods. Today that never happens.

And in those large family units, all the kids played with each other constantly and barely bothered the parents to do anything.
wait, did Yelp just call me a knuckle-dragger?
It sounds as if the root of the problem is the C standard. Wouldn't it be better to fix that instead of creating a shadow standard defined by the implementation of this boring compiler?

I also object to the presupposition that there is secure software and non-secure software. In most practical cases, it is impossibly hard to tell in which class an application falls, so it would be better not to make that distinction at all.
I agree on all points. My issue is that I can get basically unlimited work at $60/hr and my schedule is completely full. In order to accept all the work, I'll need to have other people helping and I can't pay the full hourly rate or there's no point in accepting it at all....
Uber for planes isn't happening
For the language, first read Apples Language Guide & Reference. It's free.

https://developer.apple.com/library/ios/documentation/Swift/...

I would recommend the iTunesU - Stanford iOS 8 Tutorial series as well. Been a while since I wrote an iOS app, just watched it this weekend to see what was new, and found it to be great.
Ada can be amazingly efficient. It just isn't cool. I've often wondered what would happen if someone pulled a reskining of the language (ala VB.NET >> C#) what would happen.
You're stuck in the groove of statistics. You will need to look further - and maybe gain a bit more experience in IT - to understand that PEOPLE and not the reliability of hard-drives or the uptime of cloud services are what make back-ups a vital necessity of any IT business.
Ada, and recently Rust, for example. People trying to improve C are sad to watch. People use C because they have an irrational belief in their own faultlessness. Same reason people are afraid of flying but not driving. Selling a correctness-enhancing tool to these people is an impossible task.
Unix commands happily pass around binary streams of any format. The problem is, as you noticed, there is not schema, no uniform (let alone machine-readable) description of accepted / emitted formats. Composability is possible but not entirely trivial, often with a dose of `grep` / `sed` / `cut` between commands.

It's also pretty hard to pass a function to a Unix command. Either your command supports its own syntax (grep, find), or you make do writing a loop or a temporary file.
If you are generating different amounts of garbage depending on your secrets, that's already showing up as leaked timing information.
That it's common for companies to seek to develop involuntary behavior in consumers in no way implies it's ethically sound, just that it's done.
I've always thought that there would be more value in exactly the opposite - a pathological C compiler (or C++ compiler, POSIX operating system, etc.). The pathological compiler would always implement undefined behavior in the most surprising, unpredictable manner - e.g., uninitialized memory would have a properly randomized value that changes from one run to the next, overflows would result in random values, etc.

That way, any programs that are made to work on the pathological implementation are largely guaranteed to rely only on standardized behavior, and work on any other standards compliant implementation.
Because C has a lot of momentum, and interoperability, thus lots of security software was written.

This software isn't secure because of C but despite of it, and has had a long list of security vulnerabilities that a safer language would have protected us from.
But at compile time you can definitely say "This may be a problem."
>It sounds as if the root of the problem is the C standard. Wouldn't it be better to fix that

Isn't the reason for a lot of undefined behavior either in the name of performance through optimization and assumptions, portability because the implementation can just do whatever the underlying platform natively does or the committee just couldn't agree on it?

All three of those scenarios appear inherently unfixable to me without a separate sub-standard that intentionally clamps down on performance/ease of portability and actually gets the committee to agree.
I hate to say it, but as a pilot myself, I'm glad the FAA is doing this. Unregulated ride sharing in general aviation is not a good idea. There's just too many ways expectations can be mismanaged or things can go wrong.
I guess it depends on how active development is on your project. My feeling is Rails is only suitable for actively developed projects, if you are building a small project and then handing off to a client without a budget for maintenance than Rails is worse than probably anything else (except arguably Node) in terms of long-term stability. But if your project is actively developed the gem upgrade dance is not too bad.
You're evading.

When was the last time the FDIC failed versus the last time an online storage vendor folded?
New Cycle.js version released
From wooden storage pods to taking on Amazon S3 and winning
Modern compilers/analyzers can and will report whatever statically detectable UB they can, but most interesting cases are triggered dynamically. e.g.:

int data[64];

int foo(int bar) {
return data[bar];
}

If foo() has external linkage, how does the compiler ensure it's never called with a value <0 or >63?

And that's an easy case.

clang/llvm can instrument code to detect some forms of UB and trigger a diagnostic at runtime, but these checks can be expensive (and you still have a runtime failure, rather than a compile time detection).
IF bubble might pop THEN
How far are we from having the will and ability for it to be common to use safer languages than C/C++/Java/etc.?

A long time ago, it didn't seem pragmatic to write in, say, ocaml, because no one was going to feel like building or even installing the compiler in order to try your dumb software, but now that everything is about packages from distributions...

Today it feels strange to apply security updates for necessary software where the announcements list "Multiple memory safety errors, integer overflows, use-after-frees..."
just record all conversations you have with everyone.

I hope to hell you don't live in a two-party consent state.

EDIT: Or interact with people who do. For example, California's two-party consent law applies to people calling Californians from other states.
Great interview with Backblaze's CEO on how they went from building wooden storage pods in a one bedroom apartment to taking on Amazon S3 cloud storage and crushing them on price.
I definitely do see gulp et. al. as belonging to the same category of tools, although they're much more general-purpose. I think that's where I map the terrain differently than you. I do so because I'm hopeful that future innovations there will find their way back to tools like Lektor, etc.

(And completely agree on the programmer-centric nature of these tools.)
agreed, another "not quite C", something where you can control what happen when you multiply 2 integers, something where you can control bit banding, memory mapped registers, float behavior, etc. All with sane defaults.
I believe in many cases in C, you would need to insert runtime checks (and I believe gcc/clang has a flag for inserting these when statically checking for it is infeasible).

One such behavior which is considered undefined is signed integer overflow/underflow. Without this being undefined, some important loop optimizations would not be possible [1]. The blog link below has lots of information about undefined behavior from the perspective of a compiler implementer.

[1] http://blog.llvm.org/2011/05/what-every-c-programmer-should-...
So what's a good way to build a build lava lamp in 2015? I'm thinking wall adapter that has wifi and offers a simple webserver that switches on and off on POST.
Speaking of things that the Haskell type system lets you make explicit, the isomorphism between streams and functions from the natural numbers means that streams are "representable functors" in the jargon of category theory. [1] Knowing that a data type is representable allows you to immediately build a bunch of other interesting structures on the data type. [0]

[0] http://covariant.me/notes/rep-functors.html
[1] https://pamiz.wordpress.com/2014/02/13/the-functor-of-infini...
The author lists his fido addresses... I'm feeling nostalgic even though nostalgia isn't what it used to be.

A quick google shows that he headed Checkpoint's vulnerability research until recently. Another name on this article, Eden Shochat, is now running Aleph[0] - a VC with a blog worth reading.

[0] http://aleph.vc/
[EDIT: more clearly distinguished between undefined and unspecified behavior.]

> Question: why can't existing C compilers clearly indicate when they encounter undefined behavior?

Why can't existing programs clearly indicate when they encounter unexpected input?

Not every instance of undefined behavior has explicit handling in a compiler; sometimes, undefined behavior occurs as part of the implicit functioning of the compiler implementation. The compiler does not need to consider undefined behavior at all. It doesn't necessarily have an explicit case for "undefined, choose a behavior"; it can simply act as though undefined behavior does not exist, and have the behavior in that case depend on whatever the code written to handle defined behavior happens to do in the undefined case.

[EDIT: This example is unspecified behavior, not undefined behavior. The example does still illustrate what I meant by behavior that arises out of the compiler implementation without explicit notice by the compiler.]

For instance, if you write f(g(), h()), C doesn't specify whether g or h gets called first. The compiler doesn't explicitly parse that whole expression and internally note "oh, you have unspecified behavior here, I'll silently choose an interpretation and not tell you about it". The compiler just parses the expression and breaks it down into sequential operations, implicitly choosing an interpretation based on its parsing, evaluation, and optimization. The compiler might evaluate g() first because it parses left-to-right, or h() first because it parses right-to-left, or h() first because h() was an inline function and it expands those first...

A compiler explicitly designed to flag undefined behaviors would need to have additional logic to notice undefined behaviors; you couldn't just take an existing compiler and find all the places where it explicitly notices undefined behavior and chooses a way to handle it.

Existing compilers have started to add warnings for cases where they explicitly exploit undefined behavior for optimization, such as assuming a lack of signed overflow, or assuming that you never dereference a NULL pointer. But retrofitting a compiler to flag cases where it currently just doesn't even consider the undefined behavior would require far more work.
You realize the author is Dan Bernstein, right?
This is actually something the ISO C++ committee is looking at.

See https://isocpp.org/std/the-committee - SG12

An example of this is P0145R0 which specifies the previously unspecified order of evaluation.

See https://isocpp.org/blog/2015/11/kona-standards-meeting-trip-...

Apparently, the performance difference is expected to be zero on currently popular architectures and around 1% on older architectures.
Most of us here, I would venture to guess, learned to read before Kindergarten. We can look at the group of people who learned to read as early as 2 already.
What are the essential features that they share?
A little bit of background: I learned Django first. Then I learned Rails via Code School, and flirted with building my app with Rails instead of Django. I saw the asset pipeline specifically as a Rails advantage over Django (I write Emblem, indented Sass, and CoffeeScript whenever I can avoid HTML/Handlebars, CSS, and JS). Also, building JSON APIs with Rails has better out-of-the-box support than it does in Django.

I always felt Rails' model layer is clunky compared to Django's. What is the definitive representation of my model? The validations in SomeModel < ActiveRecord::Base or what's automatically generated in schema.rb when I run migrations via Rake? In Django everything, including migrations (in simple cases), is derived from the classes in models.py. But I thought it would be worth it to persevere, due to the above-mentioned advantages.

Then I realized I could (and should) compile assets via Ember-CLI, and Django Rest Framework is just a pip install away. So the two main advantages of Rails disappeared, and switching back to Django became, for me, a no-brainer.

Edit: I also prefer Django's less magical approach. This may seem ironic given my love of Ember, but Ember's magic is easier for me to understand than that of Rails.
I recently tried to use Ada, that ended in sadness. I couldn't try Rust, because it doesn't (didn't?) run on arm-none-eabi.
It's common now for parents to put their kids in Kindergarten at the age they used to start first grade. My kid just made the cutoff but my wife wants to hold him back and some of his friends parents with kids born in January or march are holding their kids back a year.
But why? That's a way more complicated and a way less usefull.
Patent lawsuit hits Atlassian prior to IPO
People trying to improve C are sad to watch.

Cyclone had a fighting chance once.
Please don't spread unnecessary fear. ("deep magic").

C is as secure as developers take their time to implement. A fantastic amount of dangerous stuff currently runs on C. C has several substandards, such as MISRA and JSF, to aid developers in writing safe C, eliminating arguments about "well-defined."

A good start is bounds checking and following MISRA. Languages like Rust make it cheaper, but security never comes for free.
> Shouldn't it be okay for someone to say "yeah I get that you're not the same as a real pilot" and sign off on that risk themselves?

I think at least part of the regulations is to limit the incentive for less-qualified pilots to fly at all. If pilots without commercial licenses are allowed to fly as de facto commercial pilots, they will have additional incentive to fly, and do more of it.

The risks the FAA manages are not just those to paying customers; aviation imposes external risks, as well.
I honestly believe you're either taking this personally and/or using emotional arguments from some deep hatred of advertising. Nevertheless I hope this clears it up for you:

---

Advertising is meant to gain your attention. This is not a secret conspiracy, it is quite literally the entire business. That being said, there is vast differential in the amount of energy expended in ignoring content vs the amount needed to make a willful decision of how to value and purchase said content.

Subscriptions are actually even harder to decide on because they are a much higher cost that requires a commitment with a single outlet and trust that their quality will continue to be to your liking vs a single article.

Patreon is not an alternative funding model - it is still direct payment/funds transfer. It's just optional. It's also not viable for any scalable business. Not everything can or should be a small little site.

Advertising is packaged with content because the publisher owns the right to that content and how it's distributed. This is the same in every other medium ever invented. Same with any other product you buy. You get it as it comes. If you're not compensating that advertiser for that content directly, then they have every right to include advertising to offset the cost of creating and distributing that content to you which you requested. Would you rather they deny your request?

Everything is a security risk. You should stay in a nuclear bunker and off the internet to truly minimize surface area. However that's not realistic. Ad networks definitely have an implementation problem with not enough standards on malware testing, and yes they're a good choice because of their scale. However guns are also efficient at killing and cars are efficient at escaping, should we also get rid of both because they're used by criminals?

Any database containing data and thus value becomes a target. Should we also stop creating any kind of database because it might become a potential target? So medical records, court proceedings, tax records, insurance claims and every other database should immediately be destroyed because someone might want to access it? Again the real problem here is the fact that criminals will be criminals, not the tools they use or targets they go after. There should absolutely be more safeguards with ad networks along with liability as I've stated in previous posts (and I'm doing my best to make that happen) but arguing that we should get rid of the advertising model because of some security issues does not make sense.
What you say is true, but this case could easily trigger a warning about possible use before assignment. The compiler doesn't have (and can't) to prove that either branch will always be taken at runtime. And there's no benefit to code like this anyway, just write it so it's obviously to be assigned. Your coworkers will thank you.
You are misunderstanding me( I know sit seems to be a common pattern for you) whether I stand behind what I say is totally separate concept from your motivations and how they reflect on you as a person. The quality of my technical reputation is not in question here and my employer is welcome to read this thread.

I didn't call you an "alarmist" I said worrying about whether amazon will stay in business, "get hacked", or if S3 is going to disappear without warning is "alarmism" They were responsible for 39% of all commercial internet transactions last year and store 2,000,000,000,000 objects. If they go under we are are all in a heap of trouble. A NAS device in some remote part of the netherlands isn't going to save us.
Edit, did my own research: these codes are part of the credit report and represent the status of the account each month. They aren't the only factor (length of history, utilization, number of accounts, and type of accounts matters too):

R0 or I0: Not enough credit history to judge risk.

R1 or I1: On-time payment, in 1 month.

R2 or I2: Late payment, in 2 months.

R3 or I3: Late payment, in 3 months.

R4 or I4: Late payment, in 4 months.

R5 or I5: 120+ day late reporting.

R7 or I7: Consolidated debt payment.

R8 or I8: Repossession.

R9 or I9: Default.
Software Freedom needs your help
It's purpose is much the same as Maple or R a language designed with mathematics and stats. The standard library is just one of the peculiarities of how Wolfram decided to design his language. Instead of using libraries like R it's all built in. Beneath that it's not so terribly odd being a mostly functional language with a standard library that covers maths requirements.
Day care is far more labor-intensive than college. The student:staff ratio in daycare is at most 6:1, for 40 hr/wk attention to students.

At a college, the ration is 10:1 or 20:1, for <20 hrs/wk attention to students
From the article:

> * Claim that a boring C compiler can't possibly support the desired
system _performance_. Even if this were true (which I very much
doubt), why would it be more important than system _correctness_?
> and has had a long list of security vulnerabilities that a safer language would have protected us from.

Care to point to the "long list of security vulnerabilities" in qmail?
As an anecdote, after intentionally avoiding credit cards through college, I was rejected from several when I applied for my first after graduating in 2010— and was only approved for a 'student' card (despite having graduated) at a bank where I had a savings account.
I remember that Blogger, in the beginning, used to work as a static site generator. You edited your posts in the user interface, and you could publish the result to a static hosting via FTP.
Induction cooktop.

More efficient. Solar powered (renewable) so no need for going out for fuel which can be very dangerous and time intensive. Much, much safer than an open flame. No fumes. Small footprint and extremely portable. Robust. Cool.
I am also a Rails dev, but one feature I think Django really got right that is head and shoulders above Rails are Form Objects (https://docs.djangoproject.com/en/1.9/topics/forms/). Rails' attr_accessible stuff and even strong_parameters really pales in comparison.
I will admit that my comment was poorly phrased.

It's better stated if I say that I prefer to err on the side of less, rather than more, regulation.
Register for hack.summit() 2016 – huge virtual conf with 64k+ attendees
MBA vs. entrepreneur – how they think (differently)
> I think that saying that m "equals infinity" is probably a bit of a simplification.

Yes, it is, I agree. For the limit example, one might instead say, "As m approaches infinity, the result approaches 1." By definition, limits approach their target values, they never equal them -- otherwise we would accept division by zero and similar things.

The other reason I agree is because infinity isn't a number. I'm guilty of compressing the lexical description of a limit to a ... ahem ... finite size.

> ... what is meant in the examples you gave, which are both limits.

One of my examples was an infinite sum, not a limit per se, but the same argument can be made, i.e. that infinity is addressed without being literally achieved.