skysight-inc/HackerNews huggingface dataset:
In regards to graphics, there is really nice work being done by Daniel Jones. His Gadfly.jl (https://github.com/dcjones/Gadfly.jl) package implements the grammar of graphics and it can already produce high quality plots similar to ggplot2.

I will also disagree with your statement about Julia not catering to statisticians. Especially as datasets grow, performance keeps becoming more and more important. And this essentially means that statisticians implementing new methods in R packages have to drop down to C++ via Rcpp anyway. And this is exactly the problem Julia tackles. Of course, you could argue that practitioners do not care about the trouble the method developer went through in order to optimize the code via Rcpp. Yet, the practitioner will just use the language which offers the statistical tools he needs, thus Julia will draw him in, if it can first attract method developers.

There's also the people working on systems biology. People there usually use Matlab to do all of their simulations, modelling, fitting the data, etc. Yet, for some of the data, such as gene expression data, which is fed into the models, it is a lot easier to analyze/normalize it with packages available in R/BioConductor. Here Julia could also provide a unifying interface, so you won't need to be constantly switching languages.
High level isn't really helping, it is giving the compiler room to either screw up or shine.

It is great if the compiler shines, but frustrating if it screws up.

And yes, that applies to other tools, too. TeX, for instance, most of the time does a great job, given few specific directions, but sometimes, it doesn't quite do what you think is possible. Then, you may have a long fight ahead to make it do what you want.
This is correct. If a disease if life threatening or potentially disabling AND therapies already exist for it's treatment, you can't ethically put them on a placebo for a trial.

However, there are many diseases that aren't that severe and diseases with no current therapies, so a decent number of trials are still run with just placebos as controls.
You can copy/paste the Os and 0s if you're not sure.
I don't see this as that much of a hurdle to exclude BSD entirely. The same situation exists even with Linux. EL7 supports POWER7 and in the future ARM server clusters may even be a reality. I don't think we are ever going to be in the nirvana where a single runtime is going to be portable across the breadth of platforms a large organization needs to support. This is precisely why more focus needs to be on continuously building container dependencies in the same way upstream packages are.

The same organizations that are interested in deploying on POWER/ARM are likely the same that would like to see BSD/Solaris support.
What do you mean by, "do not portray competitiveness"? Do you mean "don't be competitive"? If yes, why would you ever be competitive while traveling?
ROT47 solves this exact problem.
I've posted on here about CounterPAC before. We didn't crush it but we learned a lot for just $500k and we took out one terrible incumbent.
And yet most software today is free. Yes, I was on the internet in that era. And no, I never did understand what was so awful about giving away software. All the software I write today I give away, too :-)
Why? Seems to simple. I normally go straight for drop=FALSE the most evil default issue of the language.
I disagree. I think not having a continuous build pipeline for your containers is a bad idea. As a large enterprise I want to make sure that my software builds on all platforms my organization supports even if I don't _yet_ have any clients requesting compute there yet. Implementing the pipeline is risk mitigation against that and a whole other class of problems (namely not being able to rebuild containers, compliance/audits, etc).
gadfly interfaces with d3/svg, which while currently at the primitive stage, will ultimately be extremely powerful.

While julia 'prefers' for loops according to the docs, I tend to write things in vectorized form.... I have a toy neural net library I play around with (https://github.com/ityonemo/julia-ann/blob/master/NN.jl) - you'll note that the "nnlog" function is one line, vectorized, and the meat of the evaluated is a dot product. I did once write a benchmark comparing the unvectorized, for loop form of these matrix multiplications, and it was slower than the vectorized form (I didn't bother trying to figure out why).
Look at the Help button (top right); that explains all their syntax.
why post this now?
ah, ok, had no idea that the capsid was that sensitive to genome length! Thanks! So it really did compress it for a useful purpose.
I love gpg but openpgp tooling is just ancient piece of crap from CLI perspective.

- writing gpg just gives you cryptic “gpg: Go ahead and type your message ...” without any more information.

- `gpg --list-keys` apart from being hard to remember* has a table of misaligned values without any headers.

- I still can’t figure out how to make use of gpg-agent.

* I always tend to write --keys and I get another non-helpful info error “gpg: Option “--keys” is ambiguous”)
PG is also meeting these founders as a peer. Working in advertising, I've seen a lot of successful people who were perfectly nice to me, but terrors to underlings and people they felt were unimportant or incompetent (and much of of what was seen as incompetence was often the result of little communication from the top of the bureaucratic ladder).

I would never call these people nice, but I'd say they were nice to me. Often how nice someone is depends on where you're standing and how they see you.
Yeah, I get the distinction between "applied" and "granted". The old link had less information, without further searching around for the casual reader. The fact that 16 out of 17 claims had been mentioned as invalidated, but still leaving one remaining, was suggestive of part of the patent being granted.

Are you claiming the USPO doesn't grant overreaching patents, by the dozen?

The "prior to 2000" part is interesting, though. I wonder who filed what patent in 2000 about emulating old bitty boxes?
Yes, it's possible. Just pass -static to gcc, for example.
I think this is the result of other places getting better rather than the U.S. getting worse. Globalization has made opportunity obtainable almost wherever you need it these days.
Agreed. Other government housing auctions have been recently documented in the press as bearing signs of bidder collusion. A closer look here would be welcome.
By the way, the backreferences make the game non-regular.
One of those text-entry boxes with buttons for emphasis, list items, etc.
I do; of all the lightweight markup languages, it seems like only txt2tags has a sane representation of HTML links.
[1] http://en.wikipedia.org/wiki/Lightweight_markup_language#Lin...
Abuse of monopoly power as detailed in the Findings of Fact in the DoJ's case against Microsoft:

http://www.justice.gov/atr/cases/f3800/msjudgex.htm

In particular:

http://www.justice.gov/atr/cases/f3800/msjudgex.htm#v

There was more than just what the court found, however.
Regular crossword entries (that only have letters in them) are already valid regexen.
Thanks, I'll definitely pick these up for Christmas and check them out.
To provide only a small detail, the character's in Project Gutenberg's version of Hamlet are:

\n\r !&'(),-.1:;?ABCDEFGHIKLMNOPQRSTVWYZ[]abcdefghijklmnopqrstuvwxyz

"J", "U", and "X" aren't in the upper case, but all lower case letters are used.

The punctuation [.'!?] are used in the line: Laer. Drown'd! O where?

The punctuation [&,;] are used in the line: Qu. Aye me; what act, that roares so lowd, & thunders

The punctuation [:-] are used in the line: for and a shrowding-Sheete:

The punctuation [()] are used in the line: Was (as you know) by Fortinbras of Norway,

There are four uses of "1", of the form "1.Play. What speech, my Lord?"

The "[" and "]" are used for editor's corrections, like "...thing so ouer-done, is fro[m] the purpose of Playing, whose...", and needn't be in a copy.

A more precise reckoning would be 26 characters + ~14 other characters.

On the plus side, there are only 167,771 bytes in that document, and that includes multiple spaces and other things which aren't relevant. After all, we know there are "textual differences between various copies of the first folio", so "Hamlet" is a fuzzy concept.

40 ^ 167771 == 10^(10^5.42939566795654)

Add back in the 23 used upper-case characters gives 10^(10^5.4798302603626)

Working in log_10 (log_10 (x) ) makes it hard to really see that the ratio of the last two numbers is 10^18782, and between your estimate and theirs is 10^129735.
Rather than read pg on this (his essay is a lot of wishful thinking backed by zero evidence), I'd suggest the master:

http://www.gutenberg.org/ebooks/1232

"Is it better to be feared or loved" comes straight from old Nick.
Wouldn't the characters have to come first, in order to be referenced in the first place? I.e. "DOG" would read "GDOG," no?
I think it is 2^61 now, the paper that once showed the 2^52 attack has removed the claims.
I think it would be great to develop support for generic sets in a separate package that could eventually be merged into Distributions. I'm not sure that I think all of the issues you've linked to are related to that problem, though. For example, the issue about using Vector{Rational} as an input to the Categorical distribution type's constructor is a relatively minor issue since there are very few cases in which you'd want to evaluate the PDF of a Categorical variable using rational numbers rather than floating-point numbers. As such, it's not clear that you'd want to have a Categorical{Rational} type that's separate from the current Categorical type (which could be called the Categorical{Float64} type).
Does your webapp really need network access?
It's not a tactic, it's just a fact that people remember stories that confirm their prior beliefs and contrary evidence makes little difference.

If it makes you feel any better, I'm mostly criticizing myself for engaging in a pointless and unwinnable debate :)
Even making heroin available to addicts doesn't make sense, when you can feed them subutex as a ready alternative.

Anyway, you can legalize all these drugs, but make the harder ones prescription only and highly taxed.
People contribute to compilers because they need features or performance improvements, not "to kick that other compiler's ass". Sometimes (as here) contributions are from CPU vendors who want to make certain that compilers show off the features of their new hardware. There were tons of great performance impovements in every new version of GCC before clang, and there continue to be today. You just can't model an open source compiler the way you model some closed source word processor :(.

The real question that should be asked is whether, now with two compilers to contribute features into instead of one, whether the progress of either of the compilers is actually faster than the one previous one. Again: people aren't just not going to improve the compiler if there is only one of them, as improvements come from contributors who need the better compiler, not from some abstract notion of "have the bestest compiler". Having multiple open source projects in the same space is a detriment--it is a cost--that hopefully is justified by the benefits.

What happens in a world of "competition", is that now Intel has to ask whether it is valuable to add this feature to GCC or to clang; maybe they have time for both, but probably not. That this work ends up in one compiler and some other work ends up in a different compiler is unfortunate. It isn't even clear who is "competing" or what they are "competing" for. It certainly isn't the performance optimization itself: you can't credit the GCC team (whatever that might even mean) for that, as this work is from Intel. GCC is an open source project that is contributed to by a vast number of independent actors, not centrally developed by a small handful of people.

The argument for clang and LLVM being helpful is therefore not "competition" (which would make absolutely no sense), but instead "GCC has accumulated years of entrenched architecture that, in 2010 as opposed to 1980, we would design differently: LLVM is thereby designed in a way that is easier to modify; so, even though effort is now forked (meaning fewer contributions to each compiler), a smaller number of contributions will have a more powerful effect on the state of compilers". If this is true (and many think it is), then that's great, but it isn't "competition" in the way people normally consider that concept.
Is it possible to see any screenshots without having to signup?
Natural to write? This:

|Name |Quantity|Part Number |Distributor|
|:--------------:|:------:|:------------------:|:---------:|
|BAT1, BAT2, BAT3|3 |534-082 |Mouser |

is not "natural to write"
The help button doesn't really explain that point ( I don't think) at least not in a very clear way for someone inexperienced with regex
For my own use case, and I use 5-10-giga-plus financial tick datasets, I find Numpy to outperform Julia 3:1. R users who need perf have already found other ways (like me). I think this Julia performance argument is hugely overrated. When I don't need Numpy, R gives me more than everything I will eve need and I don't see where these developers are going to come from to reinvent the wheel for a language which does not target their user base. I just don't see what Julia brings to the table. Now if it had gone the whole hog and give us full infrastructure for ingesting massive streaming data, then it would have skated to where the puck is going to be (see Clojure/Storm). As it stands, the only main benefit I see for Julia, is as an open source (and better) replacement for Matlab.
Music publishers sue an ISP over piracy
so in your first example, "AB" was in the capture group and the \1 repeats it?
Well, anything is a major PITA for someone who doesn't use emacs…

More seriously, ASCII tables are always a major pain to edit, without the proper tools (like emacs—and I'd not be at all surprised if there's something for vim and/or Sublime Text too). That's no reason to avoid them; they are useful.
ColdFusion is kind of a dead language at this point, but there are still many legacy products build in CF that need to be maintained. With CF developers in short supply, you could carve out a valuable niche for yourself if you want to deep end on the language.

Getting a CS degree on the cheap seems like the big pro here and would help you down the line. Even though its possible to get a developer job without a CS degree, it certainly helps. Many companies screen out anybody without a CS degree altogether.

If you have a lot of downtime you might be able to pick up some consulting work as well and broaden your exposure to some other technologies.
"Historically, beards in the boardroom have been a barometer of the relative vitality of capitalism and its critics."

Either that or,... hipsters.
I'm sorry to say that I have discovered that this first appeared in an essay, The Conquest of Ubiquity, published in 1928. So, not quite as amazing as I thought. Walter Benjamin didn't identify the precise source when he quoted it.
Hacker News seems to have a weird fetish for its 'minimalist' UI ... probably because it has a higher than typical ratio of users who spend time behind a terminal, and due to some underlying belief that the lack of bells and whistles keeps the normies away. If they added a rich text editor there would probably be a riot.

But to be fair, at least markdown is a lot cleaner than bbcode.
Its a shame to think people seeing this as a "self promotion", when its not. What i am promoting is the data that this crawler obtained, and all the insights people can get for free, just by using it. As opposed to an API, that will limit either the access for the data or the way you can access it, acessing the raw data on a database directly has no limits.

Anyway, thanks for the reference, i will make sure to add it to the project's wiki as a related link.
Nope! I'm happy to say this one is real :)
> It is almost 2015 and we are still typing symbols on each side of words in text boxes when we want to emphasize something.

That's called markup. It's what HTML is; it's what any plain-text format is. And it's a good thing: it's interchangeable and archiveable.
there is no sign up required. if you click on "View Demo" you can login using the "demo/demo" account to use the system.
Not sure why people are so readily negative, but I think this is a clever way to create class-like models with less boilerplate.

Even in PHP I get tired of writing explicit getters/setters.
Here's an Evil-mode best practices thread on StackOverflow: http://stackoverflow.com/questions/8483182/evil-mode-best-pr...

I found at least the mini-buffer quit addition to be a practical necessity; without it I would fairly frequently get stuck in Emacs minibuffer (i.e., its command line) even after I pressed escape. ctrl-G would get me out,but it's much nicer to have the fix so <esc> will (almost?) always get out off command line and back to normal mode.

It's also worth learning how to map keys in Evil, so you can add mappings as you desire. It's easy.

Org-mode is for me the big attraction when moving from Vim to Emacs, and to give it Vim-like usability you really need to do a lot of remapping of Org functions (i.e., create Evil-mode map for Org functions), otherwise you'll be doing lots of chord-keying. There really should be some kind of small open source project that does this; I've been meaning to do it myself for a while. . . .
So how do I know if my key ID is 32 bit?
Treasury issues $1T in new debt
>A Prussian spy later sent to keep tabs on him reported with a mixture of awe and anxiety: “His hair and beard are quite black. The latter he does not shave.”

How does the statement convey either awe or anxiety? How else would you describe a black haired man with a beard?
I believe the answer to your question lies in what Tel said:

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

If you avoid recursion and use explicit state passing and create an API with combinators hiding the state passing plumbing you get very fast Haskell.

I believe many people never get to the "write combinators to hide plumbing" part and assume to get very fast Haskell they have to duplicate the explicit state passing everywhere.
There are in fact programs that don't run in the browser.

Schocking, I know. But wait, there's more! Some programs don't even use Javascript!
This clinical trial was run in August, before anyone had contracted Ebola outside of Africa (and before the comment you linked to).
Okay... So, having been down this road and beyond already, what do you think of this guy's approach which is nice and visible for inspection?

Might help not only him but some of us learn further, us tinkerers, those who might have a faint curiosity in c# etc if you shared. Then you'd be able to plug away shame-free.
i realized this might not have been obvious so I've updated the login page with the verbiage around demo login.

thanks for the feedback
Ugh, that's the syntax of TVTropes. What a mess, I never know if the title comes before or after the link, and whether to wrap with 1 or 2 square braces.
Hack4ac: Text-mining and analyzing author contributions in PLOS articles
Not totally unrelated. For instance, interest in car ownership has gone down as a product of... maybe both, or some intersection.
TLDR - added to https://github.com/globalcitizen/taoup ...

Sin #1 - Unnecessary distributed parallelism: It does not always make sense to parallelize a computation. Doing so almost inevitably comes with an additional overhead, both in runtime performance and in engineering time. When designing a parallel implementation, its performance should always be compared to an optimized serial implementation in order to understand the overheads involved. If we satisfy ourselves that parallel processing is necessary, it is also worth considering whether distribution over multiple machines is required. The rapid increase in RAM and CPU cores can make local parallelism economical and worthwhile. Establish the need for distributed parallelism on a case by case basis.

Sin #2 - Assuming performance homogeneity: Virtualized cloud environments exhibit highly variable and sometimes unpredictable performance. Base reported results on multiple benchmark runs, and report the variance.

Sin #3 - Picking the low-hanging fruit: It is unsurprising that it is easy to beat a general system by specializing it. Few researchers comment on the composability of their solutions.

Sin #4 - Forcing the abstraction: In some application domains, it is unclear if a MapReduce-like approach can offer any benefits, and indeed, some have argued that it is fruitless as a research direction. Ideally, future research should build on [iterative processing, stream processing and graph processing], rather than on the MapReduce paradigm.

Sin #5 - Unrepresentative workloads: The common assumption in academic research systems is that the cluster workload is relatively homogenous. Most research evaluations measure performance by running a single job on an otherwise idle cluster.

Sin #6 - Assuming perfect elasticity: The cloud paradigm [...] its promise of an unlimited supply of computation. This is, of course, a fallacy. Workloads do not exhibit infinite parallel speedup. The scalability and supply of compute resources are not infinite. There are limits to the scalability of data center communication infrastructure. Another reason for diminishing returns from parallelization is the increasing likelihood of failures and vulnerability to "straggler" tasks.

Sin #7 - Ignoring fault tolerance: Many recent systems neglect to account for the performance implications of fault tolerance, or indeed of faults occuring. For each system, we should ask whether fault tolerance is relevant or required. If it is, it makes sense to check precisely what level is required, and what faults are to be protected against; consider and ideally quantify the cost.
It's pretty simple. You need to negotiate a deal with your employer now, quit the company or keep working at the company with the knowledge that they will own it. By doing nothing it will be regarded as a work-for-hire owned by the employer.

How would this be done:
If they are open to negotiating with you, then I'd keep the deal pretty simple. Incorporate a company, figure out the structure of the cap table, and figure out how you are going to handle any obvious possible future disputes that will affect the continuity of the business. Eg. they stop paying you, you stop working on it, etc.

What type/amount of ownership should I request?
In business you should try to be equitable and leave some money on the table. Don't forget about all the time they have spent testing and giving feedback on the product. Figure out how much time each side has invested in this product, and also figure out who is going to be a better custodian of the product if there is a dispute in the future. Change the cap table accordingly. You can if necessary separate these two concepts. For example, one side can have dominant voting power over the company, but distributions of shares could be (if deemed appropriate) payed out 50/50 between the parties.

Any other next steps (eg. like getting a lawyer involved) would be a dumb idea.
HTML is great, mostly because it actually does the job and knows its place.

Markdown and their ilk are all trying to be sorta-not-quite-HTML, but fail precisely because they are not HTML.
Does anyone know if -O3 (or -O2?) -march=native should be enough to get reasonable optimization for running on the same cpu as the gcc host? Or are one better off tweaking options manually (note, I know that knowing the details of how gcc works will always be better than not -- I'm just wondering if -march=native is currently considered stable/"good enough" from reasonable value of "enough" ;-)