skysight-inc/HackerNews huggingface dataset:
>A Random Walk Down Wall Street...

While the conclusions in this book happen to be valid for the vast majority (i.e. somewhere between 95-99% of the population should stick to index investing), people often mis-apply the conclusions in this book to suggest that certain things are impossible, and that is clearly false and misleading.

There are people who invest and trade successfully, and they are not lucky outliers any more than a brain surgeon is a lucky outlier.

I once asked a guy who made his living off of trading stocks and futures how long would it take me to learn. His answer was sobering. If I made it my full time job for 3-5 years, I could learn to be marginally profitable, and with additional years of experience I could make enough to live off of. He guessed maybe 5-10 years of 40+ hours per week dedicated to trading, and even then, if I did not study the right things I could still fail. Contrast this with the average Joe trying his hand at investing, and of course they will fail. You can't dedicate 3-5 hours per week and expect to be a competent brain surgeon.

Using the same logic in this book, we could conclude that it's impossible for anyone to start a successful business. The message should be, it's really hard and takes a lot of work, and it takes a lot of knowledge about how to run a business, and it takes a high level of competency at some skill (coding, carpentry, whatever), and you have to be competent at communicating with others, and leading others, and not have personal baggage to draw your focus away from the business, and, well, you get the idea. It's hard, and it's not for everyone, but it's not impossible.
shrug. This seems like a pretty standard use of the ternary operator to me. I mean, just google examples of Comparator, and you'll find tons of examples like this:

@Override
public int compareTo(Object arg0) {
Country country=(Country) arg0;
return (this.countryId < country.countryId ) ? -1:
(this.countryId > country.countryId ) ? 1:0 ;

}

(http://www.javacodegeeks.com/2013/03/difference-between-comp...)

But that's orthogonal to my point, which is that lambdas offer significant improvements to readability because they remove the irrelevant cruft and simplify the code.
Christmas Offers Revealed – Discount Yourself on Business APIs
He just started running afl-fuzz few years ago and redirects fitting outputs as blog posts.
I've heard the big problem is that a referendum can't raise taxes, but can require the state to spend money.

It would be cool if each proposal had to be financed (e.g. "sponsoring this thing will require raising state income tax by 0.024%"), though I guess that's impractical?
It is certainly substantially better than it used to be, but it is still pretty far away from an AOT compiled native executable. And forget it entirely if you are running Clojure or Groovy code.
Once abolition of slavery was an "extreme position", wouldn't it have been better that the US voted on it, rather than burning down the country?
You can do one-to-many messages via notifications, though it's less elegant.
Katie was like all of us at one time. She sucked at something. People are often too afraid to admit it or persevere past the suckiness. But Katie did. And she's in inspiration to me.
That's not true, a referendum can raise taxes. However on account of a previous referendum these tax-raising propositions need a 2/3rds supermajority to pass, while spending projects require only a bare majority.
Well. What do you need?

For me I've found I only need a few things to get started. One is the JDK, obviously. Another is Maven. It downloads dependencies for you and is pretty standard (there's also Gradle which some projects use). Finally there is IntelliJ for development. That's about it. Pretty much everything else can be downloaded and installed automatically be Maven or your IDE.

For web development, I've found Ninja Framework to be quite nice. The documentation is very good. The biggest problem is that it tends to delegate to lots of other libraries for functionality, and often those libraries have been around a long time and in some semi-standardised state that can be horrifically confusing (e.g. Hibernate). The Java world REALLY likes to take good open source libraries and then copy their interfaces into standards that other products can then implement. This sounds great in theory, and I'm sure some people do benefit from that, but it makes learning this stuff a giant PITA because the documentation for everything always has five versions, four implementations and every annotation or API has two identical versions in different namespaces, only one of which will actually work. Argghhhhh.

However if you do make it past this swamp, then the tools themselves are actually rather powerful and performant.
Too bad for your parents, while it can be 'weird' again to have the house to yourself it is quite liberating as well. Stepping outside your comfort zone, as you have with the boat, is also a great way to uncover new frontiers to conquer.

My challenge is like Charlie's everything is grey now in terms of information. Few things are 'good' or 'bad' in a way that they were in my youth. Having seen a lot you come to appreciate how bad things can result in good outcomes and good things in bad outcomes. That can be oddly frustrating at times. It affects the firmament of belief such that you have a hard time believing in something when you can argue yourself both for and against it. And of course deconstructing past beliefs is, I suspect, a proximate cause of many mid-life crises.
One Month's Cyber Monday Super Sale
In that case specifically, no, but in general doing type inference means running a constraint solver over the entire program, which will definitely add some overhead to the compilation time.
With the old fashioned film you are probably referring to, projectors are designed to flash each image twice or even three times, meaning that a 24fps movie has a flicker rate of 48 or 72 Hz[0].

The takeaway is that the perceptual frame rate for brightness is higher than the perceptual frame rate for motion.

[0] http://en.wikipedia.org/wiki/Movie_projector#Shutter
Sorry, your wrong.

Self employment tax is higher than just social security tax so you need to look at after tax earrings to compare a 1099 job to a w-2 job. Also, more expences can be deducted as an uber driver than a wage slave ex: a percentage of your cell phone bill and car depreciation.
What does a bouncer give you over running weechat in tmux, or weechat and a relay?
I just map a request like /users/:groupId?orderBy=name to A java object like "int groupId", and "String name" and it puts them automatically by converting, and if you wish you add some checks, notnull, range etc. and It replies bad request to client. Therefore, I do not do this conversion and checking each time.
Announcing Hipache WebSocket-Supporting HTTP Proxy
As an IRC OP on a server with mostly non-technical channels, I can guarantee you that people are not mostly well-mannered. They are welcoming of others though.
I hope so. But honestly, I think we will not be able to stop it. There is too much traction from behaviors that will prevent us from actually doing anything. Preventing it would require us to give up many luxuries and things we call a standard. Greed is too strong. Earth will probably end up like Venus because of us.
10 prototyping kits any maker would love for Christmas
The equivalent in Oort produces:

localhost:~/oort/examples% ../oort callcc2.nl
2
1

as expected since Oort uses heap allocated activation records.

The Oort program:

typedef continuation_t = fn (p: int32) -> void;

call_cc (fun: fn(k: continuation_t) -> void) -> int32
{
retval: int32;

fun (fn (v: int32) -> void {
retval = v;
goto current_continuation;
});

// If fun returns without calling the continuation,
// then just return 0
return 0;

@current_continuation:
return retval;
}

x: int32 = 0;

print call_cc (fn (k: continuation_t) {
x = 1;
k (2);
});

print x;
AEG: Automatic Exploit Generation on Source Code (2011)
Keep in mind that JAX-WS with JAX-B beats other rival libraries in other languages. If your requirement is to be a client that consumes SOAP web service given wsdl, I'd take Java any given day. The wsimport and wsdl tool that JDK provides beat any libraries.

Also, JAX-B annotation can serialize and deserialize to JSON given the right provider. That's JSON, XML with POJO with the price of one. Good example of Java ecosystem: build on top of existing one / backward compatible / play nice with others.
Try checking out Ninja Framework. It's pretty decent.
Well, the group-chats of whatsapp seem to be quite hip with the youth.
How long till afl-fuzz reaches consciousness?
Hmmm, their statement doesn't say that nobody can but says that some people can't. Those for whom the value is 60Hz or less. What their statement does say is that around 80Hz is a value that is indistinguishable from anything higher
Welcome to the Java world! Like some of the comments so far I think the Java world is actually a pretty cool place to be right now, the language and approaches are becoming a lot less verbose. I blogged about some of the best Java books, hope it'll help you out! http://scalabilitysolved.com/dont-hold-back-your-java/
Crunch in the UK is pretty good to startups. Many places these days give you a fixed fee for stuff and then throw in online software aswell.

Can recommend Quickbooks online for managing...though I hear Xero is good also.
I think the mindset still applies. Surprisingly, I know people who get 6 figure salaries and yet are not financially independent.

The secret here is to start early since the expenses rise exponentially after wife and kids.
I've been following posts about this tool for a few weeks and it is really remarkable how many interesting results are already popping out already. In particular since static analyzers have been around for years and years.

I'm assuming afl-fuzz is particularly CPU-bound, and it would be interesting to see some numbers about how many CPU years are being dedicated to it at the moment - and if we would see even more interesting stuff if a larger compute cluster was made available.

It's also super scary how "effortlessly" these bugs appear to be uncovered, even in "well-aged" software like "strings".
Isn't one of the main advantages of IRC that it's still a true federated protocol? I.e. you can host a channel #foobar across 10 servers and that channel will always survive netsplits (albeit with some number of clients splitting off), whereas with Jabber some server will always have to be the sole host of that channel?
You can actually get high enough resolution to distinguish a stupid face?!
I think that's why they said 60Hz to 120Hz. If you take a factor you essentially change the true frequency
Not currently, though that would be quite cool. For now, I clarified my version of that card, which unfortunately had a typo. Thanks..
CH=0.8+(1.1log10f-0.7)hM-1.56log10f
You will be excited to learn about gcj, then. The Gnu Java compiler compiles to native code, but it's currently not maintained, so newer Java features are out of reach.

gcj has been abandoned. It was last updated over 5 years ago. It's not clear to me why you would even mention it.

I'm a software developer that primarily uses and likes Java, and the lack of a good and free ahead-of-time compiler for Java that produces native binaries is what I miss most in the Java ecosystem.
To put it blindly immigration from western countries, asian countries and north america good, imigration from south america, the middle east and africa bad.
The reasons why we are still relying a lot on software written in low-level languages have been discussed to death, and are quite orthogonal to the insight in the article, which is that seemingly lo-tech techniques can discover much about an opaque, potentially vulnerable piece of software. And even some seemingly insurmountable difficulties (“the algorithm wouldn't be able to get past atomic, large-search-space checks such as …”) may simply, with a bit of luck, fail to materialise.

Still, quoting from a sentence a few lines down in the article:

“this particular example is often used as a benchmark - and often the most significant accomplishment - for multiple remarkably complex static analysis or symbolic execution frameworks”

The author is thinking of backwards-propagation static analysis or symbolic execution frameworks, for which is it indeed a feat to reverse-engineer the condition that leads to exploring the possibility that there is a “CDATA” in the input. Forwards-propagation static analysis needs no special trick to assume that the complex condition must be taken some of the times and to visit the statements in that part of the code. The drawback of static analysis (especially with respect to fuzzing) is then with the false positives that can result from the fact that a condition was partially, or not at all, understood.
> many instances of the same small services that don't really need to be aware of each other

Then your problem is embarrassingly parallel and your solution does not need to be "micro services" to scale.

Sorry if I missed something, I skimmed your text.
That covers the easy cases for ownership and lifetimes. But it's apparently necessary in Rust to use "unsafe" code in libraries to implement basic structures like re-sizable arrays. This suggests a limitation of the ownership primitives.

I looked at this problem a decade ago for C/C++, and got as far as borrow semantics (I used the term "keep", as the opposite of borrow). But there were ownership cases I couldn't figure out a good way to handle. This sort of thing is why the C++ committee beat their head against the wall with "auto_ptr". Rust has the same problems, and the solutions don't seem to be entirely clean.

Living with strict single ownership semantics is hard. One amusing approach is to have an atomic "swap" as a primitive. Swap is safe as regards single ownership. With enough swaps, you can do things like move the contents of an array to a new, larger space. This is an inefficient way to do it, but easy to prove sound. "Move semantics" can be viewed as a special case of swap, where one of the moved pointers is known to be null.

It can be useful to view something like moving the contents of an array as a sequence of swaps, which are then optimized. If the destination array is all NULL at the start, each swap operation becomes a pointer copy followed by a store of NULL into the source pointer. Then, if we can show that all the swap operations are non-overlapping, we can do all the pointer copies before all the
stores of NULL. Then, if the source buffer is about to be discarded and is never read again, we can omit the stores of NULL. Then if the pointer copies are all adjacent, they can be rolled up into one MOV operation.

This may be a way to avoid using "unsafe" so much.
Java's start-up time is on the order of tens of milliseconds:

http://nicholaskariniemi.github.io/2014/02/11/jvm-slow-start...

The 'Hello' program there takes a little over 100 ms for me. I guess my computer is even less of a powerhouse than the author's.

FWIW, the Python equivalent takes about 30 ms on my machine. So, you pay maybe 70 ms to use Java. I don't think many users will notice an extra 70 ms on their command line.

Java's notoriously slow startup is really about the slow startup of software written in Java. Application servers are probably the worse offenders - how can it take a minute and a half to start a fancy webserver? What's it doing in there? They've got a lot better, though; the current generation of app servers start in one or two seconds. Not that anyone cool uses app servers any more anyway. Big bloated GUI apps also deserve some shame here (although i will forgive Eclipse, because i like my IDEs with some meat on them). Language platforms like Clojure and Groovy also manage to take their time, but then they're doing some pretty amazing stuff, i suppose.
Their explanation of why aerospikes aren't used isn't very convincing.. ie: that they ere worked on in 1969; that nasa already has old rockets in stock; etc.

There have been new rockets since 1969, yet they didn't include an aerospike in the design.

Does anyone know: Is this just an experimental idea that hasn't been tested? Or why aren't these on every new rocket design in the past 40 years?

I mean, the article makes it sound like this is an easy win -- more efficient at lower altitudes, and only slightly less efficient at higher altitudes. Makes me think they are leaving something big out of the article.
I only got this error when my macbook was closed (i.e. camera not available.)
Right. In OO, you can inherit, but in Haskell, you can't.
The irony is that CDATA isn't even very useful; there's no way to escape the ]]> closing tag so you still have to invent some special escaping mechanism to use it.

Nobody expects entity definitions in XML either, and yet about once a year some new service or software is found vulnerable to XXE attacks. (Summary: a lot of XML parsers can be made to open arbitrary files or network sockets and sometimes return the content.)

XML is a ridiculously complex document format designed for editing text documents. It is not a suitable data interchange format. Fortunately we have JSON now.
You might enjoy rr, 'record-replay', which works kind of like gdb (and I believe is based on it) after you record a program execution --- you can then use gdb multiple times on the stream of execution. rr-project.org.
Sony executive heralds a revolution in virtual reality
Well, Dalvik is a JIT and ART can also do JITC and is designed for newer devices. So not sure that's a great example. The main reason Android doesn't use the HotSpot JVM is memory usage and licensing, I guess. The JVM class/jar format is very inefficient in many ways. On the other hand Dalvik is a very weak JITC. ART is stronger because it has more time to work and is, frankly, better engineered. Dalvik had a lot of problems even quite late in its lifecycle with things like lock inversions and strange method count limits, etc.
> their healthcare system is being privatized and education is getting more and more expensive,without the "neo-fascists" in power.

Huhwhat? The recent damage to the benefit and healthcare system and the huge increase in university fees both happened under the current Conservative government, not because of immigration but because of policy. Turns out the left-right axis is real, and the far right really is further to the right (e.g. UKIP's deputy leader recently said that he couldn't see the NHS surviving in its current form because it didn't have any free-market competition).
You know, I love inform 7 and was incredibly inspired when I first saw it and played with it. I DID try to create a simple game but was stymied by the documentation. There's a tutorial with the most basic game, and then there's in-depth documentation. There's not a lot of in-between. Syntax examples of how to do a handful of common things would have been wonderful.
Muni bond interest is interest dividend income; has nothing to do with capital gains or AMT or whatever else you Googled. I lived in California and received 1099-DIV -- have you?

For a Googler making a big salary, that's 39.6% Federal plus 11% California state. Matt didn't say this in his post, you obviously don't know what you're talking about in your comment, and we've once again proven why giving investment advice on the internet is stupid.

It's either so general to be obvious, or so specific to an individual that it risks misleading people in similar (but not similar enough) scenarios. Matt did the world no favors with his post and you're not doing much with your comments.
"With few exceptions (such as parsers), unit tests are a waste of time."

I was in full agreement aside from this.
Unit tests are more than just a substitute for static typing.
If only you knew the power of monads.
I guess it depends how you define "walled garden", but HipChat is built on top of XMPP: http://help.hipchat.com/knowledgebase/articles/64377-xmpp-ja.... Facebook chat used to be as well, though I'm not sure if it is these days.
How do you even parse JSON in Java? I remember in the days of XML, there was a kind of specification standard for the xml (a specification for how to specify a specification?). From that you could generate Java classes that would correspond to the elements of the XML. But for JSON there is no such meta description, so you are stuck with manually parsing the JSON and hoping you catch all nuances?
Yeah, or you could just play candy crush on your phone. There's always going to be a cool level of dorky absorption that's great as a learning opportunity and obsession for people so inclined.
Startup time on my Win7 box: 0.08 sec.
There's Avian. It can produce standalone, compact ELF files that have no dependencies. It's not an AOT compiler though. The problem with AOT in the Java ecosystem is quite a lot of modern frameworks and the like have ended up relying on the ability to synthesise code at runtime. Android has put a check on that kind of behaviour but it's still there.

There's also Excelsior, which is an AOT JVM, but it's for Windows only.

I agree that a really good AOT JVM would be very nice. It doesn't necessarily imply better performance however. I remember when GCJ compiled Eclipse for the first time, lots of people were surprised that it didn't magically fix every performance problems. GCJ engineers view was "HotSpot is an excellent compiler and it will take a lot of effort to beat it". When Sun Java became open source therefore, a lot of the incentive to develop GCJ disappeared. It was always primarily a licensing project not a performance project.
Well, it may have hardcoded support for those, but if you look closely, even github has the go-import meta tag. It's just worth mentioning, cause you can put it on your own pages, pointing at your own git repo. There's nothing saying "Get on github if you want people to be able to go get your code"
You are allowed to chain CDATA-tags: ]]]]><![CDATA[>

> CDATA sections may occur anywhere character data may occur;

(http://www.w3.org/TR/REC-xml/#sec-cdata-sect)
...quite a few of those allow for AOT compilation to native code

Do you know of any good and free ahead-of-time Java compilers that produce native binaries without any additional dependencies?

I haven't been able to find any, but perhaps my Google-fu is weak. gcj is obviously not a good answer.
Alright, let me clarify. It's quite easy compared to most countries.
Taxi Owners in New York Seek Inquiry on Medallion Prices
I used it as a wallpaper for a long time too :)

> There is also another one, with a small Earth shining
above the horizon.

Do you mean a shot on Mars? Can you link to it please?
"Fortunately we have JSON now."
Which doesn't support big ints. JSON isn't a silver bullet.
So here's the thing about annotation and Jersey, I believe you can annotate the seralization of return type once at the top of your resource class, the rest, like http verb, needs to be repeated unless you take the convention one more level up a'la Rails. But that's Rails, a web framework that people said does not fit for microservice. Sinatra is.

But if you take a look at how Sinatra (or Rails) serialize the returned object, you notice the duplicated code. Especially if you want to return both JSON or XML based on the request header. To add to this, both frameworks do this serialization as part of the code logic that you have to write, instead of slapping annotation once...

Let's take this further: exception mapping to http response code. In JAX RS, you can map application exception to certain WebApplicationException with specific http response code, I believe you have to handle them manually in Sinatra. You would have to catch the exception and convert it to the intended one per method on your controller.
Like-Wrong
>IntelliJ has historically looked pretty native on MacOS X.

Because they require the use of Apple's hand-rolled Java 1.6

https://youtrack.jetbrains.com/issue/IDEA-117324#comment=27-...