skysight-inc/HackerNews huggingface dataset:
This is called reference counting, and it's nigh-impossible to do quickly in a nondeterministic system.

https://en.wikipedia.org/wiki/Reference_counting

See this for why it's slow compared to other schemes:
http://www.cecs.uci.edu/~papers/ipdps06/pdfs/1568974892-IPDP...
> This is the best part - over 90% of the memory allocation is not needed at all. Most of the memory is probably allocated to make the life of the developers easier.

Makes sense to me.

"Silicon is cheap while carbon is expensive."

i.e. Machine time is cheaper than developer time (to a point).
I was excited at the start. But then I couldn't figure out where this article was going because it started talking about us going to space and polio.My take on the headline is that I don't believe the OS needs to be rewritten;I think that GUI's and user experience on Linux needs to be redefined.I know we can do better so why don't we do better.
personZ mentions [1] escape analysis [2] which is kind of similar.

[1] https://news.ycombinator.com/item?id=8485522

[2] http://stackoverflow.com/questions/8222561/escape-analysis-i...
Besides that whole price fixing thing, sure.
I've steeped grains before, but that's pretty significantly different from a real mash. Usually steeping grains was used to enhance a base extract which formed the base of the boil. So you're saying you can just steep grains without using any extract? How do you keep your temps stable to have a good mash? Do you have any links to this method? Or book references? I appreciate your response!
From OP: "There are huge amounts of objects which are allocated and discarded milliseconds later."

Any mature generational GC should handle this with literally zero overhead. Assuming it is not doing a nursery gc every millisecond, all those objects should die in the nursery almost immediately. It has been well understood for at least twenty years how to do that in O(live objects), and the JVM has for all its many faults a very good garbage collector. So I am quite skeptical. This is also at odds with empirical evidence which is that going from 1.7 to 1.8 with the same world improves framerate.

Now the JVM gc has about a million tuning parameters and most hardcore Minecrafters have a witches brew of tuning that they run with. It's far from impossible that those tuning parameters are totally inappropriate with 1.8. But the GC should handle this fine.
A lot of big companies like MS hire boy scouts (or girl scouts) who feel that they need a certification to carry around a pocket knife at camp for their entry level jobs. They also hire really smart people too, but they tend to hire the B's, not the A's. Sometimes it isn't clear whether they can tell or not. They like people who can be molded ushered in a direction over time. What you are describing isn't isolated is all I am saying. For better or worse, these are hires that they can shape into sequoias in their forrest of talent.
Is this something that could be accomplished with the help of CCV?

https://github.com/liuliu/ccv
Check out http://clashofclanshelper.com/ - I got free Clash of Clans gems here! Get yous too in less than two minutes!! Couldnt believe at first but it really works!(y71n8meUzs)
>The problem is that nobody has come up with a good way to filter through the self-published dross to find the gold.

If you self-publish without doing an ounce of marketing through curation of an audience, then your book falls under the "vanity publishing" sphere. Then why should anyone care if your work is good? You clearly didn't do a good enough job of selling it.

(Note that publishers don't do anything for first time authors in this regard, either.)
I've never used (or even heard of) gulp or AMD (I'm guessing they're widely used outside of JS-only environments), but from your statement I infer that one must be implemented as a JS library, and one must be a DSL with JS-like syntax.

Are you implying that my parenthetical is invalid because the DSL has JS-like syntax? You must have missed where I said "no easier" and "perhaps more difficult". If the DSL's syntax is identical to that of the library's, then clearly the denotation of the library is no easier to understand than that of the DSL – they are identical.

Was your wife's question supposed to be funny?
+1 for jq. A lot of my work these days involves using web APIs in addition to "local" ones from CLI tools. xpath was good for dealing with XML stuff in a similar fashion, and HTML-XML-utils is an awesome suite of CLI things for slicing and dicing, if you're into that sort of thing: http://www.maketecheasier.com/manipulate-html-and-xml-files-...
Neither. It is the type of comment that takes two opposing concepts and instead of contrasting them on both edges of the idea spectrum places them one inside the other.
That applies to a certain amount of throughput, for parallelizable applications. Latency in a game isn't "machine time" per se, it's a core requirement and not something you can get away with via "more silicon".
With ido-everywhere, flx-ido and ido-vertical-mode you can get nice, fast buffer-switching with fuzzy matching via C-x b. See these two screenshots for an example: http://imgur.com/a/sZk8m
Great talk. Do you know what tools was he demonstrating?

Are these tools available to use?
So, the nursery is a certain size. If you are filling it up continually you're going to be spending a lot of time managing it. Not only that, but if your rate of allocation is high enough you might inadvertently promote a number of objects that have not gone out of scope yet to the tenured section which in a less demanding allocation scenario could have been collected from the nursery.
Over the years I've read a lot of arguments from both sides: China's growth will continue for a quite long time vs. it'll end soon. Both have some valid and interesting points and I'm still not convinced either way.

But there's a more general theme I find interesting. If you are to predict how long something is going to last, given it already lasted longer than its peers, there are always two kinds of thinking: a) it's already stretching itself so it'll end soon, or b) the fact it already lasted this long means our references are not correct, and this could last a lot longer than we thought possible.
C-x C-b brings up a list of open buffers. Is that the same as what you are looking for?
My favorite part of the 7:1 split is that the new stock price could be thought of as a percentage value of the highest AAPL ever was before the split, which was ~$700 or so back in Sep 2012.
You still have to trace the object graph - it's not "zero overhead" unless the escape analysis can determine that the object can be stack-allocated (and hence collected without tracing the graph).
It is all iterative and relative to the current time: hardware, software, network speeds, access, mobile etc.

Just like the sexy new iPhone 6 looks like the thing, in a few years it will look old and dated. Everything looks good in its time.

The same goes for software, however simple fundamentals do remain and grow stronger. Hopefully over time iteration does simplify, but as a whole, it can look complex to meet the needs of the current market. Everything we do now won't be used in the future, it does expire, but it is useful as a step or else there is no future version without this version.
For .NET you should really read about structs, which allocates on the stack instead of the heap, and thus avoids the GC most of the time. Oracle is working on a struct implementation for Java 9 or Java 10.

Using an arena/buffer/cache in Java and .NET is not unheard of, and is a good way of avoiding allocations, and thus postponing collections. An arena will, however, increase your live memory which means that when a collection finally does happen, it will take longer. The arena will probably be promoted to the oldgen quickly though, so the collector shouldn't scan it to often.

"if nothing points into this entire arena dump it in one chunk" -> is more or less how a GC works, so you get that for free. The way the GC does it, is that it scans everything that is live and considers everything not scanned as garbage, which is then collected. The beautiful part of this, is that even if you have allocated 1Gb of memory, you only pay for what is live. If you have 200mb of live memory, collection will be constant regardless of how much garbage you have, whether it is 1Gb or 2Gb of garbage. Increasing the size of memory of course makes collections happens less often.

Your point regarding JIT is irrelevant in this particular case, as this case is exclusively related to the GC. We would be talking about the same potential speed improvements here with or without a JIT. That being said, you are also wrong.

A JIT can produce faster code than any pre-compiler, due to there being more information available, and because a JIT can easily "undo" compiled code, allowing it to experiment with code that can fail in certain rare cases, but most of the time is vastly faster. Mono, the open source .NET implementation, can be pre-compiled using LLVM (originally a C/C++ compiler), but using the JIT produces faster code.

The reason Java and .NET is "slow" for idiomatic (not higly optimized, which most code isn't) code, is due to the GC, which causes the application to freeze at certain intervals. This problem increases the larger live memory you have. A GC is probably faster overall compared to manual memory management though, the problem with GCs today is that they de-allocate (garbage collect) all at once, instead of de-allocating memory once said memory becomes garbage, which evens things out a bit.

That being said, there are of course downsides to a JIT. It takes time before the JIT is "warm", which is to say it takes time before most of the code in the application is compiled. If you have applications that run for a short amount of time (I think Java's JIT compiles functions that are run 32 times or more), like shell scripts, they get no performance benefit of using a JIT. Another thing is memory use. Since a JIT compiles code as it goes, and nothing is pre-compiled, the JIT has to store compiled code in memory. So a JIT will naturally use more memory than a pre-compiled program, and a GC normally ads to this.
Has anyone tried to add gestures, with a Leap Motion for example, to their development process? A handful of subtle motions could be used to automate some repetitive tasks.
Ruby on Rails vs. PHP – The good, the bad
Escape analysis can't handle the case when a short-lived object is returned from the scope it's created in. It will be heap allocated and become garbage soon after. Value types can be returned and still not become garbage. A further optimization of reference types might be ownership analysis, like rust's borrow checker, but I'm pretty sure that would require an analysis of the entire program, and so would not be possible without AOT hints
Hi, I'm David, one of the co-founders of UpSwell.

We're trying to build a social-platform where individuals can coalesce into groups to indicate what they want to exist in the world. In doing so, we're hoping to create ways for the crowd to speak with a single voice to companies, organization, governments -- even individual people -- about what it is the group would like to see exist.

I'd love any feedback, good or bad, that might help us improve the site and the idea.
I'm just disappointed this isn't called "Djangoogle"
SIGGRAPH Asia 2014 papers on the web
Getting Help from People in Your Industry
This is probably too geeky for Apple to do, but I wish they offered direct video input on their iPads. You'd be able to use them for extra screen space, hobby projects, dedicated views for things like audio production, temporary screens for headless terminals... so many possibilities! (I know there are apps that do that, but they're workarounds at best and have too much latency and/or quality degradation.)
Because gob encodings begin with type specifiers, all objects of the same type number are grouped together. That's the only guarantee made across all types.

For strings and numeric arrays, lexicographic order is maintained, yes. But be careful with structs and other types - I'm not sure about those yet, or of gob's byte ordering can be depended on.

I'm implementing for-each-of-type iteration right now, and for stringified keys, this iteration will function will be lexicographic.
The “Natural Language of the Hand” and the Early History of Educating the Deaf
A "rubber dome" or membrane keyboard requires the typer to press the dome all the way down to trigger the key press. On a mechanical keyboard, it is a mechanical switch to trigger the keypress. On Cherry MX blacks greens and reds, there is no feedback when you have pressed the key. However on a blue or a brown there is a tactile "bump" when the press is registered. Critically this happens before the key "bottoms out" or hits the bottom of the switch groove, so you can release the key before that second strike occurs on your fingertip. With the blues, the "activation point" as it's called makes a loud click as well as the tactile bump, so as you get used to typing on them, you'll release right after the click.

I'm not sure of the effects of mechanical keyboards with regard to RSI, but if you're a hard typer, they might help train your hands to not bottom out the keys.

http://www.daskeyboard.com/blog/wp-content/uploads/2011/08/C...

http://www.daskeyboard.com/blog/wp-content/uploads/2011/08/C...

http://www.daskeyboard.com/blog/wp-content/uploads/2011/08/C...
As someone who has spent extensive time in West and Central Africa, poverty is as much a second order (or third or fourth) effect as the Ebola outbreak, and much harder to fight. System fragility (whether it's relative to disease, famine, or other natural disasters), is a function of poor leadership more than anything. What is scary is that there is plenty of evidence that government to government aid does more harm than good, and Western attempts at fixing the problems only make things worse.[1]

[1]See any of Bill Easterly's writing - http://williameasterly.org/
Except you can sell a GPL compiler.
You are completely missing the point. You can't just say "So what if a mechanic forgets to check the brakes to make sure they work before setting a customer loose in a car that is going to run off a cliff and DIE."

Insurance can certainly cover the cost, but is it your company's official stance that it produces coders who need to be paired with supplemental errors and omissions insurance policies because they will crash your company's product or that it would be ok if they cause major problems?

I think you are somehow confusing graphic design with software engineering and programming here. Maybe what you should be telling people is that you are teaching people how to build brochure websites for a living. If that is it then your perceived quality or capability bar might not be objectionable.
I have done it, and I grew up in family owned businesses where my parents would build something then fail or sell it and go to the next thing.

My personal experience has been if you two communicate well and can work together well on other tasks, then it is just extending the partnership. With my wife now she is involved in aspects of the business and does awesome things for the business. However, she doesn't want a day to day role because she likes having some separation, which honestly has really been the best for us.

We work really well together because we respect each other for what we bring to the table, and for the most part we can swallow our egos.

I'd say for what to watch out for: having separate time is important, having the ability to separate work from home is critical, having time set aside where work topics are not a focus etc. Respecting each others decisions and abilities as well as checking the ego is very important. I don't believe it is possible to say you can't talk about work at home etc, but you have to be able to have conversations about life outside of the job. To me that is no different than dedicating time to work out, having hobbies together etc.
Based on the press sentiment analysis here http://financeai.com/stock/nasdaq/aapl It is looking pretty good for Apple as well!
Leap Motion isn't nearly as accurate as they show in their videos. I have one and it's completely useless for anything more than a simple "swipe left" gesture.
Problem is that escape analysis can't always do a good enough job, it doesn't catch everything. Lead JVM developers have stated this themselves, which is why Orcale is exploring how to implement value types on the JVM. Naturally, value types doesn't magically solve things either (I'm well aware of the shortcomings as described in that article), but for this particular use case, it seems like the perfect solution.
Wouldn't be better to host a web application and the database on the same server for better performance?
MX blue and brown keys also require slightly less force to press than a rubber dome key.
I was tempted to say I didn't think your plumbing metaphor holds water, but I refrained.
There is a benchmark comparison with Rails. See http://www.akitaonrails.com/2014/10/19/the-new-kid-on-the-bl...
Olfactory cell transplant sees paralysed man walk again
This is a cultural problem. We use structs all over the place in Roslyn. You need to train your developers on how to appropriately use the features available to them on the platform.
Sir, there is nothing uncool about static typing. :)

(verbose typing is uncool, though)
The pressure curve and click placement on Cherry MX blues are generally conducive to learning to not bottom out on the keys and apply the proper amount of pressure to the key.

Bottoming out on the keys and using excessive force because of a lack of tactile feedback on the keypress are leading causes of injuries, because they provide a sudden jolt (when the key stops moving, but your finger doesn't) and unnecessary strain (to generate the extra force). Bottoming out in particular is bad, because you end up momentarily pressing against the keyboard frame with the full force you pressed down on the key, doing nothing but straining your wrist, while if you stop the downstroking on a spring loaded key before bottoming out, you'll end up stopping your motion in a cushioned manner (and the key assists a little bit in retraction).
Yes, but bread-machine bread is f-ing horrible compared to the real stuff. I assume that picobrew at least produces good beer.
It varies WIDELY with the program. Not all of these are rip offs. Not all of the students get the same or need the same things as you. There are all kinds of different ways that people learn. There are also lots of different levels that people are coming into things on.
Cache of Historic Newspapers Unveils the Mysteries of Old New Orleans
This is true, and much of that C is spent implementing the lisp interpreter. I'd love to see how much C is used outside that functionality.
I'll answer my question. They tackle this problem by advertising as such:
"Lives in DigitalOcean, near your app"
So basically, for optimal performance, my app should be hosted on DigitalOcean.
In other words, every kid who knows how to code thinks they can make Minecraft faster and better than the actual Minecraft developers. Pretty old story.

1.8 performs a lot better than the old version.
you can see only Marc's annotations on his profile page: http://genius.com/MarcAndreessen
Are AES-128 and 2k RSA keys not secure?

I know 1k RSA isn't secure, but I thought 2k was.
Steve Hanov: My thoughts on various programming languages
It could make sense if you are developing a server-side application where you own all the machines that it will run on and can take a cost-benefit analysis of dev time vs. server cost.

It makes absolutely no sense when you are selling a program to users that will use it on a wide variety of hardware, from high-end to decade old. That's a great example of a selfish externality, asking millions of players all around the world pay for expensive new machines (even top of the line ones are going to have problems managing 200 megabytes of garbage per second without dropping frames) just to make your job easier.
Rails Rumble – Let the Judging Begin
Piketty in his well-known "Capital in the 21st century", points out that rapid growth isn't unusual as countries catch up to the state of the art. Countries that are leading technologically grow more slowly, but from a higher level. Beijing and Shentzen may have caught up, but the interior provinces of China are still in catch-up mode.

China is still building out its inter-provincial highway system and its high speed rail system. There's about another ten years of building those out. The government of China has been building new cities far from the coast, recognizing that the coastal areas are way over-urbanized and growth has to be moved elsewhere. It's still not clear how those will work out.
Hey, now; either my grocery store sucks, or I am/was a dang good home brewer.
Seriously; when it came out well (2/3 batches), the only thing that could compete with it was straight from the microbrewery tap. Never could make a decent lager, but for any kind of ale, it was great. I blame freshness, which is an under appreciated beer quality. Also, lack of the now popular practice of overhopping; almost everything in the store these days seems to be an IPA or overhopped porter.
Doesn't it make more sense that without the subsidy the iPad is treated more like a computer that someone upgrades every few years when they have an issue (breakage or speed) instead of every year or two like an iPhone (where you're throwing money away)?

The iPhone is pretty exceptional product, is it really fair to hold everything else to that standard? Are people going to cry foul when consumers don't replace their Apple Watch every 18 months?
Alternatively: http://emacsformacosx.com/

Easy-peasy!!! (But, clearly, not as secure as verifying the sources and compiling yourself.)
A former professor of mine wrote his PhD thesis on categorizing human emotion (I believe it was out of an AI department). Not sure how much help it will be, but it might have some ideas you can pull from.

http://condor.depaul.edu/elliott/ar/papers/dis/elliott-phd.h...
http://www.catb.org/~esr/writings/taoup/html/ch10s05.html lists alternatives for each short option, so which do you choose?
this is all I think of when I think about programming by voice: https://www.youtube.com/watch?v=KyLqUf4cdwc I remember laughing so hard the first time I saw this. (granted its from vista, and I know voice has come a long way since then)

However I could see myself using voice commands that activate Macros or other actions. I just bought a Nexus9 and am going to try to use it for coding, I can definitely see potentially using voice commands to augment that workflow.
Reference counting is a runtime operation, an alternative to mark-and-sweep as a GC algorithm that allows for deterministic deallocation at the cost of memory overhead. While the net time overhead will probably always be greater than mark-and-sweep's (although there are optimizations which can make them quite similar), mark-and-sweep has the disadvantage of causing infrequent, long pauses rather than a predictable uniform slowness. Reference counting is used in Python (which also has mark-and-sweep to detect reference cycles), C++ in the form of shared_ptr<T>, Rust as Rc<T>, and objective c/swift (and certianly many more).

Compile time memory management refers to things like escape and ownership analysis. Escape analysis finds locals that never escape the scope they're allocated in, directly or indirectly, and allocates them on the stack rather than the heap. It's used in openJDK and probably other major JVMs, and required by the Go standard. Ownership analysis verifies that there only ever exists one live reference to an object in memory, so that a deallocation can be statically inserted whenever it leaves scope, so it doesn't become garbage. I have only seen it used in languages where there are explicit ownership annotations, such as Rust and C++.

To be sure, these are not the only forms of compile time memory management, but they're probably the most versatile.