skysight-inc/HackerNews huggingface dataset:
> The JSX is not the same as it is encapsulated in the render() method withing the JS file.

I'm not quite sure what you mean by this.

Anyway, I can't help but think that the distaste of the way React does stuff is due to first impressions and not actually using it in a meaningful way. I get where you're coming from - when I first saw React I thought the JSX was a terrible idea, raising many of the same concerns you have. I'm not sure what your experience is with it, but I definitely didn't like the syntax at first. Also, although we are talking about react specifically, usually you'll be using other libraries along side to it handle the other non-viewy type stuff.

But then I actually used it, and lead a reasonably sized team to create a non-trivial web app with it. People who have been programming since before I was born, and people who learnt React for this project. Not all of them love it, but everyone is very productive with it and we all see the benefits it brings and we haven't been burned by some 'anti pattern'.

Traditional programming common sense still applies here: bad developers are going to write bad code. When something gets too large, take another look at the problem and perhaps break it down into sub functions. If you're repeating thinks, create a common module for it. Nothing really revolutionary about that.

I'm not convinced there's no one working on or with React who's seen the pain of poor separation of concerns. There are lots of smart people working on React, both at Facebook and in the community, who are just as aware of the programming. "principles [that] have been forged to be tried and true since the 70's"

Additionally, the Aurelis example we both mentioned isn't a webcompoent. It's as much of a web standard as React is.
It's an issue for me too, it caused by a bug with the CSS vh unit. The content is there, just a long way down! It's not too tricky to fix so I hope the author see this! (I tend to use js to fix this one)
For all practical purposes, so does any other way of producing a document from plain old desktop printing (http://33bits.org/2011/10/11/everything-has-a-fingerprint-%E...) to handwritten letters.
Far too detailed character development on non mainstream characters.

Far too detailed descriptions of landscapes and environment. The first couple of times they are great to read, after that, very boring.

Far too detailed description of politics.

The books could have been half the size and probably would have been better for it.
Buy a keyboard with integrated USB hub and ports. Then you can plug your rat into the keyboard without taking up valuable ports on the system.

This PC is a little weaksauce to be running Windows, but for typical Linux applications it's overkill. I don't know what its niche is, except as a terminal server or digital sign -- not exactly growth markets for home users.

Businesses will eat it up.
Hiring managers don't care about how you feel about social justice
One more:

"A ‘newbie’, in Haskell, is someone who hasn’t yet implemented a compiler. They’ve only written a monad tutorial"
There are many things you don't know and don't know you don't know, that is complicated to explain. I, for sure, am ignorant of a lot too, but at least I know that estimating heritability on the occurrence of bipolar disorder doesn't prove that these disorders are "caused" (you used this word, while the article doesn't) by genetic factors.
This is one of the best articles I've been linked to from here. Makes me excited about designing web pages, which never happens.
There are many styles of functional programming; the thing they have in common is that they all use first-class, high-level functions to implement features which other languages might implement via special-purpose syntax, bytecode, compiler passes, etc.

The "lambda the ultimate" papers are the classic example of using functions to implement a variety of language features, including jumps. Hence the author's claim that functional programming is an "inside-out" approach is more of a question of style than of paradigm.

For example, even simple function composition can approach the clarity of imperative code for following a step-by-step process. The result tends to look like UNIX pipes, although traditionally they're read "right to left" (but you can trivially define your own composition function which goes the other way).

Here's an example of the author's task, written in a compositional style rather than an "inside out" style:

heatedOven = preheat 175 oven

preparedPans = grease . flour $ pans

flourMixture = whisk . add flour . add bakingSoda . add salt $ smallBowl

creamedMixture = until (all [light, fluffy]) . cream . add butter . add whiteSugar . add brownSugar $ largeBowl

bananaMixture = mix . add bananas . repeat eggCount (beat . add egg) $ creamedMixture

batter = stir . add (chop walnuts) . repeat (size / spoonful) (add (spoonful flourMixture) . add (spoonful buttermilk)) $ bananaMixture

baked = take . wait 30 . add (add batter preparedPans) $ heatedOven

cake = take . wait 10 . add baked $ dampen teaTowel
I enjoy "functional languages" because they force good practices, especially those that may not pay off immediately. Merely offering some nice features (C#, Java 8, etc) doesn't force you to write your new code better, let alone refactor all that old code, and thus I'd argue the benefits don't follow.
Also, Backus' 1977 Turing Award lecture "Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs" (http://worrydream.com/refs/Backus-CanProgrammingBeLiberated....) would be a good read.
I'm a big fan of his making this in Unity
BCoin: full and SPV Bitcoin node written in JavaScript
Agreed - it seems like the largest problem they faced was using Scala build tools - so it's funny the blame is placed on Javascript.
In the Python world also, Alex Clark recently blogged about exactly this: http://blog.aclark.net/2016/02/21/updated-django-website/

He shared his makefile: https://github.com/aclark4life/python-project
Morgan Stanley Marks Down Its Stake in Palantir, Dropbox
Are you arguing with or against my claims? Since we're talking about reimplementing existing protocols, problems with the spec are either fixed our not our fault. Thus, high- and low-level bugs are ruled out, leaving...not much.
I've successfully refactored way too much code that was needlessly complex to agree. Better understanding of a problem frequently leads to simpler solutions. It doesn't always lead to more complexity.
Nothing is going to force you to write new code better or refactor old code if you don't have the motivation yourself. I can guarantee you that I could write horrible spaghetti code in any functional programming language.
Why the heck would you write the functional recipe the way he wrote it?

1. Take an oven and apply 175 C setting on it, producing a preheated oven. Set this aside.

2. Take two 8 inch round pans and some grease and flour, produce two 8 inch round pans with grease and flour applied on them.

3. Take a small bowl, some flour, baking soda, salt, salt and a whisk (a first-class function), return a small bowl with flour, baking soda and salt whisked in it.

and so on.

When you think of functional programs as series of operations chained together, it becomes really natural. In most recipes you don't need to loop back to an existing state.a
Ugh, I am sorry, I tried to upvote but I fatfingered it and downvoted instead.
The cover art alone is worth a look.
React is not really a framework in the same sense Angular, Django, or Rails are. It does not dictate how you should architect your app.
>I just love how Google datacenters are somehow "the real world"

They totally are though, especially to the HN crowd where a lot of us may be putting hardware in data centers.

I agree that this isn't going to give us a clear picture of what to expect out of an SSD in say, a netbook or something. On the other hand, data from a million SSD's reported by one company in a controlled environment is a hell of a control group if you want to go test factors like temperature, etc.
I've built software for companies that sell on Amazon exactly the way these guys work. The products sold were different but the logic exactly the same. Write software that intelligently guesses the optimum prices and automates listing on Amazon. There's more to it than that, but this is the crux.

This is a TOUGH business to be in. They're under attack from every conceivable angle every single day:

1) Customers complaining on Amazon, often not legitimately

2) Minimum wage employees doing the "picking and packing" to ship to customers not turning up for work, making mistakes or worse still stealing from the company

3) The postal service letting them down not delivering an item which results in more 1) customers complaining

4) Suppliers spotting that my clients are on to a good thing and trying to rip them off, gouging them on prices or just messing them about in general

5) Margins so tight that they squeak when they walk. This business is all about volume of sales because of those margins. Which means you need to have lots of people, floor space, and other associated fixed overheads to achieve said volume

As if all of that isn't bad enough, you're in the pocket of Amazon. A company who at any given point in time for any reason they deem fit could simply shut your Amazon listings down and just like that your business dies.

I'm sure they're doing great, and I wish these guys well, but holy shit is this a tough business to scale.
I dunno. In Rust we've found that the functional idioms are frequently faster than the imperative ones. That's because it's easier for the compiler to remove bounds checks with functional programming styles. Also, we eliminated the overheads usually assocated with FP (closure construction, indirect branches).
Thanks Jason, glad you found it useful. You make an excellent point on the "fixing". I usually advise people to do it at least 3 months before a sale (ideally 12 months) to fully benefit from the potential valuation upside of improvements.
There is no such thing as politics without money. It is some socialist utopia.

I think companies lobbying for competing causes is better than some regulation where only scums get to lobby scumbag politicians.
Interestingly, the Haskell fans that I know happen to be mathematicians by inclination, and programmers because it seems useful. I think you are right that mathematical thinking maps quite naturally onto Haskell. I also think that most programmers are only middling-good mathematicians and aren't the type that enjoys doing air-tight proofs in their spare time as a hobby.
Where did I even mention anything about privacy ? Wrong comment ?
Perhaps I was not clear. I thought that the joke ended in "opin". I read it a few times, thinking that it didn't continue beyond "opin". Then I notice the link and that the joke continue.

Anyway, thanks for the explanations, because I didn't get all the details. Perhaps they can add an explanation wiki like http://explainxkcd.com/
TTL: Tera Term Macro Language (terminal Emulator)
Problem is... that code is an asset, until it's not. As most cases, it depends on the project, but changes in requirements have insidious effects on code, which might turn your asset in a liability before you realise it.
Yeah, but it's just easier to refactor in a functional language. :)
If you don't share common dependencies you're doomed to have security hazards.

Consider it this way: if you install package FOO with its dependencies A,B and C, and FOO's developer thinks it's "feature complete", the package will never be updated, but every time a vulnerability is disclosed in his dependencies you'll be it. For _every_ program maintained this way.
239,989,522 wifi networks: https://wigle.net
For me, a non-gamer, this is the killer app for any of the new head-mounted displays. I've been waiting for years for some sort of goggles I can plug into my dev machine, put on to block out all visual distractions, and get work done.
Article is really thin on details, I'm skeptical. Last I checked, pixel density was still a big issue with HMD's and text. Contrast, as well is a problem with AR style HMD's.

I'd love it if the tech really was there though, it would be awesome. I actually think using some flavor of DLP tech and a foveated display with eye tracking might allow for phenomenal pixel density, wonder if anyone is working on that yet.
Hah! This is amusing.

In one of my classes freshman year, one of my favourite professors (Kathi Fisler <3) gave us an assignment where we made a silly game with an airplane that flies around and drops things. And I remember wondering how to do that without mutable state for the location of the plane, etc. Then I just remember seeing in the instructions for the assignment something like:

> write a function that takes a world and returns a new, updated world with the plane at its next location

and I just remember sitting there with my mind completely blown. Looking back at it, it doesn't seem as profound as I thought it was at the time, but maybe that's just because the novelty has worn off for me and a few years in industry have made me cynical, who knows :-)

Anyway, I think just learning to look at a problem differently I think gives you valuable insight into it and into your mind. Doesn't matter if you end up using it or not.

> I spend too much time trying to figure out how to say things as opposed to figuring out what to say.

Ha! Again, I think this is just a different approach. When I tried out haskell, it was intriguing that the modus operandi was: "think a lot about a problem, then write down a little code". I like that this is the opposite of my instinct to jump in with a solution, then kinda heuristically change it to get to code that works, and ultimately I think lead me to think a bit more and end up with clearer problem definitions and solutions.
Show HN: Concorde – yet another Python 3 ACME automation tool
> Everyone should learn at least one functional programming language and try to apply what they learned in other languages. But if functional programming languages want to become popular, they have to be less about puzzle solving.

Because FP relies on an insane amount of theory.

Often FP aficionados are incapable of explaining functional programming concepts to others without using FP idioms or jargon. I still don't have the foggiest idea of what a monad or a functor is, or why the hell would I want to use currying or partial application, when my imperative code just works (that's not entirely true, and javascript has done a great job at popularizing some concepts, like closures, partial applications or first class functions).

Now compare with OOP : polymorphism , inheritance and encapsulation are easy to explain : Everybody can understand that a machine can be turned on by pressing a button, no matter what machine it is(phone,computer,screen) : polymorphism. It's easy to explain encapsulation : you don't need to how the inner working of a microwave in order to use it. Same with inheritance.

I agree that one should learn at least an FP language so one is forced to deal with a specific problem a certain way, that's good exercice. But I shouldn't have to understand category theory in order to learn Haskell or Clojure.
Erlang is functional, but I/O is just functions (that send messages).
I was expecting to read about drives being bricked by buggy firmware. I guess they finally solved the firmware side.
Nice, looks to me like it covers most of what is proposed in here the Deprecating Observers paper here:
http://infoscience.epfl.ch/record/148043/files/DeprecatingOb...
Slightly different implementation since it uses untracked() instead of .Now to avoid dependency creation and a nice bridge to the regular observable universe (they have autorunAsync) but it would be good to have a reactor that can act as an observable using emit etc and if the observables could be modified with throttle, or buffer etc.

Edit: I have been enjoying similar reactiveness using ractivejs but it hasn't managed to split the reactive data from the view logic.
> * feel like people pushing Haskell and all of the weirdness that comes from lazy evaluation did more harm to FP perception in the general programmer community than good*

You've hit the nail on the head. Haskell has the combination of being very extreme and popular enough that it is damaging the perception of FP as a whole. I really wish Haskell didn't exist.

For anyone skeptical of FP who might be reading this: start with a dynamic FP language or a typed FP language that is strict rather than lazy. Examples of the former are Erlang/Elixir or Scheme. Examples of the latter are OCaml, Elm, F# or good old Standard ML.
Adsense? Knowing what movies the user likes, you could probably relate that to products that people are selling.
> Will JavaScript take over front-end?

Has it not? A more appropriate question would be "When will it step down?"

> it takes 40% more development time to finish a project with AngularJS than without using it.

And by "without using it", does it mean you write in vanilla JS? I believe you jumped into conclusions way too early. Working with any technology will take long. It's not the actual writing of code that will take long, it's the learning (if you're a total noob), setting up (if you don't have scaffolding tools), and debugging (if you don't have tools). The actual work is just a fraction of what you're actually doing.

> How was your experience with React or any other

If you mean React alone, then it's like Angular with directives... alone. You'll have to debate on your router, your data flow library, your server-communication layer, your build tooling, your process. It's all the same thing under the guise of a different syntax.

> Should I invest more time to keep me updated with one of them?

Get to know all the libraries, but never try to use them all. Choose one and get things done.

> I still think, front-end should just present the information, not the whole application logic.

It's like saying JS should have stayed on the browser, but wait! There's Node.js (server), Espruino (hardware), FirefoxOS (OS), PhoneGap (mobile), NW.js (desktop). If everyone was thinking the way you do, these would have never been invented.
I'm not really sure what I'm looking at here. Could you put some sort of explanation for the y-axis? I haven't the foggiest what a sentiment score is, and nothing seems to really change when I put in Obama, Trump, Angular, or React.
Stateless Functional Components in React!

const ProgressMeter = ({ className, percentage }) => {
const meterStyle = {
width: `${Math.round(Math.min(Math.max(percentage, 0), 1) * 100)}%`,
};

return (
<div className={cx('root', className)}>
<div className={cx('meter')} style={meterStyle}/>
</div>
);
};
The parent of my comment was making a joke (I doubt he seriously thinks people say "floating full stops" in the UK) so I made a joke too, in the same vein. You know, period/full stop...

It may not have been the best joke ever but I don't think it deserved 3 downvotes. People can be really tiresome sometimes.

(I'm not saying to you BTW; I don't think you downvoted.)

Edit: Okay, I received two upvotes after writing this, so now my post feels way too bitter. I'll leave it because I do think the point still stands - people are sometimes way too ready to downvote posts here (I don't mean mine, but anyone's) - but I'll also say people here are really very nice most of the time too.
> FP solves are problems that I think many developers genuinely don't have

I've felt this way [1] about Python, well, more than once. I'm feeling the same way by learning Haskell.

Except that with Python I learn the good parts fast, and then it's back to normal life. With Haskell things keep getting better and better... It's in part because Haskell is harder, but the improvements are also much larger.

[1] https://xkcd.com/353/
Bitbar is really great, I made a simple plugin for Gitlab in a very short time : https://github.com/matryer/bitbar-plugins/blob/master/Dev/Gi...

I also made a menu at my company to improve our workflow :
http://imgur.com/EpVb300

Thank you bitbar !
On one hand you say that FP aficionados are unable to explain FP concepts to others, and on the other you succinctly do it later on in the same paragraph (first class functions, closures, partial application).

I think you're conflating Haskell with FP, which is definitely not the case. No one needs to understand category theory to write Clojure or Lisp.
> Perl devs don't think twice about shelling out to an external binary

No, most of them do. Perl ecosystem has a killer feature called cpantesters, that allows everyone to see which modules work on which systems out of the box. You should always check cpantesters matrix before choosing a particular dependency.

> Even if regexs are not needed

They got overly complicated over the years, but they are needed. They are DSLs to make things easier when working with strings. I.e. so you wouldn't have to write 20 lines of hard to grasp code with bytes.Index(), bytes.HasSuffix(), bytes.TrimRight(), etc., like people do in Go, but a single nice regexp and therefore reduce your chances to make a mistake in that code.
Why don't you use lmdb ?
The real cake recipe can specify how to achieve the results instead of just saying that they should be achieved. It does not have to deal with issues like lazy evaluation or defining a batter monad. It does not have to trail off into "and so on" or else go on for far too many lines because of how tortured an exercise it is to make "pure functional" cake recipes.

If you want to argue with this, just deny that cake recipes are a good metaphor for programming, since they are essentially imperative and that is begging the question. But you aren't going to convince people that weirdly abstracted cake recipes are easier to write or follow.
> I just love how Google datacenters are somehow "the real world". ... It is easier to do stats this way, though.

From the paper's abstract (you did read the abstract, right?) :

"... While there is a large body of work based on experiments with individual flash chips in a controlled lab environment under synthetic workloads, there is a dearth of information on their behavior in the field. This paper provides a large-scale field study covering many millions of drive days, ten different drive models, different flash technologies (MLC, eMLC, SLC) over 6 years of production use in Google’s data centers. We study a wide range of reliability characteristics and come to a number of unexpected conclusions. For example, raw bit error rates (RBER) grow at a much slower rate with wear-out than the exponential rate commonly assumed and, more importantly, they are not predictive of uncorrectable errors or other error modes. The widely used metric UBER (uncorrectable bit error rate) is not a meaningful metric, since we see no correlation between the number of reads and the number of uncorrectable errors. We see no evidence that higher-end SLC drives are more reliable than MLC drives within typical drive lifetimes. Comparing with traditional hard disk drives, flash drives have a significantly lower replacement rate in the field, however, they have a higher rate of uncorrectable errors." [0][1]

I guess it's easier to draw incorrect, snarky conclusions based on inaccurate summaries of papers than it is to take a moment to read a paper's abstract to double-check the work of a tech journalist. shrug :(

[0] https://www.usenix.org/conference/fast16/technical-sessions/...

[1] http://0b4af6cdc2f0c5998459-c0245c5c937c5dedcca3f1764ecc9b2f...
Apart from Make, I actually like Rake too, too. It's very Make-like and works similarly to Make, but it's in Ruby, which isn't a bad thing.