skysight-inc/HackerNews huggingface dataset:
I'm interested in those stories too. Also do a search for Rust in the story subject here on HN. There are many many 'one week with rust' and 'moving to rust' articles posted. Many are interesting reads.
It could be useful it it allowed you to scroll the cursor in text by swiping you fingers left or right. You could even have another vertical bar on the left for vertical scrolling. All without moving from normal typing position.
The problem comes when MBAs, generally without technical background, build companies without real value and expand an already existing bubble.
Avionics certifications are well past the extent of my knowledge and I will gladly accept your point. I was generally addressing the idea that the need for preemptive scheduling precludes the use of a Linux-like kernel.
North Carolina--East Coast state in USA--is basically contiguous forest once you leave the downtown area of our few big cities. Farms and neighborhoods still punctuate the landscape, but any land that isn't routinely maintained by farming and mowing begins to revert back to woods very quickly.
Here's an overview from last year showing nvidia's wayland support under way:

https://www.phoronix.com/scan.php?page=news_item&px=mtgxmde
Depending on how you think about it, purchasing a suit is an investment.
The first virtual reality treadmill app Indoor running made fun and social
I personally don't see Rust as a good replacement for C - it's too complex a language, and it is especially easy to loose sight of what is happening at a low level due to all of the abstractions.

Even if you did decide to use Rust instead of C in C's typical domain - operating systems, drivers, and constrained resource devices - you would be forced into using "unsafe" blocks anytime you had to interact directly with the hardware, manually manage memory, or issue ASM commands; at which point you're as vulnerable to programming mistakes as C.
Dittoing userbinator here. Avionics systems aren't generally treated so casually. DO-178B [0] has several levels of designations for criticality of systems. A is the highest. Essentially, if these fail, people will die. E is the lowest. If these fail, people are inconvenienced. Passenger AV systems, wifi, those are conveniences and are not held to a terribly high standard.

[0] http://en.wikipedia.org/wiki/DO-178B
What are the hardware display refresh rates of these devices?
If it can do 120fps I'm more interested in putting my phone on a spinning motor and turning it into a volumetric projector.
>At the time I wrote that post, YouTube was not a real business; [...] The fact that they were forced to sell a business that is now worth $100-150b for $1.6b is a good indication for how close to the brink of destruction they were.

I don't follow this point. How is selling something to Google for $1.6b an indication of being on the brink of destruction? And if the point here is that they were worth a discounted $100b then (so sold undervalued), how can that be the brink of destruction either? Either way I don't follow the author's reasoning here. It sounds like he's saying, "they were REALLY worth a discounted ~$100b, but they were in such dire straits they had to sell for 1.6% of that." But that contradicts his point that it wasn't a 'real' business.

So either way, I don't see how that sentence supports the point he is making.
Not sure this is relevant in a coffee thread, but for me it started with urinary tract infection symptoms (frequent, burning urination) which is what brought me to the doctor. I started antibiotics, which improved it slightly but it didn't go away completely. When it returned and got much worse, the doctor referred me to a urologist who diagnosed it as prostatitis. After months of various antibiotics and a half dozen specialist visits at $200/pop I finally gave up on going to the doctor, as he didn't seem any ideas outside of pumping me full of more antibiotics.

As fugoogs mentions, non-bacterial chronic prostatitis isn't well understood and there isn't an effective standard treatment protocol. There are theories ranging from it being caused by nano-bacteria that do not show up in normal tests to it being a muscular tension issue that can be resolved with physical therapy.
I recently went to a furniture store dressed like a 'cholo'. No sales-person would talk to me, to the point of struggling to get a brochure.

Returned to the same shop in a collared shirt. The salesman wouldn't leave me alone.

Next time I return, It'll be back in my scruffy attire, ready to make a purchase.
You're not going to convince C programmers simply by beseeching them. The article is missing an entire component: the argument for Rust. There needed to be examples of C programs that one may write that are actually unsafe and of how Rust addresses that. There needed to be a discussion on the performance of Rust, and of its ability to call into C without overhead (or to be called by C without overhead). Everyone already knows what the problems of C are, what they need to know is what the alternatives offer and how in the end you are not giving up too much.
At the same time, turning young trees into old trees isn't a very difficult problem. Once the decision is made either by economics--farming is no longer viable--or aesthetics to let the trees grow back, it's only a matter of time.
Meet the Man with Two Full-Sized, Functioning Penises
I'll confess, I have looked ever-so-briefly at D and Go and I figured that Rust was probably similar to Go but I just didn't take the time to learn about it. I like the idea of D (especially design-by-contract), but I have difficulty convincing my colleagues (and myself) that a product with a garbage collector can perform consistently well enough.

Then I read this in TFA:

> Despite guaranteeing memory safety, Rust does not have a garbage collector or runtime, and one of the benefits of this is that Rust code can be called from C with no setup at all.

Maybe I should think about it as "you always enable ASan in your production binary"? That suits me just fine, if that's one of its major benefits. I will resolve today to follow up on Rust and try to learn more about it.
Nice, but full screen mode won't accept input on OS X 10.10.3 using Safari 8.0.5.

I can input in the browser and it shows fine.
If I full screen it the text remains but it ignores input.
What about pervasive virtualization? The issue here is not really fsync. A fault-tolerant in-memory cluster should not lose data.
I think its a reference to state space control. Traditionally, PID controllers fell under 'classical control', which is basically the entirety of control theory before the rise cheap computing. They involved devising all sorts of "tricks" to make designing controllers tractable by hand (more or less) - stuff like frequency domain representation, pole-zero plots, root locus method.

State-space representation is a strictly time domain approach, where you break your model and controller into a bunch of 1st degree DEs. This method is really only tractable with computing support.

In general, state-space and frequency domain models can in theory accomplish the same goals. You could for many situations design a PID controller using classical methods, and then take the same situation and use a state space approach, and in the end result in the equivalent controller/behavior.
So what did you do today to solve those problems? Why do people in Pittsburgh count as "Silicon Valley" to you anyway?
Tune House – Free Living Space for Women Studying CS
>Well, there's Go.

Not for the things C is good for. OS work, drivers, common libs like OpenSSL callable from other apps, infrastructure work, etc.

Besides Go is nothing new. There have been similar languages ever since 1970, and they are not replacing C.
Not necessarily as the idea is to isolate those components into the unsafe blocks, and having locality on a bug is a pretty big component of fixing it.
Countries don't just compete on taxes by providing the same service more efficiently, but also by providing a _worse_ service to their citizens. It's a race to the bottom.
> at which point you're as vulnerable to programming mistakes as C.

Yes, but if you start off in C's typical domain, then you cannot decompose your problem set into safe and unsafe bins using C. So you're stuck with unsafe-lowest-common-denominator everywhere you go.
To what end? It seems like the package overhead would destroy any savings in package size to be able to mix and match rather than just having a larger, more complete package.
I'm sorry, but as a user and hacker of UNIX, POSIX and all things GNU/Linux since 1996 I have to say this is just fruitless and counter-productive. Although, I will support the sentiment "Death to C++" :-)

The argument is over-simplified and rather than looking to the root of the problem tries to sweep it under the rug by also ignoring the fact that many new languages have their interpreters written in C. The root issue is that the C language needs an update, an overhaul, and that once the standard has been refreshed, C will continue to be the #1 language among programmers.

Sadly, nothing can be done for C++ and to lump C and C++ together is as upsetting as calling for programmers to cease the use of C! :-)

Last thought: There needs to also be more focus on teaching programmers how to write secure C programs. Every year new exploits are released that target insecure C programming styles, and the C community should make sure programmers are being educated on how to avoid these issues. Look to subsets like MISRA C as an example and a move in the right direction; advocating secure programming/language subsets rather than changing languages ultimately makes more sense.
Ordinary people are pushing to own their own homes; not only for financial reasons. Rental agreements in the UK greatly favour landlords and typically don't allow you to own a cat or paint your own walls.

Renters have limited security of tenure in a sense which can be very apparent: even if you meet all the conditions of rental, you can be kicked out of your own home when the landlord decides their interests lie elsewhere.
I'm sure C will be still going for a while yet in embedded development ... microcontrollers, etc. There's usually no other option except assembler.
And here's hoping for the death of sensationalist articles with zero substance.
Newbie here. My first language was Python, then I wanted to learn a so-called low-level language, but not C or C++, as I felt I don't have THAT much free time to waste.

This left me only Rust, and it is a pleasure to learn. The compiler errors are very helpful, and so is the community. You can take your time and gradually discover new stuff, like the difference between heap and stack, static/dynamic dispatch, Move vs. Copy semantics, usefulness of tagged unions in combination with pattern matching and so on...
The interview is excellent, and has great nuggets of wisdom. The one that particularly stood out was--

"People always say you should live every day as though it's your last. I sort of have taken the opposite tack, where I think you should live every day as though it's going to go on forever. You should treat people like you're going to see them again in the future. You should start working on projects that may take a long time. And so I want to live every day as though it's going to go on forever." [0]

The one I couldn't agree with (and one that features in his book Zero to One) was about 'Competition is for loosers' I find it ironic that he brings up example of Google and the monopoly it holds over the market... but wasn't Google entering the search market as a competition to multiple other internet firms before they leap-frogged them with all the talent they gobbled up from DEC?

I like the hypothesis about how there is always more than one entity (or a person) that's trying to do invent something almost at the same time-- theory of Relativity [1], the airplane[2], the light blub [3]... and how each of them were competing against time as much as each others to be the first to achieve the breakthrough.

[0] http://www.goodreads.com/quotes/218217-work-for-a-better-lif...

[1] http://en.wikipedia.org/wiki/Relativity_priority_dispute

[2] http://en.wikipedia.org/wiki/Early_flying_machines

[3] https://en.wikipedia.org/wiki/Incandescent_light_bulb#Histor...
howitwouldlookandhowyouwillreaditwithoutspacebar.
Most of Rust's safety guarantees are at compile time, not at runtime, and so have no runtime overhead. ASan's docs claim a 2x slowdown.

That said, defense in depth is always nice. kmc got AFL working with Rust recently, and it's uncovered some things. Using an ASan-like tool to do some of the runtime stuff would be great to have.
>* The article is missing an entire component: the argument for Rust. There needed to be examples of C programs that one may write that are actually unsafe*

Every C programmer already knows what kind of C issues exist, and how with C you can screw up things and what operations are unsafe.

It's not like he's saying something novel that will leave C programmers scratching their head as to the value of a safer language.

>There needed to be a discussion on the performance of Rust, and of its ability to call into C without overhead

He suggested they look at it, and he gave the basic 10,000 foot overview. It's not like C programmers (an industry with millions) will convert simply if some random blog post gave more specific examples...
This is okay. The point is that the majority of time, compiler checks/errors warn you from mistakes in safe code blocks. As such, you can put more focus on the actual unsafe parts.

It is not about completely removing unsafe stuff. It is about reducing the possible mistakes as much as possible.
I wouldn't even call them tech-utopians. I would call them people who do know that a) the world can be made a better place but that b) for that to happen people must make it happen. I can't speak for any of the three but I don't think any of them are utopians; understanding that progress can be made isn't the same as utopianism.

Journalists seem to like phrases like "techno-utopian" in order to make them sound more like the other and like a different species than their readers.
Yeah, it's odd. It's not clear why they're just not using json... json will give you an homoiconic language of arbitrary descriptive power.
I mainly program in C and C++, but have recently started a side project in Rust. So these are thoughts from a Rust newbie (which I still think can be valuable):

Pros:

- Pattern matching is beautiful, and is one of the things I miss most when not working in Racket.

- I love their static typing. I think they hit a sweet spot with type inference inside of functions but required types to be specified as parameters (too much inference can make it hard to know exactly what type something is, too little inference means I spend all my time writing type signatures).

- Borrowing and lifetimes are neat and have helped me avoid some lifetime-related bugs.

- Being able to call Rust code from C is a huge win, and I think this world needs more "systems-level" languages than C and C++.

Cons:

- Borrowing and lifetimes. This is actually is a huge pro, but sometimes the compiler can spot a lifetime issue that I don't understand (which makes fixing it hard). I'll get better with this with time, but associating lifetimes with object types is a bit confusing and hard to do if you want to do anything nontrivial. Again, I'm sure this is mostly because I'm a newbie, but it's also reality.

- Verbosity. Rust is actually concise for the most part, but if you want to pass a &str to a function, but have a String, (which, FYI, is fairly common in my experience, as most string-related functions take a &str), you've got to either call as_str() (which is unstable) or dereference-reference (i.e. &*) the String. There are a few simple things that require you to be more verbose than some other languages do.

Overall I like Rust. I think it's worth experimenting with, but I wouldn't start a really serious project with it right now (because it's so young and volatile). If someone wants to use it for a really serious project, I'd suggest checking out Rust in another year or two when it's a little more mature.
I agree. One of the best parts of C is how simple it is.
Exactly, it's a holistic approach, everything matters differently depending on the context. Sadly it kills my dreams of unification on the way.
Hello! Is there any chance that this would work with other language front-ends that generate LLVM IR?
> but this surely paves the way for complete virtual keyboard where all the physical keys will be replaced by virtual keys.

Like the laser keyboard: http://www.laserkeyboard.com/ ?

Or every tablet/phone in existance? Personally, I don't find typing on a flat surface to be a very pleasant experience. As a touch typist, I depend on a certain amount of feedback to my fingers to identify when a key has been actuated, and I'm not always looking at my screen when I'm typing something out.

With this device, how could I know the spacebar registered properly, and didn't accidentally send my cursor into another location due to an errant swipe of my thumb as it rests on the spacebar?
Being snarky, but a lot of the world's consumer economy can be seen as shoveling fuel at crackpot industries.

You're correct, but I'd rather a few million dollars going to this research than a few million dollars going to some magnetic-healing-band toting pseudo-guru.

The "first world" wastes ridiculous amounts of money every second. Can we divert at least some of it to disproving crack-pot scientific ideas? It'd at least be entertaining (like Mythbusters on steroids!).
The unsafe code is neatly delimited, so you can write 95% of your application in safe code, and the remaining 5% in unsafe code and offer a safe interface to the programmer. This is the real strength of Rust IMO, you don't need to be hyper alert in every single function you write.
Or sensationalist comments with zero substance.

Perhaps there should be this unwritten rule, that if a post has made it to the front page of HN, it means enough HN users voted it, and it's interesting to them, so it's counter-productive to dismiss it as uninteresting...
Well, that's locality on what in theory could be causing a bug, but not on where it might manifest, i.e. a wild pointer trashing data maintained by purely safe code.

Still, in theory isolating the possible causes is a fantastic advantage.
The software field is very picky in what it thinks is right... for instance, iron grip of Apple over the entire iOS eco-system is fine with most developers who'd continue to build on their platform, whilst any such move by a company that isn't really in the tech scene as much (like the ISPs) is scrutinized to hell and back.
While this is true for many embedded platforms, if it's an architecture that LLVM knows about, you can use Rust on it. That said, many have just a proprietary C compiler, or something similar for a barrier to entry, it's true.
Euclidean plane? Not line? Did I misunderstand the construction?
Yes, you can think about it irrationally if you like to justify your spending.
And plenty of devs go and work for such companies and individuals…

One would think we'd come up with better ways by now to lessen the allocation of resources for things in the present that are of marginal utility for most people, but somehow, humans have a knack of creating/engaging red queens races relative to other things that are theoretically possible and feasible.
This is a great idea. Genius, actually. But I shamefully feel obligated to say when I first saw this, I read it as "tuna house".
Right. The discrepancy in reward, prestige, and chance of advancement between founders and employees is Silicon Valley's elephant in the room. Founders don't really take on more risk, because they have the social resources to get seed funding right away and because their backers will protect their careers no matter what happens, but they get orders of magnitude more equity and, if the business succeeds, recognition and credibility. It really is a new caste system, and it might be Silicon Valley's weak point right now. The illusion that most people have when they go there is that they'll be founders in 3 years, when the reality is that most will never be founders because they don't have the right social class background and pedigree.

It can still be worth it to be a startup employee if you can get more responsibility and faster promotions than elsewhere. However, if the startup is one of those that always promotes externally, while the engineers who built the original work get shat on for mistakes made in chasing deadlines-- this is a common anti-pattern-- then you're wasting your time and should bounce as soon as possible.
LaborVoices looking for a rails developer
Glad you're having a good time with Rust. :) One small note:

> if you want to pass a &str to a function, but have a String

You can just add a & to your String. &String coerces to &str. Deref coercions are one of the few places where Rust does an implicit coercion: http://doc.rust-lang.org/nightly/book/deref-coercions.html
Summary of http://qz.com/393209/google-wants-to-do-away-with-space-bars...
There's already some toy OSes written in Rust: http://scialex.github.io/reenix.pdf

I think Rust IS able to replace C, precisely for the same reason why Java and Go fail to do that: they have runtimes and they are garbage-collected. That means that you can't easily write a library in Java or Go and then call into that from another language without complicated interop and overhead. You can't write low-level code without headaches. Et cetera. Rust doesn't have a runtime, so it's like safe C++, for that matter.
We will always have legacy code because most software is writen to satisfy business requirement, and those requirements change over time. Except for hobbyists and academics, software is not written with advance knowledge of every eventuality. From a business point of view good software adapts to change. Those adaptations may make the code more "legacy" or icky to future developers, but it's always a cost/benefit tradeoff.

Software is not the only technology that turns legacy and needs refactoring. Have you ever done a significant remodel on a kitchen or bathroom? Did you curse the original plumbers and electricians for not anticipating you would tear a wall out and move the sink? No. You factor those costs into the job, expecting that some things will not be as easy as they first appear. If you hired a contractor to remodel your bathroom and he saw "legacy" plumbing that made the job harder, would you let him tear the house down and start over?

Programmers tend to think of software very narrowly: the things they value are performance, an abstract notion of elegance, how impressed their peers will be by the code. They may try to anticipate future requirements but they risk violating the YAGNI principle if they get carried away (to say nothing of overrunning the budget and schedule).

The people who pay for and use software have a different set of requirements. In most real businesses the data that runs the business, usually living in a relational database management system, has more long-term value than the application software. Data has a longer lifespan than software in most applications, too. Yet many programmers who bang the "legacy code is shit" drum give very little thought to data integrity or the long lifespan of critical business data.

Sometimes legacy code is crap that has outlived its usefulness, and is now too expensive or dangerous to keep tinkering with. More often the legacy code works and isn't really that bad, even if it uses spaces instead of tabs, or has funky variable names, or isn't written in a cool language. Programmers need to step back from their own fashions and prejudices and spend some time figuring out the legacy code and how to fix and refactor it. Almost all of my consulting clients come to me after they've been told by three or four other consultants that their code is so bad it has to be thrown out and rewritten (in some cool new language). That is almost never necessary in my experience.

I've written more about maintenance programming on my blog.