skysight-inc/HackerNews huggingface dataset:
> Stocks are generally such assets and the disposition of stocks results in capital gain income (or capital losses). Apples are not intended for investment; they are intended for consumption.

Wheat is also intended for consumption, but it -- as with many other goods, consumable or not -- is also a commodity that is traded.

I realize I may have pointed out some edge cases that weren't actually edge cases. I am not a tax attorney, so I don't know what the law says.

I am only trying to point out that determining what is income and what is a capital gain is a hard problem, even though laws exist that try to put various activities into one of the two categories. The US uses an arbitrary 1-year limit, while the tax code of my country of residence (Denmark) says the tax rate is determined, not by how long the assets are held, but by trying to determine whether the profit constitutes ones primary source of income. If the answer is "yes", it's taxed as income.

So different countries use different methods to solve this problem of discerning income and capital gains, but I still maintain that it's a hard problem, that has not been solved adequately anywhere. And that there are many edge cases, resulting from current law, that are counter-intuitive.
How to Choose the Right Business Chart
To aide your Google search: look for corporations that have elected the "B Corp" designation. Here's a good list of them: http://bestfortheworld.bcorporation.net/

More info about B corps: https://www.bcorporation.net/what-are-b-corps
It feels like I have decent intuitive hunches about what compilers can do; I mostly just ask the question, "is the problem conceptually simple?", and go from there. Of course, I'm missing all of the edge cases and subtleties when I'm doing that. And I don't actively try to do it when it comes to actual code; mostly for quizzes like this.

My intuition seems to fail me, though, when we get to things like escape analysis in languages like Java. It seems like a conceptually simple problem - that is, stack allocating or "unpacking" objects (like value classes/objects)that are __obviously__ going to not escape the scope of a method. I don't mean simple as in determining all objects. And the __obvious__ ones seem much more common than the non-obvious ones, in regular code. But then it seems that this is a fairly recent implementation, which might suggest that it isn't so simple to implement?
Even if that happened, all the retailers have to do is push their alternative along until it gets traction. Their will be a cost of acquiring customers, but its in their long term interest to pay that upfront fee. Then once you have two competing systems, there is nothing preventing the POS system from first prompting for payment with CurrentC and then only falling back to Apple Pay and other CC company backed NFC solutions if that fails.
I'm trying to get basic MSVC support into version 0.5.0, which is planned for release in late November. The reflection and dynamic APIs probably won't be supported initially because too much would have to be rewritten to work around missing C++11 features in MSVC -- they'll come online as soon as MSVC adds support. But, most common use cases don't need them anyway.

0.5.0 will also feature cmake support (this is already in git).
Arguably 3.
It's nice to be able to annotate functions that should have some optimization done to it, and then the program fails to compile if it isn't able to perform the optimization.
Recreating the spectrogram face
Not sure how this is good, I for one won't use CVS/RiteAid just because of this. And I'm sure their app will be terrible.
https://hn.algolia.com/?q=assange#!/story/sort_by_date/0/ass...
cough https://en.wikipedia.org/wiki/Halting_problem cough
I like how the news story says "acquired", but the actual blog post (http://blog.twitpic.com/2014/10/twitpics-future/) doesn't use that word and says that Twitpic is essentially just giving the domain and existing data to twitter.

Generally "acquired" means a) they pay a lot of money for the company and b) some or all of the employees of that company work at the new place. I'm guessing in this case neither of those are true. Granted on the scale of "sensationalist headlines" this isn't worth losing sleep over, but it's funny that the tech press can't help itself in covering stories like this.
It builds in Cygwin -- not that I'd expect typical Windows developers to be satisfied by that.

MinGW and limited MSVC support will come soon.
such an amazing post. Loved it !!
The point Jane Jacobs makes about innovation and cities is that old buildings are essential. Basically, you need clusters of places with cheap rent. If all the real estate is new and shiny and impressive and nice, it's only going to be available to businesses that are already firing on all cylinders. And that's great for them, for a while. But the other point she makes is that nothing lasts forever. The conditions that make a business work will eventually change, and in most cases, the kinds of business that worked well at one time won't be able to adapt to another. They'll just go away.

If the city in which this constant drama is playing out has a decent stock of old buildings, there's a good chance that there will be another generation of businesses that are better attuned to the times who are ready to move into the high-rent districts. But if a city falls prey to short-term thinking and allows all its cheap neighborhoods to be gobbled up by rapacious developers, it's going to find itself driving off a cliff in terms of long range economic viability.

In agricultural terms, getting rid of cheap rents is like eating your seed stock. In more vivid terms, it's like setting your house on fire to stay warm in the winter.
https://github.com/combinatorylogic/mbase/blob/master/src/l/...
Didn't I see a question on how to get the object when an AttributeError is thrown on stackoverflow yesterday?
The security risk is that input from the file that strings is run on ends up in places it shouldn't. One classic place is on the stack; after the random data your function puts on the stack is a bunch of bookkeeping information the compiler puts there, including the address to jump back to when the function returns. If you read user data onto the stack carelessly, you can overwrite the instruction pointer with attacker-controlled data, and the program will return from the function, jump there, and begin executing code.

In this case, he was just fuzzing with "AAAAAAAAAAA" and the program ended up at 0x41414141 ("AAAA"), which is alarming. The next step would to be to figure out where the input file is in memory, replace AAAA with that address, and replace the data there with code. Now "strings" is executing CPU instructions that were in the input file. That's bad.

Some compilers do workarounds, like putting a canary value between the user data and the compiler data, and checking the canary before returning. Some compilers also randomize the location where things go in memory, so it's harder for an attack to predict that address. Some OSes set certain pages to "not executable", so even if an attacker can jump to that memory address, the CPU won't run code from there. None of these are fixes; just barriers for the determined attacker. (W^X is easy to get around, just call code that's already in the binary legitimately, like execve()!)

The fix is to only write to memory you've actually allocated; something the C compiler will not help you with.
My guess is it's because the current R8 has been in production since 2007 without any significant upgrades and therefor lacks the tech to achieve full autonomous driving, also the RS7 tops R8s performance (out of factory). As an owner of the latest model A6 (which the A7 shares most of the components with) I can attest that the factory car is already almost capable of driving itself (but I guess purposefully limited because of legal concerns of taking it on public roads). For example, the A6/A7 is factory equipped with camera's all around, radar and ultrasonic sensors that allow for things like 'staying in it's lane' and adaptive cruise control.
Yeah, they could do that, and if they do, I honestly hope this whole thing boils down to a standoff where government gets involved and regulates against blocking competitors from markets using app stores. Users should be free to install apps from other sources or other app stores. This is so obviously an anti-trust issue. Security is achievable without gatekeepers, but there has been no innovation in this space because their is a market incentive for abusing the monopoly power of app stores.
Sorry I was unable to reply sooner. This debate is perhaps one that will never be settled; here's a discussion on the front page today: https://news.ycombinator.com/item?id=8508382

> I completely reject the idea that my personal decision to purchase stocks instead of bonds is work.

But you can see, can't you, that what active traders and investors do is work? I'm talking about the people who do select individual stocks and do attempt to time the market. To do that with any degree of success takes both skill and work.

And is what you're doing really different in kind from that activity? I understand that it's different in quantity; you're now just following a plan that you decided on previously, so the amount of work you're doing is very small by comparison. But is it really zero? You did a certain amount of reading and study before coming to the conclusion that your preferred strategy is to buy equity ETFs. Wasn't that work?
The announcement says that they will "give" the domain and archive to Twitter - that's not really the kind of arrangement you traditionally associate with an acquisition. In fact if anything, "give us the domain" is more commonly associated with the outcome of trademark infringement proceedings. (Although clearly it's unlikely that those events occurred in this particular case, as the previous spat with Twitter didn't seem to go that far.)
Who Knew What Poo Could Do?
I think there's a page or two that describes what the jsx transformer does(which is it converts them to React.DOM elements IIRC). I think that's where I learnt that you could use raw JS functions instead of jsx, even though it said that jsx should be preferred or something to that effect.
They're likely not working with the R8 because their self-driving capabilities are a marketing tool to compete with the likes of the Mercedes S-Class.

The R8 is also at the end of its product life-cycle so they're probably trying to keep it out if the limelight as much as possible.

And yes, formula 1 comparisons are unfair, but if they're actually within 30 seconds of DTM cars that seems pretty impressive.
I agree, but I think by now we should have accepted that the programmer is their own worst enemy. Laziness is a virtue and all that : )
Short-term capital gains can be taxed more because there's less of a chance that you're just taxing inflation on capital that didn't grow very much, or shrank.
Let's see how this bold move plays out for them when Google and Apple block their mobile apps from the App Stores. Doh.
The article didn't make very clear the differences
between Soft Machines and some now quite old work by
Michael J. Flynn on universal host machine and
some work by Kemal Ebcioglu on using very long
instruction word (VLIW) on code for nearly any
instruction set.

Last I heard, Ebcioglu's execution timing
simulations were getting 9:1 speedup on IBM's 370
code via 24-way VLIW.

My favorite old idea was to find and offer some
programming language constructs that, in their
implementation, could make good use of multiple
threads without the programmer having to consider
multiple threads.
The impressive part about Audi's technology is that it doesn't use very detailed track data to achieve this but is mostly depending on a variety of sensors to anticipate to current road conditions 'on the fly'.
Exactly. Eventually they will converge and copy the best features. It might take them a while, but app building is a commodity now. If they build a shitty first experience, it will eventually get corrected. For example, look at airlines, it took them a long time to produce a decent experience, but now many of them realize how important design and UX is to their bottom line and have re-written their web interfaces to produce something usable.
Skip uninteresting files and functions in gdb (2011)
Yeah, not giving Walmart (or its proxy, CurrentC) my bank account number. Sorry. The credit card system creates a buffer between me and vendors, and I like it that way.
Unknown, but it seems like a stance that would be fairly unique to (a few states in) USA. Norway, for example, where Tesla outsells all other cars, do not enforce this.
California Startup Unveils Gun Technology for Cops
The loader mmap()s the file and it's demand-paged in.
Code of Ethics and Professional Conduct
Retailers Are Disabling NFC to Block Apple Pay
sweet. my friend dominic from nz has been working on a similar project.
There's nothing inherently bad about it.

But why shouldn't an automaker be free to decide how it distributes its product?
Bitcoin 2.0: Sidechains and Ethereum and Zerocash, Oh My
You can use the core library to get standard functions with no runtime. I'm not sure what you're saying about constructors and destructors. There's nothing special about calling strlen that adds overhead.
Someone on GitHub asked "why shouldn't this be used":

https://github.com/dutc/didyoumean/issues/1

Here's the answer I gave:

It's not a particularly useful feature in practice. Misspellings resulting in AttributeErrors are generally caught pretty quickly, and this addition to standard error reporting would mostly be useful in interactive settings where the mistake would be obvious.

(Note that linting tools like PyFlakes already do a fairly good job of picking up on NameErrors, which result from using variables that don't exist.)

I have two other approaches to supplement error reporting with spelling suggestions (https://gist.github.com/dutc/3f2c79048d95287be138) that are a little less ‘janky.’

What makes this approach particularly offensive are:

- I implement this by hooking into a C function in the Python interpreter itself, `PyObject_GetAttr`: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

- I find the function, unprotect its memory page, then clobber first few assembly instructions with a jump: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

- I need to jump to an absolute address, since I don't want to (or can't?) calculate the relative addresses. I don't believe I can do this with a `push` and a `ret` or with a regular `call`, so I use a `jmp` instruction. The `jmp` instruction won't take an absolute address as an immediate value, so I have to use the `%rax` register: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

- Since I'm using this register, I have to save & restore its value. In the hooking code, I save its value with a `push %rax`. In order to restore its value, I have to patch the assembly for the hook function to stick a `pop %rax` before any other instructions: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

- In order to figure out the candidates for the spelling correction, I need to call `dir` on the object. But `dir` calls`PyObject_GetAttr` internally, and those calls can themselves trigger exceptions. In order to avoid this unbounded recursion, I have to implement a parallel code-path for `dir` by creating a `safe_PyObject_Dir`: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

- In some builds of Python, the internal CFunction which provides the Python builtin function `getattr()`, `builtin_getattr`, is compiled without explicit calls to `PyObject_GetAttr`. In order to hook into these `getattr` calls, I need to patch the builtin module. But because someone could have already gotten a handle on `getattr`, I need to directly patch the function: https://github.com/dutc/didyoumean/blob/2c9f01d03c1574f93155...

This approach is probably not portable, and it's definitely not a good idea.

However, figuring out all these small problems was a great way to put some low-level knowledge to use!
So we would need to write Rust libraries without using Rust stdlib? Not exactly a great advantage in that case. Especially so when you are rewriting a ton of C code.
New dare, good deed, and truth on guudintentions
There is only so many of those discussions one can bear, and they have always been OT because they are politics anyway.
I run a subsidiary of First Data (called Clover). I wrote and published the code for a few reasons:

- so I could answer questions more accurately and thoroughly during press interviews and with current and prospective partners. Nothing beats running code for this.

- My team doesn't trust me to write production code much any more but I need my kicks. ;)

- I'd like for people to understand Apple Pay crypto well -- it's the best I've seen in the payments industry. I'd like to even see something like this standardized for protecting cardholder data (both for card-present/POS transactions and e-commerce), where 3DES/DUKPT is still standard practice.

- There's been some misunderstandings that Apple Pay In-App is a closed system and you need to partner with them to use it. This is an existence proof that this is not the case.

- For people who are their own processor/gateway (e.g. very large companies), this gives them a bit of a head start on understanding what they need to do.

First Data has a commercialized version of Apple Pay in their new e-commerce gateway: http://www.payeezy.com/ (not to mention many gateways which process through First Data and support Apple Pay).
I can, because:

You need to give them your checking account access.

You need to somehow show that QR code, the fastest I can think of on iPhone is getting it from location-based Passbook notification, which is still way slower than touching my finger to home button.

Sure, they won't notice me, but, well, Walgreens got a new customer.
makes like a little more interesting... [text]
Take a deep breath and relax.

First of all I stupidly thought that the part about KDE/GTK which is
in this comment of mine https://news.ycombinator.com/item?id=8508094,
was included in the comment to which you replied. So my bad and -1 for me.

What I meant is I don't think that anyone sees Qt or GTK as monolithic
systems and they are about 1000 times more complex than any JS library
you could name, as they solve a myriad problems to which JS is oblivious
and wouldn't be able to solve anyway.

Contrast that with the web situation today, where they can't even decide
which is the view, which the controller or "hey, maybe these don't map
very well on the web side of things". Yes I agree about Tim Berners-Lee
and the http stuff. But at some point things have to converge into
something coherent, because the problem we have to solve is quite elementary,
compared to other technologies.

Also if you honestly believe that people who developed KDE and people who
develop with AngularJS are performing the same type of work... it just
betrays the fact that you're just a JS programmer and haven't seen some
real engineering work.

Javascript touches the tip of the iceberg with regards to technical challenge
and Software Engineering, so please... just take a breath :)
It was as big a leap in UI as it's made out to be.
I don't understand.

If you make $500, then pay $100 in income tax, you're left with $400.

If you invest the $400 in a stock and sell later for $500, you're not taxed on the $400 you've already made (and were taxed on), you're taxed on the $100 capital gain, which you haven't paid taxes on.

Or am I misunderstanding things?

-----

Further ... Is your argument is that once a pool of money has been taxed, that pool of money should never be taxed again? If so, does that mean you don't believe anyone should pay sales tax on anything they've purchased (since they're purchasing it with post-income tax dollars)?

-----

Lastly, you mention that if "someone has a large pool of wealth, then they have already been taxed when they earned it". This is not necessarily so thanks to dynastic wealth, an issue others have brought up in other comments.

The issue is exacerbated when someone inherits wealth (and pays little to no taxes on it), then invests it and has a capital gain of say $40k -- enough to cover basic living expenses in many parts of the country for a year. That person's tax rate is lower than a person who worked for an employer and made $40k. The question is, why is the government incentivizing this through tax code?
Sure, you can reduce it down to the Halting Problem, but it's much simpler just to invoke Rice's Theorem.

http://en.wikipedia.org/wiki/Rice's_theorem
curl pipe sh
That's why I believe it's fear and not real risk that drives it.

What other BSL-4 pathogen are you referencing here? Or are you suggesting BSL-4 is an unappropriate classification? Maybe you think the scientific and biosafety community erred when they created the BSL-4 designation?

There is plenty of research out there that documents the objectibe risk.

There is very little research that documents supports a strategy of "see no evil, hear no evil, speak no evil".

People don't need to panic.

But that's entirely seperate from lack of comprehension of the actual risks involved. After all, you can't solve problems you don't admit to having.

Trying to deal with a BSL-4 pathogen with BSL-2 safety gear is a fools errand. We might not havy any better options, especially in backcountry settings, but lets not pretend its "not risky".

In densely populated urban areas those risks are simply not tolerable. They are not tolerable for two reasons: (1) we can do better; and (2) the technology that allows for (1) makes the risks of not doing (1) more problematic.

Technology allows us to isolate patients; but it also allows non-isolated patients to spread the pathogen further/faster. People with hemoraggic fever don't walk 1000Ks or cross continents on their own power. They only do so by using technology.

It makes sense that the appropriate technology be dedicated to helping contain these bio-hazards and to compassionately care for the afflicted.

But seriously, what do we have to gain by sticking our heads in the sand? It seems this is a cynical strategy by people who don't want to "get their hands dirty"? Mayb we can continue to provide false confidence to 'volunteers' to go to africa and do our dirty work for us?

Why do we need to play this charade? Lets just give these people the tools they need (including time, money , and gear) and properly de-brief them and the public about the risks and what is at stake from either mistakes or inaction.
We Just Thought, 'This Is How You Start a Company in America'
As I wrote some time ago,

http://www.drdobbs.com/architecture-and-design/cs-biggest-mi...

it is easy to add bounds checking arrays to the C language. The trouble is, nobody is interested in doing it.

It'd be a heckuva lot easier than changing languages.