College admissions scandal fallout: Stanford students sue UCLA, USC and Yale - <AUTHOR> https://www.latimes.com/local/lanow/la-me-ln-college-admissions-scam-stanford-ucla-usc-lawsuit-20190314-story.html <comment><USER2> I'm a little confused with this one. It would be one thing if these students didn't make it into an ivy league college because of this....but they did. A class action is good, but seems like it would be more powerful if it was students who did not make it into and Ivy.

<comment><USER3> ??? Stanford is definitely not an Ivy League school.

<comment><USER4> Stanford is ranked #7, following a tie between Columbia, MIT, U of Chicago, and Yale at #3.

[https://www.usnews.com/best-colleges/rankings/national- unive...](https://www.usnews.com/best-colleges/rankings/national-universities)

<comment><USER5> That's not what Ivy League means though, right?

[https://en.wikipedia.org/wiki/Ivy_League](https://en.wikipedia.org/wiki/Ivy_League)

</comment></comment></comment></comment><comment><USER6> Something else that's not mentioned here which I've seen in other coverage is the issue of financial aid. Students who did not require financial aid were given preference over more qualified students, simply because they could afford the full ride in cash. Had I known this when applying for college, I would've checked no on the financial aid intention.

</comment><comment><USER7> Someone at Stanford suing because they couldn't get into Yale honestly sounds post-satire.

Stanford is pretty universally considered better...and if it isn't it's the same. This sort of lawsuit sounds insulting to people like me who had no chance at any of the above.

<comment><USER8> Stanford is also included in the lawsuit. And it is not about getting admission, it's about the application fee they paid without getting a fair process. Read the article.

<comment><USER9> I mean in light of the scandal the fee seems mostly symbolic.

</comment></comment></comment><comment><USER10> I like that these students are making a statement and trying to put pressure on universities to have greater integrity and accountability for making admissions truly merit based.

</comment><comment><USER11> This hardly seems right – UCLA, USC and Yale are victims of the bad actors involved just as much as the students are. I haven't seen any indication that the colleges involved were aware this was happening in a way they overlooked.

You can file a lawsuit for anything in the United States. I would love to hear how this lawsuit isn't frivolous or (at worst) searching for a payday.

<comment><USER12> >I haven't seen any indication that the colleges involved were aware this was happening in a way they overlooked.

No doubt the colleges involved are aware when someone is admitted whose credentials don't measure up. That's not something the colleges can bury there head in the sand about. We are talking about billion dollar institutions with entire admissions departments that pride themselves on a standard of student...you can't just say in some instances rouge actors took bribes to allow students in school and no one knew anything about it.

<comment><USER13> The whole scandal is around faked credentials – faked sports accomplishments, fake standardized test scores. The schools, from what I've seen, were kept totally out of the loop.

<comment><USER12> That's not at all what I read, for example:

>Singer used the foundation to collect payments from parents and pay bribes, court records show.

</comment></comment></comment></comment><comment><USER14> What standing could these students possibly have? They didn't get in to all the colleges they wanted to because the admissions process wasn't "fair"? It never was fair nor does any admissions office I've ever heard of claim to be.

<comment><USER15> > What standing could these students possibly have?

The fact that they paid for something, via the application fee, that was advertised with features it doesn't have, and the fact that there are consumer protection laws that call that a deceptive trade practice and provide a remedy for it. (Also, the lawsuit is much broader than the universities and includes claims, including civil RICO pclaims, against the parties more directly involved in the core bribery scandal.)

<comment><USER14> What features didn't the application process have? Every college I've ever seen advertises "diversity" in their admissions process. If we peek under that diversity umbrella, we can see: Legacy, Donors Kids, Athletes, Full-Tuition Payers, Hard-Luck-Feel-Good-Stories, Employees' Children, Political Backscratching & everyone else.

Please show me one college that says "we _only_ use this list of criteria to determine admission". None do because they need the wiggle room for the aforementioned higher-value candidates. New buildings/NCAA titles/Sponsored Chairs don't cost nothin'!

<comment><USER15> > What features didn't the application process have?

See Count II of the suit, commencing on p.21, and the preceding factual allegations referenced within that Count.

[https://www.courthousenews.com/wp- content/uploads/2019/03/Co...](https://www.courthousenews.com/wp- content/uploads/2019/03/College-Suit.pdf)

<comment><USER14> You know that wiggle room I described? It's quoted right there in the linked document.

1) Yale - "The Admissions Committee then factors in student qualities such as motivation, curiosity, energy, leadership ability, and distinctive talents." [Ed. Note distinctive talents - includes being related to someone who paid for that new building on campus. Having your family name on a campus building is quite distinctive, or so I presume]

2) Stanfurd - "Remember, however, that our evaluation goes beyond any numerical formula. There is no minimum GPA or test score; nor is there any specific number of AP or honors courses you must have on your transcript in order to be admitted to Stanford." [Ed. Note: the evaluation goes beyond a numerical formula because it also includes who your parents are and how your enrollment will affect football season ticket sales]

3)G-town - "Georgetown maintains a holistic review process..." [Ed. Note: because holistic includes the whole Legacy thing]

4) UCLA - "These select applicants are the ones who would contribute the most to UCLA's dynamic learning environment;" [Ed. Note: Is that a double entendre? You be the judge!]

etc., etc.

In summary, this lawsuit is DOA.

</comment></comment></comment></comment></comment><comment><USER16> It would be very poetic if it turns out that one of these students actually had their test scores flipped by their parents without their knowledge.

<comment><USER17> Most schools require the organization that administers the exam to send the official scores. I can't imagine any school worth going to would allow for self-reporting of scores. It seems like the guy in charge of all of this had everyone from the exam proctors to heads of athletic departments to look the other way or just out right lie. I would be extremely pissed if I had been given an SAT or ACT by either of those two exam proctors, my college would instantly have a good reason to be suspicious about my exam scores.

I doubt these kids did any of the actual college application. If you are paying that much to get your kid into school, you are paying for someone to fill in the app, take the exams, write a bogus personal statement, and to pay off anyone to vouch for the lies. It's probably very turn key, you write a check and your kid gets an acceptance letter in the mail 6 months later. I'm sure these kids aren't in regular highschool either, they probably have "tutors" faking homeschool transcripts and credits for them. I wonder how well these kids do in college if they had to fake their application so badly.

</comment></comment><comment><USER18> [https://outline.com/sCMqJj](https://outline.com/sCMqJj)</comment>


Why we built Deal Score: A concert ticket is not like an airline ticket - <AUTHOR> http://seatgeek.com/blog/seatgeek-news/save-money-on-sports-concert-and-theater-tickets-with-deal-score

<comment><USER2> I feel a little uncomfortable with mysterious scores which essentially say "buy this!". Kayak.com essentially has to lie to me to artifically raise an airline's ticket in the search results (at least, lie by omission), but SeatGeek seems like they could massage the rankings easily for a fee. I don't really have a reason to trust them more than, say, Yelp!, do I?

<comment><USER3> Certainly a fair question. I can pledge to you that we do not (and never will) alter our Deal Score based on fees or relationships with ticket sellers. Our team has spent countless hours building the components of this thing to make it hyper-useful, and it would be pretty awful for us if its integrity were compromised. But I realize that doesn't mean the calculation is transparent.

Beyond that, two things that may be worth considering:

1) Any inaccuracies with Deal Score are in plain sight. If a calculation is off and a ticket isn't given the Score it deserves, that's sitting out there in the open on our site. So it would still be easy for people to "call foul" if there were ever a problem.

2) You're welcome to ignore Deal Score and just sort by price. At that point you're effectively getting the same experience as Kayak. Deal Score is something we built to add additional utility.

</comment></comment><comment><USER4> Why we built Deal Score: Stubhub has an affiliate program.

[edit: opinion about brokers/scalping removed]

<comment><USER4> I'd appreciate some responses from those who downvoted the above post.

update: fair enough, and thanks for the replies. I shouldn't let my own bias against ticket brokers get mixed into commenting on an application like this.

<comment><USER5> I didn't down vote but I could see issues with the comment.

I don't really see what is wrong with building a site based off of affiliate revenues, especially when the site is adding value. Kayak built a pretty substantial company off this model and there are plenty of other examples.

If the issue is with ticket scalping, is a secondary market that horrendous of a thing when the primary market is so inefficient? Also, what about the tickets listed and sold on Stub Hub and similar sites that sell below face- value?

If I'm going to pay over face for a ticket, I'd rather have Stub Hub around than the old way of dealing with ticket brokers. I'd venture to guess that Stub Hub has forced more tickets to be sold for > face but has reduced the margin between face and scalp price. I'd also guess that its value in reducing scalping margins has outweighed the fact that it creates more tickets that are scalped.</comment></comment></comment>


Airbnb Raises $850M at $30B Valuation - <AUTHOR> http://www.wsj.com/articles/airbnb-raises-850-million-at-30-billion-valuation-1474569670 <comment><USER2> For the layman like me, raising this much money for a company that is founded in 2008 sounds like it is still in the startup phase, and sustainability is not achieved. Am I reading this correctly?</comment>


Managed Assembly - Hacker News / Twitter / Stack Overflow hybrid - <AUTHOR> http://john-sheehan.com/blog/introducing-managedassemblycom/ <comment><USER2> I built this. It's not really supposed to be a Twitter/Stack Overflow hybrid but it does incorporate some of those things with more integration to come. It's supposed to be Hacker News (as you can obviously tell) for .NET devs since that community is very fragmented.

If anyone has any feedback, I'd love to hear it.

Also here are direct links: <http://managedassembly.com> and <http://managedassembly.com/twitter> for the .NET Twitter stream I launched Sunday.

<comment><USER3> Gray-on-gray-on-gray with big bold fonts don't make for good readability.

<comment><USER2> Very true. I'll work on it.</comment></comment></comment>


Dray: Unix pipes for Docker - <AUTHOR> http://dray.it/

<comment><USER2> Calling it Unix pipes for Docker is bit misleading since it's nowhere near as simple..

And you can already use pipes between containers, it's just a little ugly: `docker run -ia ... | docker run -ia ... | docker run -ia ...`</comment>


Show HN: HTML5 Game Engine Built with Backbone – Super Mario Bros Level 1-1 Demo - <AUTHOR> http://martindrapeau.github.io/backbone-game-engine/

<comment><USER2> Seriously great work!</comment>


Toronto Homeowners Are Suddenly in a Rush to Sell - <AUTHOR> https://www.bloomberg.com/news/articles/2017-05-24/toronto-bidding-wars-turn-to-homebuyers-remorse-as-market-slows <comment><USER2> Gee. Where have we seen this before? Human memory is overrated. At the end of the day (macro) history is just five to ten things repeating over and over and over AND OVER again.

SMH. This is embrassing.</comment>


Think you can get an A in Bio 101? Care to bet? - <AUTHOR> http://www.post-gazette.com/pg/10224/1079423-455.stm

<comment><USER2> Previous submissions of relevance:

<http://news.ycombinator.com/item?id=1597650>

<http://news.ycombinator.com/item?id=1595995>

<http://news.ycombinator.com/item?id=1595526>

<http://news.ycombinator.com/item?id=1592416></comment>


Because of Covid-19, REI to Sell Its New Iconic HQ - <AUTHOR> https://www.wsj.com/articles/rei-built-an-iconic-hq-because-of-covid-19-the-outdoor-retailer-wants-to-sell-it-11597263188 <comment><USER2> I was curious, having seen REI stores with the "Co-op" branding lately in my area... turns out they consider themselves a consumer's cooperative.

From the REI Wikipedia page[1]:

> The Andersons originally established the co-op structure to secure reduced > prices for its members

I am not a member of REI, but I shop there a couple times a year.

Am I missing out on some serious discounts or something... because in my experience, REI is definitely the most expensive place around to buy outdoor gear.

Obviously I miss out voting for board members... but I don't really care about that (and I assume most members likely don't either).

[1] [https://en.wikipedia.org/wiki/Recreational_Equipment,_Inc](https://en.wikipedia.org/wiki/Recreational_Equipment,_Inc).

<comment><USER3> I'm a member and I certainly don't regret it. I also only shop a few times a year, I paid the $20 dollar lifetime fee to be a member about 4 years ago and I've earned over $150 in dividends. I primarily choose to shop at REI for their 1 year return policy, that buys a lot of piece of mind when you buy a different type of shoe, a backpack that you want to test out, or maybe a sleeping pad that looks comfortable in the store but may not be comfortable in the wild.

<comment><USER2> From what I've read, the dividends are only 10% of what you spent in the previous year, so if you've earned $150 over 4 years, that's a total spent of $1500.

In my experience, everything in REI is overpriced, sometimes greater than 25% over Amazon or even Bass Pro Shop.

So... did you actually save any money? Even with the "trial" period for products (did you actually return something 9 months later?).

<comment><USER3> I have had products that I've returned after 9 months. Many of the brands they carry are price controlled, yeti, osprey, Patagonia, smart wool, etc. I wouldn't go there for everything but when price is controlled that extra 10% is nice.</comment></comment></comment></comment>


Engineering breakthrough may lead to batteries that never die - <AUTHOR> http://www.zdnet.com/article/engineering-breakthrough-may-bring-batteries-that-never-need-replacing/ <comment><USER2> I would rather have a permanent battery. The technology has been understood since the 1970s and the military has been using them for at least 15 years.</comment>


All About Nerve Growth Factor and 50 Ways to Increase It - <AUTHOR> https://selfhacked.com/2016/03/27/all-about-nerve-growth-factor-and-50-ways-to-increase-it/ <comment><USER2> Giant pop-up after 10 seconds of viewing article. Nope.</comment>


Be a Good Turk Boss - Mechanical Turk Tips from Feedback Army - <AUTHOR> http://blog.feedbackarmy.com/business-musings/be-a-good-turk-boss-mechanical-turk-tips/

<comment><USER2> I always get the feeling when reading about Mechanical Turk that for a service which promises the ability to get arbitrary amounts of lumpen labor for pennies with an API you have to do an awful lot of speaking to individually identifiable people about pennies, which is so far from my desired job description it isn't even funny.

(The attraction for me when I used FeedbackArmy was that they took care of the "managing turkers" headache for me. I boggle that someone would want to do that, but I guess people boggle about my business model, too...)

<comment><USER3> Mechanical Turk is the Pink Sheets of human dignity.

</comment></comment><comment><USER4> Neat tips. I especially like the idea of joining Turk-worker communities and asking what they prefer. Good customer service to your employees, too ;-)

Solid numbers for times and prices are also welcome.

And "ask open-ended questions" sounds like good advice, especially early on when you want reviews and ideas rather than very specific, closed tasks.

</comment><comment><USER5> Most Turkers are women? That's very odd to read. I distinctly remember an article posted to HN a few weeks ago where a "Turk Boss" asked Turkers to take pictures of themselves, and a vast majority appeared to be Indian men.

<comment><USER6> This could easily be self-selection bias; many women may very well shy away from sending their pictures away anonymously for cultural reasons.

</comment></comment><comment><USER7> great article. thank you for posting.</comment>


Whistleblower alleges manipulation in the VIX fear gauge - <AUTHOR> https://www.cnbc.com/2018/02/13/whistleblower-alleges-manipulation-in-the-vix-fear-gauge-urges-regulators-to-investigate.html <comment><USER2> Why wait until the end to point out that this letter is most likely nonsense? Seems unlikely that people are getting scammed out of hundreds of million dollars a month.

I tracked down the actual letter here and confirmed it has all sorts of stupid stuff in it. [https://assets.bwbx.io/documents/users/iqjWHBFdfxIU/r8LCxXQ4...](https://assets.bwbx.io/documents/users/iqjWHBFdfxIU/r8LCxXQ4CfqU/v0)

Repeatedly blames the CME, which has nothing to do with the VIX. Losses to investors of trillions in a week, what? The mechanism they describe is that the indicative VIX value is affected by option orders (true) and this somehow affects VIX futures (I'm skeptical). The only time this index affects VIX futures directly is during settlement, and the only example they provide totally mangles the definition of implied volatility.

Furthermore, they are complaining about someone posting a 0.35 executable bid in a illiquid market where the offer price is oscillating between 1.40 and 9.80. Doesn't seem sinister considering far out of the money options are known to be illiquid.

</comment><comment><USER3> >A Cboe spokesman told CNBC: "We take our regulatory responsibilities and the oversight of our markets very seriously. This letter is replete with inaccurate statements, misconceptions and factual errors, including a fundamental misunderstanding of the relationship between the VIX Index, VIX futures and volatility ETPs, among other things. As a result of these errors, we feel the conclusionary statements contained in this letter lack credibility."

</comment><comment><USER4> A brokerage made a bet against the VIX[1]. Was on HN several days ago [2].

[1] [http://fortune.com/2018/02/10/vix-index-hedge-fund- colorado/](http://fortune.com/2018/02/10/vix-index-hedge-fund-colorado/)

[2] [https://news.ycombinator.com/item?id=16346175](https://news.ycombinator.com/item?id=16346175)

</comment><comment><USER5> Their allegations don't explain volpacolypse though, which is the really interesting and somewhat of a gray swan scenario.

Also, those rumors (people manipulating VIX near expiration dates) have been circulating for a while now and CBOE has denied all of them.

I'm mostly interested to see what the SEC makes of it all and if there will be any indictments made, but I honestly doubt that there will be.

</comment><comment><USER6> The manipulation was not with the vix. it may have been with the vix futures that caused XIV and SVXY to fall so much . Vix and vix futures not the same thing.

</comment><comment><USER7> This article is old news - it's from a week ago.</comment>


PHP compiler for JVM - <AUTHOR> https://github.com/dim-s/jphp <comment><USER2> This is not the first attempt. This seems to be focused on extending PHP's performance and capabilities. Personally, I'm more interested in porting PHP applications away from PHP.

Caucho Resin offers 100% php compatibility on the JVM, so that you can host your entire app in a servlet container, and port features one by one. [http://www.caucho.com/resin-3.1/doc/quercus.xtp](http://www.caucho.com/resin-3.1/doc/quercus.xtp)

The PHP-to-Scala migration helper uses Resin/Quercus to provide the standard library to translate PHP to Scala. The output is a Scala codebase, so that you never have to touch the legacy PHP again. [https://code.google.com/p/php-to- scala-migration-helper/](https://code.google.com/p/php-to-scala-migration- helper/)

<comment><USER3> Are there any unbiased comparisons of Resin and other app servers? The only source for their claims of better performance is their own benchmark of serving what seem to be static files. [0] A discussion of it pointed out that the comparison is totally moot, since Resin caches 1k files (and thus outperforms Nginx for that metric), but otherwise is pretty similar for larger files. [1]

[0] [http://www.slideshare.net/billdigman/resin-outperforms- nginx](http://www.slideshare.net/billdigman/resin-outperforms-nginx) [1] [https://www.ruby-forum.com/topic/4404987](https://www.ruby- forum.com/topic/4404987)

<comment><USER4> Used Quercus (the actual php -> java bridge) years ago. I can't recall exact numbers, but generally was about 50-80% faster than the same php based site using a well tuned xcache install (ie, both avoiding the file load/compile).

Ran it using resin, tomcat, glass fish, and jboss. No real difference by app server.

That said, the biggest issue is always site design. Page too big, too many queries, too many assets loaded, etc. will not benefit much from Quercus or any similar technology.

</comment></comment></comment><comment><USER5> See also: [http://www.php-compiler.net/](http://www.php-compiler.net/)

      > Phalanger – full-featured PHP runtime & compiler for .NET/Mono
      > frameworks. Phalanger is modern open-source implementation of PHP,
      > compatible with the vast array of existing PHP code

</comment><comment><USER6> It's nice to see some progress on the PHP Front, with this and HHVM. Though I'm not really a fan of PHP, it needs to be done, too much PHP code has been written.

I think the PHP guys themselves should push a bit more for a new runtime though. Otherwise they'd have to write an actual spec and declase theirs as "just" the reference implementation or something.

<comment><USER7> I believe there are preliminary plans to implement a JIT compiler for PHP 6. FB has certainly helped push changes being discussed into the ecosystem given their problems scaling PHP.

</comment></comment><comment><USER8> Nuno Lopes attempted this first using LLVM in 2008:

[http://llvm.org/devmtg/2008-08/Lopes_PHP-JIT- InTwoDays.pdf](http://llvm.org/devmtg/2008-08/Lopes_PHP-JIT-InTwoDays.pdf)

I think the cost of the garbage collection involved in a JVM implementation vs LLVM significantly outweigh any immediate perceived benefits, especially when you factor in double reference counting anomalies.

</comment><comment><USER9> How does this deal with the load-all-discard-all-per-request approach of PHP? With everything in the JVM, does it keep eating up the memory on a per-request basis?

I don't know anything about language design or compiling something for JVM.

</comment><comment><USER10> Does this use InvokeDynamic?

<comment><USER11> [https://github.com/dim-s/jphp/search?q=invokedynamic&ref=cmd...](https://github.com/dim-s/jphp/search?q=invokedynamic&ref=cmdform)

</comment></comment><comment><USER12> How about a PHP interpreter for erlang?

[https://github.com/altenwald/ephp](https://github.com/altenwald/ephp)

<comment> manuel-rubio Thanks for see the project, I'm under hard construction phase now with the system, at the moment it's not usable for OOP, only for functions ... but I'm on it.

If you want to follow the progress of the project, you can see this page:

[https://github.com/altenwald/ephp/blob/master/doc/COMPATIBIL...](https://github.com/altenwald/ephp/blob/master/doc/COMPATIBILITY.md)

A very simple example is available in this gist:

[https://gist.github.com/manuel-rubio/7949523](https://gist.github.com/manuel- rubio/7949523)

If you have suggestions, recommendations or questions, don't hesitate to do them to me :-)

</comment></comment><comment><USER13> Why JVM when you have HHVM?

<comment><USER13> I see they are offering the "Ability to use java libraries in PHP". But there aren't many Java libs that meet needs unfulfilled by PHP libs, that I know of. And you would have to cross languages to modify the Java libs.

<comment><USER14> > But there aren't many Java libs that meet needs unfulfilled by PHP libs

Only a bajillion bespoke enterprise apps full of Java-implemented business logic.

<comment><USER15> Business logic most likely is application code. Not library code.</comment></comment></comment></comment>


How Microsoft Hit CTRL+ALT+DEL on Windows Phone - <AUTHOR> http://www.wired.com/gadgetlab/2010/11/making-windows-phone-7/

<comment><USER2> It still isn't too late even though iPhone captures a major share of the market.</comment>


Blackbird - Open Source JavaScript Logging Utility  - <AUTHOR> http://www.gscottolson.com/blackbirdjs/

<comment><USER2> Besides the different logging levels, I don't think this brings much improvement over console.log. I think I'll stick with that.

<comment><USER3> I suppose this could be very useful in debugging in IE. But the way IE shuts down the JS interpreter once an error in encountered may just render it useless anyway. Will have to try it out.

<comment><USER4> When I tried it out late last week, I could not get it to run. Installed using the sources provided in the download.

The error was 'blackbird Cannot read property 'style' of undefined'

</comment></comment></comment><comment><USER5> I found this project a few days ago while looking for a javascript logging framework. It looks slick, but I think I'll stick to my choice of using log4javascript due to it's support for logging to a server via AJAX -- this is a very important feature for a JS logging framework, as far as I am concerned.

</comment><comment><USER6> Isn't this what Tapestry uses for client side error messaging? It's actually pretty useful for including in web-app frameworks: you can alert the developer to framework errors which might go un-noticed if just written to console.log. Of course you can disable in production.

On a side note, I've wondered how useful/practical server-side logging of js running client-side would be. For keeping track of what your users are doing, errors thrown etc.

<comment><USER7> That's not a bad idea. Some suggestions/ideas:

\- It would need to be asynchronous

\- It would be nice to collect a log locally and send it centrally under specific circumstances (e.g. an error occurs send everything that has been logged so far)

\- Using some kind of local storage option might be nice (e.g. the interface to SQLite that WebKit-based browsers have).

<comment><USER6> It'd be fairly simple I think: a global object with .info(), .debug() etc methods. You'd have to make x-domain ajax calls to post back the message as the log server would have to run on another port. Various config options to change server, port, log-level defaults. And then a simple server to handle the posts and write out to log file on disk. You could even have a hosted/cloud service for those that didn't want to run their own logging server.

</comment></comment></comment><comment><USER8> It's nice, the only thing is, if your site's style sheet uses class names like "error", "debug" and so on, it will mess up the log window.

You have 2 options: 1 - modify your styles 2 - modify blackbird styles + code

I'll stick to console.log as well but a great tool nevertheless.

</comment><comment><USER9> MochiKit has LoggingPane (works in IE): [http://mochi.github.com/mochikit/doc/html/MochiKit/LoggingPa...](http://mochi.github.com/mochikit/doc/html/MochiKit/LoggingPane.html)

</comment><comment><USER10> Would be useful for me if it supported mobile browsers. Maybe bring up the logging GUI by doing a "secret" gesture?</comment>


Readline in Vim's Insert Mode - <AUTHOR> https://github.com/jonhiggs/vim-readline <comment><USER2> > _Why am I always exiting from insert mode? Because I don 't know the insert > modes special keys._ > _Why are those special keys so different from > Readline?_

You were doing it right the first time. Vim's "insert mode special keys" are basically incredibly basic terminal controls that are the same as Readline anyway (like backspace, or ^U to delete to the beginning of the line), or incredibly obscure things like inserting the contents of a specific register. Vim doesn't expect you to move the cursor much in insert mode, it's just for typing.

As it turns out, the extra Readline bindings this emulates are basically emulating Emacs' standard bindings, so if you want those bindings in an editor, you know where to look.

Personally, I just stick these settings in ~/.inputrc:

        set editing-mode vi
        set keymap vi

...and then every application that uses Readline (including bash, the Python REPL, the PostgreSQL REPL, and a bunch of other things) defaults to vi keybindings. It's dreamy.

<comment><USER3> have you ever found a solution to make readline change cursor shape depending on mode? not knowing the mode before typing keeps me from turning this on, even though I prefer vi bindings.

<comment><USER4> You can do something similar using the show-mode-in-prompt option:

      show-mode-in-prompt
        If set to `on', add a character to the beginning of the prompt indicating
        the editing mode: emacs (`@'), vi command (`:'), or vi insertion (`+').
        The default value is `off'.

Unfortunately it's currently hardcoded to only use the '+' and ':' chars, and to only display at the beginning of the prompt.

Chet accepted a patch I submitted for custom indicators, and this will be coming in bash 4.4/readline 7.0: [http://thread.gmane.org/gmane.comp.shells.bash.bugs/22580/fo...](http://thread.gmane.org/gmane.comp.shells.bash.bugs/22580/focus=22613)

I have patched versions of bash 4.3/readline 6.3 available on github (the bash page has gifs showing the functionality in action): [https://github.com/calid/bash](https://github.com/calid/bash) [https://github.com/calid/readline](https://github.com/calid/readline)

Note that the '\m' escape hasn't been accepted into the mainline yet, so as of now the custom indicators will still only display at the beginning of the prompt in the new versions.

</comment></comment></comment><comment><USER5> Counterargument: It might disrupt your flow and make undos and using the dot more difficult.

There is an [episode of vimcasts]([http://vimcasts.org/episodes/modal-editing- undo-redo-and-rep...](http://vimcasts.org/episodes/modal-editing-undo-redo- and-repeat/)) which compares editing in vim's insert mode to making a brush stroke in a graphics program. With this plugin one must be careful not to make the brush strokes too long.

<comment><USER6> Very interesting analogy. Many 3D modeling programs had undos based on clean abstractions (history of transformation matrices for object P/O/S, stack of operators to influence geometry) but it often broke when you go below. Houdini (one that was fairly dogmatic about being 'procedural') had to reify vertices/edges modification as an Edit node in its object graph to stay coherent without losing information (or making it a second class citizen).

</comment></comment><comment><USER7> No ! just say no ! Don't do it ! This repo is created by an emacs lovers who pretends to use vim and then creates subversive plugins just so that they can spread confusion, fear and chaos among vim users !!

:-)

Ah, well, whatever peels your banana...

<comment><USER8> > confusion, fear and chaos among vim users

What, more than usual? How could you even tell?

</comment></comment><comment><USER9> There is already a plugin that does the job pretty fine : tpope/vim-rsi

<comment><USER10> vim-rsi... Readline-Style Insertion or Repetitive Strain Injury?

<comment><USER11> Tomato tomato</comment></comment></comment>


Ragel will Target C, C++ and ASM Only - <AUTHOR> http://www.colm.net/news/2016/07/31/ragel-target-langs.html <comment><USER2> The about page for Ragel: [https://www.colm.net/open- source/ragel/](https://www.colm.net/open-source/ragel/)</comment>


Ask HN: What mouse do you use? - <AUTHOR> I bought a vertical ergonomic mouse a year ago and since I don't have so much pain like I used to after working long hours.<p>Does any of you still own the mouse where your palm is horizontal? Why? <comment><USER2> I used the trackpoint and touchpad a lot on my ThinkPads. And any noname office mouses. Because changing workplaces frequently.

</comment><comment><USER3> I tried 5 different mouse options. Finally settled on 3M joystick type mouse. I have no pain in my hands anymore.

</comment><comment><USER4> Logitech Ergo trackball mouse. I have two for home and work. They are amazing.

</comment><comment><USER5> Logitech M570 Trackball. Cheapest mouse to get you started on a Trackball.</comment>


SpaceUp Sweden Twitter stream - <AUTHOR> https://twitter.com/hashtag/SpaceUpSweden?src=hash <comment><AUTHOR> Tweets from the latest installment of the SpaceUp unconference movement [1][2]. A day of hacking the "Space conference" :).

[1] [http://spaceup.org/](http://spaceup.org/)

[2] [http://www.spaceupsweden.org/](http://www.spaceupsweden.org/)</comment>


Customizing class creation in Python - <AUTHOR> https://snarky.ca/customizing-class-creation-in-python/ <comment><USER2> I don't see why you'd need this sort of indirection. It's a very strange way of hiding behaviour from people that is currently clearly understood. Should metaclasses really be able to magic up decorators out of thin air and why is importing a decorator and using it bad?

As for __init_subclass__() it literally allows you to mess with things when subclassing objects in totally unexpected ways!

"Adjusting how classes are created can be very difficult to debug and so should only be used when you have a really legitimate use-case."

I'd say never use it - if anyone has a good reason to do magic like this I'd like to see it!

<comment><USER3> Take a look at SQLAlchemy/django's ORMs.

Personally I have two uses, one is in proprietary code, but the idea is basically use python to generate json, but allow incoherence of json pieces via natural python flows. (metaclasses specifically allowed me to reverse the flow of creating objects, so that visually, code wouldn't look like

        inner1 = JsonObject(config)
        inner2 = JsonObject(config)
        outer = JsonObject(config, children=[inner1, inner2])

but instead

        class outer(JsonObject):
            inner1 = JsonObject(config)
            inner2 = JsonObject(config)
            _config = config

ish. With this isn't not clear why this is important, but with highly nested structures, having the python code visually mirror the output in terms of nesting is really nice.

The second is at [https://github.com/gtagency/pyrostest/blob/master/pyrostest/...](https://github.com/gtagency/pyrostest/blob/master/pyrostest/rostest_utils.py). This isn't strictly necessary, but "The documentation states that all test_* methods in a RosTest subclass spin up roscore" is a lot simpler and safer than "if you forget to add `RosTest.setUp()` and `RosTest.tearDown()` at the beginning and end of all of your setUp and tearDown methods, your tests will fail. (and further, future invocations of tests may fail until you run something like `killall -9 roscore && killall -9 rosmaster` in shell because you've unintentionally broken your environment."

Generally speaking, Metaclasses allow you to make better user interfaces for developers, and avoid the repetitive kinds of things you encounter in "enterprisey" code. Specifically, they allow you to make interfaces much more declarative than you otherwise could (ie. the SQLAlchemy example of "this is a table and here are its columns" vs. "My table is a function that takes in some stuff and magic happens within it")

<comment><USER2> Personally I find a language with Macros easier to understand and far more powerful for such things, and it's not a load of special cases that are still being added to (in this case the __init_subclass added in 3.6).

Fine about meta classes for some things but you haven't covered why you'd use the two examples in the article.

<comment><USER3> I actually wanted prepare in production, because it would have allowed me to override the class dict with an ordereddict, which was a more preferable solution to making output jsons deterministic than just sorting the components, but you do what you can.

As for init subclass, if you're alright with a DSL that does weird things with the class line, it can be useful, as an example applied to SQLAlchemy, they could do this (in pseudo sqla):

        class MyTable(Table, primary_key='uid'):
            uid = Column(int)

which would enforce via the api that there can only be 1 primary key.

<comment><USER2> I don't actually understand either example which kinda proves my point ;-)

<comment><USER3> How do you mean?

So for prepare, imagine you have a class whose entire job is to be serialized to some external format. I'll use json, but it could be csv, yaml, whatever. Heck, maybe you're doing code generation and its a group of functions that will be placed into another file.

Say I have an instance of this class:

        class JsonObject(Serializable):
            key = "value"
            second_key = "second_value"

This gets serialized to

        {
            JsonObject:
            {
                key: "value",
                second_key: "second_value"
            }
        }

Except that sometimes what you get is

        {
            JsonObject:
            {
                second_key: "second_value",
                key: "value"
            }
        }

Minor, but important, difference. Python stores object attributes in a dict. Python's dicts are unordered, and so when serializing, the order that things are printed in is undefined behavior. That means that now instead of just using a normal diffing module, you need to write some json-differ that parses and compares the json, and you lose the ability to do side-by-side comparisons. So you want deterministic, ordered, output generation.

Now, to be clear, you could model your api like this:

        output = JsonObject()
        output.append(key="value")
        output.append(second_key="second_value")

And that works well for this simple example, but as soon as you start nesting things, it gets confusing, so just assume that for reasons you want this DSL for code generation.

You have 3 options:

1\. Create some determinism: your serialize function looks something like this (pseudopython):

        def serialize(self):
            for k, v in self.attrs:
                write(jsonify(k, v))

A fix is really easy:

        def serialize(self):
            for k in sorted(self.attrs.keys):
                write(jsonify(k, self.attrs[k]))

Not bad, but a few problems, you can't customize the output order, everything now needs to be comparable, and its a smidge slower, especially for really big objects (remember: you're writing a DSL for generating large serializable things, there's a good chance you'll want to have some way to autogenerate large quantities of data to be serialized).

2\. add an `_order` attribute to your class, then your serialize method becomes

        def serialize(self):
            for k in self._order:
                write(jsonify(k, self.attrs[k]))

Well, now you have to forward declare everything, which is kinda annoying, you're populating your namespace with crap (what if your generated json/python/whatever needs a `_order` attribute!), and if you ever forget to update your order attribute, your stuff doesn't work write.

3\. Replace your class's dict with an OrderedDict. Now, you've done some dark magic to do this, but you don't need to forward declare, your users control the output order naturally in a way they expect, and you don't have to sort a bunch of things every time you want to serialize any data. (admittedly python 3.6 I think voids this issue by making the class dict and OrderedDict anyway, but that's technically an implementation detail)

Does that make sense?

</comment></comment></comment></comment></comment></comment><comment><USER4> > aside: please don't abuse collections.namedtuple to make a simple Python > object; the class is meant to help porting APIs that return a tuple to a > more object-oriented one, so starting with namedtuple means you end up > leaking a tuple API that you probably didn't want to begin with

I haven't heard this before. I subclass namedtuples regularly—whenever I need a simple immutable object. I haven't had any problems personally. (Except when pickling them. I would not recommend that.)

Can any experienced Pythonistas weigh in? Is this bad practice?

<comment><USER3> You'll get surprises such as your subclass being indexable when you (probably) don't want that.

<comment><USER5> What problem would that cause? Wouldn't it only be a problem if you attempted to index into it, which you wouldn't do (on purpose) if you didn't think it was indexable? And if you did try to index into it thinking that it wasn't indexable, it would be a bug, which is the same as when it's indexable...

<comment><USER3> Exactly. You probably don't want this thing that is essentially a namespace to be indexable, but you index into it, which is a bug, but it quacks like a tuple, so your mistake propagates silently, which is a _bad thing_.

Its more permissive than one would expect. Although the bigger issue is what dragonne mentioned.

</comment></comment></comment></comment><comment><USER6> > Adjusting how classes are created can be very difficult to debug and so > should only be used when you have a really legitimate use-case.

...and you never have a really legitimate use-case. Seriously, please don't use this sort of magic in production code that you expect other people to use and depend on. I'm looking at _you_ Django project. Bloddy cowboys.</comment>


Erllambda: Run Erlang and Elixir in AWS Lambda - <AUTHOR> https://github.com/alertlogic/erllambda <comment><USER2> Every time i read this kind of news i wonder : is there any real point to use erlang if you're not taking advantage of its concurrency model ?

Since the lambda model means concurrency is completely managed by the platform, why would you code in this language ?

<comment><USER3> I can't speak for Erlang, but I use Elixir and not primarily for the concurrency model. I just really like the language (and it's functional-but- accessible approach), relative speed (compared to Ruby), fault-tolerance, community.

In particular the fault tolerance and process-based approach is just awesome. I regularly find myself writing code with just the 'happy path' (and only the obvious error handling), which just feels a ton nicer than the more defensive approach I generally take in other languages.

The tooling around the language is also really nice.

<comment><USER4> I can't speak for Elixir, but I love Erlang for exactly those reasons.

<comment><USER3> Ha, I do suppose all those count for Erlang too. I get the impression that syntax-wise it's very much a matter of taste, although for some Elixir's macros might make it preferable.

</comment></comment></comment></comment><comment><USER5> I've been saying for a while that Lambda (and serverless in general) should just be a compilation target, not a Radically New Computing Concept(tm). This is another inch towards that.

<comment><USER6> I think it is already through libraries. At least for lambda in python you have libraries (Zappa for example) that allow you to write basic flask and Django apps and then deploy them to lambda. These apps can still be deployed the "old" way with no or minor modifications

</comment></comment><comment><USER7> Does this run a separate Beam instance for every Function? If so, isnt that an enormous waste of Erlang? If not, how isolated are requests? Can I send messages between them? Should I?

<comment><USER8> Maybe it shares a beam instance per AWS account. Definitely curious about the isolation level of lambda in general since the same comment also applies to the JVM.

<comment><USER9> This means AWS would keep a beam instance running for you the entire time? I doubt that

<comment><USER8> I assume it'll cold boot one up for you if you didn't already have on running on first request, keep it around for a while, and when it becomes idle for a while, shut it down. There's a lot of blog content out there to try to ping lambda enough so the instance stays around to avoid the cold boot issue.

<comment><USER10> If only there were a feature of lambda where it stayed up all the time...

<comment><USER11> Never having a cold boot isn't quite the same as being able to set a minimum concurrency level, though both would be very valuable.

At re:invent this year, someone on the Lambda team indicated that they were working on something in this space, but couldn't say exactly what, or give any real timeline.

</comment></comment></comment></comment></comment></comment><comment><USER12> Pattern matching is a good fit for lambda use cases.

<comment><USER13> Yep! Single biggest reason I'm excited for this.

Nearly 100% of the lambda functions I've written could make use of erlang/elixir style pattern matching.</comment></comment>


Developers vs iphone - <AUTHOR> http://www.techcrunch.com/2009/11/12/facebook-please-back-developers-vs-iphone/

<comment><USER2> Surprise, surprise... Yet another post against Apple on TechCrunch.

</comment><comment><USER3> bad title, I know - and you mangled it further, but still, +1 from me.</comment>


New Xen vulnerabilities and how Linode addressed them - <AUTHOR> http://blog.linode.com/2012/06/13/xen-security-advisories-and-how-we-handled-them/

<comment><USER2> I guess if you have a SAN hosting the vm data disks then you can just 'xm migrate' the machine from the vulnerable cluster to the updated ones without much of a hassle. This would be a massive job for cloud providers though.

<comment><AUTHOR> Indeed. But Linode doesn't use SANs. They only use local storage. So I can only imagine how much more of a task it was to get this done.</comment></comment>


Brad Fitzpatrick on the future of Go - <AUTHOR> http://dotgo.sourcegraph.com/post/99652962343/brad-fitzpatrick-on-the-future-of-the-go-programming <comment><USER2> Well, it's good to have a hard-compiled language that's (almost) memory safe. Three problems with Go:

\- The Go mantra is "share by communicating, not by sharing". Then look at all the thread examples in "Effective Go". They all share memory, while trying to construct locks using message passing. Multi-threaded Go programs are not memory-safe. That's why Google won't let you use them on their AppEngine. Compare Erlang, which takes message passing seriously.

\- The lack of exceptions is resulting in hacks using the "panic" mechanism to create an exception mechanism. This is where we were with "longjmp" in C. I know someone at Google who has constructed a language on top of Go mostly to deal with exceptions.

\- The lack of generics is resulting in hacks using the reflection mechanism to create generics. This is painful and slow. Go has generics for built-in objects; channels and maps are parameterized types, so there's already syntax for instantiating a parameterized type. Extending that to user-defined types would not be too bad. Fear of the C++ template mess seems to have been the problem.

<comment><USER3> Rust addresses all of these problems. It's memory safe through compile-time reference counting and borrow checking (not garbage collected), and it has exceptions and generics. It also has a more powerful type system with type inference.

Having tried out both Go and Rust I don't see any reason to prefer Go, at least once Rust has a 1.0 release, which is supposed to happen the next 2-3 months.

Both languages were designed to replace C++, but only Rust has the features to actually succeed at that, IMHO.

<comment><USER4> I think at this point Go is more of a replacement for Java than C++.

<comment><USER5> People love to say this, but the observation falls apart quickly under scrutiny. People working in Java are doing so to retain access to the JVM and to the zillion libraries built on it. The JVM with its ecosystem is a colossal asset for Java; one of the greatest in all of commercial software development. (I say this as someone who does not enjoy Java).

Meanwhile: Golang neatly fills in a sweet spot just "below" Python and Ruby, where finer-grained control of memory and more predictable performance characteristics are required, but bare-metal performance isn't. That sweet spot actually describes a huge fraction of all the use cases for C/C++ in Internet software.

So this is a meme I'd like to see die. It somehow manages to simultaneously get Golang, Java, _and_ C++ wrong all at the same time. The only way to make it worse would be to work in some kind of Lisp comparison, based on Golang's parsimony with parenthesis.

<comment><USER6> Couldn't agree more.

Anyone who thinks Go will ever be a replacement for Java is frankly clueless about enterprise software development. Go has almost non-existant integration with enterprise systems e.g. SAP, Hadoop. It lacks operational management capabilities e.g. JMX. And seriously the range of libraries on the JVM covers pretty much everything e.g. banking/finance use cases.

And concerningly there is not a single reasonably sized Go project to get an understanding of how it works with 20, 50, 100 or 500+ developers working on the same codebase.

<comment><USER7> Docker is fairly large, cloc output:

       </comment></comment></comment></comment></comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment>----
       Language             files     blank    comment       code
       </comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment>----
       Go                     750     14601       9901     115877
       CSS                      8       107        194      10010
       HTML                    11       362         21       3594
       Bourne Shell            28       391        323       2044
       Bourne Again Shell      25       249        185       1475
       Javascript              12       111         48        756
       Python                   1        23         24        192
       C                        1        20         19        179
       YAML                     4        25         13        162
       XML                      1         6          2         60
       make                     2        27          5         60
       Perl                     1        11         37         29
       vim script               2         8          3         13
       </comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment>----
       SUM:                   846     15941      10775     134451
       </comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment></comment><comment>----

And I believe there are a number of projects internally within Google but they tend not to talk about internal product technologies (at least at how large they are).

<comment><USER6> No Docker is not fairly large. It's tiny. 1M - 10M LOC is the size of most of the codebases I've worked on.

Most people simply don't have an understanding of enterprise applications. The majority of the apps are single codebase, Servlet/Spring type monstrosities. They are 10+ years old and have had hundreds of contract developers who come in, add a few new features and then go onto the next contract.

And my point is that I am yet to see what Go would be like in these situations.

<comment><USER5> It seems a little unfair to ding Golang for not providing evidence of something Golang was designed to avoid. "Where's all the boilerplate? Where are all the 10 layers of XML mapping? What would an AbstractStrategyFactory even look like?"

<comment><USER8> Rest assured, if Go manages to become a success in the enterprise you will get them.

It happened to every language without exception.

<comment><USER9> But will it happen to one without exception _s_ , as well?? :)

<comment><USER10> Panic/Recover will be used as expections.

</comment></comment></comment></comment></comment></comment><comment><USER11> Reading this I feel Go is boring, and that's an asset. Let me explain.

Seeing [what's happening in Haskell (GHC)]([https://www.haskell.org/pipermail/ghc- devs/2014-October/0065...](https://www.haskell.org/pipermail/ghc- devs/2014-October/006518.html)), which is soooo much more exciting; but then I totally understand that "exciting" is what you want to stay away from in some cases. In these cases a Go is a much better choice I guess.

<comment><USER12> I often describe Go as being boring as a positive asset. For example, when people what makes Go special, I say " _it 's not better than any specific language at specific things, but generally better than most languages at general things._" Which is extremely dull, but most of the time you do just want something straightforward, stable and ordinary when you have normal development projects.

So I think Go is an extremely dull language - but personally I think that's what makes it so good.

<comment><USER13> I tend to think like that about C#, the thing is I feel like there are already many dull, private company managed, programming languages out there to make me curious enough to use it in real life.

<comment><USER14> Reminds me of how I described C# to someone the other day: "If you really want to write Windows programs, I'd rather do C# than the alternatives."

<comment><USER8> And with .NET Native even more so.

</comment></comment></comment></comment></comment><comment><USER15> Here's an interesting portion of a Q&A panel from the same dotGo 2014 conference ([http://dotgo.sourcegraph.com/post/99652344343/go-team-q-a- de...](http://dotgo.sourcegraph.com/post/99652344343/go-team-q-a-dependency- management-design-philosophy))

Q: There are several dependency management tools in the wild: godep, gpm, etc. Are there any plans to provide this functionality in the core?

Brad Fitzpatrick: We don't want to dictate a policy, so we hope the community fights it out and a victor emerges. Then maybe we'll bless that one. Then if everyone likes it and it has been stable for a couple of years, maybe we'll add it to the core.

Brad Fitzpatrick: Part of the reason why we don't care as much about dependency management inside Google is that we don't use the go tool inside Google.

Andrew Gerrand: The lack of versioning built into the Go tool incentivizes library authors to provide good, stable APIs.

<comment><USER16> This is quite interesting, because after the Python fiasco in 2012/13 I thought a new language like Go would have learned from that and done that right from the beginning and I always thought Go did it. "We don't care" is even worse than "we just don't know how, yet".

<comment><USER17> Different people have different requirements. It makes no sense to declare some tool to be THE STANDARD(TM) if it's of no use for a large proportion of their users.

The way $GOPATH works and dependencies are managed is well-documented. Everybody is free to develop their own tooling. Right now, many people flock towards godep, but that might change in the future. Also, since this is only relevant during development and for compilation, getting it right is not as important as if you had to deploy every single one of your dependencies. With Go, you get one binary, and that's what you deploy.

<comment><USER18> And there are people like me who think that the programming language tooling shouldn't have to be tracking dependencies. If, for no other reason, than it is common to use multiple languages for a single project, and then a language- agnostic method should be used.

I've leaned towards just having everything it our DVCS (git in our case). External libraries are handled using git subtree.

<comment><USER16> It is also using a defined way to handle dependencies. I have no problem with that either.

</comment></comment></comment></comment></comment><comment><USER19> This is a summary of a talk from the dotGo conference in Paris last week. Lots of good stuff was presented there. Recommend reading the other posts by sourcegraph on this and watching the videos when they come out.

[http://dotgo.sourcegraph.com/](http://dotgo.sourcegraph.com/)

</comment><comment><USER20> How about a better optimizing compiler? I've been using Go and everything feels quite snappy. Justifying it use over Java on the server-side, for example, might require a little more supporting data.

<comment><USER21> That's the plan, after the compiler is converted to Go and there's an internal SSA form, etc.

Also, gccgo is a very good optimizing compiler but is held back by lack of escape analysis, which I mentioned is being worked on.

</comment></comment><comment><USER22> Regarding the article's mention of GopherJS: The Google Dart project should adopt Go as its language and reboot. Dart hasn't gone anywhere. GopherJS is a great low-budget transpiler and its source could be incorporated into a Go- based Dart.

It would be great to see what could be accomplished with a big-budget GopherJS.

<comment><USER23> The big advantage of Dart over JS is the type system. Switching to Go would mean throwing that away.

<comment><USER24> PureScript and ClojureScript all have type systems better then the one in Dart. The simplest ways to get a type system is TypeScript. Not sure how I how it compares.

<comment><USER23> "Better" is subjective (and I certainly wouldn't consider any dynamic system to be better than dart's) - Dart hits a certain sweet spot IMO, being simpler than a typeclass-based approach but far more usable than Go or Java. TypeScript is pretty nice but gradual, which is its own set of tradeoffs.

Dart has other selling points than the type system, sure, but degrading it to Go-style types would be a serious loss.

</comment></comment></comment></comment><comment><USER4> Go 2.0 should be highly optimized for Android (and as a potential _main_ language for Android) and should get even better ARMv8A support.

<comment><USER25> Without generics I don't really see how that's feasible, since the Android framework leverages that feature of Java so heavily.

<comment><USER26> If this is the reason to finally add generics to Go, all the better, and a lot of people puzzled by the community's copy&paste attitude to code reuse might reconsider the language.

Also, this would require Google to finally polish up the Android NDK, which would be great even for non-Go users.

</comment></comment></comment><comment><USER27> Will there be a proper debugger I wonder?

<comment><USER28> This is the highest and most important thing I want from go. A proper debugger that is not insanely hard to setup ( on any machine! ). Gives a complete stack trace and such info. I am not sure how people can live without a debugger in 2014. GDB is not the answer to this - for sure. There are soo many things that can be done ( tooling wise! ) and this one is , I personally think, the first things the golang guys need to do .

<comment><USER29> Why do you say that GDB is not the answer? In my experience, GDB (and DDD) works great with Go!

<comment><USER28> You are probably pretty awesome at setting things up. I am not. I tried GDB, golang and windows as a combination and its an exercise in torture.

<comment><USER29> That's true, I am great at setting things up... but Go+GDB was _zero_ set up. `go build` then `gdb ${executable_file}`, and nothing else. I suspect that it's Windows being in the mix that gave you trouble?

<comment><USER30> In Mac at least you can't just do that, you need to create yourself a certificate and sign GDB. Took me a while too.

<comment><USER31> Just an FYI, you can use MacPorts to `sudo port install gdb`, and it installs gdb as 'ggdb' without the signing mess. To use with ddd invoke as `ddd --debugger ggdb` and it works like a charm.

<comment><USER30> thank you!

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER32> I've been writing Go for the past couple weeks and have really enjoyed it. My day jobs is in JavaScript land all day long, and while I really love JS I was looking for something more. Go has helped me think differently about how I approach my code in JS now and continues to be a great source of knowledge.

<comment><USER33> With the risk of sounding like a asshole...if you only know JS any other language will make you think differently.

<comment><USER34> Given that the parent wrote that his job is exclusively JS, not that the parent only ever learned JS or never had a job where this was otherwise:

I wouldn't have taken that risk.

<comment><USER35> Have a look at this compiler from Go to JS. Could be useful [https://github.com/gopherjs/gopherjs](https://github.com/gopherjs/gopherjs)

<comment><USER34> Care to explain how that is relevant to the point at hand?

<comment><USER35> Because we were talking about JS and GOLang. I'm not affiliated to whoever created the compiler. I had found it on HN

</comment></comment></comment></comment></comment></comment><comment><USER36> Anybody up for backporting Go's stdlib to C? Doing so in an automated way would be all the better.

There are just so many things in Go that feel like 80% solutions - they make great demos but in every day use you have to fight them (looking at you import system and the GOPATH, magical make() function, magical overloaded accessors, lack of expressions or at least ternary if, pre and post increment are hacks not expressions, lack of coercion to more precise types, no templating / generics / preprocessing, needs an equivalent to realloc, having to go through reflect / unsafe to get things done, lack of proper type resolution for complex types).

There are many things I do like about Go, but much of the time it feels like a very pretty prison compared to the (admittedly less pretty) freedom of C.

<comment><USER8> I rather use Go's pretty prison, than enjoy the freedom of buffer overruns and dagling pointers.

</comment></comment><comment><USER37> > GOTRACE: emits Chrome trace viewer and will allow for us to visualize > scheduler actions and more in Chrome

I'm very excited about this, but I wonder if it will scale to visualize hundreds to thousands of goroutines in a useful way. That's where existing inspection tooling like logging and snapshotting goroutine dumps fall apart.

<comment><USER38> I see anything that ties Go to a specific browser as a bad thing. Surely they should be browser agnostic if they want to encourage universal adoption of their language (or perhaps they don't really care about this)?

<comment><USER39> 1) It doesn't "tie" Go to anything - it uses Chrome for visualization purposes. You can write Go fine without ever touching Chrome.

2) Large parts of the trace viewer are separate from Chrome: [https://github.com/google/trace-viewer/wiki](https://github.com/google/trace- viewer/wiki)

3) The event format is documented, so you're free to write an alternate viewer: [https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQt...](https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU/edit)

</comment></comment></comment><comment><USER40> "at the time there was very little exotic hardware support (such as ARM). "

How is ARM "exotic hardware"?

<comment><USER41> Remember that Go is coming out of Google, and therefore was initially run almost exclusively on desktops and servers. For a desktop or server, ARM is in fact exotic hardware.

</comment></comment><comment><USER42> I see he mentions "beginnings of Android support". This is something I would love to see. Does anyone know if there is a product roadmap that provides a timeline on this?

<comment><USER8> This is a community driven effort to use Go in the NDK.

Android team only cares about Java as stated at Google IO 2014.

<comment><USER43> That's not true. The Go on Android support is being driven by David Crawshaw who works at Google.

<comment><USER8> Thanks for clarifying.

Are you allowed to say anything regarding support from the Android team?

The way Android team spoke at Google IO, I got the idea Go will only have an unofficial place on the NDK.

</comment></comment></comment></comment><comment><USER44> Android and iOS support!

</comment><comment><USER45> Will Go ever get an interactive debugger that is comparable to Java?

<comment><USER31> Look at GDB or DDD+GDB, they are more full-featured than JDB, but do not have the IDE integration and GUI-ness that you will find in Eclipse/Netbeans.

LiteIde for golang is the closest to the IDE+debugger combination you would expect if you were coming from an Eclipse/Netbeans background.</comment></comment>


Johnny Lee: Wii Remote hacks [video] - <AUTHOR> http://www.ted.com/index.php/talks/view/id/245

<comment><USER2> I see an emerging market demand for a quality manufactured version of the infrared LED pen, as demonstrated, for use with the inexpensive interactive whiteboard.

</comment><comment><AUTHOR> I love this approach of using powerful, but cheap, technology to bring a powerful new tool to the masses.

</comment><comment><USER3> I think Google was the first one to really dominate this approach (or bring to market) they started with super cheap hardware... (and I think they still use commodity hardware)...

\- I think its equally cool that he can get his PHD from hacking together a gaming system into something usable

<comment><USER4> I think his thesis actually focuses on using infrared tracking to project light onto moving targets. I guess it's still hacking a gaming system but I think that project is actually quite a bit more complicated than the white board.

</comment></comment><comment><USER5> Johnny Lee == the new Jeff Han

</comment><comment><USER6> this guy is awesome, but the funny part is probably a lot of the people at TED could buy an interactive whiteboard for 2k.

</comment><comment><USER7> the head tracking thing was done before johnny lee. it actually made it to market but was unpopular. his version looks easier and cheaper to implement. hopefully we'll see some support for games and tele-conferencing apps.

</comment><comment><USER8> this is awesome! Now, could you do the hand tracking a' la minority report as well? Seems like it.</comment>