Ignoring pull requests discourages open-source contributions - <AUTHOR> http://danluu.com/discourage-oss <comment><USER2> A part of the problem is that GitHub makes it difficult to find forks. If a project is not being maintained in the original repository, and somebody else is maintaining it, it should be made easier to discover those other forks.

Right now, when you click the "forks" link in Github it shows a pretty graph of commits across branches and repositories, which although useful in some cases, is very hard to navigate and doesn't help discover active forks.

Moreover, for the maintainer of the alternative fork, it would be nice to be able to clone the pull-requests too from the main repo. They will be able to merge any new PRs into their own fork quickly and also to automatically inform the PR's watchers.

<comment><USER3> _Moreover, for the maintainer of the alternative fork, it would be nice to be able to clone the pull-requests too from the main repo. They will be able to merge any new PRs into their own fork quickly and also to automatically inform the PR 's watchers._

Yeah, that would be cool. The only thing you can do right now it's to just watch the original repo, and send messages to the PR submitters to open a new PRs against your own fork.

<comment><USER4> You can just fetch the PR's on the command line and merge them to your fork. But being able to do it in the web ui would be nice too.

<comment><USER3> I think a lot of people like using the web UI because you don't have to add another remote just to pull from it maybe once.

I'd definitely want to contact the creators of the PRs anyway so that they are aware of my fork.

</comment></comment></comment></comment><comment><USER5> I found a simple solution to opensource burnout: when someone contacts me about a project and wants to improve it, I give them access to the repo.

I do this when:

* I don't have the time/interest on the project

* The person seems genuinely interested in maintaining it

Most people I've come across in the opensource world are polite. So I just assume that the ones I grant access to repos are nice enough for other people to interact with.

<comment><USER6> Same here, but I don't even care if the person is interested maintaining it. I have observed twice now that the interest of somebody submitting an almost trivial patch flamed up after I granted push access. The project suddenly got a burst of life again, and commits started to become more and more ambitious.

<comment><USER5> I am going to try that from now on. Giving people access to repos and then letting them pass on the baton when they are done. That is a very novel idea.

P.S: Yes I upvoted you and I wish I could do it once more :)

</comment></comment></comment><comment><USER7> OP argues that the presence of the 'Pull Requests' tab is encouraging people to create pull requests, and therefore the project owner is somehow responsible for reacting to pull requests.

There's also a 'Fork' button, which is kind of prominent, so by OP's logic, people should feel encouraged to fork the project.

"But when I looked at the mailing list for the project, I saw a wasteland of good patches that were completely ignored, where the submitter would ping the list a couple times and then give up. Did it seem worth spending a week to disentangle our IP from the project in order to submit a set of patches that would, in all likelihood, get ignored? Of course not.

If you have commit access to a project that has this problem, please own the process for incoming pull requests." (from the article)

Ok, so if the mailing list is dead and your pull requests aren't the only ones being ignored, why not just fork the project and 'own the process' yourself? You could even try to contact people who tried to contribute and got ignored, and let them now that you will 'own the process for incoming pull requests'?

And if you don't have time or energy for that, why demand it from other people?

<comment><USER8> To that end, the author also suggested that it may serve the project (and subsequent forks) well if the project owner disabled PRs.

<comment><USER9> You can not disable PRs on github. The wiki yes, issues yes, but it's not possible to disable PRs, that simply isn't an option.

At best you can add a note/contribution guideline saying you don't accept PRs, and close them as soon as they're created, but it's not possible to prevent them.

</comment></comment></comment><comment><USER10> Although the author tried to obfuscate the project he used as his example, people on Reddit quickly figured out that it was linguist. This is a library Github maintains that they use for detecting what language a file is written in. There is a special irony in Github employees encouraging then ignoring PRs that would improve their own product.

[https://www.reddit.com/r/programming/comments/1pczpr/how_to_...](https://www.reddit.com/r/programming/comments/1pczpr/how_to_discourage_open_source_contributions/)

[http://danluu.com/everything-is-broken/#github](http://danluu.com/everything- is-broken/#github)

<comment><USER11> We have no idea why the people at github did not merge this PR. Maybe several people on the team left the company. Maybe they were pulled into a project which will have higher revenue. Maybe so few people have this problem that this improvement isn't a priority. Maybe it breaks some other internal functionality that someone uses.

We have no idea whether this "would improve their own product" because we don't know what their product is, their product roadmap, their staffing, their budget, or any of the innumerable factors which affect whether a company chooses to spend time and energy and effort and money when implementing a feature.

So why do we presume?

<comment><USER10> We should not have to presume. Since Github is soliciting contributions to linguist [0], they've created an obligation to engage with outside contributors and explain their decisions. When the author wrote his blog post, there were over a hundred PRs and apparently no acknowledgement of many of them from Github. In his "How to destroy your community" talk [1], Josh Gruber refers to silence as "the most effective community destroyer of them all".

I'm not actually trying to call out Github, by the way. It's great that they've written up guidelines for contributing [0], and a glance at the PRs shows much more engagement now.

[0] [https://github.com/github/linguist/blob/master/CONTRIBUTING....](https://github.com/github/linguist/blob/master/CONTRIBUTING.md) [1] [https://lwn.net/Articles/370157/](https://lwn.net/Articles/370157/)

</comment></comment></comment><comment><USER12> Couldn't you charge people to look at their pull requests? The contributor's fix may seem very important to them, but in actuality may or may not be of any value at all.

They are using free software but asking the maintainers of it to spend their time to review their pull request. Some entitlement there. The justification, my fix is important. Well, we don't know that, and to determine it costs time.

I would think a fee system where people pay to have their pull requests prioritized. I know it goes against this misguided idea that everything free is a virtue, but there is a good reason why some things have an associated cost involved.

<comment><USER13> I seriously doubt that a financial incentive would change most maintainers' attitude towards pull requests. What is an appropriate piece rate for a PR review? There are plenty of highly paid developers who are doing a side project for free, for whom an hourly consulting rate <$100 would be well below their market rate. Well paid professionals doing a labor of love are not likely to be motivated by $5-10 here and there. Not all package maintainers are in this category, of course, but most are volunteers who don't expect financial compensation for it. Offering me $5 (or whatever nominal amount) to review a pull request is more likely to insult me than motivate me.

This is my problem with Gittip/Gratipay as well, the amounts are not enough to make a self-sustaining project, and even if it becomes a standard expectation, when someone else is willing to do it for free it would breed resentment. Open source should not be a service economy dependent on the gratuities of others.

Note that I'm not arguing that developers _should_ work for free, just that small sums aren't likely to change their behavior. Sustainable business models for open source projects are difficult, and I suspect that tips are not often going to provide one.

<comment><USER12> I wouldn't be too US centric in your assumptions. India will soon overtake the US in software devs and the average Indian dev makes approx. $5400/yr.

[http://www.glassdoor.com/Salaries/india-software- developer-s...](http://www.glassdoor.com/Salaries/india-software-developer- salary-SRCH_IL.0,5_IN115_KO6,24.htm)

Now, even on the high end if the Indian dev makes $7k a year or $3.50/hr. And I'm a relatively high paid US developer who depends on their project and I offer $50, that's 14 hrs. of work. Not insignificant.

<comment><USER14> Cloud services will destroy Indian IT services viz TCS/Infosys/Wipro/TCS/HCL

</comment></comment></comment></comment><comment><USER15> If you have no plans to maintain hobby code, you should _discourage_ usage. Say it right up front:

"TagTree is unsupported and not meant for use in a production Dart application, unless you're willing to fork the code and fix any bugs you find yourself." [1]

Or if a project is widely used but difficult to contribute to, you should say so up front, like this:

"Contributing code is one of the more difficult ways to contribute to Guava, and is almost never what the project really needs most [...] We know it's tempting to submit code before the feature is accepted, but this is not always a good use of your time." [2]

People tend to over-promise because that's what they see other open source projects doing. But you don't have to be an evangelist just because everyone else is. If you're not committed to doing something, don't sell it. Real leadership is about being respectful of other people's time.

[1] [https://github.com/google/dart-tagtree](https://github.com/google/dart- tagtree) [2] [https://code.google.com/p/guava- libraries/wiki/HowToContribu...](https://code.google.com/p/guava- libraries/wiki/HowToContribute)

</comment><comment><USER16> When I first heard about open source in the mid 90s, I thought "that can't possibly work with no leader" because I thought that writing to the repository was open to anyone. I wondered if maybe then someone would stress test a revision and if it was good enough, sign off on it as the most recommended version to download. So basically there would be no "current" version, that one would be this evolving hodgepodge out ahead of the one most people used. I guess I envisioned it working kind of like evolution, so the best versions would split and merge again like reproduction and the most fit version would rise to the top.

So on some level I think open source has actually failed, because it didn't work out that way. Instead there seems to usually be a handful of maintainers who allow certain patches to go in, but if there's too much of a disagreement, we end up with a fork, never to be merged again. The burden on that handful of people is so high that on some level I'm amazed anyone ever takes on the infinite support liability of starting an open source project in the first place.

Just out of total curiosity, does anyone know of any other ways of organizing open source, I mean from decades ago when it was first getting started? Were there ever any successful projects that were more organic, where a greater portion of the contributors or even all of them could make changes? Did they devolve into anarchy or did they work?

Update: I didn't expect this to be down voted, perhaps it was my poor choice of wording. What I meant to say was "So on some level I think open source has failed to live up to its original vision of open contribution leading to viable software".

<comment><USER17> good post -- I think you really got to the core issue -- "that can't possible work with no leader" \-- or at least a "benevolent dictator". I guess I'd like to see evidence of an old open source project that has withstood the test of time. None come to mind.

</comment></comment><comment><USER18> Back in 2012, I ran into a similar problem. The Python standard library has "isoformat()", which converts Python datetime objects to "2012-09-09T18:00:00-07:00" format. This is the format used in emails and RSS feeds. But there was no standard function for the inverse, parsing such strings, that got all the cases, including time zone offsets, right. Others had discovered this problem and tried to fix it. The Python repository, PyPi, had four different versions of such parsers, each broken in a different way. Because there's no way to fix anything in PyPi (it's just a list of links; it doesn't host the source), each person who had found a problem had forked the code and hosted their version somewhere else. People have been posting bug reports about this since 2008.

Further discussion unearthed _seven more_ different Python implementations.

[https://groups.google.com/forum/#!topic/comp.lang.python/Q2w...](https://groups.google.com/forum/#!topic/comp.lang.python/Q2w4R89Nq1w)

Two years later, there's been little convergence. There's a currently maintained version on Bitbucket at ([https://bitbucket.org/micktwomey/pyiso8601](https://bitbucket.org/micktwomey/pyiso8601)). It has four forks.

So there are now 15 different versions of this little function. A function for which there is a well defined spec, an RFC and an ISO standard, for what it is supposed to do.

That's the open source process.

<comment><USER19> Python has PEP to extend the base system including the standard library. Maybe it should go through that instead of being third party code in some "repository"?

The closed source market of (say) third party win32 controls (GUI widgets) is also messy - just look at how many calendar widgets are out there, but nobody complains there. That's "market forces at work" ;-)

<comment><USER20> Stuff like adding a single function to a library doesn't warrant the PEP process.

Fixing this is moving forward:

[http://bugs.python.org/issue15873](http://bugs.python.org/issue15873)

(Perhaps it's fair to say, slowly moving forward)

<comment><USER18> Ah, yes, I put that issue into the tracker two years ago.

</comment></comment></comment></comment><comment><USER21> I contribute to an open source project that actively solicits contributions. The README asks for PRs in preference to issues (but issues are okay), and there is even a CONTIBUTING.md that describes the process.

After being active on the project for a while I was granted commit rights. I have done everything I can in that role to support the project - responding to issues, merging other's PRs after code review & testing, updating documentation, and, in response to issues creating PRs that are: coded in the same (slightly idiosyncratic) style as the original code, don't cause regressions, have their own tests, and are well documented.

In the interest of good practice I haven't merge my own PRs, but left them to the project owner to review. There they languish despite in some cases resolving issues that the project owner himself opened issues for.

So, while I don't agree with the tone, I do sympathise with the author's position. It can be demoralizing when an open-source project owner actively solicits contributions (not just a fork or create PR button, but requests and instructions), then ignores contributions that may have taken many hours (or in some cases days) to get to the point where the PR is submitted.

</comment><comment><USER22> The obvious solution for owners of such projects is to grant more people commit access so more people can handle outstanding PR's. A single person being responsible for all pull requests doesn't scale.

But the issue is that owners don't like giving up that much control, because it can lead to the project being taken in a direction they didn't originally intend.

This is an issue for any open-source project, which is why the biggest projects tend to have a structure where there is a dictator, a hierarchy of core contributors, and everyone else should stick to mailing lists or pull requests to contribute code.

But for small projects it's difficult because it's tough to make that kind of hierarchy work on GitHub.

I'm starting to think there needs to be a boilerplate "Contribution Guidelines for Small Open Source Projects" meta-guideline that small Open Source projects (on the size of things like gems or small utilities) can adopt, similar to how projects can adopt SemVer or a particular OSS license.

Some simple tenants of such a guideline system (or basically, an example thereof:)

1) Contributions to this Open Source project shall adhere to this projects MANIFESTO.md, which shall define the goals of the project, its scope, what it aspires to be, etc.

2) The owner of this open source project shall grant commit access (promoting them to "Core Contributors") to developers who show a consistent drive to make enhancements and fixes that fall within this well-defined manifesto.

3) Only the owner shall make changes to the manifesto. Changes to a project's manifesto should require a fork of the project. Manifestos can be designed by consensus but it should ultimately be up to the owner to commit the change.

4) Core contributors should be able to merge other developer's pull requests, and even grant commit access accordingly. If any commits get merged which fall outside of the manifesto's guidelines, the commits can be rolled back by the owner, or the core contributor can make the case for changing the manifesto, or they should fork the project to keep the commit.

I don't really have the clout to be able to develop such a meta-guideline (I'm not active in any OSS projects), but I think it would be really cool if someone would.

</comment><comment><USER23> As somebody who maintains a decent amount of Rust libraries, I do try to keep on top of my PRs, but sometimes Github's notification system makes it easy to forget that some PRs have been sitting around for a long time. For example if you click on a notification in your inbox, it automatically gets marked as read - you can't keep it around as a reminder.

What would be really nice is if you could have some sort of dashboard to let you know the status of your outstanding issues and PRs on all of your repositories - how long they have been open for, whether they are stale or not... etc. It's just too hard to go through each repo individually to check on its health.

<comment><USER24> Another issue is that github's "merge a pull request" system is completely broken.

Most projects on github, by virtue of being based on git, will have several branches within the repository. The regular contributors to the project will know branch 1 from branch 2 and will submit their PR's against the projects "dev" branch (whatever it happens to be).

But irregular contributors, or out of the blue contributors, will invariably choose a branch that is not the projects "dev" branch upon which to base their patch, and then submit their pull request.

And for the project receiving the pull request, the github "handle it" interface is all-or-nothing. You either put the patch in, against the branch the requester used, no matter how wrong that branch might have been, or you simply can't merge it via. github's web interface. And if you don't merge it by github's web interface, you can't mark it accepted. Your choices are "accept and merge patch" and "refuse".

So there's a very good chance that some number of those outstanding pull requests shown have actually been merged, but were merged by the maintainer pulling a patch out of github manually, and applying the change manually via git to the correct branch and not the branch the submitter picked. And since the patch was in fact merged, poking the github "refuse" button in the web interface would seem wrong, so the outstanding pull request just hangs around, forever, because github can't be told "I did merge this, just outside of your view".

</comment></comment><comment><USER11> Something about this post does not sit well with me, though I have many colleagues who have expressed a similar sentiment.

Overall, the OP seems to be suggesting that, _merely by posting code on github_ , we have now been conferred with the responsibility of "maintaining an open source project."

In fact, I find the first couple of screenshots kind of awful. "Why this is ignored?" Ugh, I think I'm going to go back to bed.

When I make a blog post, I'm not expected to respond to every comment. Or respond to every tweet. It's reasonable to not respond to every email. So what is it about posting code on the internet which mandates that people read, review, respond to, engage with, and eventually merge your code? And I do say mandate, because this blog post is basically a take-down, of which many have been written, of some poor project which has a bunch of outstanding pull requests.

I'm sorry that individuals feel that, by not spending their time to review code, they feel that it creates a "hostile" environment in open-source.

If the author had, instead of using github, simply posted a .tar.gz file on their personal home page, this wouldn't even be an issue. If you wanted to make a change, you'd download the source, modify it, and get on with your day. But somehow github (and probably the fact that everyone's dependency management system depends on "official" releases, often from github) keeps people from doing what they used to do, which was just change the code and continue on their way, and has bred some sort of animosity towards the very folks who provided this code in the first place.

My must-read on this topic is from Armin Ronacher, who says:

"I found it quite hard this year to work on my own projects because the bug trackers were full of things I personally did not really care about. The things I wrote over the last few years all work so well for me, that I don't need to fix problems or add things. When there is something that needs fixing, I will work on it, but otherwise I don't necessarily get the motivation to work on it." [1]

Armin does take steps to improve this, but to me it is important to say that _he didn 't have to_.

I maintain several OSS projects. I have often gotten poorly-tested pull requests and merged them without reading, understanding, or testing code. It's the OSS maintainer who gets the heat, in the form of hundreds of emails, when things break, not the person who made the PR.

So I agree with the central theme that too many open pull requests is discouraging, and for projects which want to grow, there must be a process for managing it. But I think this is completely at the discretion of the maintainer, that we should take advantage of our ability to fork and modify code (since when did the definition of OSS become "they must also accept patches") and it is frankly rude for us to publicly knock a a project because they haven't chosen to accept your patch.

Here is a productive idea: make it easy for me to use `pip` to install my forked version of a library. That way I won't have to care whether it is merged into master. (In fact, pip already lets you use git as a repository source, but you can apply this to all of the other dep managers for other languages.)

[1] [http://lucumr.pocoo.org/2013/11/28/emotional- programming/](http://lucumr.pocoo.org/2013/11/28/emotional-programming/)

<comment><USER25> I think this is the result of people not recognizing two very different types of open source code.

There's the friendly dump of useful stuff. It's not an open source _project_ , but it's code people know would be useful and are nice enough to share. Obviously there is no responsibility to maintain it, everyone can just fork it and it can diverge freely and no one cares.

Then there are actual projects. A person or group saying "Here is a problem we all share. Let's stop reinventing the wheel and work together on this. I will do some management work on this in return for your contributions and my name being prominent. Forking this for no reason is considered rude. Please contribute to this project instead of starting your own clone of it with your name on it."

Those are both good things, but they are different. People should be clear about what kind of project it is.

<comment><USER26> I think you're describing project governance rather than something about open source code.

Me, I'm in a third group. I write commercial open source. Only people who pay for my software get access to it, under the MIT license. Is it sharing if it costs money? ;)

<comment><USER10> If you give people your software under the MIT License, they can give it to anyone they want to.

"Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so"

[http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)

<comment><USER26> I'm confused. Could you explain your point?

Yes, that's the MIT license I use. My customers can share the code if they want. But I sold them a copy of the software, I didn't share it with them.

<comment><USER10> You said "only people who pay for my software get access to it". I was pointing out that anyone your customers choose to share your software with get access to it.

<comment><USER26> Sorry, I let out the words "from me" because I thought it was implied. I don't share this open source software. I sell it.

freshhawk listed two categories: 1) a "dump of useful stuff" with "no responsibility to maintain it" by people who are "nice enough to share." I don't fit in that because a) I include a year of support in the sale, and b) I don't share it, I sell it.

2) "Then there are actual projects. A person or group saying 'Here is a problem we all share. ... I will do some management work on this in return for your contributions and my name being prominent'". I don't expect trade in kind, I expect money. Just like proprietary software vendors (especially those who distribute sources).

Thus I consider myself as a member of group #3.

</comment></comment></comment></comment></comment></comment></comment><comment><USER27> The solution to this "problem" is remarkably simple from a repo owner's standpoint: Verbiage in your README along the lines of "This is an unstable project and pull requests will not be honored - you are welcome to fork the project, however!"

This makes it appear on the very front page of your project and is hard to miss. (How to deal with people that contribute without reading first is an exercise for the reader)

The attitude I'm seeing in here is really quite disgusting. You've put your code up on what is basically the Facebook of coders - you _really should not_ feel put-upon when the unspoken social contract of a _collaborative code editing platform_ is acted on by someone else.

Every culture has one, and GitHub's is shared collaboration on code bases. If you want to violate that norm, fine, it's your project, but then kindly call it out ahead of time and stop whining that the community that's made GitHub awesome is the way that it is.

</comment><comment><USER28> I'm in a similar situation: [https://github.com/JuliaLang/julia/pull/7714](https://github.com/JuliaLang/julia/pull/7714)

Can someone help me what would be the polite way to do? I really don't want to annoy anyone, but also wouldn't want my work to be only on my local branch ;)

<comment><USER29> Bumping the issue by posting something is probably the best way to go. I promise we won't get annoyed and it's easy to miss things like this. I suspect that what happened here is that all of the people who commented didn't feel like they had the "authority" to just go ahead an merge it, while everyone else (myself included) wasn't following the conversation (July was a really busy month) and didn't feel informed enough to pull the trigger. From a quick scan just now, this conversation looked to me like there were unresolved issues still, but upon more careful reading, that's not the case. It can be helpful to say something like: "I believe all the issues people have raised have been addressed. This should now be good to go." This change is quite nice and I'm testing it out right now. Sorry this languished for so long and I hope it won't discourage you from contributing – it is very much appreciated.

Update: this is now merged into Julia master. Thank you!

<comment><USER28> Cool! Thanks :)

I guess Hacker News rocks and also Dan Luu is right about "Props to OpenBlas, Julia, Rust, jslinux-deobfuscated, and np for being incredibly friendly to new contributors."

</comment></comment></comment><comment><USER30> The reason many PRs get submitted is that many of them just aren't good. Over time, having to deal with formatting issues, way too many commits in a PR that change random files, solutions to things that are really important but not done in a foward thinking way. Great PRs when done right are a wonderful thing, but the reality is that the majority of them are not great and this takes a tax on the developer.

What us OSS devs can do to help fix this is be very clear about PR protocol: ONE commit, change ONE thing. Code changes should have a unit test. And then make sure we are either merging or closing PRs for active projects.

</comment><comment><USER31> I've had a similar experience and I found it to be equally frustrating.

I contributed some minor enhancements to a simple helper script, one that just made a small part of development a little smoother. I created a pull request, added a good description of what I had done, and sent it off. The author got back to me pretty quickly with a few changes he wanted done, I happily obliged, and then sat and waited for a week.

Then over the following few weeks he proceeded to nitpick and ask for changes that really just amounted to over-engineering for some future possibility he imagined for his 200 line script. I will also point out that beyond the initial commits he had made six months ago, he hadn't touched the project since.

Regardless, I obliged, made every change he asked for. That was almost a month ago and he has now gone completely silent, the pull request sitting idle.

What I learned from the experience is that beyond the points the author made, the balance of power in these projects is often an insurmountable barrier. For instance, if I say something that pisses this guy off, he simply ignores my pull request and it sits in limbo forever. Or I fork his project and other users are forced figure out which version is the best (great example of this is the shitty state of AWS libraries in the Go language).

All in all, this experience isn't enough to turn me off to contributing to open source projects. It does however make me think twice about when it's worth trying and when I might just let my private forked copy stay that way.

</comment><comment><USER32> Funny, you could write an article entitled "Why open-source maintainers quit" and have the sole text be a hyperlink to this article. The whole piece is a long whinge about "why won't maintainers do free work for MEEEEE!". Maybe they aren't using the project anymore, maybe they're busy with life, maybe they just got tired of triaging for a while - whatever.

The final story in the piece really sums it up: "But when I looked at the mailing list for the project, I saw a wasteland of good patches that were completely ignored, where the submitter would ping the list a couple times and then give up. Did it seem worth spending a week to disentangle our IP from the project in order to submit a set of patches that would, in all likelihood, get ignored? No."

This sounds like a great situation for somebody else to step in and pick up maintenance of a clearly-neglected project. Hell, if your company is using the software for critical-enough things to devote "a couple months" to fixing bugs it seems like it would be in your company's interest to start maintaining the project publicly, if _everybody 's_ patches are being ignored. It would certainly be more productive than complaining that somebody else won't QA and then support _your_ fixes FOR FREE, FOREVER...

</comment><comment><USER33> > But when I looked at the mailing list for the project, I saw a wasteland of > good patches that were completely ignored, where the submitter would ping > the list a couple times and then give up. Did it seem worth spending a week > to disentangle our IP from the project in order to submit a set of patches > that would, in all likelihood, get ignored? No.

Sounds like the OP should have checked activity levels first ...then decided not to spend the extra time.

When I look at using open source for something I often use the following to determine if I should use it:

a) does it have the functionality I need today

b) is it active and being maintained ( through frequency of updates, active mailing list, sometime a financial sponsor (bigco who uses it))

</comment><comment><USER34> The title of this article is unfortunate in my opinion; I clicked it expecting a diatribe against open source. But in fact, it isn't.

To me, the relevant part is this:

> _" This behavior, eminently reasonably reasonable on the part of any > individual, results in a systemic failure, a tax on new open source > contributors. [...] It doesn't take egregious individual behavior to create > a hostile environment."_

So the causes aren't necessarily hostile behavior, and in fact there may be both permanent and temporary solutions to this problems. Therefore, a better title would be "How to _encourage_ open source contributions" :)

<comment><USER35> > The title of this article is unfortunate in my opinion; I clicked it > expecting a diatribe against open source. But in fact, it isn't.

I was expecting a rant against shitty builds, my biggest contribution to contributing to an open source project.

</comment></comment><comment><USER36> Thanks for your post and for not picking on one project in particular, but the obfuscation of the projects name in your last screen shot doesn't really work. It's trivial to read the projects name there.

</comment><comment><USER37> In my experience, most pull requests I open have been merged quickly. When they don't, it's because the repo is part of a large company/organization and there's no owner for the github repo.

Also, what are these magical projects getting hundreds of PR's? Most of mine seem to just get bug reports instead.

I have to sympathize with both sides. It sucks to have a PR ignored, but I also don't want to open source projects if it just means something else I have to maintain. Theoretically, if I don't merge PRs, the community chooses a new fork as the "canonical" fork. I've seen this happen with small communities (its happened a few times with Haskell). I think it's tougher when it's a popular project.

</comment><comment><USER38> I agree with the point that many a times when a person sends in a pull request , that might be their first time doing so and their experience with you might be how they would perceive the whole open source community in the time to come

</comment><comment><USER39> A fairly important point that was left out is the license. If the original developer puts some form of license on the code, then people may be afraid to fork and maintain the project on their own because no one wants to try and understand the murky waters of licenses/copyright/etc. This mentality puts the onus of maintaining the repository on the original dev despite their intentions on making the code open source. In my opinion, if you are going to open source your code but with no intention of maintaining it, then make a fully open license in plain English that says anyone can take ownership of the code.

</comment><comment><USER40> I've contributed bug fixes to open source projects on github and have had my share of ignored pull requests, sometimes they are for valid reasons like the project owner being on vacation or a business trip, but often enough the owner just didn't have enough time to manage the project.

I feel that in the latter case, it should be the responsibility of the owner to delegate more project administrators, or hand a project off to someone else to maintain. It's often hard to do so, and hard to find someone you trust that would take the project and maintain it well.

</comment><comment><USER41> If an open source project doesn't merge in pull requests, then that's the business of whoever created and/or runs that project. When a project's managers let a pull request or Jira issue sit there but create their own request or issue to do exactly the same thing often with code copied from the original, however, then that's behavior that should be exposed.

</comment><comment><USER42> Another great fix for this problem if you don't have time to work on issues, or users are becoming more of a burden than a help...go to your github repo settings page and disable them.

<comment><USER43> You can't disable pull requests.

</comment></comment><comment><USER44> I also open sourced a project I was working on.

Basically the benefit to me has been net negative.

It has taught me to never give things away for free, especially code.

License it, sell it, do anything but open source it on github unless it is javascript or any program that is easy to just look at the source.</comment>


Python, as Reviewed by a C++ Programmer - <AUTHOR> http://www.sgh1.net/b4/python-first-impressions <comment><USER2> For me the biggest downside of dynamically typed lanaguages like Python and Javascript is that a small error in passing a function's parameters can propagate very far in a complex system. E.g. if you mistakenly interchange two consecutive function parameters, you could spend several hours debugging the effect several modules down. This is an error that a C++ compiler would catch right away.

<comment><USER3> C++ is not always able to detect common parameter errors, especially for things like implicit conversions of numbers. Arguably Python's option of keyword arguments make certain classes of parameter errors go away, too.

Several years ago I remember someone who (perhaps unwisely) wrote a C++ function with many floating-point values as parameters and a single default "bool". At some point the function was extended to have another float. The compiler did not catch calling code that failed to add an extra float; it simply allowed the formerly-flag arguments to be assigned to the new float argument instead. In fact, implicit conversion of parameters is such a common C++ problem that I occasionally define wrapping types for the sole purpose of being parameter types: then the compiler _has_ to trip over them when they are used incorrectly and callers _have_ to do some kind of explicit action to indicate what their values really are.

<comment><USER4> Those implicit conversion rules (largely inherited from C) are one of the bits of C++ that bit me the most when I was a primary C++ dev.

</comment></comment></comment><comment><USER5> The article doesn't mention type annotations described in PEP484 and added to CPython since Python 3.5.

It is possible to add annotations to your code like

        class Foo:
            x: int
            # ...

and then run type checks using `mypy`, so that for the annotated code probability of the "passes the checks => won't crash the runtime" case is much larger.

<comment><USER6> Sure, but most python code isn't annotated, right?

So this might be helpful for code you wrote, but not anywhere it interfaces with other peoples' code (which, in my opinion, is probably the most important place to check for type errors).

<comment><USER7> Plus, many packages dynamically add members, stomp named parameters by wrapping stuff with __kwargs, etc.

<comment><USER8> So monkey patching is bad you're saying? I agree that it's possible what you're saying about kwargs, but after about 6 years of python I've never encountered that in any of the code that I've worked on.

</comment></comment></comment></comment><comment><USER9> Interesting, but it's mostly a few observations about interpreted vs compiled and static vs dynamic typing. And a bit about having a rich collection of 3rd party libraries.

The article wouldn't have been much different had it been C++ vs Ruby/Perl/etc.

</comment><comment><USER10> What is a "C++ programmer?"

On any given day, I poop you not, I'm writing either c#, java, c++ or any number of scrpting languages (perl, bash, python, JavaScript).

Do people seriously only use a single language these days!?

<comment><USER11> Why do you jump between multiple languages all the time?

<comment><USER12> Not, OP, but I've worked for an ad-agency in a software-dev role.

Their primary code base is written in Java, monitoring scripts in Python/Ruby, and tracking pixel code in JavaScript, so I would have days in which I coded in all 3, albeit for separate use-cases.

<comment><USER13> The ad agency couldn't afford different developers for the various systems?

</comment></comment></comment></comment><comment><USER11> For what it's worth, python has been making inroads in the HPC world as well. In that context it seems like python is being used as the glue to tie highly optimized, custom written, C/C++ libraries together. [http://lorenabarba.com/publications/](http://lorenabarba.com/publications/) [http://dl.acm.org/citation.cfm?id=3019084&CFID=927535872&CFT...](http://dl.acm.org/citation.cfm?id=3019084&CFID=927535872&CFTOKEN=12671239) [http://dl.acm.org/citation.cfm?id=2830170&CFID=927535872&CFT...](http://dl.acm.org/citation.cfm?id=2830170&CFID=927535872&CFTOKEN=12671239)

It's happening enough that there has been a series of popular conferences for it, PyHPC [http://www.dlr.de/sc/desktopdefault.aspx/tabid-11992/21071_r...](http://www.dlr.de/sc/desktopdefault.aspx/tabid-11992/21071_read-48990/)

</comment><comment><USER14> This reads like it was written 10-15 years ago. But apparently it's new.

<comment><USER15> That's the same feeling I had when I was writing the article!

</comment></comment><comment><USER16> Looks like the website's bandwidth limit hit its limit. Google Cache link for those who still want to read it [http://webcache.googleusercontent.com/search?q=cache:Z6cJ7kw...](http://webcache.googleusercontent.com/search?q=cache:Z6cJ7kwRhQkJ:www.sgh1.net/b4/python- first-impressions+&cd=2&hl=en&ct=clnk)

</comment><comment><USER17> There are package managers for C++, such as Conan. Some IDEs like CLion have certain degree of integration with it.

[https://www.conan.io](https://www.conan.io)

Then, some systems cannot afford to have garbage collection, because it usually runs in an unpredictable amount of time. Such systems are for example real-time systems. In those cases a language like C++ is a good fit.

</comment><comment><USER18> One thing that is a bless and a curse is the use of indentation for code blocks.

[http://www.secnetix.de/olli/Python/block_indentation.hawk](http://www.secnetix.de/olli/Python/block_indentation.hawk)

<comment><USER19> I read that, and it absolutely does not try to make the point that indentation is a curse. Maybe it is to some (not to me!), but you would need to cite something else. This is just an explanation of how it works.

</comment></comment><comment><USER20> Good post but I think he'd have a bit more appreciation for Python if he tried writing in a functional style as opposed to object oriented.

</comment><comment><USER21> It's incredibly close to my feelings after moving from C# to Javascript. Especially the heavily leaning on compiler bit.

</comment><comment><USER22> Rust is better than C++ at "if it compiles, it works" and has a great package manager, so as far as the topics highlighted here go, Rust seems to be the best of both worlds.

<comment><USER23> One thing where Rust is rather lacking is the missionarism of some people in the community.

<comment><USER24> The Rust Evangelism Strike Force is a huge turnoff to the language. It's gotten to the point where we can't have reasoned discussions about C++ or C, let alone about their merits, without a newly enlightened user coming in and trying to direct the conversation to Rust.

It's really _okay_ to have a future where C++ and Rust are both popular, widely used languages. I'm happy to acknowledge the merits of Rust as a language and even talk about them without inserting it into every conversation about low-level computing.

I'm sure the language designers and core developers don't actively endorse this behavior, but somewhere along the way it became a core part of the culture. This world domination shit has to stop.

<comment><USER25> > "The Rust Evangelism Strike Force"

Instant classic

<comment><USER26> I think it was coined by [http://n-gate.com](http://n-gate.com) (mentioned in HN a few times last month), but I can't be sure.

What I do know is that a) it's hilariously on point b) Google search now autocompletes on it for me.

</comment></comment></comment></comment></comment><comment><USER27> Interesting perspective on some of python's features, but I hate to see this "python is neither call by value nor call by reference" silliness perpetuated with a link to the original silly blog post. I'm surprised a C++ programmer was caught by that obviously incorrect assertion.

<comment><USER28> Claims that Python/C#/Java etc., are call by value where the 'value' is the value of the pointer does not help. It only muddies things. There really ought to be different name for such call semantics and there is. Its called call by object. In C++ lingo call by const pointer comes closest: one cannot change what the pointer points to. However the pointed object may not be a const

<comment><USER27> No, no, no there is no "call by object." It is precisely this mistaken idea which muddies the waters, as you put it. Virtually all modern processors are stack-based architectures. All arguments to functions are passed on the stack or in registers. The only thing that can be placed onto the stack or into a register are numbers. Those numbers can represent either an actual value or an address in memory. The former is call by value, the latter is call by reference. All high level languages that allow calling functions or methods with arguments have to ultimately use this facility to pass those arguments. Python is most definitely call by reference.

<comment> Al-Khwarizmi In Java, this code will print the string representation of Lassie:

      Dog toby = new Dog("Toby");

      public static void replaceDogWithToby ( Dog d )
      {
        d = toby;
      }

      public static void main ( String[] args )
      {
        Dog d = new Dog("Lassie");
        replaceDogWithToby(d);
        System.out.println(d);
      }

In Pascal, this will print Toby:

      var
        toby:tDog;

      procedure replaceDogWithToby ( var d:tDog );
      begin
        d := toby;
      end;

      var
        lassie:tDog;
      begin
        {code to initialize toby and lassie here}
        d := lassie;
        replaceDogWithToby(d);
        writeln(getDogName(d));
      end.

The first is call by object (or call by sharing, in my book). The second is call by reference. The behavior is totally different.

<comment><USER27> I haven't done java in a long time so I won't try to debate the specific language level semantics with you (the same is true of pascal though it has been even longer), however assuming that your examples run and behave as you describe then what is going on in the java example is that 'Dog d' is passed as a reference to a reference, and then the value pointed to by the argument, i.e. the address of "toby," is replaced with the address of "lassie."

<comment><USER29> You got it backwards. The Java snippet will print "Lassie". In Java, object names are references to objects, and passing them to functions copies the references, so of course modifying the formal parameter (d from replaceDogWithToby()) doesn't modify the actual parameter (d from main()).</comment></comment></comment></comment></comment></comment>


Storing data on the blockchain - <AUTHOR> https://github.com/dasmithii/Stone

<comment><USER2> very interesting project. thanks for sharing. out of curiosity, how does what you are proposing, differ from or is similar to, say, what a group like ethereum is doing?</comment>


New Study Finds That Most Redditors Dont Actually Read the Articles They Vote On - <AUTHOR> https://motherboard.vice.com/en_us/article/vbz49j/new-study-finds-that-most-redditors-dont-actually-read-the-articles-they-vote-on <comment><AUTHOR> I didn't write the article, but am a co-author on the paper mentioned, and wrote the browser plugin that gathered the data.

This Motherboard article made the front page of Reddit today.

</comment><comment><USER2> I don't think this is a very surprising result, just going by the title.

<comment><AUTHOR> LOL

The funny thing is that there are _so_ many comments that say "what about X?" or "they didn't control for Y!", but that they would know otherwise if they actually read the article and/or the paper!</comment></comment>


Microsoft to Alter Software in Response to Privacy Concerns (1999) - <AUTHOR> http://www.nytimes.com/library/tech/99/03/biztech/articles/07soft.html <comment><USER2> I just got a new PC with Windows 10, replacing an older PC laptop that's a Windows 7 / Ubuntu dual-boot. (I'm running Ubuntu from a VM this time.)

Anyway, Windows 10: I was a bit shocked at all the information it sends back to Microsoft. As soon as the setup screen comes up, it gives you an option to choose "Express Install" or "Custom Install".

I chose "Custom Install", and there were about 10 privacy settings that I turned off (all on by default) before I felt comfortable using the OS. (Examples: send all search words back to MS, tie advertising info to your Windows account, etc etc)

I'm assuming most users would chose the "Express Install" without even wondering about what data they were sending back to MS.

<comment><USER3> Ironic that your other choice is Ubuntu. They pioneered sending back all your search terms (to Amazon).

<comment><USER4> > They pioneered sending back all your search terms (to Amazon).

You don't have to use Unity to use Ubuntu. There is an abundant choice of WMs on Linux. And besides, even if you had this turned on, it's about nothing compared to what Microsoft does.

</comment></comment></comment><comment><USER5> Switched from Microsoft products in 1999, back when Palladium started. That was offensive enough. This is downright disgusting.

I always ask co-workers how much liberty Windows users are willing to sacrifice to continue using their systems. Seems even I underestimated with Windows 10.

<comment><USER6> >I always ask co-workers how much liberty Windows users are willing to sacrifice to continue using their systems.

You do realize we live in an era of smartphones, facebook and cloud services. Those liberties have been given up already. Window is looking downright open these days.

<comment><USER7> Windows is not really open, has never has been and never will be. In fact it is getting worse. There's always a black box at the bottom of every stack trace, a secret in every corner and a cost to every solution be it time or money.

Users, myself included, use it because we're stuck.

<comment><USER8> I'm in the fortunate position to not need Windows for anything other than the odd game. The GNU/Linux desktop has been fulfilling my needs for over a decade now.

In today's internet-centric world, there is little need to have Windows around for anything other than very specific jobs - for the average user.

</comment></comment></comment></comment><comment><USER9> I seem to vaguely remember some internet story about how these embedded UUIDs were used to de-mask a person by matching an UUID from a document with a known author against an incriminating document. Or was it matching an Ethernet card's MAC address to an UUID in the .doc? Can't remember any details now.

<comment><USER10> I think you're thinking of the Melissa virus [https://en.m.wikipedia.org/wiki/Melissa_(computer_virus)](https://en.m.wikipedia.org/wiki/Melissa_\(computer_virus\)) which did indeed get tracked back to its author like that.

<comment><USER9> That's it! Thanks for the reminder.

</comment></comment></comment><comment><USER11> Interestingly, this seems to have been accidental. UUIDs were generated using MAC addresses to ensure some uniqueness, but I guess nobody ever realised the implications.

</comment><comment><USER12> I am nostalgic for a Windows I can PAY for that minimizes my participation in the "I am the product" monetization world.

<comment><USER13> That day has come and gone thanks to other companies and closed ecosystems like Apple

<comment><USER14> Last time I checked you pay everything you get from Apple and keep the data locally without surveillance as a service.

</comment></comment></comment><comment><USER15> Yeah, old days. Now when installing Windows 10, we have to choose custom install and make many unchecking at least to be able to say "if they do what they say, they won't track me"..

<comment><USER5> "If" is definitely a word I take to the bank.

</comment></comment><comment><USER16> Today we call this "IDFA".

</comment><comment><USER17> is it possible to just add a 127.0.0.1 *.microsoft.com in windows 10?

<comment><USER18> If that was possible, how are you supposed to get updates then ?

<comment><USER19> Setup your own WSUS server (or another update server).

</comment></comment></comment><comment><USER20> There are many reasons to choose Windows. For example, Excel is by far the most powerful spreadsheet app. But using Windows where privacy matters is foolish. And trying to lock it down is pointless.

If you need Windows for work, or gaming, or whatever, fine. But dedicate a machine to it. And use a different machine for private stuff, running VirtualBox in Debian. Or Qubes, if you're seriously paranoid ;)

<comment><USER21> Frankly I find the list of reasons to choose Windows is growing ever shorter. I find Windows 10 to be revolting, and the list of reasons to buy it seems to be:

* Games * Industry-specific apps like AutoCAD

99% of Excel users would be satisfied by Google Docs or LibreOffice.

<comment><USER22> I have witnessed two different trials of Google Apps for "regular" office workers. In my experience, the number of Excel users satisfied with Google's offering is a lot closer to 0% than 99%.

<comment><USER21> Change aversion.

<comment><USER22> Nah, it wasn't just that, although certainly that was one component of it.

Excel has developed into a mini-platform of sorts, where users do all kinds of things with it. Time cards, expense reports, order sheets, office floorpans, generic lists, by-hand Gantt charts, etc etc. And other tools -- even similar ones that are supposed to be 'Excel-compatible' like Apple Pages or Google Sheets -- don't really work with many Excel documents 'in the wild'.

The real killer feature of Excel is Excel-compatibility. That's the only reason I personally use Excel -- because, for various reasons mostly outside of my control, I sometimes have to use documents created in Excel. E.g., my employer's vacation day reporting form is created in Excel by HR, and hell no Google Sheets doesn't work with it. (Actually, even the Mac version of Excel also doesn't work with it -- I fire up VMWare whenever I need to fill one out.)

Nothing other than Excel really works perfectly with Excel documents.

I think that was the biggest reason for the failure of the two Google Apps trials I witnessed.

(But there is also the fact that Excel was massively more feature-packed, reliable, and performant than Google Sheets -- which I think is still the case today. I personally use it because I enjoy the ubiquitous access cloudy-cloud- cloud nature of it, but I don't think that wins for many users, especially those who really mainly just use it at their desk at work anyway.)

</comment></comment></comment></comment></comment><comment><USER13> This is a stupid comparison, If thats the intention to compare it to how and what the internet is used for today. get off the hate train. you want to hate Microsoft, you had best hate Google, Apple and many other companies out there

<comment><USER23> And we do. Hating on Microsoft in no way diminishes hate for all of the other violators. Hate is not governed by the laws of thermodynamics, there is enough warranted hate in the universe for them all, and then some.

<comment><AUTHOR> But there's a bit more to it than that. The marketplace has apparently decided privacy is not worth paying for. Microsoft is conceding this point. Perhaps what the market values can be adjusted by creeping people out on a personal level by demonstrating just how much information they are giving away?

Or perhaps the market is revealing that privacy in general has very little value?

(Same issue with open computing vs. closed devices)</comment></comment></comment>


Panda guts not suited to digesting bamboo - <AUTHOR> http://www.nature.com/news/panda-guts-not-suited-to-digesting-bamboo-1.17582 <comment><USER2> The particular bacteria species present (Escherichia, Shigella and Streptococcus bacteria) are typical of carnivores, not herbivores, but we don't know how much (yet) how much those strains have or have not adapted to their cellulose job. From the article:

"Eisen says that some of the microbes in the panda gut might still be highly efficient at breaking down cellulose. He argues that the study's authors examined only microbial composition, not function — and microbes can change function rapidly, making it hard to predict how they perform solely on the basis of the genera of bacteria present. A 2011 study2 found evidence that Clostridium bacteria in panda guts contained genes that resembled those known to produce enzymes that break cellulose down into simpler sugars.

'I'm not convinced at all that there's any limitation to the cellulolytic activity in this system based upon the data they have,' Eisen says of the new study.

The researchers say that the most important question of the study is whether the panda's carnivore-like microbial structure can still effectively utilize cellulose. More work will help to provide a complete picture."

<comment><USER3> I was under the impression that in addition to bacteria you would also need a different digestive system, similar to the 4 chambered stomach the cows have. Are there any other animals who have a simple digestive system, like the pandas, but due to their bacterial content can in fact digest cellulose?

<comment><USER2> Termites can digest cellulose. [http://en.wikipedia.org/wiki/Termite#Diet](http://en.wikipedia.org/wiki/Termite#Diet)

As can rabbits, apparently, via a form of hindgut fermentation. [http://en.wikipedia.org/wiki/Rabbit#Diet_and_eating_habits](http://en.wikipedia.org/wiki/Rabbit#Diet_and_eating_habits)

</comment></comment></comment><comment><USER4> Poor pandas. It's as though Mother Nature has been trying to naturally deselect these bears for some time. They're such ineffective competitors that it surprises (and delights!) me that they're still around.

<comment><USER5> Yes, but these bears have very cleverly evolved the ability to seem irresistibly cute to the current master species of this planet. From personal observations, they seem to emit some sort of aura that induce people (in particular post-puberty to adult females humans who I'm trying to date) to emotionally melt down and make incomprehensible "cooing" noises. This aura increases in strength with increases in proximity to these bears, and is most pronounced in younger bears. The effect is particularly strong and can remain for several hours in the host even if bears are removed. This can and has led the host engaging in questionable (and often regrettable) activities with me she would otherwise refrain from doing.

In any case, for all their microbiome weakness, they've evolved a rather fascinating survival strategy to cope with humans so I don't think these bears will be removed by natural selection any time soon.

<comment><USER6> I'm not sure whether you're joking, but that's actually what happened to dogs. Unlike wolves and many other beasts, we can empathize with dogs' facial features (apophenia?), thus making us less likely to endanger them. You can think of it as some sort of camouflage.

</comment></comment></comment><comment><USER7> So pandas were omnivores many years ago, then they became herbivores with physical adaptations to eat bamboo, though their guts didn't keep up with the process.

Can pandas still eat meat? Could you, for example, feed a panda in captivity a carnivorous diet with an expectation that it would thrive?

<comment><USER8> Pandas do eat some meat in the wild, they've been seen catching and eating birds and rodents.

<comment><USER3> What about in captivity. Perhaps reintroducing pandas to a meat diet would solve a lot of pandas' problems.

<comment><USER7> That's what I'm curious about. I don't presume to know better than zoologists, so maybe this has been tried and/or rejected for reasons I don't know about but it seems that it could help. Maybe wild pandas will cease to be, but it may be possible that a diet adjustment could at least keep a population viable in captivity.

</comment></comment></comment></comment><comment><USER9> Could one do the panda equivalent of a fecal transplant? If so... would this be likely to improve the panda's health and be transmitted to its offspring?

<comment><USER10> I'd like to know how gut microbes get transmitted from mother to offsprings in other mammals especially humans. I've never thought that the microbes are, in a matter of speaking, hereditary.

<comment><USER11> If you have a child, you'll read about this. A baby's digestive system is essentially sterile in the womb. There's increasing evidence that important bacteria are passed to the newborn from the vaginal canal during the birthing process – and is an argument against C-sections.

Also related is the resurgent practice of placing a newborn directly against the mother's bare chest immediately after birth, which among other benefits, is supposed to foster bacterial transference through skin-to-skin contact.

As a disclaimer, I'll just say that this field of knowledge seems rife with theories but somewhat lacking credible scientific studies that do long-term tracking of health outcomes. So, I take much of it with a grain of salt.

Here are a couple of studies I found:

Delivery mode shapes the acquisition and structure of the initial microbiota across multiple body habitats in newborns

[http://www.pnas.org/content/107/26/11971.full](http://www.pnas.org/content/107/26/11971.full)

Influence of mode of delivery on gut microbiota composition in seven year old children

[http://gut.bmj.com/content/53/9/1388.2.long](http://gut.bmj.com/content/53/9/1388.2.long)

</comment></comment></comment><comment><USER12> "He argues that the study's authors examined only microbial composition, not function — and microbes can change function rapidly, making it hard to predict how they perform solely on the basis of the genera of bacteria present. A 2011 study found evidence that Clostridium bacteria in panda guts contained genes that resembled those known to produce enzymes that break cellulose down into simpler sugars."

It sounds the authors identified the bacteria flora in the panda gut via feces, but not the bacterias' specific gene expressions which may vary even if they are known suited more for carnivore digestion (e.g., but may be specialized to digest plants cellulose in panda gut environment).

For those involved in genomics, I'm curious as to how one can obtain the RNA expression (RNASeq) of multiple bacteria present in panda gut; and how do they go from the raw sequence data sequenced from the multiple bacteria composition to match the specific gene and then also its host bacteria?

</comment><comment><USER13> So what's the panda version of paleo?

</comment><comment><USER14> This animal has failed at evolution on practically every level. Such a waste of effort to keep them alive while continuing to kill off so many other species. 1000 years from now it will just be us, the cockroaches, and pandas.

<comment><USER15> This Gizmodo piece pretty much sums up why we should just let them all die.

[http://gizmodo.com/5841175/should-we-just-let-pandas-die- off...](http://gizmodo.com/5841175/should-we-just-let-pandas-die-off-already)

<comment><USER16> They also received a grade of 'F' in their official Animal Review.

[https://animalreview.wordpress.com/2008/05/04/pandas/](https://animalreview.wordpress.com/2008/05/04/pandas/)</comment></comment></comment>


Show HN: Transform cardio machines into arcade games - <AUTHOR> My friend and I have built a mobile video game that can be played on an exercise bike/elliptical. Using the camera we track micro-movements of the body and detect the speed of motion, and use head tracking for steering.
Currently the game is in prototype mode, and consists of trying to pass obstacles, collecting orbs and destroying enemies. Here is a link to a video of the playthrough: https://vimeo.com/189210575
If you would like to try the game out, you can register on our website: pelatra.com. You will get access to this specific prototype and all upcoming versions of the game.
Any feedback, questions or concerns would be very useful so please let us know what you think. <comment><USER2> wow! Have you talked to any Gym's nearby? maybe test this out with real users.</comment>


A hidden world, growing beyond control - <AUTHOR> http://projects.washingtonpost.com/top-secret-america/articles/a-hidden-world-growing-beyond-control/ <comment><USER2> Unix geeks will note that the term "super user" has gone mainstream -- it's used to describe a handful of Dept. of Defense officials who have the utmost top secret clearance.</comment>


Where is my C++ replacement? - <AUTHOR> http://c0de517e.blogspot.ca/2014/06/where-is-my-c-replacement.html <comment><USER2> I you feel like OOP and template metaprogramming are being publicly derided, then you're welcome to use plain C. It's still going strong after 40 years and will probably still be around in another 40. I'm joking a little, maybe, but the point is that languages don't need to change in a hurry. People still start new projects in Fortran and Lisp; there are natural islands in the North Sea newer than these languages.

I think it's easy to _feel_ like C++ is due for replacement when it isn't really. Yes, it's easy to be jealous about all the new things going on in other languages but that's in languages that sacrifice performance. If you're using C++ correctly, you're in a performance critical environment (either low memory, fast speed or steady speed). Or you have a lot of integration with C/C++. From this position, the only place you can currently go is from C++ down to C.

Honestly, there just isn't an apples-for-apples replacement for C++ at the moment. Rust is the only serious effort out there at minimum/zero overhead programming but it's 6 months away from 1.0, longer still before people get used to large scale design patterns that work well in the language and type system and much longer before it approaches the level of third-party library support that C++ has.

Yes, Boost needs a lot more work. C++ has traditionally had a woefully inadequate platform independent standard library, relying too heavily on Win32 or Qt or Carbon for things that should have been platform independent.

But frankly, C++ is doing okay. It has never been the easiest of languages to use but it hasn't gotten any worse. It's actually gotten better with C++11 and C++14 and with clang on the scene and libc++ providing a libstdc++ alternative and Microsoft finally trying to reach standards compliance.

</comment><comment><USER3> I think Rust really has a chance replacing C++. To me it's in the sweet spot between C and C++: it fixes all the tedious little things in C, but still feels like a "small" language (everything is a combination of struct/enum/function) and still is very low-level.

It has no GC and zero overhead like C++. You control stack vs heap allocations and memory layout. With `unsafe` blocks it allows all kinds of crazy optimisations when you need them.

When you compile with link-time optimizations most of Rust stdlib is discarded so you can have reasonably small executables.

Rust doesn't rely on a big runtime and has first-class C interoperability, so you can use it for plugins/libraries with C API too.

And since Rust is pretty similar to Swift (except without reference counting and with saner array references ;) I expect LLVM will soon be optimized for that kind of language, so Rust's performance will be >= C++.

</comment><comment><USER4> Haskell? :)

<comment><USER5> Go was developed to replace C++

<comment><USER6> ... for a few specific tasks.

<comment><USER7> That and the runtime and garbage collector mean its unlikely to ever replace c++. Maybe for a few specific tasks, but yeah Go is not a c++ replacement.</comment></comment></comment></comment>


Introduction to the Samsung Qmage Codec and Remote Attack Surface - <AUTHOR> https://googleprojectzero.blogspot.com/2020/07/mms-exploit-part-1-introduction-to-qmage.html <comment><USER2> This is excellent- I'm impressed with the attention to detail and perseverance. I would have given up well before getting that amount of info together</comment>


Ask HN: Anyone has direct Apple Legal contact? - <AUTHOR> My game Dual Tennis has been cloned three times(Latest one being New PingPong Smash). Exact source code with graphics removed. Hell One of the games takes player to my game rating page when rating button is clicked. Apple needs to stop such clones. Cloning a game by recreating a game is still fine, but this blatant stealing of source code should be punished. <comment><USER2> The following link should help: [http://www.apple.com/legal/internet- services/itunes/appstore...](http://www.apple.com/legal/internet- services/itunes/appstorenotices/#?lang=en)

</comment><comment><USER3> Send a DMCA notice.</comment>


Fully Countering Trusting Trust through Diverse Double-Compiling - <AUTHOR> http://www.dwheeler.com/trusting-trust/

<comment><USER3> I'm not sure I understand this; is this simply a method for detecting whether (for example) a gcc4.0 binary on your system is compromised, done by checking whether it matches the binary as compiled by a gcc4.0 compiled from source on another system?

I guess I don't see why this is worth a PhD; has nobody ever bothered to verify whether checking the binary against the results of a trusted compiler works? Did this guy contribute some measure of rigor that was previously missing?

<comment><USER4> No, it's for checking whether the compiler used to compile the compiler that produced the binaries on your system was compromised.

Intuitively, let's say I write a very early version of a (say) gcc, but insert code so that if the compiler detects that it's compiling a login program, it inserts logic into the binary so that "kt" can always login without a password. For this to survive beyond the next rebuild, the compiler also has to detect when it's compiling itself and insert the same logic. This 'Trojan horse' can survive as long as people keep compiling your compiler in itself, but is never detectable from looking at any later version of the source code.

So you need to trust each version of the compiler (assembler, linker, microcode) you are using _all the way back in history_. The claim of the PhD and the 2005 paper is that you can verify the integrity of a compiler using another compiler that you _do_ trust, _all the way back in history_.

The apocryphal story is that Ken Thompson actually did this with an early Unix compiler. Here's his very short original paper:

<http://cm.bell-labs.com/who/ken/trust.html>

<comment><USER3> > The claim of the PhD and the 2005 paper is that you can verify the integrity > of a compiler using another compiler that you do trust, all the way back in > history.

Right. I'm wondering how this was sufficiently non-obvious to warrant a PhD dissertation.

<comment><USER4> The idea is that a compiler is, loosely, a self-reproducing program and is therefore in a position to propagate malware in a very subtle way - <USER2> modifying the binary version of future versions of itself.

From a security perspective, this is different from a compromised (say) Debian mirror because it's not a question of, "does this binary match the source I downloaded from?" but, rather, "does this binary do the right thing when I use it to compile my system?"

Think of it this way: you and a friend both compile GCC. But the native code which results is not necessarily the same - it depends on details of your machine and your existing compiler tools. So there is no way to say what "the binary for GCC 4.4.x on i686" should look like, so you cannot tell if your friend modified his compiler's source code just before compiling it. This is (sort of) the problem the paper is solving.

I am not an expert, but I hope this is clearer.</comment></comment></comment></comment>


The Navy Is Arming Nuclear Subs with Lasers. No One Knows Why - <AUTHOR> https://www.popularmechanics.com/military/navy-ships/a30647372/laser-nuclear-subs/ <comment><USER2> Once GPS is destroyed, a great way to navigate would be via the laser reflectors that were left on the Moon.

Many long-dead satellites also have them. You just need to receive an update on the orbit, which could come via VLF signals.

</comment><comment><USER3> Laser communications above and below, so even submariners can watch netflix.

</comment><comment><USER4> Perhaps putting subs in position around the world to knock out nuclear missiles in the sky, or even low altitude ICBM's like the ones Putin was talking about?

<comment><USER5> Submarines are portable, which means they have limited electrical power, and they are submarine, which means that they are a hundred kilometers below those missiles.

Shining a light that's strong enough to be harmful a hundred kilometers away requires a lot of power.

<comment><USER4> True, but they are nuclear powered [1] and short burst lasers can use capacitor banks for burst energy. 20MW should charge up large capacitor banks quickly. Not being an expert on laser weapons, I can't say if that is enough to damage an ICBM.

[1] - [https://en.wikipedia.org/wiki/Nuclear_marine_propulsion](https://en.wikipedia.org/wiki/Nuclear_marine_propulsion)

<comment><USER5> Are these submarines large enough to have that space? Do they even have space enough for one bed per crew member?

<comment><USER4> Some of them hold quite a few missiles. Yes, some of the subs are quite massive. There are some fairly recent pictures on google images.</comment></comment></comment></comment></comment>


Has anyone tried out that startup review site, Sussio? - <AUTHOR> Has anyone tried out that startup review site, Sussio? Looks like they're similar to Yelp for startups? They claim to help consumers 'suss out' brands" - sounds kind of tacky. <comment><USER2> No, and if they are anything like Yelp I really hope they fail. We really really don't need another Yelp.</comment>


Redirecting Stdio Is Hard - <AUTHOR> http://blog.httrack.com/blog/2014/12/20/redirecting-stdio-is-hard/

<comment><USER2> This reminds me of a bug I was hunting years ago in an obscure web server software written in C that was ported from Unix (Solaris perhaps) to Windows. It implemented connections to backend-systems and databases using sockets. Sometimes we got random file errors out of nowhere on Windows but not on Unix.

Turns out BSD sockets are closed with close() just like file descriptors but winsock requires applications to use closesocket(). The guy that ported this to Windows didn't know this and used close() on sockets leaving them dangling and sometimes closing random files on specific circumstances.

</comment><comment><USER3> Dealing with stdin/stdout/stderr is much harder on Windows than on Unix.

On Unix, you have the stdio layer (FILE *) and the file descriptor layer. On Windows, you have multiple stdio layers (one for each C runtime you have loaded in your process), multiple file descriptor layers (again, one for each C runtime), and the native "standard handles" layer (GetStdHandle/SetStdHandle).

On Unix, to redirect stdout is just a dup2() call, perhaps preceded by a fflush. But on Windows, there's no handle equivalent of dup2() (DuplicateHandle can duplicate a handle, but it will give you a new handle; you cannot use it to replace an existing handle).

So you have to either use SetStdHandle, which won't work well on multithreaded programs (see the comments for the blog post at [http://blogs.msdn.com/b/oldnewthing/archive/2013/03/07/10399...](http://blogs.msdn.com/b/oldnewthing/archive/2013/03/07/10399690.aspx)), or call a dup2() equivalent on each C runtime the process is using, which won't work if (as in the second bug report in this article) another component is directly using the underlying handle.

<comment><USER4> On windows you use DuplicateHandle() on pipes made by CreatePipe(). You can then pass these handles to, for example, CreateProcess() (which does what the name implies). Now when the child process writes to a handle (stdout), the parent process can then read from this handle as if it were stdin.

</comment></comment><comment><USER5> These problems would basically all go away if you used a process monitor to handle setting up the environment for the server process, including fds 1 and 2, and then just let it log to stdout or stderr. Any halfway-decent process monitor can do this, and most of them can handle log rotation as well.

</comment><comment><USER6> So, what about modern OSes, like plan9?

</comment><comment><USER7> tl;dr Windows and Java both have crappy file-descriptor handling.

<comment><USER8> And Unix, when it comes to O_CLOEXEC stuff. Everybody loses!

</comment></comment><comment><USER9> Interesting article...I wonder if the Java problem could have been solved more succinctly?</comment>


The more of everything problem - <AUTHOR> http://www.ianhathaway.org/blog/2018/4/15/the-more-of-everything-problem <comment><USER2> Thank you imartin2k for posting this. I just came across it on www.marginalrevolution.com, and I'm glad somebody shared it here. Should be on the front page!</comment>


Ask HN: How can I market to young parents? - mauricio-OH

Hi,
I've been working on Instagrad.com for a couple of months. Instagrad is a social funding platform to accelerate college savings.
We help parents raise funds for college by encouraging friends and family to contribute directly to a child's established 529 Savings Plan. With Instagrad, a parent can easily create a profile for his or her child, create a campaign to help raise funding (birthday, Christmas, etc.), and then easily transfer the funds to their child's college savings account (529 account).
What is the best way to reach and market to parents of young children? I'm not looking for "get mommy bloggers to talk about you" or "create a facebook page". I'm looking for specific winning tactics. <comment><AUTHOR> Use local school systems as a marketing channel. This however requires the appearance of a local presence, or an alignment of your product with that of the local school systems.

One traditional example of national companies aligning with local schools is the school book fair. Another is the fundraiser by selling crap industry.

The example of a web based service that first came to mind was one allowing parents to fund their child's lunchroom account and the school to draw payments.

Your idea is more in line with the book fair, I think.

A third approach is to develop the product for wealth management companies - that's where the real money is, hmmm. There's also an alignment of your interests and theirs - so long as you offer better value than in house services. Again, this may be better targeted at a local level to agents rather than national companies.

Good luck.

<comment> mauricio-OH great feedback - do you think facilitating the fundraising with books would help? we think this may work but it deviates somewhat from what we want to do as it means we help people do fundraising as opposed to us doing it which is what we want. If we have to change to make it succeed that works.

</comment></comment><comment><USER2> Careful there- "mommy bloggers" are both your target market and a prime marketing channel. (Case Study: Purex Crystals, <http://www.nytimes.com/2011/01/06/business/media/06adco.html>)

</comment><comment><USER3> Link: <http://www.instagrad.com/>

</comment><comment><USER4> If you have a marketing budget, use Facebook Ads. Target married people in a certain age range. The age range may vary based on education level.

<comment> mauricio-OH We have done this but CTR on FB is very low. We spent a long time improving it and then landing page interaction is poor. I find FB ads are great for continued exposure in FB, for example, towards an FB page. However, to an external site, it's very difficult unless your value proposition is crystal clear. Considering young parents are not thinking of college per se, makes it difficult to be crystal clear in 2 seconds.

Have you seen succesful campaigns with FB ads?

<comment><USER4> Yes, FB ads was one of my main user acquisition channels for several years before I shifted from marketing to development. I remember there used to be ads for "Dad Scholarships go back to school" campaigns running for a long time, so what you're trying to do should work.

On FB, CTR is really really important, and you want to get your CTR up at least over .07%. My best campaigns started at .10% CTR and with a lot of refinement and optimization of the audience, I was able to get .20% to .40% CTR with more traffic than my dedicated server could handle for almost a year. Keeping in the FB ecosystem will lower your CPC, but it's doable with external sites too.

Based on the limited info you've provided, either you are not targeting the right demographics, or you have a messaging problem.

<comment> mauricio-OH I think we target the right demographics but definitely are experimenting with messaging. Will definitely come back with more data on messaging.</comment></comment></comment></comment>


Watch Out, Demonic Hidden Voice Commands Could Hijack Your Phone - <AUTHOR> http://www.vocativ.com/395762/ok-google-demonic-hidden-voice-commands-could-hijack-your-phone/ <comment><AUTHOR> Project is also here: [http://www.hiddenvoicecommands.com/](http://www.hiddenvoicecommands.com/)

</comment><comment><AUTHOR> Don't know what to do with this awful clickbaity title.

Maybe rename to just 'Hidden Voice Commands Could Hijack Your Phone'?</comment>


The U.S. Blew $1.4B on Abstinence Education in Africa - <AUTHOR> http://www.scientificamerican.com/article/the-u-s-blew-1-4-billion-on-abstinence-education-in-africa/ <comment><USER2> It's only wasted money if you believe the aim was actually to help anyone in Africa. The real aim was purely political.

<comment><USER3> What political gains were made though? Or do you mean the goal was to make it look good to the folks at home?

<comment><USER4> I posted a comment just as you posted this, so forgive the repost of this link: [https://www.washingtonpost.com/opinions/eugene-robinson- geor...](https://www.washingtonpost.com/opinions/eugene-robinson-george-w- bushs-greatest-legacy--his-battle-against- aids/2012/07/26/gJQAumGKCX_story.html)

tl;dr: PERPAR has cost nearly ~$50B all together. The abstinence aspect may have jelled nicely with how the Bush administration sees the world, but it certainly also would have been a "sweetener" in getting a Republican- controlled Congress to approve so much foreign aid for non-terrorism-related purposes during Bush's terms.

edit: oops, posted the excerpt from the link rather than the link itself.

</comment></comment></comment><comment><USER4> Is there a link to the study? Do its conclusions throw any criticism towards other aspects of Bush's AIDS program (PEPFAR), such as its providing of antiretroviral treatment?

[https://www.washingtonpost.com/opinions/eugene-robinson- geor...](https://www.washingtonpost.com/opinions/eugene-robinson-george-w- bushs-greatest-legacy--his-battle-against- aids/2012/07/26/gJQAumGKCX_story.html)

> _When the Bush administration inaugurated the program in 2003, fewer than > 50,000 HIV-infected people on the African continent were receiving the > antiretroviral drugs that keep the virus in check and halt the progression > toward full-blown AIDS. By the time Bush left office, the number had > increased to nearly 2 million. Today, the United States is directly > supporting antiretroviral treatment for more than 4 million men, women and > children worldwide, primarily in Africa._

Obviously, there was more than one aspect to PEPFAR, and the abstinence aspect may have taken $1.4B on its own. According to the Wapo article referenced above, the total cost of PEPFAR was $46B. I wonder how much of the purpose of the abstinence program was predicated on a strategic angle to get Congress to approve the overall package. Because that's a ton of money to spend on humanitarian foreign aid, especially with a Republican-controlled Congress.

</comment><comment><USER3> Abstinence education has never been effective anywhere to prevent anything, be it teen pregnancy or the spread of STDs. It's also worth noting that in the States, the states with the highest emphasis on Abstinence only education have the highest rates of teen pregnancies.

As it turns out, hormonal teenagers when left alone will have sex regardless of how much they are told not to. I know, I used to be one. Apparently this lesson still needs teaching in huge parts of the world.

<comment><USER5> >hormonal teenagers when left alone will have sex regardless

Because you have no faith doesn't mean no one else does, what you're saying is false. There are people who obey God, even though you clearly can't imagine it.

<comment><USER3> Speaking as a Christian, here's the thing: People fuck up. A lot. Everyone does and yeah, it would be a great thing if people would wait for "the one" before they went ahead with the act.

Out here in the real world, sometimes you think you found the one. Other times you just get stuck in a heated moment and do something dumb. It happens. And when it happens you should be equipped with the knowledge to keep yourself safe. I don't have a problem with Abstinence, I have a problem with Abstinence ONLY because it denies people who we are expecting to act as adults incredibly valuable information for their health and their future.

I mean seriously, would you buy a car with no airbags in it and when you ask about it, the salesman says "Well just don't crash then?"

</comment></comment></comment><comment><USER6> An interesting question to be asked as well is why a north american country is putting their effort and money in abstinence education in another continent ?!

</comment><comment><USER7> Thanks, Bush, and the religious fundies who hijacked the Republican party!

<comment><USER8> Bush is widely considered to have been the best president for African aid by Africans. See for instance [http://abcnews.go.com/blogs/politics/2013/04/george-w- bushs-...](http://abcnews.go.com/blogs/politics/2013/04/george-w-bushs-legacy- on-africa-wins-praise-even-from-foes/)

and [http://www.usnews.com/news/the- report/articles/2015/07/28/ob...](http://www.usnews.com/news/the- report/articles/2015/07/28/obamas-legacy-on-africa-lacks-compared-to-bush)

Seriously. Bush is well loved in Sub-saharan africa, speaking very broadly of course.

<comment><USER7> You only need to google "bush abstinence only program" to see a great deal of documentation of the changes the Bush administration made to sex-education funding, both domestic and international:

[https://www.google.com/search?q=bush+abstinence+only+program...](https://www.google.com/search?q=bush+abstinence+only+program&ie=utf-8&oe=utf-8&client=firefox-b)</comment></comment></comment>


Ask HN: What is the Holy Grail for Software Engineering? - <AUTHOR>

Physics has its Theory of Everything - what's out there for Software Engineering? <comment><USER2> Holy grail, eh? Well, if you really want to swing for the fences...

* Programming a computer in plain English.

* Teaching a machine to compose (real) music, or draw (real) art.

* Simulating a brain -- or, even better, emulating one.

* A programming language that makes it possible to write code that's worthy of being read as literature.

<comment><USER3> While I agree those are worthy goals, the middle two are CS, not SENG. Real AI is probably the loftiest goal in CS, but it requires a lot more theory work before anyone will be able to implement it.

</comment></comment><comment><USER4> Minimizing the cost of producing secure, reliable, efficient systems that fulfill business objectives and are inexpensive to modify (where modifications preserve reliability and performance.) Included in the cost must be the risk of finding engineers to provide maintenance and changes.

</comment><comment><USER5> Building software like we build bridges.

There are a lot of things wrong with this analogy, but I think it still encapsulates a nice ideal. We'd like to get it right the first time, and make it last with minimal maintenance.

(This is for software engineering, not computer science)

<comment><USER4> Physical construction envy is naive.

Many bridge-building projects go over time and over budget.

Most bridges have a feature list fixed years before construction is begun.

Bridges are static. Even draw-bridges do not adapt to their environment automatically, but require human intervention.

There is a categorical error when you try to apply construction practices of static things to the construction practices of dynamic things, hence the failure of waterfall. Note that the original papers that introduced waterfall actually suggest a system that more closely resembles iterative development than BUFD.

<comment><USER6> If we found a way to make BDUF work reliably, it would transform the industry overnight, and turn software development into a recognisable engineering discipline. The fact that we haven't _yet_ , and that one particular approach failed, doesn't mean that it isn't possible. Nor does it mean we should stop trying.

Iterative development is an interesting stop-gap, but it's certainly not the be-all and end-all we should be looking for.

</comment></comment></comment><comment><USER7> Enterprise software perspective - IT managed directly by business users. In that, the system can accept natural language descriptions of business logic, resolve ambiguity, and can self-modify, maintain, and heal itself. In other words, a virtual software architect.

<comment><USER8> Such system would be necessarily self-conscious with all severe problems it implies and human reproduction already produces such systems.

</comment></comment><comment><USER9> The Holy Grail of software engineering — the one true approach to building software systems that can be applied, universally, to any and all software projects.

<http://www.cse.unsw.edu.au/~se4921/PDF/CACM/p15-glass.pdf>

</comment><comment> daniel-cussen There's really three problems I can think of, in decreasing order of difficulty:

1) writing an AI,

2) proving P=/=NP, and

3) founding a 200-billion dollar company.

<comment><USER10> These are computer science, not software engineering.

Oh, and #3 is neither...

</comment></comment><comment><USER11> You know that scene in Independence Day when Jeff Goldbloom flies into the mothership and uploads a program to shut it down? That.

No, I don't mean an alien empire running on Mac OS 7.6.5, I mean extreme interoperability so software can rewrite itself to work on a different platform (self-porting, in other words).

Having said that, their firewalls were lacking!

</comment><comment><USER12> A self programming, learning computing machine.

</comment><comment><USER13> Doing correct time estimates? Finding an engineering methodology that actually works?

</comment><comment><USER14> A lot of the suggestions so far have really been for CS, not software engineering.

For software engineering, how about a practical way to do proofs of correctness for large real-world systems written in mainstream languages?

</comment><comment><USER15> Users that read the manual

</comment><comment><USER16> Solve the P vs. NP problem. <http://en.wikipedia.org/wiki/P_versus_NP_problem>

<comment><USER17> Let us not conflate computer science with software engineering.

<comment><USER16> Ahh, yes, my bad.

</comment></comment></comment><comment><USER18> A model checker that somehow cleverly handles external input and statespace.

Lacking that, haskell's type system :D

</comment><comment><USER19> To make software so extensible that you never have to rewrite it, or so painless to rewrite that you never mind.

</comment><comment><USER20> A programming language that does exactly what you want, exactly how you want it, exactly when you need it.

</comment><comment><USER21> How to talk to women? Couldn't resist.

</comment><comment><USER22> Something that could have answered this question for us.

</comment><comment><USER23> "Good, Cheap and Fast" and not being forced to pick two.

</comment><comment><USER24> A general purpose memory manager that doesn't suck.

</comment><comment><USER25> Provably secure, stable, error free code.

</comment><comment><USER26> It's a Holy Grail. It's a mystery!

</comment><comment><USER27> Becoming more than human.

</comment><comment><USER28> The Singularity.

<http://mindstalk.net/vinge/vinge-sing.html>

I think Vinge explains it better than Kurzweil.

<comment><USER19> Vinge's "superhuman intelligence" rhetoric bothers me because it suggests that intelligence is a one-dimensional quantity. I don't think this makes sense except in the context of specific domains. For example, a basic calculator has superhuman intelligence when it comes to arithmetic, because it can evaluate arbitrary expressions much faster than a human can and doesn't make mistakes. But it's dumb about everything else.

Update: The child comment by binaryfinery points to where Vinge addresses this. Sorry, I failed to add the disclaimer that I only skimmed the article.

<comment><USER28> FTFA: "Let an ultraintelligent machine be defined as a machine that can far surpass all the intellectual activities of any any man however clever"

</comment></comment></comment><comment><USER29> Here's a real holy grail of software engineering that might actually be attainable without getting Strong AI.

Significant code reuse without using a lot of hacks. I think Lisp and Ruby made great strides towards this, but I don't think we're quite there yet.

</comment><comment><USER30> KISS</comment>


Worse Than China? U.S. Government Wants To Censor Search Engines And Browsers - <AUTHOR> http://act.demandprogress.org/act/protectip_docs/?source=fb

<comment><USER2> This article, like the headline, is light on facts and high on sensationalism. However, the bill (full text available at [1]) does look pretty ugly.

[1] [http://leahy.senate.gov/imo/media/doc/BillText- PROTECTIPAct....](http://leahy.senate.gov/imo/media/doc/BillText- PROTECTIPAct.pdf)

</comment><comment><USER3> We need a new constitution.

<comment><USER4> The Constitution is fine; the government's habit of ignoring it is the problem.

EDIT: The Constitution is fine; our habit of letting the government ignore it is the problem.</comment></comment>


Mysterious giant hole suddenly appears in Siberia - <AUTHOR> http://sploid.gizmodo.com/mysterious-hole-discovered-in-siberia-1605872539

<comment><USER2> Scientists just returned from expedition, here are the two links in Russian with newest information:

[http://sever- press.ru/obshchestvo/nauka/item/3638-uchastniki...](http://sever- press.ru/obshchestvo/nauka/item/3638-uchastniki-ekspeditsii-sdelali-pervye- vyvody-o-proiskhozhdenii-zagadochnoj-voronki-na-yamale)

[http://www.youtube.com/watch?v=ELqw-m6rVhQ](http://www.youtube.com/watch?v=ELqw-m6rVhQ) (via [http://ura.ru/content/yamal/17-07-2014/news/1052185489.html](http://ura.ru/content/yamal/17-07-2014/news/1052185489.html))</comment>


The Cult of Busy - <AUTHOR> http://www.scottberkun.com/blog/2010/the-cult-of-busy/

<comment><USER2> Unable to connect: Cached Version

[http://webcache.googleusercontent.com/search?q=cache:zisZwuq...](http://webcache.googleusercontent.com/search?q=cache:zisZwuqy1zIJ:www.scottberkun.com/blog/2010/the- cult-of- busy/+cult+of+the+busy+scott&cd=1&hl=en&ct=clnk&gl=us&client=firefox-a)</comment>