Ask HN: What Vim plugins do you use? - <AUTHOR>

Hello. I am returning to Vim after a short break. I thought this thread would be a good idea to make sure that I am up to date and that I haven't missed any new plugins.<p>Also, what's the best plugin/setup for python code completion these days? <comment><USER2> Managed with [https://github.com/gmarik/vundle](https://github.com/gmarik/vundle) here are the plugins I'd say I use every day:

[https://github.com/airblade/vim-gitgutter](https://github.com/airblade/vim- gitgutter) show git change/deleted lines

[https://github.com/bling/vim-airline](https://github.com/bling/vim-airline) light weight, pure vimscript status line

[https://github.com/kien/ctrlp.vim](https://github.com/kien/ctrlp.vim) fuzzy file finder that mostly works

[https://github.com/tpope/vim-fugitive](https://github.com/tpope/vim-fugitive) very nice Git wrapper

[https://github.com/scrooloose/syntastic](https://github.com/scrooloose/syntastic) generic in Vim syntax checker plugin

[https://github.com/sjl/gundo.vim](https://github.com/sjl/gundo.vim) undo tree viewing

</comment><comment><USER3> Far too many. Some I'm using maybe every twentieth time I start vim, but whenever I throw them out I suddenly need them...

vim-easymotion - Jump to positions easily (I still use the mouse too often)

vim-powerline - Prettier and more customizable display of useful data and the mode we're in

vim-supertab - Still fails me too often but I'm having it set to omnicomplete most of the time

minibufexpl - Old but I don't like the way the tabs works

ctrlp - Good fuzzy finder. Not sure if it's the best, but it doesn't require compiling Ruby extensions and weird crap

Gundo - Tames the undo tree

ack.vim - Integrates ack to search in files more easily

vim-css-color - Love this one. Underlays color values with the actual color

And other stuff like syntax for YAML, Jinja2 and HTML5.

</comment><comment><USER4> I have a list of all my vim plugins in its own dotfile: [https://github.com/jdonaldson/dotfiles/blob/master/vim/setti...](https://github.com/jdonaldson/dotfiles/blob/master/vim/settings/vundle.vim)

</comment><comment><USER5> I use [https://github.com/skwp/dotfiles](https://github.com/skwp/dotfiles) for all my vim and zsh needs. I don't need/want to maintain my plugins and I like the recommended shortcuts.

</comment><comment><USER6> The plugins you were using before your break still work so I'm not sure you need to look for new plugins. Unless some of your plugins didn't satisfy you.

In which case you could list the offenders so that we try to come up with alternatives.

Anyway, there seems to be a consensus around youcompleteme+jedi, these days.

Welcome back.</comment>


It ain't about the callbacks, it's about the flow control (2013) - <AUTHOR> https://idea.popcount.org/2013-09-05-it-aint-about-the-callbacks/ <comment><USER2> I think that, like programming in general, there are different styles that click for different people. Different analogies, like the "push" vs "pull" described in this article come with different trade offs, and different people see them more easily than others.

In reality, I just want more options. I know that synchronous IO on UI threads is bad, but I also know that I can avoid bottlenecks by not pulling from slow IO sources. Choice means that a problem can be expressed in the most natural way to a programmer or a team, which ultimately helps convey the ideas better than trying to work in an unnatural convention.

I love Ruby primarily because you can usually accomplish tasks multiple ways. You can usually find the most natural way _to you_ and use that, over, say a prescribed "best" way.

<comment><USER3> If you are writing an API that others are incorporating, create equivalent pull methods for every push where possible (or alternatives if necessary).

The reasoning is simple, sometimes programs get in bad states. When a bad state is detected, a program _should_ be able to go into a recovery mode and return to normal. But I've seen push-only libraries (that I could not modify), where access to the data I'd need could not be guaranteed.

This particularly holds true in a client-server relationship. The client should have a method of asking the server for help without needing to reset the session.

Ignoring state effects, a pull model will permit recovery by default, while it needs to be planned in a push model.

</comment></comment><comment><USER4> the important part of flow control is to accept enough work to keep yourself busy, but not more than you can eventually retire at that rate, and not more than would require holding more intermediate state that you have room for. [edit: those are really two sides of the same coin...ideally you would also come close to saturating some throughput limit (network/disk/memory bandwidth). and even better come close to saturating all of them]

if the work includes tasks with variable delay (using the disk, or an external network service), or uses variable amount of compute, then you need to look at creating appropriate adaptation and overall scheduling strategies (i.e. retire older work first)

so while having a queue depth of 1 and implementing everything as fully blocking in the naive threading case is maybe a better place to start than having an infinite queue depth in the naive callback implementation....neither one really gets you to where you need to go without further structure.

the only real frustration I have with the threaded approach in trying to build the 'right' system is that at some point you have to deal with the system scheduler being largely workload oblivious.

once you build you own scheduler, then whether you are assuming synchronous returns from a programming perspective really is a matter of style, and probably involves more language-provided safety and less boilerplate.

</comment><comment><USER5> I don't quite get the mapping of "pull" and "push" and "synchronous" and "callbacks".

        foo.asyncPush(callback);
        foo.asyncPull(callback);

and

        const result = await pull();
        await push(data);

Both feel similar in terms of idioms, capabilities, etc... I know that async/await was not a thing in 2013 JavaScript, but as a pattern (promises, futures, etc...) it's been around for some time.

<comment><USER6> I had the same confusion reading the article.

IMO, the reall issue with callbacks is that they split your functions into two sets of uncompatible functions that cannot call each other -- the "async" functions with callbacks and the "sync" functions without them.

[http://journal.stuffwithstuff.com/2015/02/01/what-color- is-y...](http://journal.stuffwithstuff.com/2015/02/01/what-color-is-your- function/)

async/await mitigate this a bit because although the two kinds of functions are incompatible at least the syntax is the same.

<comment><USER7> The two kinds of functions are also more clearly declared.

</comment></comment></comment><comment><USER8> I agree that not having a natural flow of control is more prone programming debugging. However, he does say things that are wrong, ex: "It's impossible to slow down the pace of accepting new incoming client connections." You can slow down the pace by doing the following:

         const http = require('http');
         let count = 0;
         const THRESHOLD = 1;
         const server = http.createServer((req, res) => {
           if (count++ < THRESHOLD) {
             // do work
             res.write('success');
             res.end();
             setTimeout(() => count--, 10 * 1000);
           } else {
             res.write('limit');
             res.end();
             count--;
           }
         });
         server.listen(10000);

<comment><USER9> First, this post is not about flow program control, it's about controlling data-flow. I made the same mistake at first, but the post literally makes zero sense with the other reading.

Second, your solution does not limit the acceptance of new incoming client connections, it only limits the frequency with which "work" is done. That solves some possible problems, true, but it does not solve the problem that the post is about.

On the other hand, I see no evidence in this blog post that callbacks are the inherent cause of the flow-control problem; it's rather that high-level languages that abstract the connection event are the inherent cause. Callbacks or no callbacks, the problem is the level of abstraction.

</comment></comment><comment><USER10> I still like highland.js to solve these issues</comment>


We Should Worry About How China Uses Apps Like TikTok - <AUTHOR> https://www.nytimes.com/interactive/2019/05/02/opinion/will-china-export-its-illiberal-innovation.html <comment><USER2> Not to get too "whatabouty" here, but it always feels a bit less poignant to call China out for the same things the United States, and massive private US corporations, are doing. Censorship, collection of private data, public data, biometrics, DNA, monitoring and incarcerating ethnic minorities. At least in China they have public healthcare.

<comment><USER3> Unhelpful comparison without acknowledgement of the serious shortcomings and corruption in Chinese healthcare; and the free debate in the US concerning privacy. The gap is too large to "what about".

<comment><USER2> Free debate doesn't do much when the people in power have no motivation to change, and when even small wins (like net neutrality) are so easily undone. I really don't think the gap is as large as you might think.

The US is a bit more liberal in its allowances of public discourse than China but at the end of the day US media mostly serves to maintain the status quo; you're not going to make any real lasting change via freedom of speech alone.

Also look at actual movements within the US which have made an impact on people's lives and see how the US state has cracked down on them, the Black Panthers are a good example of this.

</comment></comment></comment><comment><USER4> It's hard for me to read this in a US newspaper and square it with the real world. It bemoans race riots and military police in Xinjiang - in China. From the context of the Baltimore race riots three years ago I cast my mind to Xinjiang Muslim radicals _within_ China - right next to the Afghans who American troops and military police patrol 18 years and counting, on the other side of the world. Radicals in Afghanistan who the US had originally armed in the 1970s and 1980s to overthrow the then secular Afghan government incidentally.

Then from Facebook Google and most of the surveillance San Francisco establishment, in lockstep with government PRISM, we look East to see the Chinese doing the same?

Africans in the US, native Americans at the Standing Rock reservation being water cannoned, are no better off than those in Xinjiang. More African men in the US are in the prison system than college.

The demonization of China by Americans for what Americans are doing, with less reason, is silly.

It is like the hypocrisy of telling Venezuelan military to revolt and cheering street protests in Venezuela, then going back to hearings about Russian interference in the US or condemnations of yellow vest protests. Macron praises the destructive protests in Caracas and condemns yellow vests in Paris in the same press conference.

<comment><AUTHOR> _> no better off than those in Xinjiang._

This is false equivalence.

While treatment of many groups is disgraceful in the US, the level of surveillance, social control and repression is nowhere near what happens in China.

China has locked up millions Uyghurs and other ethnic groups in re-education camps.

[https://en.wikipedia.org/wiki/Xinjiang_re- education_camps](https://en.wikipedia.org/wiki/Xinjiang_re-education_camps)

Yes, America's wars are shameful.

Guantánamo Bay, the FISA "court" and domestic concentration camps for asylum seekers are contemptible.

But these things are not on the same scale as what China is doing.

The fact that we can have this conversation without censorship or fear of arrest is evidence that the US and China are far from equivalent.

</comment></comment><comment><USER5> We should worry about all such apps, regardless of provenance... As a non-US citizen, I don't really see the difference between e.g. a China-based app and an US-based app.

<comment><USER6> As a non-US citizen I would trust US apps, especially those by companies like Google or Apple, any day over Chinese apps.

<comment><USER7> Me too, the consequences are less severe. (For now).

<comment><USER5> For example? Can you give some concrete examples of consequences for _you_ in the two cases?

</comment></comment></comment></comment><comment><USER8> NYT's China hit article of the day

</comment><comment><USER9> Of course we should</comment>


The Mistake that Cost Me $100,000 in Cash this January - <AUTHOR> http://www.profitalist.com/the-mistake-that-cost-me-100000-in-cash-this-january/

<comment><USER2> I've made very stupid hires - one jerk cost me my largest customer.

However, I've hired people who needed a first IT job and didn't have a good resume. One in particular was working in furniture rental store, and after working well for my company for a few years, he went on to bigger and better things and is earning probably 80k.

Hiring people that need a leg-up can be a good thing for this world.

I would square the two ideas("hire carefully", "hire good people that need help") by immediately firing anybody that displays any sort of ethical lapse. All my 'bad' employees showed signs of ethical problems long before they did their damage.

</comment><comment><USER3> Did I miss the part about where we learn HOW he actually lost the $100,000 in cash? Or what specifically lead to that other than some vague BS?

<comment><USER4> It was in JANUARY! JANUARY! But in 6 WEEKS he managed to MAKE $100,000. CASH!

So to answer your question, you might need to buy the 2 day seminar, 8 tape set, and special VIP membership (available for 1 day only) to find this out. But it's worth it. You do like money, don't you?

<comment><USER5> *she

</comment></comment></comment><comment><USER6> Ugh, the way this blog post is written reminds me of all those fast-cut YouTube videos made to hold your attention by changing camera angles every 2 seconds.

<comment><USER7> I was waiting for the "BUY OUR EBOOK NOW AND YOU TOO WON'T LOSE $100,000!" at the bottom of all the scrolling. I was kinda disappointed.

</comment></comment><comment><USER5> "Your best employees should be so good that you practically never think about them."

I'd just LOVE to work for her /sarcasm

</comment><comment><USER8> This article seems to have been automatically generated by a computer -- it makes no sense. Almost all paragraphs are one sentence, at most two.</comment>


Ask PG: Why not allow links from the text field on submissions - <AUTHOR>

I frequently see ask HN articles that are posted with links in their text field. I have read the submission form where it says "If there is a url, the text will be ignored" but I don't understand why HN does that. HN is my conduit to interesting articles and links are the fastest way to get to these articles when a little context is required.<p>My question: Can you make those urls into hyperlinks? If not, why? <comment><USER2> From the FAQ (<http://ycombinator.com/newsfaq.html>):

"How do I make a link in a question?

You can't. ( _This is to prevent people from using this method as a way of submitting a link, but with their comments in a privileged position at the top of the page_. If you want to submit a link with comments, just submit it, then add a regular comment.)"

Emphasis mine.</comment>


What is good color? (2015) - <AUTHOR> https://pavelkosenko.wordpress.com/2015/08/13/what-is-good-color/ <comment><USER2> Like all "theories" of art and music this model is no good as it isn't predictive. There are plenty of good art with brightly saturated color. Deciding spontaneously that muted colors are the one true way and then that preference for saturation is some sort of retardation in development is just laughable at best. I have a friend who prefers muted colors precisely because he's color blind.

</comment><comment><USER3> His point seems to be 'don't go near the scary end of colour and you're all good: stick to pastels and use a million shades of nearly the same colour.

I don't think it explains good colour use, vision differences (e.g. Tetrachromacy) or _why_ artists can sometimes seem to make horrible colours work really well.

Better gradients does not necessarily equal better colour.

</comment><comment><USER4> I find it fascinating that many Asian cultures do not distinguish between Blue and Green, including their traffic signals [0]. And color symbology varies between cultures [1].

There are also interesting parallels between the color wheel and the musical circle of fifths. Or as Boards of Canada would have it, Music Is Math [2].

[0] [https://www.japantimes.co.jp/life/2013/02/25/language/the- ja...](https://www.japantimes.co.jp/life/2013/02/25/language/the-japanese- traffic-light-blues-stop-on-red-go-on-what/)

[1] [https://jenndavid.com/colors-that-influence-food-sales- infog...](https://jenndavid.com/colors-that-influence-food-sales-infographic/)

[2] [https://www.youtube.com/watch?v=F7bKe_Zgk4o](https://www.youtube.com/watch?v=F7bKe_Zgk4o)

</comment><comment><USER5> The artist in me agrees with a lot of what he says but I do feel it necessary to point out that in many applications there are other considerations than colour harmony. Specifically accessibility for the large proportions of the population who have some form of colour blindness and the need to develop clearly distinguished palettes for information presentation (as opposed to art). My go-to resource for non-artistic palette development is [0]

[0] [https://blog.graphiq.com/finding-the-right-color-palettes- fo...](https://blog.graphiq.com/finding-the-right-color-palettes-for-data- visualizations-fcd4e707a283)

<comment><USER6> This is a good resource, I have seen this authors articles before on forums before too

Personally, what I have been doing with color choice selection is just use HSL format. It makes it very easy to reason about and A/B test different colors to see what pallettes work. I have not really considered color blindness though, but per the article having color hues work in greyscale makes sense. Its like printing black/white documents VS color based docs.

General rule of thumb to me is don't use more than 3 primary colors.

The first starting point is to work with the existing theme's logo color choices. This vastly limits what range of colors you can use, depending on what emotions you want to evoke.

Finding good color palletes is _hard_. Even with all the color choice palletes out there. Somedays I spend literally an entire day tweaking color choices on some projects. The critic in me cannot stand poor color choice selections.

I sometimes wish I wasn't terrible at art either, telling stories is so much easier when you can make nice hand-drawn / watercolor drawings.

</comment></comment><comment><USER7> A great tool for choosing harmonic colors:

[https://color.adobe.com](https://color.adobe.com)

There are others out there, but that URL stuck to my mind.

<comment><USER8> Similar for paint harmonies and comparison: [https://encycolorpedia.com/paints?color=dac8ac&brand=Pantone...](https://encycolorpedia.com/paints?color=dac8ac&brand=Pantone+/+PMS)

</comment></comment><comment><USER9> As someone who does not have a great eye for color but would like to become better, I really liked this model of color and how to create harmonious color pallette. The color wheel never made sense to me.

<comment><USER10> Me too. It did a good job of putting in to words that which I had a gut feeling for.

</comment></comment><comment><USER11> there's no universal standard for good color because it depends on context and fashion.

eg. MS used blue as a calming color for error screens, but it became a symbol for failure and frustration via the bsod.

It's also common knowledge to use warm colors for food, but this creates a vacuum of blue colored food brands which now stands out (eg. blue apron)

</comment><comment><USER12> I only know that green isn't a creative color.

<comment><USER13> Teal and magenta is creative. You can't make nonconformist movies unless they are color graded teal and magenta. And drink your coffee!

</comment></comment><comment><USER14> The first thing I did was to change the text color from #666 to #000. It is soooo much easier to read now. I don't understand why gray - and a pretty light shade even (666 is pretty far from 000) - has become the standard text color on (way too many) websites. None of my displays, from middlish quality laptop to Adobe color space 32 inch monitor, show that as even close to being the most readable text color. In addition, the page sets a font weight of 300, combined with the font used it ends up with a pretty thin font that looks grayish to begin with.

By the way, what is this character that's all over the text for me?

<comment><USER5> > By the way, what is this character that's all over the text for me?

It's a Line Separator character: U+2028 or HTML entity code &#8232

Not all browsers display it correctly. Based on a quick test, Firefox and Edge do, Opera and Chrome don't. This is why it's worth checking your web content in a variety of browsers as your content creation / publication tools aren't guaranteed to produce browser-independent output.

</comment></comment><comment><USER15> Don't want to sound ungrateful, but, if you're going to write an interesting article on good colour, the least you can do is make sure the text of the article isn't in light grey against a bright white background.

Just sayin' :)

<comment><USER16> #666 is closer to dark grey than it is to light grey.

<comment><USER15> Indeed.

And #000 is closer to black than to grey, and makes for a better contrast to #ffffff, and hence easier to read for those of us mere mortals with eyesight problems.

(p.s. apparently my original comment got downvoted - my apologies if my comment was somehow offensive in some manner to someone - I honestly thought I was making a good observation. Or perhaps it was a web designer who loves making reading web pages as difficult as possible by camouflaging text as much as they can get away with against a #ffffff background ;) )

<comment><USER17> Downvotes make text grayer, perhaps it was a communal attempt at humor?

<comment><USER15> That hadn't entered my head as a possibility - since I'm feeling mean, have an upvote to ensure your excellent comment stays black :)</comment></comment></comment></comment></comment>


Ask HN: Is data visualization a viable career? - <AUTHOR> Is it possible to make a decent living (5k+ per month, USD) doing data visualization? Are there jobs in this field? Are there freelance projects?<p>To be clear, I am not talking about dashboard creating tools like Tableau (which doesn't take much skill) but more of d3 style, unique ways of telling a data story. <comment><USER2> > Are there jobs in this field?

There are in media, finance, and science. You just have to look.

> Are there freelance projects?

There are companies who are looking for freelancers.

> Is it possible to make a decent living (5k+ per month, USD) doing data > visualization?

Good luck.

> To be clear, I am not talking about dashboard creating tools like Tableau > (which doesn't take much skill) but more of d3 style, unique ways of telling > a data story.

Then it sounds like you might be interested in data journalism. The field is rife with people working in data viz. Though, you need several skill set beyond just putting lines on a screen: pulling a story out of data, reporting it out, understanding journalism ethics and processes, interviewing, etc.</comment>


I changed my default search engine - <AUTHOR>

5 Queries which fired google - http://searal.wordpress.com/2013/10/08/5-queries-where-google-failed/ What do you mean failed ?
It means I have found better results in another search engine Which search engine you have compared with ?
Searal. I have compared my results with Searal and Google Ok, I see. Where are the queries ?
Here it is. Decide yourself Where is a good place to eat dinner? – I have found a direct place name in search engine searal, according to my location. Google just sends me to another url . JBAS014688: Wrong type for max-threads. Expected [EXPRESSION, INT] but was OBJECT – Yahoo and DuckDuckgo has better results. And google has not even understood the query. 2013 Nobel prize winner - Before finalizing your answer, check out the results in DuckDuckGo tab at searal.com. DuckDuckgo is providing live results. Unknown lifecycle phase "checkout". You must specify a valid lifecycle phase or a goal in the format <plugin-prefix>:<goal>  - Google failed completely here. I have found results in bing search. Remote EJB communication cluster hangs with load - Now if you cannot provide answers to this query. Then what is your use ?
I never thought that i can get better results in Searal. How can that possible ?
You are not the only one. I have changed my default search engine for searal. And I am able to find solution quite early than my colleagues do. It is possible because alots of people just think google is the internet. Whatever Google is displaying is correct and is a final answer. But above are very simple query.
Should i salute you ?
Three Salutes to Yahoo , Bing and DuckDuckgo Or one salute to Searal ! <comment><AUTHOR> Full article - [http://searal.wordpress.com/2013/10/08/5-queries-where- googl...](http://searal.wordpress.com/2013/10/08/5-queries-where-google- failed/)</comment>


Hong Kong protests: Rule of law on 'brink of collapse', police say - <AUTHOR> https://www.bbc.com/news/world-asia-china-50384360 <comment><USER2> It is, by the police</comment>


Ask HN: Office space in Mountain View or Palo Alto? - <AUTHOR>

I'm looking for office space for 1 or 2 people in Palo Alto / MV at the moment.  When I looked 6 months ago, it seemed like Craiglist was the only game in town - with the other "AirBnB for office space" type services not having any inventory for Palo Alto / MV.
Is there a good service matching small startups to office space?
I know there's a bunch of serviced offices and a couple of Plug'n'Play type companies, but it seems pretty hard to find a sublease around here. <comment><USER2> I am brazilian and I got a really nice office in downtown Palo Alto (Lytton Ave, next to 10gen HQ). I used Regus (<http://www.regus.com/>) and they have a really good service.</comment>


Alexa, Are You Listening? - <AUTHOR> https://labs.f-secure.com/archive/alexa-are-you-listening/ <comment><AUTHOR> How to implement this yourself: [https://github.com/echohacking/wiki/wiki](https://github.com/echohacking/wiki/wiki)</comment>


Ask HN: Where are RapGenius and other startups in the PRISM debate? - <AUTHOR>

Several startups are working on organizing information on the web by letting users annotate, collect, and comment on stories - RapGenius, Storify, and Hypothes.is, etc.<p>Have any of them tried to make sense of the PRISM revelations? For example, what news and commentary has surfaced, and through which sources. <comment><USER2> It's annotated via crowdsourcing, if you have something to say on subject - here you go:

[http://news.rapgenius.com/President-barack-obama-remarks- on-...](http://news.rapgenius.com/President-barack-obama-remarks-on-nsa- wiretapping-prism-lyrics) [http://news.rapgenius.com/United-states-foreign- intelligence...](http://news.rapgenius.com/United-states-foreign-intelligence- surveillance-court-nsa-order-to-collect-verizon-phone-records-lyrics) [http://news.rapgenius.com/Apple-google-facebook-yahoo- micros...](http://news.rapgenius.com/Apple-google-facebook-yahoo-microsoft- tech-company-denials-about-prism-lyrics) [http://news.rapgenius.com/Google- denial-of-prism-cooperation...](http://news.rapgenius.com/Google-denial-of- prism-cooperation-lyrics)</comment>


Abandoned Soviet Energia rocket in derelict hanger, in pictures - <AUTHOR> http://www.telegraph.co.uk/news/2017/03/28/mission-impossible-abandoned-soviet-space-rocket-waits-lift/soviet-rocket-1970s-stands-abandoned-disused-hanger-baikonur4/ <comment><USER2> Before Buran, Energia launched Polyus. The ominous looking black Russian deathstar satellite. Polyus was rushed and the failure to reach orbit was not due to Energia. I called my laptop polyus.

The Russian economy might have collapsed and killed off Buran and the Energia launcher but the engine technology survived so I think images of abandoned Russian rockets probably don't give a balanced impression of their space program.

Energia was powered by the four chamber RD-170 engine. Thirty years after Buran, the two chamber variant, the RD-180 powers ULA's very reliable Atlas V which carries a lot of US government payloads to orbit and the single chamber RD-181 variant powers Orbital ATK's new Antares rocket. Good engine designs hang around. SLS is going to fly on a stockpile of saved Shuttle engines.

Energia's engines are going to remain a player in US launches until Bezos's Blue Origin get their BE-4 engine to market and vehicles like ULA's Vulcan and Blue Origin's New Glenn are built.

</comment><comment><USER3> So cool. Also Buran, the first automated shuttle flight. Who knows what might have been.</comment>


New Features in C# 7.0 - kruse-tim https://blogs.msdn.microsoft.com/dotnet/2017/03/09/new-features-in-c-7-0/ <comment><AUTHOR> Wow! They seem to be adding lots of the things that make Python feel more convenient than C#, tuples being big.

Out parameters are going to make some things much nicer. I can certainly see local functions being useful as well.

Out of all of it, I think the thing I'm most excited about is pattern matching. Having used F# for a short time, that was the biggest stand-out feature; it really does make some code much more concise and expressive.

I love C# but lately I've been using Python for my quick-and-dirty work because in general I find it to be more expressive. It seems like C# 7 might make me reconsider.

<comment><USER2> The big impediment imho between c# and scripting language is the whole Visual Studio project experience. With Roslyn they introduced the csx format for c# scripts so you can have a stand-alone 1-file executable c# script, but the tooling hasn't caught up yet.

I'm using LinqPad for all kinds of one-off scripting jobs and loving it. I was trying to learn PowerShell for that task but I've finally given up on that. PowerShell has some great features, but the overall chaotic syntax just kills me.

<comment><USER3> I think MS should buy LinqPad and give it away for free. It's just an amazing experience (having the full version is critical though).

<comment><USER2> There's a decent F/OSS implementation called CShell (bad name, I know, that's already a thing)

[http://cshell.net/](http://cshell.net/)

Either way, neither of them run "true CSX files", but their own homegrown format that predates csx. But it has made me hopeful for the future of C# scripts.

<comment><USER3> And another called RoslynPad

</comment></comment></comment></comment></comment><comment><USER4> I'm probably in the minority, but I'm not really a fan of these new changes. Some are OK, but a lot of them seem likely to be abused more than used appropriately.

         p.GetCoordinates(out int x, out int y);

vs

         var coordinates = p.GetCoordinates();

out parameters should be deprecated, not enhanced.

Patterns are OK, but switch statement with patterns...why? I'd much rather do something like this:

        class ShapeHandler()
        {
             public void Handle(Circle c)
             {
                 ...
             }
             public void Handle(Rectangle s)
             {
                ...
             }
        }

The argument for Tuples:

> Custom-built transport type for every method: A lot of code overhead for a > type whose purpose is just to temporarily group a few values.

I disagree. Before you know it, that 'temporary group' becomes a first class citizen and deserves its own type. If it's code overhead, I'd rather the IDE/tooling help me with it than it be built into the language.

Overall these changes make the language more expressive which is good. I just fear they will be abused more often than not.

<comment><USER5> I think C#'s designers make it clear that they don't want you to use out parameters. They're a hack; they were only included at all to make it easier to communicate with C/C++ libraries. But now that they're there, they have to stay because of back-compat - Microsoft definitely does not want a Python 3 situation. They might as well make them as painless as possible for the people stuck with them because of some library. And at the same time, they should offer a compelling alternative to out parameters, which they have finally done with tuple returns.

<comment><USER6> I mentioned this in another thread, but I wish they'd tell the Visual Studio Team not to use them, then - The SOAP and WCF tools will still happily generate code that requires out parameters.

<comment><USER2> People still use WCF? I suffered enough getting one project running with Windows Configuration Fuckup. Never again.

<comment><USER7> Some of us are stuck using them as part of legacy systems. We're eliminating them as we move to a newer stack but legacy code can be quite sticky.

</comment></comment></comment></comment></comment><comment><USER8> What I love in C# is, each update the language gets even faster, far more natural to write. Soo different of Javascript, where looks you are fighting against the language first, and then if you win, can develop something useful. I use js why I need use it, but I hope use c# instead, high hopes with webassembly, etc

<comment><USER9> I worked for 6 years on C#, I was C# MVP and I really enjoyed the language.

4 years ago I started to work more with js and then node.js until I stopped working on c#. Js has been for me a gateway to transition to other languages and get paid for that. I learned bash, python, a bit of ruby, go, etc.

If I see c# code today I don't understand what it does. Sure every version has a lot of new very useful stuff but it also introduces noise, "why he used out x instead of the new shiny out var x, he might not know about it, lets send PR".

Along the way I have learned to appreciate simpler languages that does not change that often. Where there are few or just one way to do something.

I think I read an interview to Mitchel Hashimoto (hashicorp) and he said he choose Go over all languages because it was boring.

A boring and simple language allows you to focus on the problem you are solving. A language that doesn't change for years allows people to catch up and master the tool. It also means that you can open a file written by someone else years ago and understand what it does.

IMHO js was in that sweet spot until ES6.

<comment><USER7> Not only that but a lot of very questionable programmers use features just because they're there. C# is becoming like C++ in the sense that it can enable beautiful code from the good coders and truly terrible code from the bad coders.

</comment></comment></comment><comment><USER10> So happy _out variables_ are finally a thing, removes such a pain point in the language, especially when having to write:

        SomeReallyLongTypeNameICantQuiteRemember data;
        if (dict.TryGetValue(id, out data)) { ... }

Now reduced to:

        if (dict.TryGetValue(id, out var data)) { ... }

<comment><USER11> While it's good in that example, in the real world I'm expecting a tonne of bad code to use it as a multiple return mechanism.

<comment><USER12> Surely tuples should get rid of the need for that hack?

<comment><USER13> Sure for new code, but I think the concession here is that it provides convenience for dealing with existing code/libraries.

Additionally, it allows restricting the scope of the variable, like in the TryParse examples. The output variable in something like "if (int.TryParse(someString, out var i))" is now scoped to the if block. It cannot be used in the else, nor inadvertently later in the parent scope.

</comment></comment></comment></comment><comment><USER14> Does anyone else just feel underwhelmed by the pattern matching? It seems like syntactic sugar over a standard if(x is Type) that doesn't bring a whole lot to the table other than being able to write more error prone code.

<comment><USER15> Yeah, I was expecting something like what you get in F#.

But maybe it is just the nature of the [C#] language. Still, I think this looks more readable than if-statements.

EDIT: Maybe it is just a bad example of pattern matching, the one they put on that page. I'm betting pattern matching works on the added tuple type. That would be pretty handy.

<comment><USER14> Didn't want to do this out of the gates, but now that I've started a discussion, and folks seem to agree, check out this library I'm working on.

[https://github.com/Jagged/OneOf](https://github.com/Jagged/OneOf)

I've got some more performance improvements and code cleanup in my stash RN I've not quite finished up yet.

<comment><USER14> Forgot to say earlier - Currently being distributed @ [https://www.nuget.org/packages/DiscU](https://www.nuget.org/packages/DiscU)

</comment></comment></comment></comment><comment><USER16> No mention of option types in the standard library. Next time maybe?

The fact that tuples aren't so painful to write and declare is going to make me use them much more - happy about that.

</comment><comment><USER17> Glad to see C# (and ES too in a way) approaching towards F# (& co.) inch by inch with every release. Next and final step, introduce optional "indentation layout" to get rid of braces and semis and I'm a happy camper. FP through the backdoor! =)

<comment><USER16> I'm wondering why the C# team is so keen on pattern matching - I feel like multiple dispatch would suit the language more and accomplish much the same thing. But C# is a weird beast in some ways - a pure OO language that keeps introducing features to make writing getters and setters more and more convenient.

Maybe I just need to move on with the times. I still see a lot of value in OO, but it's clear it's not at all in vogue. I am glad that functional ideas - particularly immutable data, and anonymous functions - have come into the mainstream. But I don't feel the need to throw the baby out with the bath water.

<comment><USER17> > I'm wondering why the C# team is so keen on pattern matching

It's kind of a pre-condition (though not in the current initial limited variation) for the introduction of Algebraic Data Types (as F# & co. have them), which I'd still be missing in C# if I had to get working on a C# codebase (might happen again soon, I just don't get any Haskell enquiries in my freelance channels =)

<comment><USER16> With multiple dispatch, you could already use the existing way of having sum types - class hierarchies - without introducing a second kind.

I just don't see why you want both inheritance and ADTs in the same language. But it's entirely possible I'm missing something, I'm an amateur PLT enthusiast at best.

<comment><USER17> Would just be syntactic sugar anyway, F# surely compiles its ADTs and parametric polymorphism down to something supported in MSIL bytecode.. but potentially powerfully productive "sugar", any highly expressive language is 80-90% sugar (just the right kind) over a much smaller intermediate core language of way fewer actual primitives

</comment></comment></comment></comment></comment><comment><USER18> Looks similar to the Scala syntax: [http://docs.scala- lang.org/tutorials/tour/pattern-matching.h...](http://docs.scala- lang.org/tutorials/tour/pattern-matching.html)

I wonder if there will be a way to do something like case classes in C#.

<comment><USER19> I think they're still working on that:

[https://github.com/dotnet/roslyn/blob/features/records/docs/...](https://github.com/dotnet/roslyn/blob/features/records/docs/features/records.md)

<comment><USER18> Nice. I hope it's interoperable with F#

</comment></comment></comment><comment><USER20> As a Java developer, I am really jealous!

<comment><USER21> As a C/C++ developer, C# feels like unreachable high level heaven. But then again, I prefer my code to have no garbage collector, be portable without any problems and have very high performance. So, C++ it is. If I was writing a Windows-only GUI app with no resemblance of realtime requirements, I would only use C#.

<comment><USER22> Across how many compilers and operating systems is your code portable without any problems?!

<comment><USER23> When written with discipline C++ is very portable. I've worked on codebases that spanned devices with ~8mb of memory to full-blown desktop PC and arches(x86/MIPS/ARM/PPC just to name a few).

<comment><USER24> Across devices it seems it is very portable.

Now, across compiler vendors and versions it is hard

<comment><USER25> Generally speaking when you are targeting that wide of a range of devices you are targeting a wide range of compilers. It requires some discipline but it's far from the hardest thing in the world assuming you are regularly building and testing for all platforms. I'd say that most major C++ applications or libraries compile in Clang, GCC and MSVC without issue and often build for less common targets as well (icc, nvcc for cuda support, etc.) Things definitely get harder when you move to weirder embedded platforms.

<comment><USER23> Yup, we targeted GCC, MSVC, plus a few proprietary compilers. As long as you stick to a reasonable set of features(which you should anyway for sanity reasons) it works pretty well.

Having a good CI is a must though but it's not nearly as hard as porting an old codebase backwards.

</comment></comment></comment></comment></comment></comment></comment><comment><USER26> Man I used to love C# so much - and then I realized what a godsend Maven/Gradle were. I still think C# is the better language and I'm biding my time - is there a decent Maven/Gradle equivalent for C# yet?

<comment><USER27> Pick up some F# and use FAKE / Paket? I'm not sure I'd call Maven a "godsend" though, it has its own class of annoyances.

[http://fsharp.github.io/FAKE/](http://fsharp.github.io/FAKE/)

[https://fsprojects.github.io/Paket/](https://fsprojects.github.io/Paket/)

<comment><USER26> It definitely does, I think Gradle is better... but it's still better than NuGet.

</comment></comment></comment><comment><USER28> I like that new mainstream languages, and updates to major existing languages, are bringing in a lot of ideas from functional programming languages.

Perhaps the C# of tomorrow will look like the Haskell of today.

<comment><USER29> But then what would the Haskell of tomorrow look like?

<comment><USER30> Like C# of yesterday, after people realize they can put all their program code in a single IO monad for ultimate power and flexibility :)

</comment></comment></comment><comment><USER31> Man, if C# got case classes I'd dump scala for life.

<comment><USER32> I wouldn't just yet. The platforms that you can reach with Scala, including JS, and soon LLVM, plus all the goodies that are being developed in Dotty, are pretty compelling for me to stay. Scala keeps getting better and better. It is very exciting to see that other languages, like C#, also keep adding excellent features.

<comment><USER33> I don't like Scala much, a personal preference, but the research behind Dotty is utterly amazing, and when it becomes ready for prime time, it'll be a killer feature.

DOT is some great math, letting them bring simplicity and a ton of high level features to the compiler with very little cost.

</comment></comment></comment><comment><USER3> For anyone who is disappointed at the lack of exhaustive matching / Discriminated Unions, please try out my library OneOf* ([https://github.com/mcintyre321/OneOf](https://github.com/mcintyre321/OneOf)). Hopefully something similar will be brought into C# soon, but in the meantime, these libraries provide fairly idiomatic substitutes.

Also, ValueUtils ([https://www.nuget.org/packages/ValueUtils/](https://www.nuget.org/packages/ValueUtils/)) is nice for making value types.

*or one of the many alternatives ([https://www.nuget.org/packages?q=discriminated+unions](https://www.nuget.org/packages?q=discriminated+unions)) e.g. SuccincT, DiscU

</comment><comment><USER34> I wish C# had standalone functions without needing to wrap them in classes.

<comment><USER35> It'd never pass code review on Hacker News but the classic C# hack for that is just to make a class called Global or whatever and throw your must-be- everywhere functions in there.

<comment><USER36> c++ namespaces are so great for this. Don't know why theyre not available in most languages.

<comment><USER37> Too bad the standard library didn't get the memo and shoved everything into a single namespace :-)

</comment></comment></comment></comment><comment><USER38> Any idea when Mono will support C# 7.0?

</comment><comment><USER39> Been learning C# as I learn Unity/game development and I'm really excited to see local functions, tuples and destructuring coming in 7.0.

<comment><USER40> Too bad you won't see Unity supporting C# 7.0 anytime soon... :(

</comment></comment><comment><USER41> This might be the most exciting group of new features since the beginning of C#. Those tuples...seriously sexy.

But, as much as I love C# (I changed jobs so I could work in it) this just has a pungent code smell to me:

p.GetCoordinates(out var x, out _); // I only care about x

Ug, some random underscore? I'm no language designer, but something maybe could have been done better here? It just looks fugly to me.

<comment><USER42> It's pretty common in languages with pattern matching to use underscore as a catch-all (ML family, Haskell, etc.). I'm not sure how the underscore is a code smell; if you want wildcard patterns without throwing a bunch of unused variables into scope (which can definitely lead to non-obvious bugs), you have to use some symbol.

<comment><USER41> Mostly like if I submitted some code for review and peppered it with underscores because "I don't care about those variables" I'm pretty sure it'd come back to me with a remark about starting to care.

At the point your writing code you don't care about, something might be wrong.

<comment><USER43> When working with an object, you don't always care about all of its properties. If it's packed in a certain way (tuple, Optional wrapper, etc.) that is easy to unpack with destructuring, then you might use an underscore to say "this is how it's structured, but I don't care about the _particular_ value it has so please don't bind it to a variable."

If you bound it to a variable and didn't use it, it'd be the same as declaring an unused variable.

</comment></comment></comment></comment><comment><USER44> I do a lot of coding in few different languages regularly (C#, Python, JS mainly) but what I find is that it is the language I feel enjoyable. Although part of that is probably because of tooling (Visual Studio, Visual Studio Code) and also features like LINQ.

</comment><comment><USER45> A long time ago I tried to use a throw in a ternary expression in C++ (e.g. "return is_good ? value : throw;") and it caused an internal compiler error! Really cool to see that it's now a feature of C#.

</comment><comment><USER46> Are there any c# free lancers on this thread? Our company is exploring the use of the technology for some data projects. If interested in discussing please reach out: leo at finsight dot com.

</comment><comment><USER47> Having left C# for iOS development a while ago, it's really interesting to come back and see how many features (tuples, discards, local functions, etc.) have made their way into both languages.

</comment><comment><USER48> Solid features, Pattern Matching and Local methods are favs!!!

<comment><USER49> Really liking the extras with Tuples/Destructuring... that was always a pain point imho with dealing with Tuples previously. Would still love a regexp literal though.

</comment></comment><comment><USER50> These all look great, especially tuple literals. I wonder why they chose to make tuples mutable though. Can anyone answer that question?

<comment><USER51> They're not. The type ValueTuple is a value-type.

<comment><USER2> While value-types are recommended to be immutable, it is not mandatory.

</comment></comment></comment><comment><USER52> As a hobbyist python developer it's nice to see c# take some of the good parts of python.

</comment><comment><USER53> If they only added deterministic constructors the language would be perfect for me.

</comment><comment><USER54> Local methods are really cool, but kind of remind me of GOSUB in QuickBasic from back in the day. It was considered an anti-pattern, if I remember correctly.

<comment><USER55> Local methods are literally nothing like GOSUB. For starters, GOSUB was originally global, it was only in later structured versions of BASIC (like QB or VB) that you could have functions with local labels, and therefore local GOSUB.

And the reason why GOSUB was an anti-pattern was not because it was local, but because it was so low-level. It was not really a function call - it changed the current instruction pointer to a new statement _in the same function_ (so you didn't get a new execution frame etc), and pushed original instruction pointer onto its own internal stack, from whence you could then return to (effectively, GOTO) it with the RETURN statement. Because it had no execution frame, it also had no provision for passing arguments. And because it was the same code, there were no boundaries - you could flow into the section of code that was meant to be GOSUB'ed into without the use of GOSUB, and you could flow back out without RETURN. E.g.:

       foo = 1
       IF foo THEN GOSUB bar
       PRINT "No GOSUB"
       bar:
       PRINT "Inside bar"
       IF foo THEN foo = 0: RETURN
       PRINT "No return"

On the first run, this will do GOSUB, you'll see "Inside bar", then the flag is reset and we return to the point where GOSUB is invoked. But then the natural code flow will pass the "bar" label, and all that code is executed again, except this time it doesn't RETURN, but instead just keeps flowing on.

So, basically, there's an utter lack of structure here. There's no matching of GOSUB and the corresponding RETURN - indeed, there may not even be a corresponding one, or there may be many, and the same RETURN can be reached via GOSUBs through different labels (and will return to wherever the GOSUB came from). If you RETURN without any GOSUB on the return stack, that's a runtime error, not a compile-time one. If you GOSUB without a RETURN, it's not an error, but you will eventually overflow the stack if you keep doing it. And so on.

So, it's a very messy mechanism that dates back to pre-structured days of BASIC. That's the only reason why it was discouraged why BASIC got SUB/FUNCTION.

<comment><USER54> Ah, thanks for the explanation. Your memory is certainly much better than mine!</comment></comment></comment>


What px means in CSS (Hint: It's not a pixel) - <AUTHOR> http://inamidst.com/stuff/notes/csspx

<comment><USER2> In CSS, "px" is not an angular measurement and it is not non-linear[1]

[http://omnicognate.wordpress.com/2013/01/07/in-css-px-is- not...](http://omnicognate.wordpress.com/2013/01/07/in-css-px-is-not-an- angular-measurement-and-it-is-not-non-linear/)</comment>


Vice investigates the Detroit foreclosure crisis (10 min) - <AUTHOR> https://www.youtube.com/watch?time_continue=5&v=gHLaWw_PnQY <comment><AUTHOR> One thing the story doesn't cover is that real estate investor will use the services of a lawyer (because he knows to do so) and lower the $30,000 value of the house to the $3500 that both he and the original owner paid for the property.

So at a $500 monthly rent he will have his investment back in 7 months and a 90% reduction in his property taxes.</comment>


Maybe programming is rocket science - <AUTHOR> https://medium.com/@zendar/maybe-programming-is-rocket-science-d42eff99a2a9 <comment><USER2> More self aggrandizing?

We already have people with job titles like "Software Engineer" despite a lack of engineering degree. "Data Scientist" seems similarly bad, but at least most people claiming that one can justify the "scientist" part with a B.Sc. degree of some kind.

And then there's this gem: "Very seldom do we hear of buildings collapsing or people not getting into their house because of bad planning."

Directly insulting real engineers... We don't hear about problems, so engineering must be easy!

The level of arrogance displayed by rank and file programmers never ceases to amaze me.</comment>


Ask HN: Who are the significant adopters of IPv6? Does anyone run IPv6 100%? - W-Stool <comment><AUTHOR> A lot of corporate networks use both ipv4 and ipv6. I use ipv4 when debugging because it's easier to type.

</comment><comment><USER2> My last comment from the last time this question was asked a couple weeks ago:

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

TL;DR: I'm an IPv6 early adopter that is beginning to think that IPv6 is doomed.</comment>


The AI Bot That Scans Your Email and Automatically Schedules Meetings - <AUTHOR> http://www.wired.com/2015/01/virtual-email-assistant/

<comment><AUTHOR> I've seen a couple of talks by these guys, and it definitely seems like some cool tech, especially the seamless fallback to human operators when the NLP algos fail.

That being said, this vertical seems limited in market size. I have a sneaking suspicion that their true strategy is to build up a good AI/NLP stack and sell to FB, MSFT, or GOOG.</comment>


Ask HN: What are the most interesting mailing lists? - <AUTHOR>

Do you know any mailing lists that are full of interesting stories and experiences, programming-related or not? I love reading stories like that of Carmack's inverse-square-root, or interesting pranks. Would I be better off just looking at some blogs? If so, which ones?<p>edit: spelling <comment><USER2> The book Surely You're Joking, Mr. Feynman! sounds like it would be a great read for you.

[http://www.amazon.com/Surely-Feynman-Adventures-Curious- Char...](http://www.amazon.com/Surely-Feynman-Adventures-Curious- Character/dp/0393316041)

As far as mailing lists go, I also would be interested in this.

<comment><AUTHOR> I've read it, and love it! One of my favorites, I reread it every so often solely because Feynman is so awesome :)

</comment></comment><comment><USER3> one of my favorite blogs that is littered with satire and tech-related gadgets and stories is <http://www.geekologie.com/></comment>


A strange Firefox address bar behavior - <AUTHOR> http://hexatomium.github.io/2016/04/26/gogoogle/ <comment><USER2> I disabled all magic in the address bar so if I type "foo" it tries to connect to "[http://foo"](http://foo") or else returns an "Unable to Connect" error. I was surprised how many steps were required to accomplish this.

<comment><USER3> I'd love to read the details on what you did, and I'm pretty sure plenty of others here would, too.

<comment><USER4> Set keyword.enabled to false in about:config. I do this because if I want to search, I can just press Ctrl+K or click on the search bar. I use Ctrl+L or click on the location bar only when I want to navigate to a specific URL.

</comment></comment></comment><comment><USER5> %67 is "g" encoded. In this example, it's goo_g_. Typing %hexcode for any letter of a site in your history/bookmarks at the appropriate position triggers the behavior.

edit: %22 is interesting. It triggers a JSON snippet.

<comment><USER6> yeah, but the string that pops up has the >> gogoogle.com part as a literal. If you hit return it'll search that string in the default search engine.

Similar things happen if you do goog%6c or g%6f (i.e. urlencode other chars in the string)

</comment></comment><comment><USER7> The address bar on Firefox for Android also exhibits bizarre behavior. Type in github and then go to the end and try to add a username after the slash. Horrible!

<comment><USER8> That's different... That's just the standard UX of their mobile autocomplete. It's the same on iOS (I type "f" and it autofills a URL - next letter I type is appended to the end of that URL, slash and all).

This is a problem with how it's interpretations the encoding of characters - they should be escaped by default and be able to be enabled with a flag if there's a valid use for them.

</comment></comment><comment><USER9> It's probably just a JS bug where the length of the urldecoded string is used as an index into the fully url-encoded string.

</comment><comment><USER10> Nope, redirects me to:

[https://duckduckgo.com/?q=goo%2567+%3E%3E+gogoogle.com%2F&t=...](https://duckduckgo.com/?q=goo%2567+%3E%3E+gogoogle.com%2F&t=ffab)

</comment><comment><USER11> Note: must type, do not copy and paste

<comment><USER8> Copy and paste down arrow? On mobile.

</comment></comment><comment><USER12> maps.%67 >> mamaps.google.com/

Bizarre.</comment>


Offline messaging app (that actually works) - <AUTHOR> http://www.bridgefy.me

<comment><USER2> Really curious on how this works, is it just bluetooth or something fancier like Google Tone[0]?

[0] [http://googleresearch.blogspot.com/2015/05/tone- experimental...](http://googleresearch.blogspot.com/2015/05/tone-experimental- chrome-extension-for.html)</comment>


Programming Language Checklist - <AUTHOR> http://colinm.org/language_checklist.html <comment><USER2> >[ ] The name of your language makes it impossible to find on Google

Unless you work for Google, in which case your language's name (maybe shared with a common verb or a popular board game) will quickly become the top search result!

<comment><USER3> For me, in an incognito window (so Google is less likely to tweak search results for my preferences), the Wikipedia page for the game Go is the first result, and five out of the top 10 are also about the game. The other results are Disney's "go.com" domain, golang.org, and the movie Go on IMDB.

Doesn't really suggest unfair weighting to me.

<comment><USER4> This is what I see in an incognito window: [http://i.imgur.com/BI4zvXB.png](http://i.imgur.com/BI4zvXB.png)

<comment><USER5> Given that incognito doesn't obscure your IP address (not to mention the myriad other ways your identity could be leaked to Google), I wonder if incognito's enough to get a "clean" page of Google results. On this search, I get different results from you but ones similar to djur: [http://imgur.com/7KTqZFV](http://imgur.com/7KTqZFV) (on Firefox in private mode: [http://imgur.com/Jn400wX](http://imgur.com/Jn400wX)). For reference, I probably would only visit a page on Go if it were linked to on a blog; I don't use it or (normally) search for it.

</comment></comment></comment></comment><comment><USER6> It's surprising to me that people view this as primarily negative. I think it's (a) funny, and (b) actually serves - as does the best humor - to make people think about things more deeply: by enumerating all the knee-jerk reactions in one place, discussion can focus on more interesting aspects.

<comment><USER7> People want to be offended, it makes them feel superior.

It is clearly a joke, anyone taking it seriously shouldn't really have any attention paid to them.

</comment></comment><comment><USER8> This is such a bummer of a file that incorrectly assumes that the only valid goal of a new language is to achieve widespread adoption.

I know its en vogue to turn up our noses at "X at Y lines of Javascript", but programming is actually a pretty fun and neat thing to do, and its okay to create something even if its not particularly groundbreaking or commercially viable.

 _This is a bad language, and you should feel bad for inventing it._

I can't help but imagine the person who penned this sentence also routinely tells children that their macaroni artwork could use more symmetry.

<comment><USER9> I cannot agree more, especially reading the history of T by P. Graham, a language I have never heard of before or written a line in, but whose history I find extremely interesting from a developers perspective.

The whole "X at Y lines" argument is the same as saying "I created an OS in language X in two lines of code" by writing:

      Import OS.*;
      OS.Run();

<comment><USER10> Checkmate, one line.

      Import OS.*; OS.Run();

<comment><USER11> Compile error: only the full sequence ";\n" ends a statement.

<comment><USER10>
      for(;
      ;
      )
      {
          print "I don't like your compiler.";
      }

</comment></comment></comment></comment></comment><comment><USER12> This is like lowbrow-dismissal bingo. Someone (cough) should turn this into actual bingo cards.

</comment><comment><USER13> > You have reinvented PHP better, but that's still no justification

Preach.

</comment><comment><USER14> "You have reinvented Brainfuck but non-ironically" \- brilliant. :)

<comment><USER15> Ah, so _that_ is what this checklist yields for Urbit!

</comment></comment><comment><USER16> With a little cleanup, this could have been the original government procurement checklist for Ada.

</comment><comment><USER17> As the developer of Myrddin ([http://eigenstate.org/myrddin.html](http://eigenstate.org/myrddin.html)), I felt the need to fill it in for my pet language:

        You appear to be advocating a new:
        [ ] functional  [ ] imperative  [ ] object-oriented  [x] procedural
        [ ] stack-based [x] "multi-paradigm"  [ ] lazy  [x] eager
        [x] statically-typed  [ ] dynamically-typed [ ] pure  [x] impure
        [ ] non-hygienic  [ ] visual  [ ] beginner-friendly
        [ ] non-programmer-friendly  [ ] completely incomprehensible

        programming language.  Your language will not work.  Here is why it
        will not work.

        You appear to believe that:
        [ ] Syntax is what makes programming difficult
        [ ] Garbage collection is free
        [ ] Computers have infinite memory
        [x] Nobody really needs:
            [x] concurrency  [x] a REPL  [x] debugger support  [x] IDE support  [ ] I/O
            [x] to interact with code not written in your language
        [ ] The entire world speaks 7-bit ASCII
        [x] Scaling up to large software projects will be easy
        [x] Convincing programmers to adopt a new language will be easy
        [ ] Convincing programmers to adopt a language-specific IDE
            will be easy
        [ ] Programmers love writing lots of boilerplate
        [ ] Specifying behaviors as "undefined" means that programmers
            won't rely on them
        [ ] "Spooky action at a distance" makes programming more fun

        Unfortunately, your language (has/lacks): [Lacks => L, Has => H]
        [L] comprehensible syntax  [L] semicolons
        [L] significant whitespace  [L] macros
        [L] implicit type conversion  [H] explicit casting
        [H] type inference [H] goto  [ ] exceptions  [x] closures
        [L] tail recursion  [L] coroutines [L(planned)] reflection
        [L] subtyping  [L] multiple inheritance
        [L(planned)] operator overloading [H] algebraic datatypes
        [H] recursive types  [L] polymorphic types [L] covariant array typing
        [L] monads  [L] dependent types [H] infix operators
        [H] nested comments [L] multi-line strings  [library] regexes
        [H] call-by-value  [L] call-by-name [L] call-by-reference
        [L] call-cc

        The following philosophical objections apply:
        [ ] Programmers should not need to understand category theory
            to write "Hello, World!"
        [ ] Programmers should not develop RSI from writing "Hello, World!"
        [ ] The most significant program written in your language is
            its own compiler
        [X] The most significant program written in your language isn't
            even its own compiler
        [ ] No language spec
        [X] Incomplete language spec
        [ ] "The implementation is the spec"
        [ ] The implementation is closed-source
                [ ] covered by patents
                [ ] not owned by you
        [X] Your type system is unsound
        [ ] Your language cannot be unambiguously parsed
        [ ] a proof of same is attached
        [ ] invoking this proof crashes the compiler
        [ ] The name of your language makes it impossible to find on Google
        [ ] Interpreted languages will never be as fast as C
        [X] Compiled languages will never be "extensible"
        [ ] Writing a compiler that understands English is AI-complete
        [ ] Your language relies on an optimization which has
            never been shown possible
        [ ] There are less than 100 programmers on Earth smart
            enough to use your language
        [ ] ____________________________ takes exponential time
        [ ] ____________________________ is known to be undecidable

        Your implementation has the following flaws:
        [ ] CPUs do not work that way
        [ ] RAM does not work that way
        [ ] VMs do not work that way
        [ ] Compilers do not work that way
        [ ] Compilers cannot work that way
        [ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
        [ ] You require the compiler to be present at runtime
        [ ] You require the language runtime to be present at compile-time
        [X] Your compiler errors are completely inscrutable
        [ ] Dangerous behavior is only a warning
        [X] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [X] You don't seem to understand basic optimization techniques
        [ ] You don't seem to understand basic systems programming
        [ ] You don't seem to understand pointers
        [ ] You don't seem to understand functions

        Additionally, your marketing has the following problems:
        [X] Unsupported claims of increased productivity
        [X] Unsupported claims of greater "ease of use"
        [ ] Obviously rigged benchmarks (Benchmarks? What are those)
        [ ] Graphics, simulation, or crypto benchmarks where your code just calls
            handwritten assembly through your FFI
        [ ] String-processing benchmarks where you just call PCRE
        [ ] Matrix-math benchmarks where you just call BLAS
        [X] Noone really believes that your language is faster than:
            [x] assembly  [x] C  [x] FORTRAN  [x] Java  [ ] Ruby  [ ] Prolog
        [x] Rejection of orthodox programming-language theory without
            justification
        [x] Rejection of orthodox systems programming without
            justification
        [ ] Rejection of orthodox algorithmic theory without
            justification
        [ ] Rejection of basic computer science without
            justification

        Taking the wider ecosystem into account, I would like to note that:
        [x] Your complex sample code would be one line in: _______________________
        [x] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] We already have a safe statically-typed eager functional language
        [ ] You have reinvented Lisp but worse
        [ ] You have reinvented Javascript but worse
        [ ] You have reinvented Java but worse
        [x] You have reinvented C++ but worse
        [ ] You have reinvented PHP but worse
        [ ] You have reinvented PHP better, but that's still no justification
        [ ] You have reinvented Brainfuck but non-ironically

        In conclusion, this is what I think of you:
        [x] You have some interesting ideas, but this won't fly.
        [x] This is a bad language, and you should feel bad for inventing it.
        [x] Programming in this language is an adequate punishment for inventing it.

Side note, this isn't something serious. It's a tongue in cheek parody of this old usenet spam-fighting idea checklist meme: [http://craphound.com/spamsolutions.txt](http://craphound.com/spamsolutions.txt)

</comment><comment><USER18> Can it output me a list of programming languages based on what I check?

</comment><comment><USER19> As the author of Kitten ([http://github.com/evincarofautumn/kitten](http://github.com/evincarofautumn/kitten)):

You appear to be advocating a new functional, imperative, procedural, stack- based, eager, statically typed, pure programming language. Your language will not work. Here is why it will not work. Unfortunately, your language has comprehensible syntax, significant whitespace, type inference, closures, tail recursion, algebraic datatypes, polymorphic types, nested comments, multi-line strings, and call-by-value. (It lacks almost everything else.) The most significant program written in your language isn't even its own compiler. There is no language spec; the implementation is the spec. Compiled languages will never be "extensible". Your compiler errors are completely inscrutable. No one really believes that your language is faster than assembly, C, or FORTRAN. We already have a safe statically typed eager functional language. You have reinvented Forth but non-ironically. In conclusion, you have some interesting ideas, but this won't fly.

And the runtime isn't even done yet. :P

</comment><comment><USER20> This checklist discourages people from writing their own programming languages. Why not rewrite the checklist as positive, constructive advice around common pitfalls, instead of complaints like "You don't seem to understand X"? There are new programming languages waiting to be invented -- providing a template for knee-jerk negative reactions does not seem like a productive endeavour.

<comment><USER21> > This checklist discourages people from writing their own programming > languages.

Rather, this checklists mocks common discussion-board dismissals that discourage people from writing their own programming languages.

</comment></comment><comment><USER22> Perfect.

To me it looks like a few new languages are introduced every week and I just cannot understand why. I can understand that a programmer who reaches a certain level wants to build his own language, but do they really think that the world is waiting for yet another programming language? It is just not getting easier with a new language.

This article is a must read for everyone who considers writing a new language. If all the arguments do not apply for your language, then the world is probably really waiting for your new language. :)

<comment><USER23> I believe that it is good for any programmer to at some point in their development create a simple language and write an interpreter for it. First, you learn parsing, then you learn what actually makes a language tick. Then you learn what goes into the design process, when you realize you've designed yourself into a corner. Then you start reading up on language design, stumble across sites like Lambda-the-Ultimate.org, and find out that there is a lot more than imperative / OO programming. Then you start getting into the Lisp literature, and reach a zen-like state. Then you snap back to reality, and become a slightly better programmer, who is a bit more humble.

<comment><USER24> Repeat several times to become a much better programmer, but possibly lose the humbleness.

<comment><USER25> Final step: Co-exist as one with John Carmack and all other ascended souls.

</comment></comment></comment></comment><comment><USER26> > You appear to believe that:

> [ ] Syntax is what makes programming difficult

Lol I went from RoR to Java (IBM Websphere stuff) & all my Python dev friends started trying to explain to me how its a career killer because Java's syntax is archaic.

Turns out the company I'm at is using very advanced builder tools and then just integrate a bit with linked Java objects. Pretty neat! And has given me time to shift study toward Play framework / Node / Dart / Clojure.

</comment><comment><USER27> I believe programmers should rather focus their attention to understanding the internals of existing languages, this will do wonders to the way they program.

</comment><comment><USER28> Re: "[ ] The most significant program written in your language isn't even its own compiler"

There's a great quote by someone which Googling can't find, that goes along the lines of: "a language whose own compiler isn't written in itself is beneath contempt."

</comment><comment><USER29> As a non-expert in programming languages I find this list a good starting point for learning: reading about each bullet point in Wikipedia might already be useful. And arguing on HN is not the single application of this knowledge.

</comment><comment><USER30> As a researcher working on experimental PLs [1]...why not

[1] [http://research.microsoft.com/en- us/people/smcdirm/liveprogr...](http://research.microsoft.com/en- us/people/smcdirm/liveprogramming.aspx)

      You appear to be advocating a new:
      [ ] functional  [X] imperative  [X] object-oriented  [X] procedural [ ] stack-based
      [ ] "multi-paradigm"  [ ] lazy  [ ] eager  [X] statically-typed  [ ] dynamically-typed
      [ ] pure  [X] impure  [ ] non-hygienic  [ ] visual  [ ] beginner-friendly

      You appear to believe that:
      [X] Garbage collection is free                [X] Computers have infinite memory
      [ ] Nobody really needs:
         [ ] concurrency  [X] a REPL  [ ] debugger support  [ ] IDE support  [ ] I/O
         [ ] to interact with code not written in your language
      [X] Convincing programmers to adopt a new language will be easy
      [X] Convincing programmers to adopt a language-specific IDE will be easy
      [X] "Spooky action at a distance" makes programming more fun

      Unfortunately, your language (H -> has/ L -> lacks) :
      [H] comprehensible syntax  [L] semicolons  [H] significant whitespace  [L] macros
      [L] implicit type conversion  [L] explicit casting  [H] type inference
      [L] goto  [L] exceptions  [L] closures  [L] tail recursion  [L] coroutines
      [L] reflection  [H] subtyping  [H] multiple inheritance  [L] operator overloading
      [L] algebraic datatypes  [L] recursive types  [H] polymorphic types
      [H] covariant array typing  [L] monads  [L] dependent types
      [H] infix operators  [L] nested comments  [L] multi-line strings  [L] regexes
      [H] call-by-value  [L] call-by-name  [L] call-by-reference  [L] call-cc

      The following philosophical objections apply:
      [X] The most significant program written in your language isn't even its own compiler
      [X] No language spec
      [X] "The implementation is the spec"
         [X] The implementation is closed-source  [X] covered by patents  [X] not owned by you
      [?] Your type system is unsound
      [X] ____________________________ takes exponential time
      [X] ____________________________ is known to be undecidable

      Your implementation has the following flaws:
      [X] CPUs do not work that way
      [X] RAM does not work that way
      [X] VMs do not work that way
      [X] Compilers do not work that way
      [X] Compilers cannot work that way
      [X] You require the compiler to be present at runtime
      [X] You require the language runtime to be present at compile-time
      [X] Dangerous behavior is only a warning
      [X] You don't seem to understand basic optimization techniques
      [X] You don't seem to understand basic systems programming

      Additionally, your marketing has the following problems:
      [X] Unsupported claims of increased productivity
      [X] Unsupported claims of greater "ease of use"
      [ ] Noone really believes that your language is faster than:
         [X] assembly  [X] C  [X] FORTRAN  [X] Java  [X] Ruby  [ ] Prolog
      [X] Rejection of orthodox programming-language theory without justification
      [X] Rejection of orthodox systems programming without justification
      [ ] Rejection of orthodox algorithmic theory without justification
      [X] Rejection of basic computer science without justification

      Taking the wider ecosystem into account, I would like to note that:
      [X] We already have an unsafe imperative language
      [X] We already have a safe imperative OO language

      In conclusion, this is what I think of you:
      [ ] You have some interesting ideas, but this won't fly.
      [ ] This is a bad language, and you should feel bad for inventing it.
      [ ] Programming in this language is an adequate punishment for inventing it.

</comment><comment><USER31> I only upvoted this because McMillen wrote it.

</comment><comment><USER32> Hilariously, C checks a lot of these boxes.

</comment><comment><USER33> I once built a stupid language for fun. Think a bastard child of FORTH and brainfuck, but in two dimensions. To give an idea of how stupid it was, I will fill this in.

        You appear to be advocating a new:
        [ ] functional  [X] imperative  [ ] object-oriented  [X] procedural [X] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [X] eager  [ ] statically-typed  [X] dynamically-typed
        [ ] pure  [ ] impure  [ ] non-hygienic  [X] visual  [ ] beginner-friendly
        [X] non-programmer-friendly  [X] completely incomprehensible
        programming language.  Your language will not work.  Here is why it will not work.

        You appear to believe that:
        [ ] Syntax is what makes programming difficult
        [ ] Garbage collection is free                [ ] Computers have infinite memory
        [ ] Nobody really needs:
            [X] concurrency  [X] a REPL  [X] debugger support  [X] IDE support  [ ] I/O
            [X] to interact with code not written in your language
        [ ] The entire world speaks 7-bit ASCII
        [ ] Scaling up to large software projects will be easy
        [ ] Convincing programmers to adopt a new language will be easy
        [ ] Convincing programmers to adopt a language-specific IDE will be easy
        [ ] Programmers love writing lots of boilerplate
        [ ] Specifying behaviors as "undefined" means that programmers won't rely on them
        [X] "Spooky action at a distance" makes programming more fun

        Unfortunately, your language (has/lacks):
        [-] comprehensible syntax  [-] semicolons  [+] significant whitespace  [-] macros
        [+] implicit type conversion  [-] explicit casting  [-] type inference
        [+] goto  [-] exceptions  [-] closures  [-] tail recursion  [-] coroutines
        [-] reflection  [-] subtyping  [-] multiple inheritance  [-] operator overloading
        [-] algebraic datatypes  [-] recursive types  [-] polymorphic types
        [-] covariant array typing  [-] monads  [-] dependent types
        [-] infix operators  [+] nested comments  [+] multi-line strings  [-] regexes
        [-] call-by-value  [-] call-by-name  [+] call-by-reference  [-] call-cc

        The following philosophical objections apply:
        [ ] Programmers should not need to understand category theory to write "Hello, World!"
        [ ] Programmers should not develop RSI from writing "Hello, World!"
        [ ] The most significant program written in your language is its own compiler
        [X] The most significant program written in your language isn't even its own compiler
        [ ] No language spec
        [ ] "The implementation is the spec"
           [ ] The implementation is closed-source  [ ] covered by patents  [ ] not owned by you
        [ ] Your type system is unsound  [ ] Your language cannot be unambiguously parsed
           [ ] a proof of same is attached
           [ ] invoking this proof crashes the compiler
        [X] The name of your language makes it impossible to find on Google
        [X] Interpreted languages will never be as fast as C
        [ ] Compiled languages will never be "extensible"
        [ ] Writing a compiler that understands English is AI-complete
        [ ] Your language relies on an optimization which has never been shown possible
        [ ] There are less than 100 programmers on Earth smart enough to use your language
        [ ] ____________________________ takes exponential time
        [ ] ____________________________ is known to be undecidable

        Your implementation has the following flaws:
        [ ] CPUs do not work that way
        [ ] RAM does not work that way
        [ ] VMs do not work that way
        [ ] Compilers do not work that way
        [ ] Compilers cannot work that way
        [ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
        [X] You require the compiler to be present at runtime
        [ ] You require the language runtime to be present at compile-time
        [X] Your compiler errors are completely inscrutable
        [X] Dangerous behavior is only a warning
        [X] The compiler crashes if you look at it funny
        [X] The VM crashes if you look at it funny
        [X] You don't seem to understand basic optimization techniques
        [ ] You don't seem to understand basic systems programming
        [ ] You don't seem to understand pointers
        [ ] You don't seem to understand functions

        Additionally, your marketing has the following problems:
        [ ] Unsupported claims of increased productivity
        [ ] Unsupported claims of greater "ease of use"
        [ ] Obviously rigged benchmarks
           [ ] Graphics, simulation, or crypto benchmarks where your code just calls
               handwritten assembly through your FFI
           [ ] String-processing benchmarks where you just call PCRE
           [ ] Matrix-math benchmarks where you just call BLAS
        [X] Noone really believes that your language is faster than:
            [X] assembly  [X] C  [X] FORTRAN  [X] Java  [X] Ruby  [X] Prolog
        [X] Rejection of orthodox programming-language theory without justification
        [ ] Rejection of orthodox systems programming without justification
        [ ] Rejection of orthodox algorithmic theory without justification
        [ ] Rejection of basic computer science without justification

        Taking the wider ecosystem into account, I would like to note that:
        [X] Your complex sample code would be one line in: almost anything, actually
        [ ] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] We already have a safe statically-typed eager functional language
        [ ] You have reinvented Lisp but worse
        [ ] You have reinvented Javascript but worse
        [ ] You have reinvented Java but worse
        [ ] You have reinvented C++ but worse
        [ ] You have reinvented PHP but worse
        [ ] You have reinvented PHP better, but that's still no justification
        [ ] You have reinvented Brainfuck but non-ironically

        In conclusion, this is what I think of you:
        [ ] You have some interesting ideas, but this won't fly.
        [X] This is a bad language, and you should feel bad for inventing it.
        [X] Programming in this language is an adequate punishment for inventing it.

In fact, it was so magnificently stupid that when I described it on a forum I frequent, one of the administrator considered banning me because I obviously deserved it if I would invent something that deranged.

<comment><USER34> Now you have to tell us what it is.

<comment><USER35> Totally agree. GP, please post a link. We won't make fun of you.

<comment><USER33> On thy own heads be it. Here is the code, as written when I was 16. You'll need Tcl 8.5 to run it (8.3 is probably fine, but you'll have to change the line at the beginning), because all the cool kids implement interpreted languages in other interpreted languages. (Actually, wasn't Arc implemented that way originally?)

[https://www.dropbox.com/s/zqahavw2yoeca5p/stringsh.zip](https://www.dropbox.com/s/zqahavw2yoeca5p/stringsh.zip)

<comment><USER34> That's pretty awesome.

</comment></comment></comment></comment></comment><comment><USER36> I'm working on a little object-oriented scripting language:

        You appear to be advocating a new:
        [X] functional  [X] imperative  [X] object-oriented  [ ] procedural [ ] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [X] eager  [ ] statically-typed  [X] dynamically-typed
        [ ] pure  [X] impure  [ ] non-hygienic  [ ] visual  [ ] beginner-friendly
        [ ] non-programmer-friendly  [ ] completely incomprehensible
        programming language.  Your language will not work.  Here is why it will not work.

        You appear to believe that:
        [ ] Syntax is what makes programming difficult
        [X] Garbage collection is free                [X] Computers have infinite memory
        [ ] Nobody really needs:
            [ ] concurrency  [ ] a REPL  [X] debugger support  [X] IDE support  [ ] I/O
            [ ] to interact with code not written in your language
        [ ] The entire world speaks 7-bit ASCII
        [X] Scaling up to large software projects will be easy
        [ ] Convincing programmers to adopt a new language will be easy
        [ ] Convincing programmers to adopt a language-specific IDE will be easy
        [ ] Programmers love writing lots of boilerplate
        [ ] Specifying behaviors as "undefined" means that programmers won't rely on them
        [ ] "Spooky action at a distance" makes programming more fun

        Unfortunately, your language (has/lacks):
        [+] comprehensible syntax  [-] semicolons  [-] significant whitespace  [-] macros
        [-] implicit type conversion  [+] explicit casting  [-] type inference
        [-] goto  [-] exceptions  [+] closures  [ ] tail recursion  [+] coroutines
        [+] reflection  [+] subtyping  [-] multiple inheritance  [+] operator overloading
        [ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
        [ ] covariant array typing  [ ] monads  [ ] dependent types
        [+] infix operators  [+] nested comments  [ ] multi-line strings  [ ] regexes
        [ ] call-by-value  [ ] call-by-name  [+] call-by-reference  [ ] call-cc

        The following philosophical objections apply:
        [ ] Programmers should not need to understand category theory to write "Hello, World!"
        [ ] Programmers should not develop RSI from writing "Hello, World!"
        [ ] The most significant program written in your language is its own compiler
        [X] The most significant program written in your language isn't even its own compiler
        [X] No language spec
        [X] "The implementation is the spec"
           [ ] The implementation is closed-source  [ ] covered by patents  [ ] not owned by you
        [ ] Your type system is unsound  [ ] Your language cannot be unambiguously parsed
           [ ] a proof of same is attached
           [ ] invoking this proof crashes the compiler
        [ ] The name of your language makes it impossible to find on Google
        [X] Interpreted languages will never be as fast as C
        [X] Compiled languages will never be "extensible"
        [ ] Writing a compiler that understands English is AI-complete
        [ ] Your language relies on an optimization which has never been shown possible
        [ ] There are less than 100 programmers on Earth smart enough to use your language
        [ ] ____________________________ takes exponential time
        [ ] ____________________________ is known to be undecidable

        Your implementation has the following flaws:
        [ ] CPUs do not work that way
        [ ] RAM does not work that way
        [ ] VMs do not work that way
        [ ] Compilers do not work that way
        [ ] Compilers cannot work that way
        [ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
        [X] You require the compiler to be present at runtime
        [ ] You require the language runtime to be present at compile-time
        [ ] Your compiler errors are completely inscrutable
        [ ] Dangerous behavior is only a warning
        [ ] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [X] You don't seem to understand basic optimization techniques
        [ ] You don't seem to understand basic systems programming
        [ ] You don't seem to understand pointers
        [ ] You don't seem to understand functions

        Additionally, your marketing has the following problems:
        [ ] Unsupported claims of increased productivity
        [ ] Unsupported claims of greater "ease of use"
        [ ] Obviously rigged benchmarks
           [ ] Graphics, simulation, or crypto benchmarks where your code just calls
               handwritten assembly through your FFI
           [ ] String-processing benchmarks where you just call PCRE
           [ ] Matrix-math benchmarks where you just call BLAS
        [ ] Noone really believes that your language is faster than:
            [X] assembly  [X] C  [X] FORTRAN  [X] Java  [ ] Ruby  [ ] Prolog
        [ ] Rejection of orthodox programming-language theory without justification
        [ ] Rejection of orthodox systems programming without justification
        [ ] Rejection of orthodox algorithmic theory without justification
        [ ] Rejection of basic computer science without justification

        Taking the wider ecosystem into account, I would like to note that:
        [ ] Your complex sample code would be one line in: _______________________
        [ ] We already have an unsafe imperative language
        [X] We already have a safe imperative OO language
        [ ] We already have a safe statically-typed eager functional language
        [ ] You have reinvented Lisp but worse
        [ ] You have reinvented Javascript but worse
        [ ] You have reinvented Java but worse
        [ ] You have reinvented C++ but worse
        [ ] You have reinvented PHP but worse
        [ ] You have reinvented PHP better, but that's still no justification
        [ ] You have reinvented Brainfuck but non-ironically

        In conclusion, this is what I think of you:
        [ ] You have some interesting ideas, but this won't fly.
        [X] This is a bad language, and you should feel bad for inventing it.
        [ ] Programming in this language is an adequate punishment for inventing it.

</comment><comment><USER37> Here is the checklist for my programming language, foil -- demo available (requires Java plugin) at [http://picomancer.com/blog/foil-compiler-tech- preview/](http://picomancer.com/blog/foil-compiler-tech-preview/)

        You appear to be advocating a new:
        [ ] functional  [x] imperative  [x] object-oriented  [ ] procedural [ ] stack-based
        [ ] "multi-paradigm"  [ ] lazy  [ ] eager  [x] statically-typed  [x] dynamically-typed
        [ ] pure  [ ] impure  [ ] non-hygienic  [ ] visual  [x] beginner-friendly
        [ ] non-programmer-friendly  [ ] completely incomprehensible
        programming language.  Your language will not work.  Here is why it will not work.

        You appear to believe that:
        [x] Syntax is what makes programming difficult
        [ ] Garbage collection is free                [ ] Computers have infinite memory
        [ ] Nobody really needs:
            [ ] concurrency  [ ] a REPL  [ ] debugger support  [ ] IDE support  [ ] I/O
            [ ] to interact with code not written in your language
        [x] The entire world speaks 7-bit ASCII
        [ ] Scaling up to large software projects will be easy
        [x] Convincing programmers to adopt a new language will be easy
        [ ] Convincing programmers to adopt a language-specific IDE will be easy
        [ ] Programmers love writing lots of boilerplate
        [x] Specifying behaviors as "undefined" means that programmers won't rely on them
        [ ] "Spooky action at a distance" makes programming more fun

        Unfortunately, your language (has/lacks):
        [Y] comprehensible syntax  [N] semicolons  [Y] significant whitespace  [N] macros
        [N] implicit type conversion  [N] explicit casting  [Y] type inference
        [Y] goto  [Y] exceptions  [Y] closures  [N] tail recursion  [Y] coroutines
        [N] reflection  [Y] subtyping  [ ] multiple inheritance  [Y] operator overloading
        [ ] algebraic datatypes  [ ] recursive types  [ ] polymorphic types
        [ ] covariant array typing  [ ] monads  [ ] dependent types
        [ ] infix operators  [ ] nested comments  [Y] multi-line strings  [ ] regexes
        [Y] call-by-value  [ ] call-by-name  [Y] call-by-reference  [ ] call-cc

        The following philosophical objections apply:
        [ ] Programmers should not need to understand category theory to write "Hello, World!"
        [ ] Programmers should not develop RSI from writing "Hello, World!"
        [ ] The most significant program written in your language is its own compiler
        [x] The most significant program written in your language isn't even its own compiler
        [x] No language spec
        [x] "The implementation is the spec"
           [ ] The implementation is closed-source  [ ] covered by patents  [ ] not owned by you
        [ ] Your type system is unsound  [ ] Your language cannot be unambiguously parsed
           [ ] a proof of same is attached
           [ ] invoking this proof crashes the compiler
        [ ] The name of your language makes it impossible to find on Google
        [ ] Interpreted languages will never be as fast as C
        [ ] Compiled languages will never be "extensible"
        [ ] Writing a compiler that understands English is AI-complete
        [ ] Your language relies on an optimization which has never been shown possible
        [ ] There are less than 100 programmers on Earth smart enough to use your language
        [ ] ____________________________ takes exponential time
        [ ] ____________________________ is known to be undecidable

        Your implementation has the following flaws:
        [ ] CPUs do not work that way
        [ ] RAM does not work that way
        [ ] VMs do not work that way
        [ ] Compilers do not work that way
        [ ] Compilers cannot work that way
        [ ] Shift-reduce conflicts in parsing seem to be resolved using rand()
        [ ] You require the compiler to be present at runtime
        [ ] You require the language runtime to be present at compile-time
        [x] Your compiler errors are completely inscrutable
        [x] Dangerous behavior is only a warning
        [ ] The compiler crashes if you look at it funny
        [ ] The VM crashes if you look at it funny
        [ ] You don't seem to understand basic optimization techniques
        [ ] You don't seem to understand basic systems programming
        [ ] You don't seem to understand pointers
        [ ] You don't seem to understand functions

        Additionally, your marketing has the following problems:
        [ ] Unsupported claims of increased productivity
        [ ] Unsupported claims of greater "ease of use"
        [ ] Obviously rigged benchmarks
           [ ] Graphics, simulation, or crypto benchmarks where your code just calls
               handwritten assembly through your FFI
           [ ] String-processing benchmarks where you just call PCRE
           [ ] Matrix-math benchmarks where you just call BLAS
        [ ] Noone really believes that your language is faster than:
            [ ] assembly  [ ] C  [ ] FORTRAN  [ ] Java  [ ] Ruby  [ ] Prolog
        [ ] Rejection of orthodox programming-language theory without justification
        [ ] Rejection of orthodox systems programming without justification
        [ ] Rejection of orthodox algorithmic theory without justification
        [ ] Rejection of basic computer science without justification

        Taking the wider ecosystem into account, I would like to note that:
        [ ] Your complex sample code would be one line in: _______________________
        [ ] We already have an unsafe imperative language
        [ ] We already have a safe imperative OO language
        [ ] We already have a safe statically-typed eager functional language
        [ ] You have reinvented Lisp but worse
        [ ] You have reinvented Javascript but worse
        [ ] You have reinvented Java but worse
        [ ] You have reinvented C++ but worse
        [ ] You have reinvented PHP but worse
        [ ] You have reinvented PHP better, but that's still no justification
        [ ] You have reinvented Brainfuck but non-ironically

        In conclusion, this is what I think of you:
        [ ] You have some interesting ideas, but this won't fly.
        [ ] This is a bad language, and you should feel bad for inventing it.
        [ ] Programming in this language is an adequate punishment for inventing it.

</comment><comment><USER38> [x] Code can be shared without compromising security

This is made possible with...

* compile-time memory protection

* automatic memory management

* compile-time data access restrictions (mark struct members as read-only)

* divide programs into small, mutually-distrusting components

* add features by adding components, not by changing existing components

The last two points are things the programmer has to do, but keep in mind that programming languages today don't even give you the opportunity to design this way. The last paradigm that did was C / Unix, and that was back when it was reasonable to send program state over a pipe.

Java tried to do this in the 90s, but a quick web search for "Java security" will turn up the historical record. In my opinion, VMs are inherently insecure, so I think the flaw in Java's approach was the decision to make Java run on a VM. VMs are inherently monolithic, and thus violate the "network of mutually-distrusting components" point above.

For more semi-coherent rambling on this topic, see my latest blog post... [http://dbpokorny.blogspot.com/2013/11/prisoner-of- paradigm.h...](http://dbpokorny.blogspot.com/2013/11/prisoner-of- paradigm.html)

</comment><comment><USER39> ...and brendan eich checked all the boxes</comment>