skysight-inc/HackerNews huggingface dataset:
I have no idea what that link is supposed to be demonstrating. It doesn't say how they measured memory usage (private working set, address space, ouija board stacks?) and doesn't share any of their data sets. It's an arbitrary set of claims devoid of substantiating context, and as someone who has measured this before, it doesn't appear to align with reality.

The fact is that single process versus multiprocess carries different tradeoffs with respect to memory. A single process has an advantage in the short run, in that it will consume less memory initially. However, in terms of private working set memory across multiple tabs you're simply not going to see anything like the 2x claimed in that link, given that much of the address space maps to shared pages. So, most likely the authors just weren't properly measuring memory usage per-browser.

On the flip side, a multi-process architecture has its own strong advantages for memory consumption. Any complex, long-running application is going to have to contend with memory leaks and fragmentation, which exert increasing memory pressure over the life of an active process. This gets even more painful when considering the multitude of heaps in your average browser, chrome layers written in Web technologies, and (iirc) Firefox using a non-moving, non-generational GC. Whereas a multi-process browser has a vastly cleaner solution to all of that: it simply disposes of an entire address space (including all fragments and leaks) when it's done with a rendering context.

Now, I don't want to undermine the really great work that the Mozilla guys have done addressing leaks and fragmentation, with things like cycle detection, JavaScript compartments, and various detection and analysis tools. However, the simple fact is that users who keep their browsers open for many hours, days, or weeks at a time are generally going to suffer from these issues more under Firefox than Chrome or protected mode IE.
I'd say you have the most accurate description of when they say "Gravity Powered". While lifting this thing, the energy gets stored and gravity is just a means by which the stored energy is released.
Kudos for bringing out a release after such a long time. Many projects don't make it this far.
Zuck Is The Voice Behind “Poke” Notification Sound, Wrote Code For App
In Latin America, Women Break Barriers To Entrepreneurship
Spacewar Video Games Blast Off: Exhibition at Museum of the Moving Image in NY
Some pictures taken by The Verge: http://www.theverge.com/2012/12/20/3788608/spacewar-history-of-science-fiction-video-games
Does it really make a difference? The two are indistinguishable from the POV of the victim.
Some pictures taken by The Verge: http://www.theverge.com/2012/12/20/3788608/spacewar-history-...
Whitehouse.gov runs on Drupal, not Wordpress.
It was just a matter of showing the potential of a tool like that, it's possible to uncover some malicious or self-serving edits like:
Sky is removing critics from his page
http://wikiwatchdog.com/#!search/en/sky.com/216355/446125412

or Dell that is removing critics
http://wikiwatchdog.com/#!search/en/dell.com/102490/32008505...

or a Dell employee that vandalizes the Dell page
http://wikiwatchdog.com/#!search/en/dell.com/102490/88573397
Mistakes happen.
"You are what you eat", when applied to software is something along the lines of "software's eating the world, and the world is turning to crap".

We've all seen it, at least those in the audience that have worked at some corporate of any size.. maybe "start-ups" face similar issues, it's difficult to get a consensus there.
Perhaps the discussion is centered around America.
The little bit of haskell FUD in this article made me largely disregard the rest (although I've heard my share of horror stories about the software s big financial institutions). Once you get past the different syntax I find haskell code to be extremely readable.
Does not work well on my phone (Galaxy S2 running CM10 nightlies) using Chrome. Animation is just not fast enough, or possibly the AMOLED screen is too quick to respond compared to an LCD. Maybe a combination of these. Anyway it's unusable (as is the HN comment text box but that's a different story)
> It contains lots of that scary thing called "text" and "information"

"Nice try kid, but it's not actually 'text' unless you typed it on a proper Model M."
Microsoft Release New Wordament Game for iOS
This is quite awesome.
Bill Gosper used Ramanujan's formula to calculate the first 17 million digits of pi
Although people suffering from mental illnesses may statistically be more likely to be victims than perpetrators of violent acts, the disproportionate focus on the latter is not unwarranted.

People are afraid of unpredictability. They are afraid of irrational people doing irrational things, and many people with mental illnesses behave irrationally. That's the long and short of it.

That said, we ought to be careful in making ex post diagnoses of mental illness as a means of coming to terms with a tragedy. It is merely a figment of the collective imagination that a person of sound mind would not consciously take the lives of many others.
Pirate Bay Censorship Backfires as New Proxies Bloom
Interesting - so maybe there is still something to develop for Android.
It's not just bad coders, management is also very responsible. If management doesn't make sure code is at least getting documented and shown to co workers, then a lot of bad code gets written only one person understands and can develop into the shape of his own fetish, and become a problem when he leaves. The second point is that I have seen very senior programmers, as in years, e.g. the guys with multiple decades of experience, that are quite used to dealing with this. When they take code over they can read through it, add the necessary comments, and document the structure, and convey it to others.
Good grief, what a vast amount of supposition backed up by very little evidence or insight. "People often write bad code." Yes, we know that. "There's more than one reason for this." Yes, we know that too.

The rest of the article is just random presumptions thrown together, for what reason I couldn't say. The best developers work in finance because the money's highest? Yeah, OK then... (To be fair, I think there is a qualifying "considered to be" in there somewhere) K is impenetrable? Hmmm. Haskell is an offshoot of ML and unreadable? Umm, factually wrong.

There's lots wrong with software at scale, and the pressures of financial institutions along with high budgets etc do produce an interesting set of problems, but this article offers nothing new about anything at all in the field.

As an aside, I already don't trust an author when they start off with a claim that textbook code is good code! It's almost universally accepted to be trivialised and simplified to the point of "don't do this in the real world" simply because it has to be. Some of the worst code I've seen has been in textbooks (and that's worst as in "dangerous" rather than as in "badly written and in need of refactoring/replacement/enclosing in concrete).

Edit to note: I think it's actually beyond incompetent journalism and in to plain lying to present a piece of code as evidence of Haskell unreadability when the link to that code on SO refers to it clearly as "obfuscated Haskell code".
Disclaimer: I have never been sued and don't know who any IV executives actually are, and I'm speaking purely hypothetically.

Hypothetically, if a legal firm is engaging in clearly predatory behavior, can a point be reached at which it is morally justifiable to retaliate against said firm in an extralegal manner? Perhaps law firms that walk the line of ethical behavior but are clearly behaving immorally by any reasonable standard present a sort of edge case. Usually, a moral person should settle his disputes in a civilized manner by going through the proper legal channels. However, if a moral person is being abused by a law firm that is capable of outmaneuvering him in all or almost all legal proceedings, what recourse does that person have? A good analogy is a battered wife who is reasonably certain that going to the police will result in her husband murdering her. In such cases, courts have ruled that a wife may initiate force against her husband and yet be acting in self-defense.

Another analogy is the idea that it's possible for the US government to become so corrupt and/or abusive that revolution becomes justified. If the people of the US were ever to attempt a revolution, however, they would certainly be labeled terrorists by the US government, and their actions would be considered treasonous. Nevertheless, there is a point at which revolution is theoretically justifiable, despite being treasonous. That point is when it becomes impossible to participate in the political process. The actions of an oppressive government amount to legal abuse, much like the actions of a predatory law firm.

I'm not trying to rile anyone up here, but all I see are comments that come off as totally defeatist. We tell our kids to use their words, but no one can be bullied forever. Eventually, something's gotta give.
I can't even tell if this is sarcasm or not.
If it's real, I wonder if the gears are noisy...
> Perhaps with a less neglectful acquirer, Flip would have been a worthy competitor to GoPro.

It'd have to flip mightily, Pure Digital did consumer "point and shoot" cameras, gopro does actioncams. They're the same thing only in that both are cameras (and then again, so are RED, would you argue RED is going to become a gopro competitor?)
It's my feeling that using the free market, which should be based on property rights, cars and roads would be "regulated" a lot more than they are now.

How many companies could operate with tens of thousands of people dying from using their products every year: cars and roads?

What advances in technology would have been required so peoples property rights were not trampled on with regards to pollutants from vehicles?
Tcl dicts are ordered, so you have a defined order for this.
http://www.tcl.tk/man/tcl/TclCmd/dict.htm#M27
Yep, it's a) only syntax (if you cannot get past syntax maybe a you need to get another job) b) a bad example in the article c) an example of how to make code unreadable which goes for every programming language. In general Haskell programmers strive to refactor to a point where you have balance between readable, performant and idiomatic Haskell.
(($300m / numberOfUsers) * numberOfExtremeUsers) / numberOfEngineersRequired / numberOfYearsRequired
First, I must say that this is some awesome tech. Though, I think people should not be sharing images that would require them to use a tech like this. Moreover, if this is applied to display sensitive information then the person who intends to steal it will not be dithered by something like this. They would certainly look at means to circumvent it. It's like limiting people to right click and save an image or copy some text. Those who want to do it, can always grab the source code and load images directly from their links or copy text from the source code.
Especially since this is obviously obfuscated Haskell. A more readable version:

pow = 1 : [ 2*x | x <- pow]
I have the feeling that you think Enlightenment compares more to KDE/Gnome then to, let's say, Blackbox.
It's basically just a window manager. It doesn't come with it's own Office Suite or Email client, etc.
If that's your definition of "bloated", you're good to go with Enlightenment. After first installation it's just a plain desktop.
>Good grief, what a vast amount of supposition backed up by very little evidence or insight. "People often write bad code." Yes, we know that. "There's more than one reason for this." Yes, we know that too.

YOU AND ME know that. The title of the article is "What Compsci textbooks don't tell you", so I guess it is targeted at people still in college, to show them how things are in the "real world".
The sickest shit (not in a positive sense) that i read in a while...
for apple.com here's some interesting pages

http://wikiwatchdog.com/?#!search/en/apple.com/89847/1151979...

http://wikiwatchdog.com/?#!search/en/apple.com/8976498/22295...

http://wikiwatchdog.com/?#!search/en/apple.com/89847/4256841...

http://wikiwatchdog.com/?#!search/en/apple.com/89847/2815399...
Well, first thing, in the Computer Science part of programming, the requirements are very simple and straightforward. For example, implementation of hashing algorithm or HashMap.

You just can't compare the requirements of "science" part with requirements of "real world business system". The "science" requirements are almost laughably trivial. And the documentation of business system will run into thousands of pages.

Now, you say if you just refactored the code, if you saw the "grand design" and rewrote the code to accommodate every little requirement elegantly and with proper abstractions and so on... I will say you would just end up with system so abstract and general, no-one would understand exactly how it is meeting those requirements. Because you would had generalized every special case (where it should've stayed a special case, and that's that).

So in a way, the simple hacked-together awful program might actually make more sense than the elegant and grand abstract program. Because you can follow the hacked-together program, and you can't follow the arhitected program. It's this "abstractions all the way down", where you can hunt abstractions down for "how exactly does it do this one thing" all day, and then find out it's a little config setting in obscure .properties file that actually covers this one business case. (And if it was there right in code, you would be done in 5 minutes. But alas - it's a config option, so to change behaviour, now you must write all infrastructure to support another possible config option.)

I say - bad code is just fact of life in real-world business. You should strive to clean it up, make it elegant, abstract and generalize... but really business just needs to to chug along.
Your analogy breaks in that we hate the "soap opera" look EVEN in soap operas and even if we happen to like soap operas (which I occasionally do).

It's not that we associate the HFR look with a bad thing and thus we think it's bad "by association".

It's that we think the HFR look is bad in itself.
The code is literally used as an example in Uncyclopedia.

http://uncyclopedia.wikia.com/wiki/Haskell#Haskell_Code_Exam...

It's like using code from the IOCCC to make a point that C code is not maintainable.
Tcl's C implementation is far from messy. Its actually one of the best commented C based language code bases i have ever seen. But your project was doomed by false assumptions. (oh, and Tcl has more than one implementation, e.g. there is a version based on Parrot for example, http://code.google.com/p/partcl/ or the JACL interpreter based on the JVM).
Readable to you after years of study of the CS principles and languages behind Haskell, but literally unreadable and undecipherable to the majority of current programmers. This is a major problem, even if you choose to ignore it and remain in an ivory tower.

That said, the actual problem described in the article has this issue at the very core - we have more software we need written than we have people who can write good Haskell. This means that a large percentage of software is going to be written poorly - and the only real solution would be to simply have less software.

Supply-Demand overrides this completely, and so bad software will remain. The true challenge is therefore making software that can be written by the semi clueless and yet still be decipherable enough to maintain. Java and C# seem to have cornered this market to great effect in the business landscape from my experience.

I think current language development trends towards functional programming is a mistake as it caters to such a tiny audience, and more emphasis should be placed on new languages that can force people to write good code.

Is this possible? Dumb example: If someone is hacking together computations of circles without knowing about PI, is there any possible way for a language to help here?

I think a language that can make it clear what the code is trying to do, even when written by someone who has no clue, would go a long way to being able to filter out and fix bad code quicker. If your code is in Haskell, it's going to take a lot of effort to work out what bad code is even trying to accomplish.
I think this article sucks, but of course they are right; by far most real world code is horrible. That goes for academic as well by the way; I cringe when I see the code people get As & Bs for in universities. "It has to work" they say and the prof seems to agree. So you can see, yes also in Python, the most incredible constructions which 'work' but are hardly real code and do not work outside of the required examples.

Code in real world companies is mostly horrible, especially when the company gets bigger and older. Spolsky has a bunch of articles about that. To counteract or prevent that you need heaps of money put into it and most companies really don't see the need or actually don't have the funds.
"Syntax doesn't matter… unless you're a programmer." ~ Rob Pike.

I otherwise agree with your b) and c) points.
> Haskell, an offshoot of ML. According to a friend in academia who’s studied it, it’s “the Taliban version of ML,” in which it’s all but impossible to write readable code

Can we stop posting this crap, please? TheReg was kinda edgy and cool circa 1998, but now it just seems a forum for trollish and content free articles.
So you find the (far more real world) code of Inufu unreadable?

Edit: actually when interviewing people I show them some Haskell code and ask what it does. Most of them do, some answer that they don't know the programming language. Of course I don't give them very difficult stuff, but still; a lot of well written Haskell code is incredible readable, even for people who never saw it. Also, I really assume if you have a CS degree that you played around with functional languages and recursion. My disappointment with a certain country was that almost none (and I interviewed 100s in the past 10 years) of the Masters of CS from that country even have a clue what recursion is, let alone functional or logic programming languages.
haha exactly, same here
Interestingly it's a wrapper around the community maintained botocore[1]. It's listed in the requirements file[2]

1: https://github.com/boto/botocore
2: https://github.com/aws/aws-cli/blob/develop/requirements.txt
There is no need to torture yourself with insane syntax and I should express that probably differently, but I find the obsession over syntax usually a lack of skills or experience. For instance, there are hordes of programmers screaming they 'cannot do' Objective C because of it's syntax. That's silly.
Well, not necessarily. There is plenty of good code out there. The dirty little secret of software development is that bad code is an effort sink. Let me run through a few truisms about bad code and see where they lead us, development wise.

Bad code is buggier, so it will require fixing more often.

Bad code is more difficult to understand and sometimes has non-intuitive side effects or method of operation and so working on it will take longer.

Because of the convoluted way that bad code often works, adding features or doing maintenance on it often makes it even more convoluted and difficult to work on.

Bad code typically has lower performance, so it will require more attention to improve performance. Due to the above 3 factors this becomes a vicious cycle of sinking effort into the code only to make it that much harder to work on in the future.

For these simple reasons bad code becomes a huge time sink. Programming tasks involving good code end up taking up a much smaller portion of the developer-effort budget because it's so much easier to work on that code, while the bad code takes so much more effort and often the code base just ends up even worse than before, perpetuating the phenomenon through to the next cycle of development.

The only way out of this cycle is to identify the code that is the main source of bugs and the main sink of effort then budget out more than enough time to tackle it and improve it. But most development shops aren't proactive enough, introspective enough, or set aside enough dev-resources to be capable of doing that. Even though such efforts tend to have an enormous impact on future development.
Let me play devil's advocate. From what she's saying I'm drawing the conclusion that mental illness correlates with drug use which correlates with violence. The prevalence of mental illness in the population is small, so the proportion of the mentally ill among violent criminals is also small, but if mental illness is a predictor of violence then being more aggressive about institutionalizing the mentally ill would provide society a better return on investment with respect to preventing violence than policies aimed at the general population (such as gun control).
I'm not a purist trying to make the argument that 24fps is the best thing since cheese for movies. Thats like the folks that say vinyl offers better sound than digital. I'm not an audiofile so I never noticed.

About a week ago I was at the Microsoft campus in Redmond and had a chance to watch an action scene from the last Batman movie in one of their living room studios. The TV was pretty new and was showing the movie in interpolation mode or something. Subjectively, it looked like the Hobbit did. It didn't seem natural and kept pulling me out of enjoying the film. This comes with the comparison that I saw the same Batman movie in the theater this year and it looked much better at the slower frame rate.

I believe the optimal goal for fps is to mimic exactly what the human brain perceives with vision. Movies and/or video games should eventually seem like you're a spectator or looking through a window.

I just read through this page and it provides some good background, http://www.100fps.com/how_many_frames_can_humans_see.htm.

Basically, I think what was lacking in the Hobbit was a significant amount of motion blur. That's what we get naturally at a lower frame rate like 24fps. Simply pumping up the fps to 48 without adjusting for motion blur is what makes it feel weird. It definitely provides more visual detail, but that isn't optimal for the viewing experience.

I think an interesting experiment to do in the next few months will be to take the 48fps non-3D version of the Hobbit and add motion blur in certain test scenes while maintaining the higher frame rate. I hypothesize this will let us see more detail and make the images richer while appearing more natural to the brain.
>"When you program for Android/IOS how much of the logic you write is referenced from optimized libraries and how much is your own craft?"

It doesn't matter either way.

For one, Apple and Google aren't that keen on optimising their stuff either.

Second, most desktop applications use libraries and GUI toolkits by a major source, like Apple and MS, so the situation regarding "a large part of the app is made by a third party that can optimise it" is there for those too.

Third, tons of iOS/Android apps use third party frameworks, like Corona, MonoTouch, Titanium, Unity, etc etc, and not the core iOS/Android framework.

Fourth, the most speed critical parts of an app are generally the dedicated stuff it does, and not the generic iOS/Android provided infrastructure code it uses.