skysight-inc/HackerNews huggingface dataset:
Compare that to virtually zero notable stories of
C++ projects switching to Go.

A lot of projects at Google have switched from C++ to Go, and the people I know who work on them are pretty excited about working in Go. Here's a blog post by a coworker who leads the Chrome Data Compression Proxy project:

http://matt-welsh.blogspot.co.uk/2013/08/rewriting-large-pro...
As a concept, "intelligence" bundles together a huuge number of concepts. In my programming job, at different times I apparently must use different parts of this bundle to be effective; using useful parts at the wrong times can lower my effectiveness.

And a lot of it is sensitive to social context. In a culture which prioritizes ads over immortality research, massive intellectual potential is unrealized because bullshit jobs are alienating. Would you work harder to serve banner ads (which you likely block), or cheat death and usher a new era of human civilization? (http://strikemag.org/bullshit-jobs/)
That's Rust: it aims to be a viable replacement for C in bare metal and high performance code including drivers, kernels, embedded and all of those areas where C used to be the only game in town. It should do everything C does, but safely and without performance penalties.
As richardwhiuk below says, this approach appears to distinguish between individuals and businesses, but many small businesses will just create an individual account anyway and share the password for a single user account.

They're still going to use customer support and infrastructure as much as other customers, but there's going to be that little bit of extra friction for users as they find out what the password is, and communicate any changes to it.

Personally in the context of Cronitor, I'd drop the user levels, and just segment on monitor counts and features. Maybe bump Slack integration up to the team level, since that's the sort of feature which is genuinely useful to a team, and less so to an individual.
My own project: http://www.appointmind.com/ Panasonic and Honda among others use it.

For a client I've built and maintain part of the backends of the largest speed camera app and data provider in Europe.
That's how things progress though isn't it? Super rich people buy the new hotness straight away before it's mass produced and there is a constant incentive to bring the price down (so that more people can buy spiber or mobile phones or take flights...).
From that post - a gem:

"Just to be clear, you’re not allowed to use Customer.io to send cold emails.."

Guess why :)
I very much dislike presentations that keep the slide history in the browser history.

Now, to go back to the original page you were on before you went to the site, you have to search through your history or click 100x times on the back button.

I also never found a use for deep-linking to an intermediate page.
I posted this yesterday: https://news.ycombinator.com/item?id=10539083

It seems timezones matter a lot. :)
Origin and Evolution of the Nervous System
C++11 in no way solves the fundamental problem of C++. C++ is too big and has too much baggage. There are too many corner cases and oddball stuff to deal with. Being a good C++ developer requires unnecessary amounts of training.

C++11 can't remove what is already there and so one just keeps piling on more stuff increasing the complexity.

I am actually sad C++11 happened because it keeps alive a language that should have died years ago.

I've worked years on projects where so many of the fundamental problems can be traced back to the usage of C++. Huge amount of legacy code which can't safely be refactored because C++ is just too complex a language for a refactoring tool to be able to deal with properly. Insane compile times. Odd hard to track down problems from static initialization and deinitialization. Templates are impossible to use in a sane way because they mix so poorly with regular OOP in C++ and increase compile times too much to be practical.

Move a project like that gradually away from C++ is a huge undertaking and nobody is going to support it as long as C++ keeps updating self to not be completely behind the times.
Advice from an old programmer
One company I worked years ago for got a Scottish CTO and he insisted the free drinks fridge be filled with Diet Irn Bru. It probably remains full to this day...
Can't do business overseas, or would have to give your profits (and possibly more!) to HMRC after doing so?
Improbable announces SpatialOS
that is some fine tongue in cheek journalism. I almost spit out my coffee
But isn't it that in practice most of the time this "last leg" is the only leg that crosses the internet? Most of the servers I see in the mail headers I receive are servers in the internal network of the sender. So IMHO transport encryption still is of real significance against passive attacks.
We have to thank Microsoft and Oracle for C++'s comeback to the news.

Microsoft for their work supporting the standards work, C++ conferences, push to improve language's safety. Also the change to back to native since the Longhorn failure that has switched focus to C++ and driven .NET to improve its AOT story, starting with Windows Phone 8.

Oracle by dropping the ball on Java support (JIT and AOT) for the mobile OSes, making C++ the only option to write portable code across all mobile OSes.

As for Go suitability for real systems programming, as a language geek and former Oberon fan, I think the day someone shows a Go bare metal runtime on top of something like Raspberry PI, the opinions will change. Thesis idea. :)
Not all MTAs do this, FWIW.
Show HN: Game Records: Social network for gamers
It actually did, once you flipped it over.

Basically it behaved like a audio cassette.

IIRC, later players could even play both ways. But by that time the VHS was firmly entrenched.
> Nobody will want to say "Yeah, GMail is actually great so I left it alone and didin't muck with it, can I have my raise?"

Does this incessant desire for change/to be seen to be doing something have a name?

It came up in a political commentary I was reading (about how politicians have to be seen to do something, even if the status quo is better), and I've noticed it in the "curve of website disillusionment" for clients ("Our website is 3 years old ergo a new shiny one will be much better. No, we didn't do any research but it's obvious 'cause it's old")
It's definitely very important for some domains, but handling OOM "properly" is a really vague/impossible concept for most non-bare-metal programming. Modern operating systems will over-allocate/over-commit memory via virtual memory (so malloc usually succeeds), and kill programs when the physical memory limit is reached, and/or just grind to a halt by swapping.

For instance, I can happily "allocate" 100 terabytes of memory on my laptop (16 GB of RAM, 16 of swap):

use std::{thread, time};

fn main() {
let _v: Vec<Vec<u8>> =
(0..100_000)
.map(|_| Vec::with_capacity(1 << 30)) // 1GB each
.collect();

thread::sleep(time::Duration::from_secs(10));
}

Of course, if I actually tried to use much of it, bad things would happen, but the point is the allocations themselves never failed.

Bare-metal programming, like a kernel, will typically use the lower-level `core` part of the standard library, rather than the whole thing (i.e. `std`) because the kernel will be literally providing the interfaces required for most of std-minus-core.

(I think it would be really great if the standard library could be less harsh when an OOM is actually detected, and I suspect it can be tuned in future, but it's not a show-stopper for most tasks.)
Berlin Erlang Factory Lite 1 Dec – Programme Up
If I happen to be cutting and pasting something that was
bold over here, I usually don't want it bold in my email!

Ctrl+Shift+V
Wow, that's huge. It's what everybody's doing anyway, but being standardized with big names and heavy hitters behind it makes it much easier to advocate and argue for.

Such an effort would be so much easier to advocate for in a C++ shop, and more importantly, very difficult to argue against.

This deserves a proper HN discussion. I've resubmitted it, it missed the front page the first time around:

https://news.ycombinator.com/item?id=10545921

(sorry for the karma stealing, lucozade totally deserves the karma if my resubmission takes off)
> Dropbox ... so for example they support Linux as well

Apart from the idea of not putting all my eggs in one basket, this is crucial for me too.

Dropbox is the only cloud-storage service with a good and working Linux client. All my machines at home runs Linux, so not supporting that means I wont even consider using the service.
Facebook director Marc Andreessen sells half his stake
Oh boy, more spam and BS nobody wants!
Hi,

I want to introduce you Game Records, a new social network for gamers. Currently we are on beta stage so it would be great if you can check it and share your comments here. Like or not please tell :)
Open issues: lessons learned building an open source business
Silicon Valley valuations may be seen as ‘marketing numbers’
Its possible, but if these solution make an language that secure, why haven't them caught on yet?

Back to my point: Tools can't replace knowledge. A fool with an tool is still a fool.
This 100x. I don't get it: if I've zoomed in the map or panned, and then make a search -- why isn't it obvious that I want the store closest to the area I'm looking at, and not one 30 miles away?
C was dog slow in its early days and there were safer systems programming languages available outside the UNIX world that were equally fast.

What has gotten C compilers to generate the code quality that have nowadays is 40 years of work in compiler optimizations targeted to improve C compilers code generation.
Java isn't exactly a big step up. Compare instead old C code to Haskell or OCaml. I am pretty sure the latter comes out a lot better with respect to serious bugs.

Also I have real world experience with working with the same type of code in two different languages and seeing a clear difference. I've rewritten a lot of Objective-C code to Swift e.g. Objective-C as a language is much like C with similar problems as C. Just doing a straight conversion the Swift compiler picked up a lot of problems from my Objective-C code I had never discovered otherwise.

Lots of other people write about similar experience of getting significant bug reduction from moving to a much more type safe language like Swift.
Unless you keep propagating "upstream" and the message gets to the "source" ISP, and they block the actual misbehaving user/account. For all we know, they can kick them off the network after sufficient transgression, and ban their account at the hardware ADSL level (assuming that's what it is). This also presumes the ISP is willing to implement such a feature, and kick-off their paying (albeit infected) users.

I don't know much about this stuff, so I'm extrapolating and pseudo-solving.
Thanks for the example. I think your coworkers' rewrite further reinforces the "sweet spot" for Go.

The transcoding was left as C++ but the other stuff including the networking was rewritten in Go. That makes sense to me because transcoding is performance intensive and cpu-bound instead of io-bound. (E.g. CPUs pegged at 100% while bytes being read at a slow 10MB/sec.) In other words, if people tried to rewrite ffmpeg in Golang, a conversion job such as avi to mp4 would run slower.

If Google's internal cpu-bound projects switched from C++ to Golang, that would be a very interesting data point. In other words, I don't expect Google would switch their machine-learning algorithms scanning petabytes of data from C++ to Go (or create greenfield machine learning projects using Go instead of C++).
In the American version too, that's the protagonist's role - the Majority Whip. In practice, in both the American and British systems, the Whip's actual power springs not from blackmail but from the more prosaic threat to withhold party support for a candidate's reelection.

What makes the British Whips (and party discipline in general) so much more powerful is that in the UK, candidates are almost completely dependent on their party for campaign financing. By contrast, in the US a candidate usually gets campaign donations directly from supporters, so a competitor from the same party supported by the party establishment is less likely to win. This is why, for example, the Tea Party in the US took the form that it did (insurgent candidates competing in primaries against the establishment's choice), whereas in the British system equivalent grassroots insurgencies are all-or-nothing affairs that target the central decision-making bodies and leadership of the party (think Jeremy Corbyn).
Microsoft unveils German data plan to tackle US internet spying
US banks attacked, manipulated and left (heart)bleeding
Properties of an language are not necessarily inherited when compiled. LLVM Code is not bound to Rust's memory access restrictions.
You guys made sth special. a big congrats to you. You should work a bit more on UI but looks so cool. good luck
7 Guerilla Hiring Strategies for Startups in Southeast Asia (Revised)
I agree. I think to a certain extent, this curve has always been the case. However, in the old days, you as a customer had an easy choice to keep your particular piece of software at the top part: Just don't use the newer version. Of course now, thanks to the "cloud everywhere" mentality and the agressive push for auto-updates that seems less and less possible.
why is this useful?
Today Ada, Rust, Spark, C++, ATS.

Eventually Swift, Systems C# (if it ever comes out MSR), D, or any other language.
That's exactly the case... I /almost/ been had last year, and I was only saved because the canadian company I worked for still had a remote small (nearly unrelated) office in the UK, so I had to re-invoice everything to them.
Does donating blood extend your life expectancy?
+1. Fascinating topic, very nicely presented.

I didn't know this platform exists.
You're not supposed to use the stdlib for baremetal programming.

> instead of trying to create something new

monadic error handling isn't new. It's an old feature used by many languages, and preferred by many over exceptions.
> Getting git working along with ssh-agent is still hit & miss
Git for Windows support ssh out of the box, any particular reason you want to use ssh-agent?
Cobol is still around.
All major open source C compilers are written in C++.
One must be careful of conflating the distinct effects of expectations of intelligence and intelligence itself. The former exerts psychological pressure[0], the latter is a catalyst for success. It's often possible to have one without another.

[0] http://web.stanford.edu/dept/CTL/cgi-bin/academicskillscoach...
One way of pushing users to use a new product is by degrading an existing product. Here, Inbox is the new Gmail. Switch. Switch. Switch
That book's been sitting on my shelf for years! I'll go read it now once I finish High Output Management (highly recommended). Thanks!
Because as the article says, it is as good as a CA-signed one, is easier to make and can have a long validity period.

StartSSL limits you to one year and Let's Encrypt is really focused on certificates for HTTPS (their ACME protocol AFAIK requires a handshake through HTTPS).
I tried using new C++14 features, but the performance was terrible. Even compared to scripting languages. The problem is that you have to now performance profile every single feature and know all the gotchas.
Wee-slack – A WeeChat plugin for Slack.com
Just this once.
Nobody is going to make you overload operators, do work in constructors, or throw exceptions. Restrict yourself to the subset of C++ that you prefer.

By comparison there is no subset of C that lacks malloc/free.
on HN, just click the "web" link below the submission title. Does the same. ;)
Yeah for snacks and company-provided meals I can see it being grey enough to be "meh". But I remember back when I worked at RIM in Waterloo, I heard that a reason they couldn't sell parking passes to their underused parking lots near the UW campus was that it would make the 'free' passes employees got a taxable benefit (and all of the headaches that implied). I guess if the perks can be taken from the office (phone bills paid?) that's an easy argument for taxability.
So science advances slowly?
> handling OOM "properly" is a really vague/impossible concept for most non-bare-metal programming

I strongly disagree. Handling memory allocation failure is trivial: throw an exception. It's also trivial to reserve enough memory to throw an exception. I honestly don't understand people who claim that recovering from OOM is futile because you need to almost always allocate memory to recover: in fact, you almost never do.

> Modern operating systems will over-allocate/over-commit memory

Windows is a very modern operating system and does not overcommit. (To its credit: overcommit is a terrible idea.) Even on overcommit systems, you can exhaust your address space and see allocation failures. No, 64 bits is not actually infinity. No, the whole world is not 64 bit. (Not every program even benefits from being 64 bit --- that's why the x32 ABI exists.)

> point is the allocations themselves never failed.

The resource you're allocating is address space. When you run out of this resource, your allocations will fail. On overcommit systems, you don't allocate commit charge until you access the memory. It's very difficult to explain to people who work exclusively on overcommit systems that "memory" isn't a single resource, but a set of related ones, each of which can be exhausted.

> I think it would be really great if the standard library could be less harsh when an OOM is actually detected

The only reasonable thing to do on OOM failure is throw an exception, like Java and C++ do. Error codes are too cumbersome even if you dress them up and call them "monads" --- a lot of code allocates, so if you used error codes to indicate OOM, you'd have to manually propagate exceptions from almost everywhere) and just panicking or aborting is too brittle, since you can, in fact, successfully recover from allocation failure, persistent folk myths aside.

Now Rust has both Result _and_ panic/catch_panic, which I think is both sad and hilarious, as it's going to lead to decades of confusion over which error reporting mechanism to use in a particular situation. (The Go designers made exactly the same mistake, as did the designers of the old java.io.File interface.)

It's a shame for such a young language to have that kind of baggage already. If Rust's designers hadn't been so stridently anti-exception in the first place, we'd have ended up with a much better language.
Well... you know, G+ is full of Google Employees...
If your app puts a lot of emphasis on sharing between its users, or depends on you really need to ship an Android version ASAP.

Otherwise, even though I am myself an Android engineer, I don't think you 'have to' ship an Android version as quickly as possible, especially if you don't have the means to do so.

On the contrary, wait until you are ready to pull it off.
The 2 platforms have widely different UX conventions, so just porting an app from platform A to B is not a very good idea, you might need to rethink a lot of its interactions.

One good thing about going multi-platform is that it can nudge you to clean your codebase (which is better for the long term evolution on any platform). It is harder to excuse a very shitty hack somewhere in your API when it has to be used on 2 or 3 platforms and creates problems on each of them.
Oh nice one, didn't know that!
Yaler.net – A relay infrastructure for secure access to embedded systems
Well, I got my own bookmarks for that :\
I'm always up for talking about Rust, but I'm not sure what you're intending to show by submitting a link to a specific page of the Rust book. :) Is there something about references/borrowing in particular that you'd like to discuss or present here?
Amongst all the technical differences, following are some of the factors from a team-lead/architect p.o.v:

1) What is the ecosystem now? If it is not good, does it look like it will improve in next X time or so?

1.1) What are the production ready libraries right now?
1.2) Who are the maintainers? Who is backing them?
1.3) How approachable is the community?
1.4) Are the current pain points are being worked at and at appropriate speed?
1.5) How is the tooling scene?

2) What is the overhead for large codebases? e.g factors = [simplicity, deployability, testability, code-review, refactorability, learnability]

3) How hard/easy it is to wrap C/C++ code/libs if we ever need? Will there be any performance impact?

4) Does it look like more CPU bound code will be added looking at the product roadmap?

We are a python shop. As long as it was network IO centric we were ok. However due addition of features, the CPU bound code has increased and we clearly see the limitations of Python. This has led to find the replacement language. Since we are reviewing now the 'X time' in #1 is '1 year'. For others the tolerance may vary.

As for #2: Code review has an additional overhead due to Python's dynamic nature. Also we need to write additional unit testcases. A language which "prevents" basic issues (not going into 'how') has less overhead on the team.

#3: From what I know, go does not do well here in terms of performance. We deal with lot of 3rd party APIs e.g using VMware APIs which are in C and are called in the main loop. Also evaluation of this point helps us to see if any shortcoming in the current libraries can be augmented by wrapping existing C/C++ libs. Rust & D are better I suppose.

refactorability: GC'ed languages inherently has an advantage (for large codebases). Counter examples welcome.

learnability: Rust suffers here most. This is a point which makes it hard for Rust to get introduced and even though I may have patience to stick with it others may not and drives down the adoption. On most occasions, other teams also need to be convinced for any meaningful transition.

Testability (i.e. unit tests): Python is really good at this. This is not a point for the testing tools but more for language features. I find dependency injection in Rust really hardest right now (or may be I might have missed something)

#4 is true in our case.

#1 (libraries/tools): Go is ahead I think in terms of production ready libs.

#1 (community aspect): Go & Rust are better here than D (right now) even though the founder of D is prolific. Note that when championing a language inside a company is concerned perceptions matter a lot. Here I think D suffers a bit in my case.

Right now I am in wait-and-watch mode but leaning towards Rust.

(edited: formatting issues)
I don't think singling out Rockstar here is fair - I'm sure devs at all the AAA publishers are hate how what they create ends up due to corporate requirements. Here's looking at you Ubisoft, EA, Activision, Konami...
Track Your Raspberry Pi / Mac / Linux Without GPS
> just make VS' compiler look like it's from the 90s. Really.

Because that's what they are.
The Snooper’s Charter would devastate computer security research in the UK
While this sounds attractive, OpenCL performance just doesn't seem to be there at the moment.

In CNN benchmarks[1] the CL based implementations consistently finish at the bottom. I think this is mostly because of the weak nVidia OpenCL implementations, but that doesn't help, since most people use nVidia (eg, Amazon GPU instances are nVidia based)

[1] https://github.com/soumith/convnet-benchmarks
They say that the paintball gun doesn't shoot the projectile fast enough for it to overcome friction from the rails, so without the magnetic field it wouldn't exit the gun at all, which seems plausible. So assuming they are trustworthy you can completely discount the energy provided by the painball gun when considering the energy given to the projectile.
Yes. However, writing a linux-like kernel that is not 95% `unsafe` code would be a lot harder than just a straightforward syntax change of C to rust.