Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

CloudFlare's "Flexible SSL" (https://www.cloudflare.com/ssl/) offers encryption/authentication from CloudFlare's server to the client, but none from the origin server to CloudFlare's. Which means that is a vector by which the content could be sniffed or modified in transit.

It's a "better than nothing" option, as there are a slightly higher number of actively exploited attack vectors that apply to the client to CDN connection than the CDN to origin server, such as "free" wifi that injects ads, malicious ISP DNS, and the like. But it's not actually secure, as the origin server to CDN connection could be tampered with, and just because there are fewer active attacks that would be likely to affect that connection right now, doesn't mean that someone won't come along later and hijack such a connection.

CloudFlare offers other TLS options that do include encryption and authentication between the origin server and CDN, but they do require that you set up a certificate on your server, so if all you're trying to do is enable TLS (and don't care about the CDN), just installing a cert on the origin server and using TLS is probably a simpler option that using CloudFlare.


We encourage users to use Strict mode which requests and validates a certificate from the origin.

It's great that shared web hosting providers and others are starting to make it easy to acquire and install a certificate, but that hasn't always been the case.

EDIT: We also provide an API that will provision a free certificate for your origin: https://blog.cloudflare.com/cloudflare-ca-encryption-origin/. The certificate is optimized for communication with our edge (essentially just as small a chain as possible, as we don't need the intermediate to walk to the root). Either that or use certbot from EFF/Let's Encrypt.


great noob elaboration. much appreciated. :)


  But if you actually try to advocate that people attend to 
  their health first and foremost by eating right, 
  exercising and making good lifestyle choices, you are some
  crazy weirdo?
I don't think that's what the article was sneering at.

It was sneering at the idea of fearmongering about what people eat, but then trying to sell them on a whole bunch of unregulated supplements and quack remedies.

There is an awful lot of "something free on the internet" that is just complete bullshit designed to sell you something.


From what Elon Musk writes, his plan is that either you'll be renting other people's cars, or making some extra money by renting out your own: https://www.tesla.com/blog/master-plan-part-deux


Or as they say, the market can remain irrational longer than you can remain solvent.


More specifically, as John Maynard Keynes said


Not according to http://quoteinvestigator.com/2011/08/09/remain-solvent/. Apparently what Keynes said was something similar, but not that same phrasing:

  There is nothing so disastrous as a rational investment 
  policy in an irrational world.


And in the long run we are all dead anyway.


And the reason that they are named "uppercase" and "lowercase" is that in the early days of movable type, the majuscule letters were stored in a case above the miniscule letters.

Furthermore, Roman and Italic are two entirely different styles of characters. For highlighting purposes, printers started using Italic within Roman text, and eventually pairs of Roman and Italic fonts became identified with each other, so that now typefaces generally include both of them.


It may also be interesting that these styles of writing characters originally went with different styles of filling a page. Around the first millennium horror vacui reigned the scriptoria and scribes tended to fill the whole of the page with as least of white space as possible. If there was space left at the end of a line or page, the last words were repeated, often framed by "va (...) cat". This style coincided with broken letter styles favoring the similarities in the various character forms.

(We may observe that the upcoming use of white space in writing in order to structure text roughly coincides with the introduction of zero into the number system. We may also observe that the use of zero was already implied by the Roman abacus, but didn't propagate to writing numbers. This may be seen in the context of Roman writing dismissing interpunctuations originally imported from the Greek and eventually also dismissing spaces between words, as it was considered important for a reader to immerse in the text in order to reveal its meaning. This approach to writing and reading may also shed some light on the horror vacui that may be observed in medieval writing. For an opposite approach we may consider the Summa Theologiae, breaking down the text in structure and form so it provides a quick and easy orientation for where in the text we currently are. This approach brings also some new characters, like "¶" to mark the beginning of a paragraph. – Historically, there's been an ongoing discussion whether to favor legibility or rather illegibility in writing and letter forms, which is linked to the question, whether a text should reveal its meaning quickly, or rather resist a cursory reading.)


Bazel was first released to the public in March, 2015. By that time, Cargo had already been in development for over a year, had reached release 0.1.0, and was already the official build tool for most Rust projects.

Furthermore, Bazel and Cargo are aimed at slightly different use-cases. Cargo is tailored towards Rust, is integrated with a Rust package repository, and can use it's knowledge of Rust to allow for builds of pure-Rust projects with a lot less configuration. Bazel is a more general purpose build system, but that means it requires a little more configuration. There's no reason you couldn't use Bazel for building a larger project that includes Rust and C, C++, Java, or other languages that need to be built, but Cargo makes it a lot easier and simpler to handle pure-Rust projects than it would be in Bazel.

Many of the other tools that you mention don't require just more support from the build tool, but also significant engineering effort on the part of the compiler, or a separate static analyzer, or other development process tools. These tools are desired, there just isn't anyone who has had the time to design and build them.

As to why Clippy is separate from the compiler, there are a couple of reasons. Adding more lints to the compiler, especially ones that are turned on by default, can cause problems as well. Any time you add a new lint, you may break people's code that has #![deny(warnings)] turned on. Even if people don't, a lot of people will still try to rewrite code to make it comply with lints; but that in itself can cause problems. I've seen many bugs introduced over the years by people trying to do too many lint cleanups at once, and making mistakes in some of their cleanups. For this reason, the Rust compiler is fairly conservative about adding new lints..

That said, it sounds like there are plans to integrate Clippy with the compiler and cargo, but probably as an opt-in separate command rather than being included in the default set of warnings: https://www.reddit.com/r/rust/comments/5ibr2a/cargo_check_ha...

Code coverage is another example. You can use some existing code-coverage tools with Rust (https://users.rust-lang.org/t/tutorial-how-to-collect-test-c...). Because there are tools out there that work, there's less of a pressing need to get code coverage integrated with the Rust toolchain; I think that it would be a good idea to do eventually, as it will make it easier to do cross-platform and out of the box, but for now it's not the highest priority.

So, I don't think that any of these omissions are due to a difference of philosophy; just a difference of focus. Rust is all about admitting that programmers aren't perfect, and that better tooling can help avoid mistakes and thus make developers more productive. Right now, that focus is on things like improving the compiler (adding MIR, which allows for fixing several bugs in the compiler and doing some Rust-specific optimizations before getting to LLVM), implementing the Rust Language Server which can be used as a backend for IDEs, improving the ability of the compiler to do incremental and parallel builds, and adding language features with a focus on making Rust easier to use.



If Gecko is ever able to get rid of all of it's C++, it won't happen for quite a while, that will be an enormous undertaking. I would expect, if Rust is successful enough that that is feasible, then by that time there would be multiple different Rust implementations, and some of them may be written in pure Rust.

There's no fundamental reason that the Rust compiler has to be dependent on LLVM. It's just a good strategic decision as it allows the Rust developers to focus on the parts of the compiler that are unique to Rust, and use a well tested backend with lots of existing optimizations and targets for the parts that aren't particularly unique to Rust. There is actually some discussion already of using a faster, pure-Rust backend for debug builds, and maybe far in the future for release builds as well (https://internals.rust-lang.org/t/possible-alternative-compi...).


I'm an Emacs user, so that's what I've written most of my Rust in, but I tried out VSCode and setting up all of the Rust integration, and it was pretty easy to set up and seemed to work pretty well playing with it briefly. Didn't seem to be worth switching from Emacs for, but I was fairly impressed, and will likely recommend VSCode for anyone looking for a Rust IDE who doesn't already have a strongly preferred editor or IDE.


It's a framework for building cross-platform applications in which the UI is implemented in HTML/CSS/JS using an embedded Chromium and Node.js.

http://electron.atom.io/


For cross-platform apps, Qt is the best I've used. But it does have its warts, and it is big, it will probably bloat your app by about as much as Electron does.

But yeah, there's no one clear winner, which means that Electron is not a uniquely bad choice. Sure, it might be a little heavyweight for a really small simple app, and if you're not aiming for something cross platform your native widget toolkit might be a better idea.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: